diff --git a/RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/InteriorDirectory/SparseLevelWidth.lean b/RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/InteriorDirectory/SparseLevelWidth.lean index 091662b3..b7826b95 100644 --- a/RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/InteriorDirectory/SparseLevelWidth.lean +++ b/RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/InteriorDirectory/SparseLevelWidth.lean @@ -1600,10 +1600,12 @@ theorem canonicalRelativeRmmInteriorCost33RightSpine_size (n : Nat) : Cartesian.CartesianShape.size, ih] omega +@[macro_inline] def canonicalRelativeRmmInteriorCost33WitnessShape : Cartesian.CartesianShape := canonicalRelativeRmmInteriorCost33RightSpine 3469 +@[macro_inline] def canonicalRelativeRmmInteriorCost33WitnessInput : List Int := canonicalRelativeRmmInteriorCost33WitnessShape.representative diff --git a/RMQ/Core/SuccinctFinal/RAM/ReviewerReachabilitySmall.lean b/RMQ/Core/SuccinctFinal/RAM/ReviewerReachabilitySmall.lean index a6d1a0bc..304a2790 100644 --- a/RMQ/Core/SuccinctFinal/RAM/ReviewerReachabilitySmall.lean +++ b/RMQ/Core/SuccinctFinal/RAM/ReviewerReachabilitySmall.lean @@ -1709,6 +1709,7 @@ private def reviewerSingletonBeforeLCA : WholeQueryProgram := (.sub .inputRight (.const 1)) ] +@[macro_inline] private def reviewerSingletonBeforeLCAState : WholeQueryState := (WholeQueryProgram.evalGlobalWordTrace (Cartesian.shape reviewerSingletonInput) 0 1 reviewerSingletonBeforeLCA @@ -1730,6 +1731,7 @@ private def reviewerSingletonBeforeRank : WholeQueryProgram := , WholeQueryInstr.lcaClose .answerClose .leftClose .rightClose ] +@[macro_inline] private def reviewerSingletonBeforeRankState : WholeQueryState := (WholeQueryProgram.evalGlobalWordTrace (Cartesian.shape reviewerSingletonInput) 0 1 reviewerSingletonBeforeRank @@ -2039,6 +2041,7 @@ private def reviewerIncreasingSixteenBeforeLCA : WholeQueryProgram := (.sub .inputRight (.const 1)) ] +@[macro_inline] private def reviewerIncreasingSixteenBeforeLCAState : WholeQueryState := (WholeQueryProgram.evalGlobalWordTrace (Cartesian.shape reviewerIncreasingSixteenInput) 0 16 diff --git a/RMQ/Core/WordRAM/Lifecycle/Accounting.lean b/RMQ/Core/WordRAM/Lifecycle/Accounting.lean new file mode 100644 index 00000000..ff3d3828 --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/Accounting.lean @@ -0,0 +1,81 @@ +import RMQ.Core.WordRAM.Lifecycle.Program +import RMQ.Core.WordRAM.Packed.Allocation + +/-! # Fixed whole-owner accounting constants + +All request and descriptor registers are inside the numeric bank. Eight control +words cover the PC, status tag and result, three owned extents, the numeric-bank +extent and a spare boundary-control word. Key values are a separate resource. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle + +open SuccinctSpace + +def numericBank : Nat := 8273 +def controlWords : Nat := 8 +def scratchWords : Nat := numericBank + controlWords +def codeWordBudget : Nat := 1116895 + +def encodedProgram (model : InputModel) : List Nat := + ((Layout.program model).map Instruction.encoding).flatten + +def retainedRho : Nat → Nat := + PackedWordRAM.allocationWithMachineRho codeWordBudget scratchWords + +theorem instruction_encoding_length (i : Instruction) : i.encoding.length ≤ 5 := by + cases i with + | old p => + cases p <;> simp [Instruction.encoding, PackedConstruction.Prim.constants] + | releaseCell => decide + | releaseKey => decide + | releaseKeyRegister => decide + +theorem program_encoding_length (p : List Instruction) : + (p.map Instruction.encoding).flatten.length ≤ 5*p.length := by + induction p with + | nil => simp + | cons i p ih => + have hi := instruction_encoding_length i + simp only [List.map_cons, List.flatten_cons, List.length_append, List.length_cons] + omega + +theorem encodedProgram_length_le (model : InputModel) : + (encodedProgram model).length ≤ codeWordBudget := by + have h := program_encoding_length (Layout.program model) + rw [Layout.program_length] at h + cases model <;> change _ ≤ 1116895 <;> exact Nat.le_trans h (by decide) + +theorem instruction_fields_fit (i : Instruction) {W : Nat} (width : 32 ≤ W) : i.Fits W := by + have hpow := Nat.pow_le_pow_right (by decide : 0 < 2) width + cases i with + | old p => + intro v hv + obtain ⟨a, _, rfl⟩ := List.mem_map.mp hv + exact Nat.lt_of_lt_of_le a.isLt hpow + | releaseCell => intro v hv; simp [Instruction.encoding] at hv; subst v; omega + | releaseKey => intro v hv; simp [Instruction.encoding] at hv; subst v; omega + | releaseKeyRegister => intro v hv; simp [Instruction.encoding] at hv; subst v; omega + +theorem all_encoded_fields_fit (model : InputModel) (n : Nat) : + ∀ v ∈ encodedProgram model, v < 2 ^ PackedWordRAM.wordWidth n := by + intro v hv + obtain ⟨words, hw, hv⟩ := List.mem_flatten.mp hv + obtain ⟨i, _, rfl⟩ := List.mem_map.mp hw + exact instruction_fields_fit i (PackedConstruction.Proof.wordWidth_ge_32 n) v hv + +theorem retainedRho_littleO : LittleOLinear retainedRho := + PackedWordRAM.allocationWithMachineRho_littleO codeWordBudget scratchWords + +theorem retained_capacity (model : InputModel) (xs : List Int) : + ((PackedWordRAM.buildMemory xs).length + (encodedProgram model).length + + numericBank + controlWords) * PackedWordRAM.wordWidth xs.length ≤ + 2*xs.length + retainedRho xs.length := by + have hc := encodedProgram_length_le model + have h := PackedWordRAM.buildMemory_with_machine_capacity_le xs codeWordBudget scratchWords + apply Nat.le_trans (Nat.mul_le_mul_right _ (show + (PackedWordRAM.buildMemory xs).length + (encodedProgram model).length + numericBank + controlWords ≤ + (PackedWordRAM.buildMemory xs).length + codeWordBudget + scratchWords by + unfold scratchWords; omega)) h + +end RMQ.SuccinctFinal.PackedLifecycle diff --git a/RMQ/Core/WordRAM/Lifecycle/Agreement.lean b/RMQ/Core/WordRAM/Lifecycle/Agreement.lean new file mode 100644 index 00000000..d6f7a480 --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/Agreement.lean @@ -0,0 +1,434 @@ +import RMQ.Core.WordRAM.Lifecycle.Calculus +import RMQ.Core.WordRAM.Construction.Calculus + +/-! # Supplied-store agreement for evolving lifecycle stores + +Read agreement is about the replies at the producing states of paired actual +steps. It includes missing replies and repeated attempts. Memory and input-key +functions may differ elsewhere; registers, owned extents and control agree. +Neither a final answer nor a separately manufactured read log is an assumption. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle + +open PackedConstruction (Operand Prim execPrim put) + +def State.Agree (s t : State) : Prop := + PackedConstruction.State.Agree s.core t.core ∧ + s.keyExtent = t.keyExtent ∧ s.keyRegExtent = t.keyRegExtent + +theorem State.Agree.refl (s : State) : s.Agree s := + ⟨PackedConstruction.State.Agree.refl _, rfl, rfl⟩ + +theorem State.Agree.regs {s t : State} (h : s.Agree t) : s.core.regs = t.core.regs := h.1.1 +theorem State.Agree.extent {s t : State} (h : s.Agree t) : s.core.extent = t.core.extent := h.1.2.1 +theorem State.Agree.keyRegs {s t : State} (h : s.Agree t) : s.core.keyRegs = t.core.keyRegs := h.1.2.2.1 +theorem State.Agree.pc {s t : State} (h : s.Agree t) : s.core.pc = t.core.pc := h.1.2.2.2.1 +theorem State.Agree.status {s t : State} (h : s.Agree t) : s.core.status = t.core.status := h.1.2.2.2.2 + +theorem State.Agree.eq {s t : State} (h : s.Agree t) : + t = { s with core := { s.core with memory := t.core.memory, keys := t.core.keys } } := by + rcases s with ⟨sc, sk, sr⟩ + rcases t with ⟨tc, tk, tr⟩ + rcases h with ⟨hc, hk, hr⟩ + dsimp only at hc hk hr ⊢ + cases hk + cases hr + exact congrArg (fun c => State.mk c sk sr) hc.eq + +/-- Only the executed numeric guard demands a memory reply. A missing cell +inside the extent is a reply `none`; an out-of-extent attempt needs no equality +of inaccessible cells. `loadKey` has the existing unguarded key-oracle lookup. -/ +def Instruction.ReadAgree (i : Instruction) (s t : State) : Prop := + (∀ dst address, i = .old (.load dst address) → + s.core.regs address < s.core.extent → + t.core.memory (s.core.regs address) = s.core.memory (s.core.regs address)) ∧ + (∀ dst address, i = .old (.loadKey dst address) → + t.core.keys (s.core.regs address) = s.core.keys (s.core.regs address)) + +theorem Instruction.ReadAgree.refl (i : Instruction) (s : State) : i.ReadAgree s s := + ⟨fun _ _ _ _ => rfl, fun _ _ _ => rfl⟩ + +private theorem old_guarded_agree (p : Prim) (s t : PackedConstruction.State) + (h : PackedConstruction.State.Agree s t) + (hm : ∀ dst address, p = .load dst address → s.regs address < s.extent → + t.memory (s.regs address) = s.memory (s.regs address)) + (hk : ∀ dst address, p = .loadKey dst address → + t.keys (s.regs address) = s.keys (s.regs address)) : + PackedConstruction.State.Agree (execPrim p s) (execPrim p t) := by + classical + by_cases bad : ∃ dst address, p = .load dst address ∧ ¬s.regs address < s.extent + · obtain ⟨dst, address, rfl, ha⟩ := bad + have ht : ¬t.regs address < t.extent := by simpa [← h.1, ← h.2.1] using ha + simp only [execPrim, if_neg ha, if_neg ht] + exact ⟨h.1, h.2.1, h.2.2.1, h.2.2.2.1, rfl⟩ + · refine (PackedConstruction.execPrim_agree_of_agree p s t h ?_ hk).1 + intro dst address hp + apply hm dst address hp + apply Classical.byContradiction + intro hn + exact bad ⟨dst, address, hp, hn⟩ + +theorem execute_agree (i : Instruction) (s t : State) (h : s.Agree t) + (hr : i.ReadAgree s t) : (execute i s).Agree (execute i t) := by + cases i with + | old p => + exact ⟨old_guarded_agree p s.core t.core h.1 + (fun d a he ha => hr.1 d a (congrArg Instruction.old he) ha) + (fun d a he => hr.2 d a (congrArg Instruction.old he)), h.2⟩ + | releaseCell => + rw [h.eq] + simp only [execute] + split <;> simp [State.Agree, PackedConstruction.State.Agree, PackedConstruction.State.next] + | releaseKey => + rw [h.eq] + simp only [execute] + split <;> simp [State.Agree, PackedConstruction.State.Agree, PackedConstruction.State.next] + | releaseKeyRegister => + rw [h.eq] + simp only [execute] + split <;> simp [State.Agree, PackedConstruction.State.Agree, PackedConstruction.State.next] + +/-- A scalar write either makes the two replies equal or leaves each old cell +unchanged. This states store/release coherence without equating unrelated cells. -/ +def CellsCoherent {α : Type} (before₁ before₂ after₁ after₂ : Nat → α) : Prop := + ∀ a, after₁ a = after₂ a ∨ (after₁ a = before₁ a ∧ after₂ a = before₂ a) + +private theorem put_coherent {α : Type} (f g : Nat → α) (a : Nat) (v : α) : + CellsCoherent f g (put f a v) (put g a v) := by + intro b + by_cases hb : b = a + · left; simp [put, hb] + · right; simp [put, hb] + +theorem execute_memory_coherent (i : Instruction) (s t : State) (h : s.Agree t) : + CellsCoherent s.core.memory t.core.memory (execute i s).core.memory (execute i t).core.memory := by + cases i with + | old p => + change CellsCoherent _ _ (execPrim p s.core).memory (execPrim p t.core).memory + rw [PackedConstruction.execPrim_memory_replay, PackedConstruction.execPrim_memory_replay] + cases p <;> try exact fun _ => Or.inr ⟨rfl, rfl⟩ + case store address value => + rw [← h.regs, ← h.extent] + by_cases ha : s.core.regs address < s.core.extent + · simp only [if_pos ha] + exact put_coherent _ _ _ _ + · simp only [if_neg ha] + exact fun _ => Or.inr ⟨rfl, rfl⟩ + | releaseCell => + simp only [execute] + rw [← h.extent] + split + · exact fun _ => Or.inr ⟨rfl, rfl⟩ + · exact put_coherent _ _ _ _ + | releaseKey => + simp only [execute] + split <;> split <;> exact fun _ => Or.inr ⟨rfl, rfl⟩ + | releaseKeyRegister => + simp only [execute] + split <;> split <;> exact fun _ => Or.inr ⟨rfl, rfl⟩ + +theorem execute_keys_coherent (i : Instruction) (s t : State) (h : s.Agree t) : + CellsCoherent s.core.keys t.core.keys (execute i s).core.keys (execute i t).core.keys := by + cases i with + | old p => + change CellsCoherent _ _ (execPrim p s.core).keys (execPrim p t.core).keys + rw [PackedConstruction.execPrim_keys, PackedConstruction.execPrim_keys] + exact fun _ => Or.inr ⟨rfl, rfl⟩ + | releaseKey => + simp only [execute] + rw [← h.2.1] + split + · exact fun _ => Or.inr ⟨rfl, rfl⟩ + · exact put_coherent _ _ _ _ + | releaseCell => + simp only [execute] + split <;> split <;> exact fun _ => Or.inr ⟨rfl, rfl⟩ + | releaseKeyRegister => + simp only [execute] + split <;> split <;> exact fun _ => Or.inr ⟨rfl, rfl⟩ + +def Transition.keyRead? (t : Transition) : Option (Nat × Option Int) := + match t.action with + | .instruction (.old (.loadKey _ address)) => + some (t.before.core.regs address, t.before.core.keys (t.before.core.regs address)) + | _ => none + +def Run.keyReads (r : Run) : List (Nat × Option Int) := r.transitions.filterMap Transition.keyRead? + +theorem instruction_read_agree (i : Instruction) (s t : State) (h : s.Agree t) + (hr : i.ReadAgree s t) : + (Transition.mk s (.instruction i) (execute i s)).read? = + (Transition.mk t (.instruction i) (execute i t)).read? := by + cases i with + | old p => + cases p <;> try rfl + case load dst address => + simp only [Transition.read?] + rw [← h.regs, ← h.extent] + by_cases ha : s.core.regs address < s.core.extent + · simp [ha, hr.1 dst address rfl ha] + · simp [ha] + | releaseCell | releaseKey | releaseKeyRegister => rfl + +theorem instruction_keyRead_agree (i : Instruction) (s t : State) (h : s.Agree t) + (hr : i.ReadAgree s t) : + (Transition.mk s (.instruction i) (execute i s)).keyRead? = + (Transition.mk t (.instruction i) (execute i t)).keyRead? := by + cases i with + | old p => + cases p <;> try rfl + case loadKey dst address => + simp only [Transition.keyRead?] + rw [← h.regs, hr.2 dst address rfl] + | releaseCell | releaseKey | releaseKeyRegister => rfl + +def Transition.Agree (a b : Transition) : Prop := + a.action = b.action ∧ a.before.Agree b.before ∧ a.after.Agree b.after ∧ + a.read? = b.read? ∧ a.keyRead? = b.keyRead? + +theorem step_none_agree (program : List Instruction) (s t : State) (h : s.Agree t) + (hs : step program s = none) : step program t = none := by + by_cases hrun : s.core.status = .running + · cases hf : program[s.core.pc]? with + | none => simp [step, ← h.pc, ← h.status, hrun, hf] + | some i => simp [step, hrun, hf] at hs + · simp [step, ← h.status, hrun] + +theorem step_agree_of_reads {program : List Instruction} {s t : State} {a : Transition} + (hs : step program s = some a) (h : s.Agree t) + (hr : ∀ i, a.action = .instruction i → i.ReadAgree s t) : + ∃ b, step program t = some b ∧ a.Agree b := by + obtain ⟨hb, hrun, i, hfetch, haction, hafter⟩ := step_spec hs + have ht : step program t = some ⟨t, .instruction i, execute i t⟩ := + step_of_running (by rw [← h.status]; exact hrun) (by rw [← h.pc]; exact hfetch) + refine ⟨_, ht, haction, ?_, ?_, ?_, ?_⟩ + · simpa [hb] using h + · simpa [hafter] using execute_agree i s t h (hr i haction) + · simpa [Transition.read?, hb, haction] using instruction_read_agree i s t h (hr i haction) + · simpa [Transition.keyRead?, hb, haction] using instruction_keyRead_agree i s t h (hr i haction) + +/-- The condition is recursively attached to the two actual producing prefixes. +No endpoint agreement is a field. Initial state agreement forces the two fetches +to succeed or stop together; each subsequent agreement is derived from replies. -/ +def DynamicReadsAgree (program : List Instruction) : Nat → State → State → Prop + | 0, _, _ => True + | fuel + 1, s, t => + match step program s, step program t with + | some a, some b => + (∀ i, a.action = .instruction i → i.ReadAgree s t) ∧ + DynamicReadsAgree program fuel a.after b.after + | _, _ => True + +theorem DynamicReadsAgree.refl (program : List Instruction) (fuel : Nat) (s : State) : + DynamicReadsAgree program fuel s s := by + induction fuel generalizing s with + | zero => trivial + | succ fuel ih => + cases h : step program s with + | none => simp [DynamicReadsAgree, h] + | some t => + simp only [DynamicReadsAgree, h] + exact ⟨fun i _ => Instruction.ReadAgree.refl i s, ih t.after⟩ + +/-- Pairing is positional: equal repeated event values remain distinct entries. -/ +def TransitionsAgree : List Transition → List Transition → Prop + | [], [] => True + | a :: as, b :: bs => a.Agree b ∧ TransitionsAgree as bs + | _, _ => False + +def Run.Agree (r q : Run) : Prop := + TransitionsAgree r.transitions q.transitions ∧ r.final.Agree q.final + +theorem run_agree_of_dynamic_reads (program : List Instruction) (fuel : Nat) (s t : State) + (h : s.Agree t) (hr : DynamicReadsAgree program fuel s t) : + (run program fuel s).Agree (run program fuel t) := by + induction fuel generalizing s t with + | zero => exact ⟨trivial, h⟩ + | succ fuel ih => + cases hs : step program s with + | none => + have ht := step_none_agree program s t h hs + simp only [run, hs, ht, Run.Agree, TransitionsAgree] + exact ⟨trivial, h⟩ + | some a => + obtain ⟨_, hrun, i, hfetch, haction, _⟩ := step_spec hs + let b : Transition := ⟨t, .instruction i, execute i t⟩ + have ht : step program t = some b := step_of_running + (by rw [← h.status]; exact hrun) (by rw [← h.pc]; exact hfetch) + have hcurrent : (∀ j, a.action = .instruction j → j.ReadAgree s t) ∧ + DynamicReadsAgree program fuel a.after b.after := by + simpa [DynamicReadsAgree, hs, ht] using hr + obtain ⟨b', ht', hab⟩ := step_agree_of_reads hs h hcurrent.1 + have heq : b' = b := Option.some.inj (ht'.symm.trans ht) + subst b' + have hrest := ih a.after b.after hab.2.2.1 hcurrent.2 + simp only [run, hs, ht, Run.Agree, TransitionsAgree] + exact ⟨⟨hab, hrest.1⟩, hrest.2⟩ + +theorem TransitionsAgree.map_eq {ts us : List Transition} (h : TransitionsAgree ts us) + {α : Type} (f : Transition → α) (hf : ∀ a b, a.Agree b → f a = f b) : + ts.map f = us.map f := by + induction ts generalizing us with + | nil => cases us <;> simp_all [TransitionsAgree] + | cons a ts ih => + cases us with + | nil => simp [TransitionsAgree] at h + | cons b us => + simp only [List.map_cons, hf a b h.1, ih h.2] + +theorem TransitionsAgree.filterMap_eq {ts us : List Transition} (h : TransitionsAgree ts us) + {α : Type} (f : Transition → Option α) (hf : ∀ a b, a.Agree b → f a = f b) : + ts.filterMap f = us.filterMap f := by + induction ts generalizing us with + | nil => cases us <;> simp_all [TransitionsAgree] + | cons a ts ih => + cases us with + | nil => simp [TransitionsAgree] at h + | cons b us => + simp only [List.filterMap_cons, hf a b h.1, ih h.2] + +theorem Run.Agree.steps {r q : Run} (h : r.Agree q) : r.steps = q.steps := by + have hm := h.1.map_eq (fun _ : Transition => ()) (fun _ _ _ => rfl) + simpa [Run.steps] using congrArg List.length hm + +theorem Run.Agree.actions {r q : Run} (h : r.Agree q) : + r.transitions.map (·.action) = q.transitions.map (·.action) := + h.1.map_eq _ (fun _ _ hab => hab.1) + +theorem Run.Agree.categories {r q : Run} (h : r.Agree q) : r.categories = q.categories := + h.1.map_eq _ (fun _ _ hab => congrArg Action.category hab.1) + +theorem Run.Agree.categoryCount {r q : Run} (h : r.Agree q) (c : Category) : + r.categoryCount c = q.categoryCount c := by + simp only [Run.categoryCount, h.categories] + +theorem Run.Agree.reads {r q : Run} (h : r.Agree q) : r.reads = q.reads := + h.1.filterMap_eq _ (fun _ _ hab => hab.2.2.2.1) + +theorem Run.Agree.keyReads {r q : Run} (h : r.Agree q) : r.keyReads = q.keyReads := + h.1.filterMap_eq _ (fun _ _ hab => hab.2.2.2.2) + +theorem Run.Agree.writes {r q : Run} (h : r.Agree q) : r.writes = q.writes := by + apply h.1.filterMap_eq + intro a b hab + simp only [Transition.write?, hab.1, hab.2.1.regs, hab.2.1.extent] + +theorem Run.Agree.final_regs {r q : Run} (h : r.Agree q) : + r.final.core.regs = q.final.core.regs := h.2.regs + +theorem Run.Agree.final_status {r q : Run} (h : r.Agree q) : + r.final.core.status = q.final.core.status := h.2.status + +theorem Run.Agree.result {r q : Run} (h : r.Agree q) : + (match r.final.core.status with | .halted v => some v | _ => none) = + (match q.final.core.status with | .halted v => some v | _ => none) := by + rw [h.final_status] + +theorem executeBoundary_agree (b : Boundary) (s t : State) (h : s.Agree t) : + (executeBoundary b s).Agree (executeBoundary b t) := by + rw [h.eq] + cases b <;> simp [executeBoundary, State.Agree, PackedConstruction.State.Agree] + +theorem runBoundary_agree (bs : List Boundary) (s t : State) (h : s.Agree t) : + (runBoundary bs s).Agree (runBoundary bs t) := by + induction bs generalizing s t with + | nil => exact ⟨trivial, h⟩ + | cons b bs ih => + have hafter := executeBoundary_agree b s t h + cases hs : s.core.status with + | running => + simp only [runBoundary, boundaryStep, hs, ← h.status, Run.Agree, TransitionsAgree] + exact ⟨trivial, h⟩ + | fault => + simp only [runBoundary, boundaryStep, hs, ← h.status, Run.Agree, TransitionsAgree] + exact ⟨trivial, h⟩ + | halted value => + have hr := ih (executeBoundary b s) (executeBoundary b t) hafter + simp only [runBoundary, boundaryStep, hs, ← h.status, Run.Agree, TransitionsAgree] + exact ⟨⟨⟨rfl, h, hafter, rfl, rfl⟩, hr.1⟩, hr.2⟩ + +theorem requestProtocol_agree (entry : Operand) (left right : Nat) (s t : State) + (h : s.Agree t) : + (requestProtocol entry left right s).Agree (requestProtocol entry left right t) := + runBoundary_agree _ s t h + +theorem TransitionsAgree.occurrence {ts us : List Transition} (h : TransitionsAgree ts us) + {k : Nat} {a : Transition} (ha : ts[k]? = some a) : + ∃ b, us[k]? = some b ∧ a.Agree b := by + induction ts generalizing us k with + | nil => simp at ha + | cons first ts ih => + cases us with + | nil => simp [TransitionsAgree] at h + | cons second us => + cases k with + | zero => + simp only [List.getElem?_cons_zero, Option.some.injEq] at ha + subst a + exact ⟨second, rfl, h.1⟩ + | succ k => + simp only [List.getElem?_cons_succ] at ha ⊢ + exact ih h.2 ha + +theorem Run.Agree.occurrence {r q : Run} (h : r.Agree q) + {k : Nat} {a : Transition} (ha : r.transitions[k]? = some a) : + ∃ b, q.transitions[k]? = some b ∧ a.Agree b := h.1.occurrence ha + +/-- The instruction and its producing state come from this exact occurrence of +the actual run. The conclusion constrains the loaded numeric register itself. -/ +theorem load_occurrence_value {program : List Instruction} {fuel k : Nat} + {s : State} {t : Transition} {dst address : Operand} {value : Nat} + (hpos : (run program fuel s).transitions[k]? = some t) + (hi : t.action = .instruction (.old (.load dst address))) + (ha : t.before.core.regs address < t.before.core.extent) + (hv : t.before.core.memory (t.before.core.regs address) = some value) : + t.after.core.regs dst = value ∧ + t.read? = some (t.before.core.regs address, some value) ∧ + t.after.core.status = .running := by + obtain ⟨_, hstep⟩ := run_transition_at hpos + obtain ⟨_, hrun, i, _, haction, hafter⟩ := step_spec hstep + have he : i = .old (.load dst address) := Action.instruction.inj (haction.symm.trans hi) + rw [he] at hafter + refine ⟨?_, ?_, ?_⟩ + · rw [hafter] + simp [execute, execPrim, ha, hv, PackedConstruction.State.writeNext, + PackedConstruction.State.next, put] + · simp [Transition.read?, hi, ha, hv] + · rw [hafter] + simp [execute, execPrim, ha, hv, PackedConstruction.State.writeNext, + PackedConstruction.State.next, hrun] + +/-- Different successful replies at one shared address force different loaded +register values at matched actual occurrences, not merely unequal log records. -/ +theorem load_occurrence_value_dependency {program : List Instruction} {fuel k : Nat} + {s u : State} {t v : Transition} {dst address : Operand} {x y : Nat} + (ht : (run program fuel s).transitions[k]? = some t) + (hv : (run program fuel u).transitions[k]? = some v) + (hit : t.action = .instruction (.old (.load dst address))) + (hiv : v.action = .instruction (.old (.load dst address))) + (haddress : t.before.core.regs address = v.before.core.regs address) + (hat : t.before.core.regs address < t.before.core.extent) + (hav : v.before.core.regs address < v.before.core.extent) + (hxt : t.before.core.memory (t.before.core.regs address) = some x) + (hyv : v.before.core.memory (v.before.core.regs address) = some y) + (hne : x ≠ y) : + t.read? = some (t.before.core.regs address, some x) ∧ + v.read? = some (t.before.core.regs address, some y) ∧ + t.after.core.regs dst ≠ v.after.core.regs dst := by + obtain ⟨hx, hrt, _⟩ := load_occurrence_value ht hit hat hxt + obtain ⟨hy, hrv, _⟩ := load_occurrence_value hv hiv hav hyv + exact ⟨hrt, by simpa [haddress] using hrv, by simpa [hx, hy] using hne⟩ + +/-- This negative control challenges exactly the positive guarded reply +predicate. Removing the source cell cannot satisfy the successful-read guard. -/ +theorem absent_source_rejects_read_agreement (s : State) (dst address : Operand) (v : Nat) + (ha : s.core.regs address < s.core.extent) + (hv : s.core.memory (s.core.regs address) = some v) : + ¬Instruction.ReadAgree (.old (.load dst address)) s + { s with core := { s.core with memory := put s.core.memory (s.core.regs address) none } } := by + intro h + have he := h.1 dst address rfl ha + simp [put, hv] at he + +end RMQ.SuccinctFinal.PackedLifecycle diff --git a/RMQ/Core/WordRAM/Lifecycle/ArrayRun.lean b/RMQ/Core/WordRAM/Lifecycle/ArrayRun.lean new file mode 100644 index 00000000..58e7f350 --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/ArrayRun.lean @@ -0,0 +1,688 @@ +import RMQ.Core.WordRAM.Lifecycle.Calculus +import RMQ.Core.WordRAM.Construction.ArrayRun + +/-! # Finite-container lifecycle execution + +The retained `Owner` contains only numeric/key arrays and scalar control. Optional +validation transitions are separate from this owner. Array sizes describe logical +ownership; no theorem here identifies native allocation capacity or external aliases. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle + +open PackedConstruction (Prim Operand put execPrim execPrimArray) + +abbrev Owner := PackedConstruction.ExecState + +def Owner.toState (es : Owner) : State := + ⟨es.abstract, es.keys.size, es.keyRegs.size⟩ + +@[simp] theorem Owner.toState_pc (es : Owner) : es.toState.core.pc = es.pc := rfl +@[simp] theorem Owner.toState_status (es : Owner) : es.toState.core.status = es.status := rfl + +/-- Reads use the same default outside a finite bank. Only destinations need a +bound; numeric and comparison-key banks can have different sizes, including zero. -/ +def destinationsBelow (R K : Nat) : Prim → Prop + | .load dst _ | .constant dst _ | .move dst _ | .arithmetic _ dst _ _ + | .comparison _ dst _ _ | .reserve dst | .compareKey dst _ _ => dst.val < R + | .loadKey dst _ => dst.val < K + | .jump _ | .jumpRegister _ | .branchZero _ _ | .halt _ | .store _ _ => True + +def Instruction.DestinationsFit (i : Instruction) (es : Owner) : Prop := + match i with + | .old p => destinationsBelow es.regs.size es.keyRegs.size p + | _ => True + +def Boundary.DestinationsFit (b : Boundary) (es : Owner) : Prop := + match b with + | .left _ => requestLeftRegister < es.regs.size + | .right _ => requestRightRegister < es.regs.size + | .entry _ | .activate => True + +private theorem lookup_set {α : Type} (xs : Array α) (i : Nat) (v d : α) + (hi : i < xs.size) : + (fun j => (xs.setIfInBounds i v).getD j d) = put (fun j => xs.getD j d) i v := by + funext j + simp only [put, Array.getD_eq_getD_getElem?, Array.getElem?_setIfInBounds] + by_cases h : j = i + · subst h; simp [hi] + · simp [h, Ne.symm h] + +private theorem lookup_push_none {α : Type} (xs : Array (Option α)) : + (fun j => (xs.push none).getD j none) = fun j => xs.getD j none := by + funext j + simp only [Array.getD_eq_getD_getElem?, Array.getElem?_push] + by_cases h : j = xs.size + · subst h; simp + · simp [h] + +/-- A pop removes exactly the tail lookup, including when earlier cells already +contain the default. The nonempty guard is discharged by the release evaluator. -/ +theorem lookup_pop {α : Type} (xs : Array α) (d : α) (h : 0 < xs.size) : + (fun j => xs.pop.getD j d) = put (fun j => xs.getD j d) (xs.size - 1) d := by + funext j + simp only [Array.getD_eq_getD_getElem?, Array.getElem?_pop, put] + by_cases hj : j < xs.size - 1 + · simp [hj, show j ≠ xs.size - 1 by omega] + · by_cases he : j = xs.size - 1 + · simp [he] + · have hh : xs.size ≤ j := by omega + simp [hj, he, Array.getElem?_eq_none hh] + +private theorem numeric_write (es : Owner) (dst value : Nat) (h : dst < es.regs.size) : + ({ es with regs := es.regs.setIfInBounds dst value, pc := es.pc + 1 } : Owner).abstract = + es.abstract.writeNext dst value := by + simp only [PackedConstruction.ExecState.abstract, PackedConstruction.State.writeNext, + PackedConstruction.State.next, lookup_set _ _ _ _ h] + +private theorem key_write (es : Owner) (dst : Nat) (value : Int) + (h : dst < es.keyRegs.size) : + ({ es with keyRegs := es.keyRegs.setIfInBounds dst value, pc := es.pc + 1 } : Owner).abstract = + { es.abstract.next with keyRegs := put es.abstract.keyRegs dst value } := by + simp only [PackedConstruction.ExecState.abstract, PackedConstruction.State.next, + lookup_set _ _ _ _ h] + +/-- The old executable evaluator is reused unchanged. Unlike its predecessor +wrapper, this refinement does not require equal numeric/key register banks. -/ +theorem oldArray_core (p : Prim) (es : Owner) + (hp : destinationsBelow es.regs.size es.keyRegs.size p) : + (execPrimArray p es).abstract = execPrim p es.abstract := by + cases p with + | load dst address => + simp only [execPrimArray, execPrim, PackedConstruction.ExecState.abstract] + by_cases ha : es.regs.getD address.val 0 < es.memory.size + · rw [if_pos ha, if_pos ha] + cases es.memory.getD (es.regs.getD address.val 0) none with + | some value => exact numeric_write es _ _ hp + | none => rfl + · rw [if_neg ha, if_neg ha] + | constant dst value => exact numeric_write es _ _ hp + | move dst src => exact numeric_write es _ _ hp + | arithmetic op dst lhs rhs => exact numeric_write es _ _ hp + | comparison op dst lhs rhs => exact numeric_write es _ _ hp + | jump target => rfl + | jumpRegister src => rfl + | branchZero condition target => rfl + | halt src => rfl + | store address value => + simp only [execPrimArray, execPrim, PackedConstruction.ExecState.abstract] + by_cases ha : es.regs.getD address.val 0 < es.memory.size + · rw [if_pos ha, if_pos ha] + simp only [PackedConstruction.State.next, + lookup_set _ _ _ _ ha, Array.size_setIfInBounds] + · rw [if_neg ha, if_neg ha] + | reserve dst => + simp only [execPrimArray, execPrim, PackedConstruction.ExecState.abstract, + PackedConstruction.State.writeNext, PackedConstruction.State.next, + lookup_set _ _ _ _ hp, lookup_push_none, Array.size_push] + | loadKey dst address => + simp only [execPrimArray, execPrim, PackedConstruction.ExecState.abstract] + cases es.keys.getD (es.regs.getD address.val 0) none with + | some key => exact key_write es _ key hp + | none => rfl + | compareKey dst lhs rhs => exact numeric_write es _ _ hp + +theorem oldArray_bank_sizes (p : Prim) (es : Owner) : + (execPrimArray p es).regs.size = es.regs.size ∧ + (execPrimArray p es).keys.size = es.keys.size ∧ + (execPrimArray p es).keyRegs.size = es.keyRegs.size := by + cases p <;> simp only [execPrimArray] + all_goals repeat first | split | exact ⟨rfl, rfl, rfl⟩ | + exact ⟨Array.size_setIfInBounds, rfl, rfl⟩ | + exact ⟨rfl, rfl, Array.size_setIfInBounds⟩ | + simp only [Array.size_setIfInBounds, and_self] + +def executeArray : Instruction → Owner → Owner + | .old p, es => execPrimArray p es + | .releaseCell, es => + if es.memory.size = 0 then { es with status := .fault } + else { es with memory := es.memory.pop, pc := es.pc + 1 } + | .releaseKey, es => + if es.keys.size = 0 then { es with status := .fault } + else { es with keys := es.keys.pop, pc := es.pc + 1 } + | .releaseKeyRegister, es => + if es.keyRegs.size = 0 then { es with status := .fault } + else { es with keyRegs := es.keyRegs.pop, pc := es.pc + 1 } + +theorem executeArray_toState (i : Instruction) (es : Owner) + (h : i.DestinationsFit es) : + (executeArray i es).toState = execute i es.toState := by + cases i with + | old p => + simp only [executeArray, execute, Owner.toState, oldArray_core p es h, + (oldArray_bank_sizes p es).2.1, (oldArray_bank_sizes p es).2.2] + | releaseCell => + by_cases hz : es.memory.size = 0 + · simp [executeArray, execute, Owner.toState, PackedConstruction.ExecState.abstract, hz] + · simp [executeArray, execute, Owner.toState, PackedConstruction.ExecState.abstract, + PackedConstruction.State.next, hz] + simpa only [Array.getD_eq_getD_getElem?] using lookup_pop es.memory none (by omega) + | releaseKey => + by_cases hz : es.keys.size = 0 + · simp [executeArray, execute, Owner.toState, PackedConstruction.ExecState.abstract, hz] + · simp [executeArray, execute, Owner.toState, PackedConstruction.ExecState.abstract, + PackedConstruction.State.next, hz] + simpa only [Array.getD_eq_getD_getElem?] using lookup_pop es.keys none (by omega) + | releaseKeyRegister => + by_cases hz : es.keyRegs.size = 0 + · simp [executeArray, execute, Owner.toState, PackedConstruction.ExecState.abstract, hz] + · simp [executeArray, execute, Owner.toState, PackedConstruction.ExecState.abstract, + PackedConstruction.State.next, hz] + simpa only [Array.getD_eq_getD_getElem?] using lookup_pop es.keyRegs 0 (by omega) + +def executeBoundaryArray : Boundary → Owner → Owner + | .left value, es => { es with regs := es.regs.setIfInBounds requestLeftRegister value } + | .right value, es => { es with regs := es.regs.setIfInBounds requestRightRegister value } + | .entry target, es => { es with pc := target } + | .activate, es => { es with status := .running } + +theorem executeBoundaryArray_toState (b : Boundary) (es : Owner) + (h : b.DestinationsFit es) : + (executeBoundaryArray b es).toState = executeBoundary b es.toState := by + cases b <;> simp only [executeBoundaryArray, executeBoundary, Owner.toState, + PackedConstruction.ExecState.abstract] + · rw [lookup_set _ _ _ _ h] + · rw [lookup_set _ _ _ _ h] + +theorem Owner.closed (es : Owner) : es.toState.Closed := by + refine ⟨es.abstract_cleanTail, ?_, ?_⟩ + · intro a ha + change es.keys.getD a none = none + simp [Array.getD_eq_getD_getElem?, Array.getElem?_eq_none ha] + · intro a ha + change es.keyRegs.getD a 0 = 0 + simp [Array.getD_eq_getD_getElem?, Array.getElem?_eq_none ha] + +theorem Owner.key_banks_empty (es : Owner) + (hk : es.toState.keyExtent = 0) (hr : es.toState.keyRegExtent = 0) : + es.keys = #[] ∧ es.keyRegs = #[] := + ⟨Array.eq_empty_of_size_eq_zero hk, Array.eq_empty_of_size_eq_zero hr⟩ + +theorem Owner.numeric_register_tail (es : Owner) (r : Nat) (h : es.regs.size ≤ r) : + es.toState.core.regs r = 0 := by + change es.regs.getD r 0 = 0 + simp [Array.getD_eq_getD_getElem?, Array.getElem?_eq_none h] + +theorem executeArray_regs_size (i : Instruction) (es : Owner) : + (executeArray i es).regs.size = es.regs.size := by + cases i with + | old p => exact (oldArray_bank_sizes p es).1 + | releaseCell => simp [executeArray]; split <;> rfl + | releaseKey => simp [executeArray]; split <;> rfl + | releaseKeyRegister => simp [executeArray]; split <;> rfl + +theorem executeBoundaryArray_regs_size (b : Boundary) (es : Owner) : + (executeBoundaryArray b es).regs.size = es.regs.size := by + cases b <;> simp [executeBoundaryArray] + +/-- Optional validation observations preserve full producing states and action +identity. They are never fields of the retained owner. -/ +structure ArrayTransition where + before : Owner + action : Action + after : Owner + +def ArrayTransition.toTransition (t : ArrayTransition) : Transition := + ⟨t.before.toState, t.action, t.after.toState⟩ + +def stepArray (program : Array Instruction) (es : Owner) : Option ArrayTransition := + if es.status = .running then + (program[es.pc]?).map fun i => ⟨es, .instruction i, executeArray i es⟩ + else none + +def boundaryStepArray (b : Boundary) (es : Owner) : Option ArrayTransition := + match es.status with + | .halted _ => some ⟨es, .boundary b, executeBoundaryArray b es⟩ + | _ => none + +def StepDestinationsFit (program : Array Instruction) (es : Owner) : Prop := + ∀ i, es.status = .running → program[es.pc]? = some i → i.DestinationsFit es + +theorem stepArray_toState (program : List Instruction) (es : Owner) + (h : StepDestinationsFit program.toArray es) : + (stepArray program.toArray es).map ArrayTransition.toTransition = step program es.toState := by + by_cases hs : es.status = .running + · cases hf : program[es.pc]? with + | none => simp [stepArray, step, hs, hf] + | some i => + have hi : i.DestinationsFit es := h i hs (by simpa using hf) + simp [stepArray, step, hs, hf, ArrayTransition.toTransition, executeArray_toState i es hi] + · simp [stepArray, step, hs] + +theorem boundaryStepArray_toState (b : Boundary) (es : Owner) + (h : b.DestinationsFit es) : + (boundaryStepArray b es).map ArrayTransition.toTransition = boundaryStep b es.toState := by + cases hs : es.status <;> + simp [boundaryStepArray, boundaryStep, hs, ArrayTransition.toTransition, + executeBoundaryArray_toState b es h] + +structure ArrayRun where + final : Owner + transitions : List ArrayTransition + +def ArrayRun.toRun (r : ArrayRun) : Run := + ⟨r.final.toState, r.transitions.map ArrayTransition.toTransition⟩ + +def runArray (program : Array Instruction) : Nat → Owner → ArrayRun + | 0, es => ⟨es, []⟩ + | fuel + 1, es => + match stepArray program es with + | none => ⟨es, []⟩ + | some t => let rest := runArray program fuel t.after + ⟨rest.final, t :: rest.transitions⟩ + +/-- Bounds only on destinations of instructions actually encountered. This +condition contains no answer, memory-equality or completion assumption. -/ +def RunDestinationsFit (program : Array Instruction) : Nat → Owner → Prop + | 0, _ => True + | fuel + 1, es => StepDestinationsFit program es ∧ + match stepArray program es with + | none => True + | some t => RunDestinationsFit program fuel t.after + +theorem runArray_toState (program : List Instruction) (fuel : Nat) (es : Owner) + (h : RunDestinationsFit program.toArray fuel es) : + (runArray program.toArray fuel es).toRun = run program fuel es.toState := by + induction fuel generalizing es with + | zero => rfl + | succ fuel ih => + obtain ⟨hstep, hrest⟩ := h + have hs := stepArray_toState program es hstep + cases he : stepArray program.toArray es with + | none => + have ha : step program es.toState = none := by simpa [he] using hs.symm + simp [runArray, run, he, ha, ArrayRun.toRun] + | some t => + have ha : step program es.toState = some t.toTransition := by simpa [he] using hs.symm + have hr := ih t.after (by simpa [he] using hrest) + simpa only [runArray, he, run, ha, ArrayRun.toRun, List.map_cons, + ArrayTransition.toTransition] using + congrArg (fun r : Run => Run.mk r.final (t.toTransition :: r.transitions)) hr + +def runBoundaryArray : List Boundary → Owner → ArrayRun + | [], es => ⟨es, []⟩ + | b :: bs, es => + match boundaryStepArray b es with + | none => ⟨es, []⟩ + | some t => let rest := runBoundaryArray bs t.after + ⟨rest.final, t :: rest.transitions⟩ + +def BoundaryRunDestinationsFit : List Boundary → Owner → Prop + | [], _ => True + | b :: bs, es => b.DestinationsFit es ∧ + match boundaryStepArray b es with + | none => True + | some t => BoundaryRunDestinationsFit bs t.after + +theorem runBoundaryArray_toState (bs : List Boundary) (es : Owner) + (h : BoundaryRunDestinationsFit bs es) : + (runBoundaryArray bs es).toRun = runBoundary bs es.toState := by + induction bs generalizing es with + | nil => rfl + | cons b bs ih => + obtain ⟨hb, hrest⟩ := h + have hs := boundaryStepArray_toState b es hb + cases he : boundaryStepArray b es with + | none => + have ha : boundaryStep b es.toState = none := by simpa [he] using hs.symm + simp [runBoundaryArray, runBoundary, he, ha, ArrayRun.toRun] + | some t => + have ha : boundaryStep b es.toState = some t.toTransition := by simpa [he] using hs.symm + have hr := ih t.after (by simpa [he] using hrest) + simpa only [runBoundaryArray, he, runBoundary, ha, ArrayRun.toRun, List.map_cons, + ArrayTransition.toTransition] using + congrArg (fun r : Run => Run.mk r.final (t.toTransition :: r.transitions)) hr + +/-- Production execution retains only the next owner, never a trace list. -/ +def runOwner (program : Array Instruction) : Nat → Owner → Owner + | 0, es => es + | fuel + 1, es => + match stepArray program es with + | none => es + | some t => runOwner program fuel t.after + +theorem runOwner_projection (program : Array Instruction) (fuel : Nat) (es : Owner) : + runOwner program fuel es = (runArray program fuel es).final := by + induction fuel generalizing es with + | zero => rfl + | succ fuel ih => + cases h : stepArray program es <;> simp [runOwner, runArray, h, ih] + +def runBoundaryOwner : List Boundary → Owner → Owner + | [], es => es + | b :: bs, es => + match boundaryStepArray b es with + | none => es + | some t => runBoundaryOwner bs t.after + +theorem runBoundaryOwner_projection (bs : List Boundary) (es : Owner) : + runBoundaryOwner bs es = (runBoundaryArray bs es).final := by + induction bs generalizing es with + | nil => rfl + | cons b bs ih => + cases h : boundaryStepArray b es <;> simp [runBoundaryOwner, runBoundaryArray, h, ih] + +/-- These read/reply observations are computed at the producing array state, +including failed reads and repeated equal addresses. -/ +def ArrayTransition.read? (t : ArrayTransition) : Option (Nat × Option Nat) := + match t.action with + | .instruction (.old (.load _ address)) => + let a := t.before.regs.getD address 0 + some (a, if a < t.before.memory.size then t.before.memory.getD a none else none) + | _ => none + +def ArrayTransition.write? (t : ArrayTransition) : Option (Nat × Nat) := + match t.action with + | .instruction (.old (.store address value)) => + if t.before.regs.getD address 0 < t.before.memory.size then + some (t.before.regs.getD address 0, t.before.regs.getD value 0) else none + | _ => none + +theorem ArrayTransition.read_toTransition (t : ArrayTransition) : + t.toTransition.read? = t.read? := rfl + +theorem ArrayTransition.write_toTransition (t : ArrayTransition) : + t.toTransition.write? = t.write? := rfl + +def ArrayRun.steps (r : ArrayRun) : Nat := r.transitions.length +def ArrayRun.categories (r : ArrayRun) : List Category := r.transitions.map (·.action.category) +def ArrayRun.categoryCount (r : ArrayRun) (c : Category) : Nat := r.categories.count c +def ArrayRun.reads (r : ArrayRun) : List (Nat × Option Nat) := r.transitions.filterMap ArrayTransition.read? +def ArrayRun.writes (r : ArrayRun) : List (Nat × Nat) := r.transitions.filterMap ArrayTransition.write? + +theorem ArrayRun.observations_toRun (r : ArrayRun) : + r.toRun.steps = r.steps ∧ r.toRun.categories = r.categories ∧ + r.toRun.reads = r.reads ∧ r.toRun.writes = r.writes := by + simp [ArrayRun.toRun, Run.steps, Run.categories, Run.reads, Run.writes, + ArrayRun.steps, ArrayRun.categories, ArrayRun.reads, ArrayRun.writes, + List.map_map, List.filterMap_map, ArrayTransition.toTransition] + exact ⟨rfl, rfl⟩ + +/-- The equalities concern the actual ordered whole run, not a second replay. +The stronger `runArray_toState` also preserves every positional pre/post state. -/ +theorem runArray_observations (program : List Instruction) (fuel : Nat) (es : Owner) + (h : RunDestinationsFit program.toArray fuel es) : + (runArray program.toArray fuel es).steps = (run program fuel es.toState).steps ∧ + (runArray program.toArray fuel es).categories = (run program fuel es.toState).categories ∧ + (runArray program.toArray fuel es).reads = (run program fuel es.toState).reads ∧ + (runArray program.toArray fuel es).writes = (run program fuel es.toState).writes := by + have hr := runArray_toState program fuel es h + obtain ⟨hs, hc, hread, hw⟩ := (runArray program.toArray fuel es).observations_toRun + rw [hr] at hs hc hread hw + exact ⟨hs.symm, hc.symm, hread.symm, hw.symm⟩ + +theorem runArray_categoryCount (program : List Instruction) (fuel : Nat) (es : Owner) + (h : RunDestinationsFit program.toArray fuel es) (c : Category) : + (runArray program.toArray fuel es).categoryCount c = + (run program fuel es.toState).categoryCount c := by + simp only [ArrayRun.categoryCount, Run.categoryCount, (runArray_observations program fuel es h).2.1] + +theorem runArray_occurrence (program : List Instruction) (fuel : Nat) (es : Owner) + (h : RunDestinationsFit program.toArray fuel es) (k : Nat) : + ((runArray program.toArray fuel es).transitions[k]?).map ArrayTransition.toTransition = + (run program fuel es.toState).transitions[k]? := by + simpa [ArrayRun.toRun] using + congrArg (fun r : Run => r.transitions[k]?) (runArray_toState program fuel es h) + +theorem runBoundaryArray_observations (bs : List Boundary) (es : Owner) + (h : BoundaryRunDestinationsFit bs es) : + (runBoundaryArray bs es).steps = (runBoundary bs es.toState).steps ∧ + (runBoundaryArray bs es).categories = (runBoundary bs es.toState).categories ∧ + (runBoundaryArray bs es).reads = (runBoundary bs es.toState).reads ∧ + (runBoundaryArray bs es).writes = (runBoundary bs es.toState).writes := by + have hr := runBoundaryArray_toState bs es h + obtain ⟨hs, hc, hread, hw⟩ := (runBoundaryArray bs es).observations_toRun + rw [hr] at hs hc hread hw + exact ⟨hs.symm, hc.symm, hread.symm, hw.symm⟩ + +theorem runOwner_toState (program : List Instruction) (fuel : Nat) (es : Owner) + (h : RunDestinationsFit program.toArray fuel es) : + (runOwner program.toArray fuel es).toState = (run program fuel es.toState).final := by + rw [runOwner_projection] + exact congrArg Run.final (runArray_toState program fuel es h) + +theorem runOwner_retired_keys (program : List Instruction) (fuel : Nat) (es : Owner) + (h : RunDestinationsFit program.toArray fuel es) + (hk : (run program fuel es.toState).final.keyExtent = 0) + (hr : (run program fuel es.toState).final.keyRegExtent = 0) : + (runOwner program.toArray fuel es).keys = #[] ∧ + (runOwner program.toArray fuel es).keyRegs = #[] := by + apply Owner.key_banks_empty + · rw [runOwner_toState program fuel es h]; exact hk + · rw [runOwner_toState program fuel es h]; exact hr + +def requestProtocolArray (entry : Operand) (left right : Nat) (es : Owner) : ArrayRun := + runBoundaryArray [.left left, .right right, .entry entry, .activate] es + +def requestProtocolOwner (entry : Operand) (left right : Nat) (es : Owner) : Owner := + runBoundaryOwner [.left left, .right right, .entry entry, .activate] es + +theorem requestProtocolArray_bounds (entry : Operand) (left right : Nat) (es : Owner) + (hl : requestLeftRegister < es.regs.size) (hr : requestRightRegister < es.regs.size) : + BoundaryRunDestinationsFit [.left left, .right right, .entry entry, .activate] es := by + cases hs : es.status <;> + simp [BoundaryRunDestinationsFit, Boundary.DestinationsFit, boundaryStepArray, + executeBoundaryArray, hs, hl, hr] + +theorem requestProtocolArray_toState (entry : Operand) (left right : Nat) (es : Owner) + (hl : requestLeftRegister < es.regs.size) (hr : requestRightRegister < es.regs.size) : + (requestProtocolArray entry left right es).toRun = requestProtocol entry left right es.toState := + runBoundaryArray_toState _ es (requestProtocolArray_bounds entry left right es hl hr) + +theorem requestProtocolOwner_toState (entry : Operand) (left right : Nat) (es : Owner) + (hl : requestLeftRegister < es.regs.size) (hr : requestRightRegister < es.regs.size) : + (requestProtocolOwner entry left right es).toState = + (requestProtocol entry left right es.toState).final := by + rw [requestProtocolOwner, runBoundaryOwner_projection] + exact congrArg Run.final (requestProtocolArray_toState entry left right es hl hr) + +/-! ## Exact numeric-bank capacity and destination-bound transport -/ + +theorem stepArray_spec {program : Array Instruction} {es : Owner} {t : ArrayTransition} + (h : stepArray program es = some t) : + t.before = es ∧ es.status = .running ∧ + ∃ i, program[es.pc]? = some i ∧ t.action = .instruction i ∧ + t.after = executeArray i es := by + simp only [stepArray] at h + split at h + next hs => + cases hf : program[es.pc]? with + | none => simp [hf] at h + | some i => + simp [hf] at h + subst t + exact ⟨rfl, hs, i, rfl, rfl, rfl⟩ + next => simp at h + +theorem stepArray_regs_size {program : Array Instruction} {es : Owner} {t : ArrayTransition} + (h : stepArray program es = some t) : t.after.regs.size = es.regs.size := by + obtain ⟨_, _, i, _, _, he⟩ := stepArray_spec h + rw [he, executeArray_regs_size] + +theorem runOwner_regs_size (program : Array Instruction) (fuel : Nat) (es : Owner) : + (runOwner program fuel es).regs.size = es.regs.size := by + induction fuel generalizing es with + | zero => rfl + | succ fuel ih => + cases h : stepArray program es with + | none => simp [runOwner, h] + | some t => + simpa [runOwner, h] using (ih t.after).trans (stepArray_regs_size h) + +theorem runArray_regs_size (program : Array Instruction) (fuel : Nat) (es : Owner) : + (runArray program fuel es).final.regs.size = es.regs.size := by + rw [← runOwner_projection] + exact runOwner_regs_size program fuel es + +/-- Numeric bank capacity is preserved at every producing state, not only at +the final abstraction where this finite-container size is erased. -/ +theorem runArray_occurrence_regs_size {program : Array Instruction} {fuel : Nat} {es : Owner} + {k : Nat} {t : ArrayTransition} (h : (runArray program fuel es).transitions[k]? = some t) : + t.before.regs.size = es.regs.size ∧ t.after.regs.size = es.regs.size := by + induction fuel generalizing es k with + | zero => simp [runArray] at h + | succ fuel ih => + cases hs : stepArray program es with + | none => simp [runArray, hs] at h + | some first => + cases k with + | zero => + simp only [runArray, hs, List.getElem?_cons_zero, Option.some.injEq] at h + subst t + exact ⟨congrArg (fun x : Owner => x.regs.size) (stepArray_spec hs).1, + stepArray_regs_size hs⟩ + | succ k => + simp only [runArray, hs, List.getElem?_cons_succ] at h + obtain ⟨hb, ha⟩ := ih h + exact ⟨hb.trans (stepArray_regs_size hs), ha.trans (stepArray_regs_size hs)⟩ + +theorem boundaryStepArray_regs_size {b : Boundary} {es : Owner} {t : ArrayTransition} + (h : boundaryStepArray b es = some t) : + t.before.regs.size = es.regs.size ∧ t.after.regs.size = es.regs.size := by + cases hs : es.status <;> simp [boundaryStepArray, hs] at h + subst t + exact ⟨rfl, executeBoundaryArray_regs_size b es⟩ + +theorem runBoundaryOwner_regs_size (bs : List Boundary) (es : Owner) : + (runBoundaryOwner bs es).regs.size = es.regs.size := by + induction bs generalizing es with + | nil => rfl + | cons b bs ih => + cases h : boundaryStepArray b es with + | none => simp [runBoundaryOwner, h] + | some t => + simpa [runBoundaryOwner, h] using (ih t.after).trans (boundaryStepArray_regs_size h).2 + +theorem runBoundaryArray_regs_size (bs : List Boundary) (es : Owner) : + (runBoundaryArray bs es).final.regs.size = es.regs.size := by + rw [← runBoundaryOwner_projection] + exact runBoundaryOwner_regs_size bs es + +theorem runBoundaryArray_occurrence_regs_size {bs : List Boundary} {es : Owner} + {k : Nat} {t : ArrayTransition} (h : (runBoundaryArray bs es).transitions[k]? = some t) : + t.before.regs.size = es.regs.size ∧ t.after.regs.size = es.regs.size := by + induction bs generalizing es k with + | nil => simp [runBoundaryArray] at h + | cons b bs ih => + cases hs : boundaryStepArray b es with + | none => simp [runBoundaryArray, hs] at h + | some first => + cases k with + | zero => + simp only [runBoundaryArray, hs, List.getElem?_cons_zero, Option.some.injEq] at h + subst t + exact boundaryStepArray_regs_size hs + | succ k => + simp only [runBoundaryArray, hs, List.getElem?_cons_succ] at h + obtain ⟨hb, ha⟩ := ih h + exact ⟨hb.trans (boundaryStepArray_regs_size hs).2, + ha.trans (boundaryStepArray_regs_size hs).2⟩ + +theorem requestProtocolOwner_regs_size (entry : Operand) (left right : Nat) (es : Owner) : + (requestProtocolOwner entry left right es).regs.size = es.regs.size := + runBoundaryOwner_regs_size _ es + +theorem requestProtocolArray_regs_size (entry : Operand) (left right : Nat) (es : Owner) : + (requestProtocolArray entry left right es).final.regs.size = es.regs.size := + runBoundaryArray_regs_size _ es + +/-- A destination bound stated on the abstract execution. `R` is the separately +counted numeric bank; the current key-register extent is part of `State`. -/ +def Instruction.AbstractDestinationsFit (i : Instruction) (R : Nat) (s : State) : Prop := + match i with + | .old p => destinationsBelow R s.keyRegExtent p + | _ => True + +theorem Instruction.destinationsFit_of_abstract (i : Instruction) (es : Owner) (R : Nat) + (hR : es.regs.size = R) (h : i.AbstractDestinationsFit R es.toState) : + i.DestinationsFit es := by + cases i with + | old p => + simpa [Instruction.DestinationsFit, Instruction.AbstractDestinationsFit, + Owner.toState, hR] using h + | releaseCell | releaseKey | releaseKeyRegister => trivial + +/-- Every actual occurrence has a destination in its own bank. Code operands +that are only read are not required for this refinement; their word/address +encoding bounds remain a separate whole-machine obligation. -/ +def TraceDestinationsFit (R : Nat) (ts : List Transition) : Prop := + ∀ (k : Nat) (t : Transition), ts[k]? = some t → ∀ (i : Instruction), t.action = .instruction i → + i.AbstractDestinationsFit R t.before + +/-- Independently established abstract trace bounds imply executable bounds. +No executable guard or final abstraction equality is assumed as a field. -/ +theorem runDestinationsFit_of_abstract (program : List Instruction) (fuel : Nat) + (es : Owner) (R : Nat) (hR : es.regs.size = R) + (htrace : TraceDestinationsFit R (run program fuel es.toState).transitions) : + RunDestinationsFit program.toArray fuel es := by + induction fuel generalizing es with + | zero => trivial + | succ fuel ih => + have hstep : StepDestinationsFit program.toArray es := by + intro i hrun hfetch + have hf : program[es.pc]? = some i := by simpa using hfetch + have hs : step program es.toState = + some ⟨es.toState, .instruction i, execute i es.toState⟩ := + step_of_running (by simpa using hrun) (by simpa using hf) + have hi := htrace 0 ⟨es.toState, .instruction i, execute i es.toState⟩ + (by simp [run, hs]) i rfl + exact i.destinationsFit_of_abstract es R hR hi + refine ⟨hstep, ?_⟩ + cases hs : stepArray program.toArray es with + | none => trivial + | some t => + have ha : step program es.toState = some t.toTransition := by + simpa [hs] using (stepArray_toState program es hstep).symm + apply ih t.after ((stepArray_regs_size hs).trans hR) + intro k a hpos i hi + apply htrace (k + 1) a ?_ i hi + simpa [run, ha, ArrayTransition.toTransition] using hpos + +theorem runArray_toState_of_abstract (program : List Instruction) (fuel : Nat) + (es : Owner) (R : Nat) (hR : es.regs.size = R) + (htrace : TraceDestinationsFit R (run program fuel es.toState).transitions) : + (runArray program.toArray fuel es).toRun = run program fuel es.toState ∧ + (runArray program.toArray fuel es).final.regs.size = R := + ⟨runArray_toState program fuel es (runDestinationsFit_of_abstract program fuel es R hR htrace), + (runArray_regs_size program.toArray fuel es).trans hR⟩ + +theorem runOwner_toState_of_abstract (program : List Instruction) (fuel : Nat) + (es : Owner) (R : Nat) (hR : es.regs.size = R) + (htrace : TraceDestinationsFit R (run program fuel es.toState).transitions) : + (runOwner program.toArray fuel es).toState = (run program fuel es.toState).final ∧ + (runOwner program.toArray fuel es).regs.size = R := + ⟨runOwner_toState program fuel es (runDestinationsFit_of_abstract program fuel es R hR htrace), + (runOwner_regs_size program.toArray fuel es).trans hR⟩ + +/-! Tiny executable controls use directly specified expected values. They run +this array layer, preserve repeated read occurrences, retire both key banks and +reuse the halted owner through the charged boundary. -/ + +private def toyOwner : Owner := + ⟨Array.replicate 302 0, #[some 9, some 17], #[some (-2)], #[0], 0, .running⟩ + +private def toyProgram : Array Instruction := + #[.old (.loadKey 0 0), .old (.load 1 0), .old (.load 1 0), + .releaseCell, .releaseKey, .releaseKeyRegister, .old (.halt 1)] + +#guard (runArray toyProgram 10 toyOwner).steps = 7 +#guard (runArray toyProgram 10 toyOwner).reads = [(0, some 9), (0, some 9)] +#guard (runArray toyProgram 10 toyOwner).categories = + [.old .keyRead, .old .read, .old .read, .numericRelease, .keyRelease, + .keyRegisterRelease, .old .control] +#guard (runOwner toyProgram 10 toyOwner).memory = #[some 9] +#guard (runOwner toyProgram 10 toyOwner).keys.isEmpty +#guard (runOwner toyProgram 10 toyOwner).keyRegs.isEmpty +#guard (runOwner toyProgram 10 toyOwner).status = .halted 9 +#guard (requestProtocolArray 0 0 1 (runOwner toyProgram 10 toyOwner)).steps = 4 +#guard (requestProtocolArray 0 0 1 (runOwner toyProgram 10 toyOwner)).categories = + [.requestAdmission, .requestAdmission, .controlEntry, .controlEntry] +#guard (runOwner #[.old (.load 1 300), .old (.halt 1)] 2 + (requestProtocolOwner 0 0 1 (runOwner toyProgram 10 toyOwner))).status = .halted 9 +#guard (boundaryStepArray .activate toyOwner).isNone +#guard (executeArray .releaseCell { toyOwner with memory := #[] }).status = .fault +#guard (executeArray .releaseKey { toyOwner with keys := #[] }).status = .fault +#guard (executeArray .releaseKeyRegister { toyOwner with keyRegs := #[] }).status = .fault +#guard (runArray #[.old (.load 1 0)] 1 { toyOwner with memory := #[] }).reads = [(0, none)] + +end RMQ.SuccinctFinal.PackedLifecycle diff --git a/RMQ/Core/WordRAM/Lifecycle/BoundarySafety.lean b/RMQ/Core/WordRAM/Lifecycle/BoundarySafety.lean new file mode 100644 index 00000000..55870644 --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/BoundarySafety.lean @@ -0,0 +1,120 @@ +import RMQ.Core.WordRAM.Lifecycle.Safety + +/-! # Represented charged request admission + +Instruction safety and external boundary safety are separate cases of the +whole trace. The boundary's fixed entry and finite destination bank are explicit. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle + +def Boundary.Safe (W len bank entry : Nat) : Boundary → Prop + | .left v => requestLeftRegister < bank ∧ v < 2^W + | .right v => requestRightRegister < bank ∧ v < 2^W + | .entry target => target.val = entry ∧ entry < len ∧ entry < 2^W + | .activate => True + +def Transition.ActionSafe (W len bank entry : Nat) (t : Transition) : Prop := + t.Safe W len ∨ ∃ b, t.action = .boundary b ∧ b.Safe W len bank entry + +theorem instruction_action_safe {W len bank entry : Nat} {t : Transition} + (h : t.Safe W len) : t.ActionSafe W len bank entry := Or.inl h + +theorem boundary_execute_fits {W len bank entry : Nat} {s : State} {b : Boundary} + (fit : s.Fits W) (safe : b.Safe W len bank entry) : (executeBoundary b s).Fits W := by + obtain ⟨⟨hr, hp, he, hm, hh⟩, hk, hkr⟩ := fit + cases b with + | left v => + refine ⟨⟨?_, hp, he, hm, hh⟩, hk, hkr⟩ + intro r + change (PackedConstruction.put s.core.regs requestLeftRegister v) r < 2^W + by_cases h : r = requestLeftRegister + · simpa [PackedConstruction.put, h] using safe.2 + · simpa [PackedConstruction.put, h] using hr r + | right v => + refine ⟨⟨?_, hp, he, hm, hh⟩, hk, hkr⟩ + intro r + change (PackedConstruction.put s.core.regs requestRightRegister v) r < 2^W + by_cases h : r = requestRightRegister + · simpa [PackedConstruction.put, h] using safe.2 + · simpa [PackedConstruction.put, h] using hr r + | entry target => + refine ⟨⟨hr, ?_, he, hm, hh⟩, hk, hkr⟩ + change target.val < 2^W + rw [safe.1] + exact safe.2.2 + | activate => exact ⟨⟨hr, hp, he, hm, fun _ h => by cases h⟩, hk, hkr⟩ + +theorem boundary_execute_closed (b : Boundary) (s : State) (closed : s.Closed) : + (executeBoundary b s).Closed := by cases b <;> exact closed + +theorem boundary_execute_tail {W len bank entry : Nat} {s : State} {b : Boundary} + (safe : b.Safe W len bank entry) (tail : ∀ r, bank ≤ r → s.core.regs r = 0) : + ∀ r, bank ≤ r → (executeBoundary b s).core.regs r = 0 := by + intro r hr + cases b with + | left v => simp [executeBoundary, PackedConstruction.put, + show r ≠ requestLeftRegister by have := safe.1; omega, tail r hr] + | right v => simp [executeBoundary, PackedConstruction.put, + show r ≠ requestRightRegister by have := safe.1; omega, tail r hr] + | entry target => exact tail r hr + | activate => exact tail r hr + +theorem runBoundary_safe {W len bank entry : Nat} (bs : List Boundary) (s : State) + (allSafe : ∀ b ∈ bs, b.Safe W len bank entry) (fit : s.Fits W) (closed : s.Closed) + (tail : ∀ r, bank ≤ r → s.core.regs r = 0) : + (runBoundary bs s).final.Fits W ∧ (runBoundary bs s).final.Closed ∧ + (∀ r, bank ≤ r → (runBoundary bs s).final.core.regs r = 0) ∧ + ∀ t ∈ (runBoundary bs s).transitions, + t.ActionSafe W len bank entry ∧ t.before.Fits W ∧ t.after.Fits W ∧ + t.before.Closed ∧ t.after.Closed := by + induction bs generalizing s with + | nil => exact ⟨fit, closed, tail, fun _ h => by cases h⟩ + | cons b bs ih => + have hb := allSafe b (by simp) + have restSafe : ∀ c ∈ bs, c.Safe W len bank entry := fun c hc => allSafe c (by simp [hc]) + cases hs : s.core.status with + | running => simpa [runBoundary, boundaryStep, hs] using + (show s.Fits W ∧ s.Closed ∧ (∀ r, bank ≤ r → s.core.regs r = 0) ∧ + ∀ t ∈ ([] : List Transition), t.ActionSafe W len bank entry ∧ + t.before.Fits W ∧ t.after.Fits W ∧ t.before.Closed ∧ t.after.Closed from + ⟨fit, closed, tail, fun _ h => by cases h⟩) + | fault => simpa [runBoundary, boundaryStep, hs] using + (show s.Fits W ∧ s.Closed ∧ (∀ r, bank ≤ r → s.core.regs r = 0) ∧ + ∀ t ∈ ([] : List Transition), t.ActionSafe W len bank entry ∧ + t.before.Fits W ∧ t.after.Fits W ∧ t.before.Closed ∧ t.after.Closed from + ⟨fit, closed, tail, fun _ h => by cases h⟩) + | halted value => + have hf := boundary_execute_fits fit hb + have hc := boundary_execute_closed b s closed + have ht := boundary_execute_tail hb tail + have rest := ih (executeBoundary b s) restSafe hf hc ht + simp only [runBoundary, boundaryStep, hs] + refine ⟨rest.1, rest.2.1, rest.2.2.1, ?_⟩ + intro t hm + simp only [List.mem_cons] at hm + rcases hm with rfl | hm + · exact ⟨Or.inr ⟨b, rfl, hb⟩, fit, hf, closed, hc⟩ + · exact rest.2.2.2 t hm + +theorem requestProtocol_safe {W len bank : Nat} (entry : PackedConstruction.Operand) + (left right : Nat) (s : State) + (hl : left < 2^W) (hr : right < 2^W) (he : entry.val < len) (hw : entry.val < 2^W) + (hbank : 301 < bank) (fit : s.Fits W) (closed : s.Closed) + (tail : ∀ r, bank ≤ r → s.core.regs r = 0) : + (requestProtocol entry left right s).final.Fits W ∧ + (requestProtocol entry left right s).final.Closed ∧ + (∀ r, bank ≤ r → (requestProtocol entry left right s).final.core.regs r = 0) ∧ + ∀ t ∈ (requestProtocol entry left right s).transitions, + t.ActionSafe W len bank entry.val ∧ t.before.Fits W ∧ t.after.Fits W ∧ + t.before.Closed ∧ t.after.Closed := by + apply runBoundary_safe _ s _ fit closed tail + intro b hb + simp only [List.mem_cons, List.not_mem_nil, or_false] at hb + rcases hb with rfl | rfl | rfl | rfl + · exact ⟨by change 300 < bank; omega, hl⟩ + · exact ⟨hbank, hr⟩ + · exact ⟨rfl, he, hw⟩ + · trivial + +end RMQ.SuccinctFinal.PackedLifecycle diff --git a/RMQ/Core/WordRAM/Lifecycle/Builder.lean b/RMQ/Core/WordRAM/Lifecycle/Builder.lean new file mode 100644 index 00000000..54bde55b --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/Builder.lean @@ -0,0 +1,287 @@ +import RMQ.Core.WordRAM.Lifecycle.BuilderProvenance +import RMQ.Core.WordRAM.Construction.Proof.Static +import RMQ.Core.WordRAM.Packed.Setup +import RMQ.Core.WordRAM.Packed.Width + +/-! # Live hosted construction for the continuous lifecycle + +This adapter consumes the existing builder source at its actual program offset. +It exports the still-running state, its exact canonical output interval, and the +reservation occurrence that produced register 3. Input materialization and the +later charged descriptor transfer remain separate operations. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle.Builder + +open PackedConstruction PackedConstruction.Structured PackedConstruction.Proof +open PackedConstruction.Builder +open PackedWordRAM (buildMemory wordWidth) + +theorem metadata_zero (xs : List Int) : (buildMemory xs)[0]? = some xs.length := by + rw [PackedWordRAM.buildMemory_metadata_prefix xs 0 (by decide)] + simp [PackedWordRAM.metadata, PackedWordRAM.scalarMetadata, + PackedCellProbe.packedReviewerCartesianShape_size] + +theorem metadata_seven (xs : List Int) : + (buildMemory xs)[7]? = some (buildMemory xs).length := by + rw [PackedWordRAM.buildMemory_metadata_prefix xs 7 (by decide)] + rw [buildMemory, PackedWordRAM.shapeMemory_length_eq] + simp [PackedWordRAM.metadata, PackedWordRAM.scalarMetadata] + +theorem metadata_length (xs : List Int) : 8 ≤ (buildMemory xs).length := by + have h := PackedWordRAM.shapeMemory_metadata_length_le (SuccinctClassic.cartesianShape xs) + change 174 ≤ (buildMemory xs).length at h + omega + +theorem regsBelow_writesOnly (b : Block) (R : Nat) (h : b.RegsBelow R) : + b.WritesOnly (fun r => r < R) := by + induction b with + | skip => trivial + | action op => exact Prim.dest_lt_of_registersBelow h + | exit src => trivial + | seq a b iha ihb => exact ⟨iha h.1, ihb h.2⟩ + | ifZero c a b iha ihb => exact ⟨iha h.2.1, ihb h.2.2⟩ + | loop c b ih => exact ih h.2 + +theorem prim_keyRegs_frame (p : Prim) (s : State) {R : Nat} + (h : p.RegistersBelow R) (r : Nat) (hr : R ≤ r) : + (execPrim p s).keyRegs r = s.keyRegs r := by + cases p <;> simp only [execPrim, State.writeNext, State.next] + case loadKey dst address => + have hne : r ≠ dst.val := by simp only [Prim.RegistersBelow] at h; omega + split <;> simp [put, hne] + case load dst address => + split + · split <;> rfl + · rfl + case store address value => split <;> rfl + all_goals rfl + +theorem eval_keyRegs_frame {P : State → Action → Prop} {b : Block} {s t : State} {k R : Nat} + (e : EvalG P b s t k) (h : b.RegsBelow R) (r : Nat) (hr : R ≤ r) : + t.keyRegs r = s.keyRegs r := by + induction e with + | stopped => rfl + | skip => rfl + | action op s _ _ => exact prim_keyRegs_frame op.prim s h r hr + | exit => rfl + | seq _ _ iha ihb => exact (ihb h.2).trans (iha h.1) + | ifZeroTaken _ _ _ ih => exact ih h.2.1 + | ifZeroFallthrough _ _ _ _ ih => exact ih h.2.2 + | ifZeroFallthroughStopped _ _ _ _ ih => exact ih h.2.2 + | loopExit => rfl + | loopStep _ _ _ _ _ ihb ihr => exact (ihr h).trans (ihb h.2) + | loopStopped _ _ _ _ ih => exact ih h.2 + +/-- A structural source inventory: one past its largest key-register write. +Control nodes combine inventories; this does not execute the source. -/ +def keyRegisterLimit : Block → Nat + | .action (.loadKey dst _) => dst.val+1 + | .seq a b | .ifZero _ a b => max (keyRegisterLimit a) (keyRegisterLimit b) + | .loop _ b => keyRegisterLimit b + | _ => 0 + +theorem action_keyRegister_frame (op : Action) (s : State) (r : Nat) + (outside : keyRegisterLimit (.action op) ≤ r) : + (execPrim op.prim s).keyRegs r = s.keyRegs r := by + cases op <;> simp only [Action.prim, execPrim, State.writeNext, State.next] + case loadKey dst address => + have hne : r ≠ dst.val := by simp only [keyRegisterLimit] at outside; omega + split <;> simp [put, hne] + case load dst address => + split + · split <;> rfl + · rfl + case store address value => split <;> rfl + all_goals rfl + +theorem eval_keyRegister_frame {P : State → Action → Prop} {b : Block} {s t : State} {k : Nat} + (e : EvalG P b s t k) (r : Nat) (outside : keyRegisterLimit b ≤ r) : + t.keyRegs r = s.keyRegs r := by + induction e with + | stopped => rfl + | skip => rfl + | action op s _ _ => exact action_keyRegister_frame op s r outside + | exit => rfl + | seq _ _ iha ihb => + exact (ihb (Nat.le_trans (Nat.le_max_right ..) outside)).trans + (iha (Nat.le_trans (Nat.le_max_left ..) outside)) + | ifZeroTaken _ _ _ ih => exact ih (Nat.le_trans (Nat.le_max_left ..) outside) + | ifZeroFallthrough _ _ _ _ ih => exact ih (Nat.le_trans (Nat.le_max_right ..) outside) + | ifZeroFallthroughStopped _ _ _ _ ih => exact ih (Nat.le_trans (Nat.le_max_right ..) outside) + | loopExit => rfl + | loopStep _ _ _ _ _ ihb ihr => exact (ihr outside).trans (ihb outside) + | loopStopped _ _ _ _ ih => exact ih outside + +set_option maxRecDepth 100000 in +theorem word_keyRegister_limit : keyRegisterLimit (builderSource wordLeaf) = 0 := rfl + +set_option maxRecDepth 100000 in +theorem comparison_keyRegister_limit : keyRegisterLimit (builderSource keyLeaf) = 2 := rfl + +/-- The live producer's state and trace facts, all about one hosted execution. -/ +structure HostedBody (W : Nat) (program : List BInstr) (base : Nat) (leaf : Block) + (xs : List Int) (s abstract final : State) (ts : List Transition) : Prop where + evaluation : SafeEval W (builderSource leaf) s abstract ts.length + intermediate : final = {abstract with pc := base+(builderSource leaf).size} + execution : RunsTo program s final ts + shapes : ∀ u ∈ ts, TransitionShape (Action.Safe W) base (builderSource leaf).size u + safe : Run.Safe W program ⟨final, ts⟩ + fits : final.Fits W + running : final.status = .running + pc : final.pc = base+(builderSource leaf).size + work : ts.length ≤ 3+(25*W+40+39*(5*W+20))+2100*(400000*(xs.length+1)) + baseLower : s.extent ≤ final.regs 3 + baseUpper : final.regs 3 ≤ s.extent+3200000*(xs.length+1) + extent : final.extent = final.regs 3+(buildMemory xs).length + cells : ∀ i, i < (buildMemory xs).length → + final.memory (final.regs 3+i) = some ((buildMemory xs).getD i 0) + inputFrame : ∀ a, a < s.extent → final.memory a = s.memory a + keys : final.keys = s.keys + cleanTail : CleanTail final + numericFrame : ∀ r, 400 ≤ r → final.regs r = s.regs r + keyFrame : ∀ r, 400 ≤ r → final.keyRegs r = s.keyRegs r + reservation : ReservationReceipt program s final ts 3 + +/-- The caller provides the actual live entry PC and supplied input predicate; +the body computes its output rather than receiving an output equality. -/ +theorem hosted_body {W : Nat} (hW : 32 ≤ W) (xs : List Int) (Inp : State → Prop) + (leaf : Block) (hleaf : KeySpec W xs Inp leaf) + (hbank : (builderBody leaf).RegsBelow 400) + (program : List BInstr) (base : Nat) (s : State) + (entry : s.pc = base) (hrun : s.status = .running) (hregs : ∀ r, s.regs r = 0) + (hext : 0 < s.extent) (hmem : s.memory 0 = some xs.length) + (hinp : Inp s) (hInp : InpBelow Inp s.extent) + (hbankcap : 2^32*(2*xs.length+4)^8 < 2^W) + (hcap : s.extent+64*(400000*(xs.length+1)) < 2^W) + (hWW : wordWidth xs.length ≤ W) + (host : HostedAt program base ((builderSource leaf).compileAt base)) + (bound : base+(builderSource leaf).size < 2^32) + (inside : base+(builderSource leaf).size < program.length) + (programFits : program.length < 2^W) (initialFits : s.Fits W) (tail : CleanTail s) : + ∃ abstract final ts, HostedBody W program base leaf xs s abstract final ts := by + obtain ⟨t, k, e, hk, hr, hlo, hhi, he, hm, hb, hkeys⟩ := + builderSource_spec hW xs Inp leaf hleaf s hrun hregs hext hmem hinp hInp hbankcap hcap hWW + obtain ⟨ts, hrunBody, len, receipt⟩ := + reservation_receipt e hr entry host bound (builder_reserve_path leaf) + obtain ⟨us, urun, ulen, shape⟩ := compile_running e hr program base host bound + have se : ({s with pc := base} : State) = s := by rw [← entry] + rw [se] at urun + have traces : us = ts := by + have a := urun + have b := hrunBody + unfold RunsTo at a b + rw [ulen] at a + rw [len] at b + exact congrArg Run.transitions (a.symm.trans b) + subst us + let final : State := {t with pc := base+(builderSource leaf).size} + have operational : run program ts.length s = ⟨final, ts⟩ := hrunBody + have safety := Run.Safe.of_transitions program W programFits ts.length s initialFits (by + rw [operational] + exact fun u hu => (shape u hu).safe hW inside) + have fit := safety.final_fits initialFits + rw [operational] at safety fit + have rb : (builderSource leaf).RegsBelow 400 := ⟨by + simp [Block.RegsBelow, Action.prim, Prim.RegistersBelow], hbank⟩ + refine ⟨t, final, ts, ⟨?_, rfl, hrunBody, shape, safety, fit, hr, rfl, ?_, hlo, ?_, he, hm, + hb, hkeys, ?_, ?_, ?_, receipt⟩⟩ + · simpa only [len] using e + · omega + · change t.regs 3 ≤ s.extent+3200000*(xs.length+1) + omega + · have h := run_cleanTail program ts.length s tail + rw [operational] at h + exact h + · intro r hr + exact PackedConstruction.Proof.EvalG.regs_frame e + (fun x => x < 400) (regsBelow_writesOnly _ _ rb) r (by omega) + · exact fun r hr => eval_keyRegs_frame e rb r hr + +theorem hosted_linear_work {program : List BInstr} {base : Nat} {leaf : Block} {xs : List Int} + {s abstract final : State} {ts : List Transition} + (h : HostedBody (wordWidth xs.length) program base leaf xs s abstract final ts) : + ts.length ≤ 1000000000*xs.length+1000000000 := by + have hw := h.work + have hb := budget_ge xs.length + rw [builderBudget_eq_mul_add] at hb + omega + +/-- The hosted builder's historical numeric extent is bounded before its +continuation starts; no property of code after that point is assumed. -/ +theorem hosted_peak {W base : Nat} {program : List BInstr} {leaf : Block} {xs : List Int} + {s abstract final : State} {ts : List Transition} + (h : HostedBody W program base leaf xs s abstract final ts) + (fuel : Nat) (hle : fuel ≤ ts.length) : + (run program fuel s).final.extent ≤ final.extent ∧ + (run program fuel s).final.extent ≤ + s.extent+3200000*(xs.length+1)+(buildMemory xs).length := by + have hm := run_extent_mono program (ts.length-fuel) (run program fuel s).final + have whole := h.execution + unfold RunsTo at whole + rw [← Nat.add_sub_of_le hle, run_add] at whole + have hf := congrArg (fun r : Run => r.final.extent) whole + dsimp only at hf + rw [hf] at hm + exact ⟨hm, by have := h.baseUpper; rw [h.extent] at hm; omega⟩ + +/-- Numeric finite support throughout the hosted body, including its endpoint. -/ +theorem hosted_numeric_prefix_frame {W base : Nat} {program : List BInstr} {leaf : Block} + {xs : List Int} {s abstract final : State} {ts : List Transition} + (h : HostedBody W program base leaf xs s abstract final ts) + (entry : s.pc = base) + (host : HostedAt program base ((builderSource leaf).compileAt base)) + (bound : base+(builderSource leaf).size < 2^32) + (bank : (builderBody leaf).RegsBelow 400) + (fuel : Nat) (hle : fuel ≤ ts.length) (r : Nat) (outside : 400 ≤ r) : + (run program fuel s).final.regs r = s.regs r := by + have rb : (builderSource leaf).RegsBelow 400 := ⟨by + simp [Block.RegsBelow, Action.prim, Prim.RegistersBelow], bank⟩ + have abstractRunning : abstract.status = .running := by + have hr := h.running + rw [h.intermediate] at hr + exact hr + obtain ⟨us, urun, ulen, frame⟩ := compile_running_frame h.evaluation abstractRunning + program base host bound (fun r => r < 400) (regsBelow_writesOnly _ _ rb) + have se : ({s with pc := base} : State) = s := by rw [← entry] + rw [se, ← h.intermediate] at urun + have traces : us = ts := by + have a := urun + unfold RunsTo at a + rw [ulen] at a + exact congrArg Run.transitions (a.symm.trans h.execution) + subst us + exact run_prefix_frame hle (fun r => r < 400) (by + rw [show run program ts.length s = ⟨final, ts⟩ from h.execution] + exact frame) r (by omega) + +theorem hosted_word_key_frame {W base : Nat} {program : List BInstr} {xs : List Int} + {s abstract final : State} {ts : List Transition} + (h : HostedBody W program base wordLeaf xs s abstract final ts) : + final.keyRegs = s.keyRegs := by + funext r + rw [h.intermediate] + exact eval_keyRegister_frame h.evaluation r (by rw [word_keyRegister_limit]; omega) + +theorem hosted_comparison_key_frame {W base : Nat} {program : List BInstr} {xs : List Int} + {s abstract final : State} {ts : List Transition} + (h : HostedBody W program base keyLeaf xs s abstract final ts) (r : Nat) (outside : 2 ≤ r) : + final.keyRegs r = s.keyRegs r := by + rw [h.intermediate] + exact eval_keyRegister_frame h.evaluation r (by rw [comparison_keyRegister_limit]; exact outside) + +/-- Both useful header words are present in the exact produced interval. -/ +theorem produced_metadata {W base : Nat} {program : List BInstr} {leaf : Block} {xs : List Int} + {s abstract final : State} {ts : List Transition} + (h : HostedBody W program base leaf xs s abstract final ts) : + final.memory (final.regs 3) = some xs.length ∧ + final.memory (final.regs 3+7) = some (buildMemory xs).length ∧ + final.regs 3+7 < final.extent := by + have hl := metadata_length xs + have h0 := h.cells 0 (by omega) + have h7 := h.cells 7 (by omega) + simp only [List.getD, metadata_zero, Option.getD_some, Nat.add_zero] at h0 + simp only [List.getD, metadata_seven, Option.getD_some] at h7 + exact ⟨h0, h7, by rw [h.extent]; omega⟩ + +end RMQ.SuccinctFinal.PackedLifecycle.Builder diff --git a/RMQ/Core/WordRAM/Lifecycle/BuilderProvenance.lean b/RMQ/Core/WordRAM/Lifecycle/BuilderProvenance.lean new file mode 100644 index 00000000..c81d6a1d --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/BuilderProvenance.lean @@ -0,0 +1,251 @@ +import RMQ.Core.WordRAM.Construction.Proof.RunFacts + +/-! # Positional output reservation in a hosted builder + +The source witness follows the output reservation through sequencing. Only its +suffix needs a register frame; no reduction of the complete compiled builder is +used. The resulting receipt names the actual producing state and trace position. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle.Builder + +open PackedConstruction PackedConstruction.Structured PackedConstruction.Proof +open PackedConstruction.Builder + +/-- A reserve action followed only by code that preserves its destination. -/ +inductive ReservePath (dst : Operand) : Block → Prop where + | here : ReservePath dst (.action (.reserve dst)) + | left {a b} : ReservePath dst a → b.WritesOnly (fun r => r ≠ dst.val) → + ReservePath dst (.seq a b) + | right {a b} : ReservePath dst b → ReservePath dst (.seq a b) + +theorem eval_add_writes {P : State → Action → Prop} {b : Block} {s t : State} {k : Nat} + (e : EvalG P b s t k) (allowed : Nat → Prop) (hw : b.WritesOnly allowed) : + EvalG (fun s op => P s op ∧ WritesOnly allowed ⟨op.prim⟩) b s t k := by + induction e with + | stopped b s h => exact .stopped b s h + | skip s h => exact .skip s h + | action op s h hp => exact .action op s h ⟨hp, hw⟩ + | exit src s h => exact .exit src s h + | seq _ _ iha ihb => exact .seq (iha hw.1) (ihb hw.2) + | ifZeroTaken h hc _ ih => exact .ifZeroTaken h hc (ih hw.1) + | ifZeroFallthrough h hc _ hr ih => exact .ifZeroFallthrough h hc (ih hw.2) hr + | ifZeroFallthroughStopped h hc _ hr ih => exact .ifZeroFallthroughStopped h hc (ih hw.2) hr + | loopExit h hc => exact .loopExit h hc + | loopStep h hc _ hr _ ihb ihr => exact .loopStep h hc (ihb hw) hr (ihr hw) + | loopStopped h hc _ hr ih => exact .loopStopped h hc (ih hw) hr + +theorem compile_running {W : Nat} {b : Block} {s t : State} {k : Nat} + (e : SafeEval W b s t k) (hr : t.status = .running) + (program : List BInstr) (base : Nat) + (host : HostedAt program base (b.compileAt base)) (bound : base+b.size < 2^32) : + ∃ ts, RunsTo program {s with pc := base} {t with pc := base+b.size} ts ∧ + ts.length = k ∧ ∀ u ∈ ts, TransitionShape (Action.Safe W) base b.size u := by + obtain ⟨mid, ts, hrun, hlen, ha, hp, shapes⟩ := e.compile_realizes + (fun _ q _ h => h.pc_set q) program base host bound + have hm : mid.status = .running := ha.status.trans hr + have he : mid = {t with pc := base+b.size} := by rw [ha.eq_set, hp hm] + exact ⟨ts, he ▸ hrun, hlen, shapes⟩ + +theorem compile_running_frame {W : Nat} {b : Block} {s t : State} {k : Nat} + (e : SafeEval W b s t k) (hr : t.status = .running) + (program : List BInstr) (base : Nat) + (host : HostedAt program base (b.compileAt base)) (bound : base+b.size < 2^32) + (allowed : Nat → Prop) (hw : b.WritesOnly allowed) : + ∃ ts, RunsTo program {s with pc := base} {t with pc := base+b.size} ts ∧ + ts.length = k ∧ ∀ u ∈ ts, WritesOnly allowed u.instruction := by + have ew := eval_add_writes e allowed hw + obtain ⟨mid, ts, hrun, hlen, ha, hp, shapes⟩ := ew.compile_realizes + (fun _ q _ h => ⟨h.1.pc_set q, h.2⟩) program base host bound + have hm : mid.status = .running := ha.status.trans hr + have he : mid = {t with pc := base+b.size} := by rw [ha.eq_set, hp hm] + refine ⟨ts, he ▸ hrun, hlen, ?_⟩ + intro u hu + rcases shapes u hu with ⟨op, hi, _, hw⟩ | ⟨c, target, hi, _⟩ | + ⟨target, hi, _⟩ | ⟨src, hi⟩ + · simpa [hi] using hw + all_goals simp [hi, WritesOnly, Prim.destination?] + +/-- Ordered segment factorization around the source reservation. -/ +theorem reserve_factor {dst : Operand} {b : Block} (path : ReservePath dst b) : + ∀ {W : Nat} {s t : State} {k : Nat}, SafeEval W b s t k → t.status = .running → + ∀ (program : List BInstr) (base : Nat), + HostedAt program base (b.compileAt base) → base+b.size < 2^32 → + ∃ pre before after, + RunsTo program {s with pc := base} pre before ∧ + pre.status = .running ∧ program[pre.pc]? = some ⟨.reserve dst⟩ ∧ + RunsTo program (execPrim (.reserve dst) pre) {t with pc := base+b.size} after ∧ + before.length+1+after.length = k ∧ + ∀ u ∈ after, WritesOnly (fun r => r ≠ dst.val) u.instruction := by + induction path with + | here => + intro W s t k e hr program base host bound + cases e with + | stopped _ _ hs => exact (hs hr).elim + | action op s hs hp => + refine ⟨{s with pc := base}, [], [], RunsTo.refl _ _, hs, host.head, ?_, rfl, ?_⟩ + · have he : execPrim (.reserve dst) {s with pc := base} = + {execPrim (.reserve dst) s with pc := base+1} := by + simp [execPrim, State.writeNext, State.next] + simpa only [Block.size, he] using + RunsTo.refl program (execPrim (.reserve dst) {s with pc := base}) + · intro u hu; cases hu + | @right a b path ih => + intro W s t k e hr program base host bound + cases e with + | stopped _ _ hs => exact (hs hr).elim + | @seq _ _ _ mid _ ka kb ea eb => + have hm := eb.running_of_result hr + have ha := host.append_left + have hb : HostedAt program (base+a.size) (b.compileAt (base+a.size)) := by + simpa only [Block.compile_length] using host.append_right + obtain ⟨ta, ra, la, _⟩ := compile_running ea hm program base ha (by + simp only [Block.size] at bound; omega) + obtain ⟨pre, before, after, rb, hp, hf, rz, lk, frame⟩ := + ih eb hr program (base+a.size) hb (by simpa only [Block.size, Nat.add_assoc] using bound) + refine ⟨pre, ta++before, after, ra.trans rb, hp, hf, ?_, ?_, frame⟩ + · simpa only [Block.size, Nat.add_assoc] using rz + · simp only [List.length_append, la]; omega + | @left a b path frameB ih => + intro W s t k e hr program base host bound + cases e with + | stopped _ _ hs => exact (hs hr).elim + | @seq _ _ _ mid _ ka kb ea eb => + have hm := eb.running_of_result hr + have ha := host.append_left + have hb : HostedAt program (base+a.size) (b.compileAt (base+a.size)) := by + simpa only [Block.compile_length] using host.append_right + obtain ⟨pre, before, after, ra, hp, hf, rz, lk, frame⟩ := + ih ea hm program base ha (by simp only [Block.size] at bound; omega) + obtain ⟨tb, rb, lb, frames⟩ := compile_running_frame eb hr program (base+a.size) hb + (by simpa only [Block.size, Nat.add_assoc] using bound) _ frameB + refine ⟨pre, before, after++tb, ra, hp, hf, ?_, ?_, ?_⟩ + · simpa only [Block.size, Nat.add_assoc] using rz.trans rb + · simp only [List.length_append, lb]; omega + · intro u hu + rcases List.mem_append.mp hu with hu | hu + · exact frame u hu + · exact frames u hu + +theorem run_frame_on_trace (program : List BInstr) (fuel : Nat) (s : State) + (allowed : Nat → Prop) + (hw : ∀ u ∈ (run program fuel s).transitions, WritesOnly allowed u.instruction) + (r : Nat) (hout : ¬ allowed r) : + (run program fuel s).final.regs r = s.regs r := by + induction fuel generalizing s with + | zero => rfl + | succ fuel ih => + cases hs : stepProgram program s with + | none => simp [run, hs] + | some u => + have first : WritesOnly allowed u.instruction := hw u (by simp [run, hs]) + have rest : ∀ v ∈ (run program fuel u.after).transitions, WritesOnly allowed v.instruction := + fun v hv => hw v (by simp [run, hs, hv]) + have he := (step_spec hs).2.2.2 + have hf : u.after.regs r = s.regs r := by + rw [he]; exact execPrim_frame _ _ allowed first r hout + simpa only [run, hs] using (ih u.after rest).trans hf + +theorem run_prefix_mem {program : List BInstr} {s : State} {short full : Nat} + (h : short ≤ full) {u : Transition} + (hu : u ∈ (run program short s).transitions) : + u ∈ (run program full s).transitions := by + rw [← Nat.add_sub_of_le h, run_add] + exact List.mem_append_left _ hu + +theorem run_prefix_frame {program : List BInstr} {s : State} {short full : Nat} + (h : short ≤ full) (allowed : Nat → Prop) + (hw : ∀ u ∈ (run program full s).transitions, WritesOnly allowed u.instruction) + (r : Nat) (hout : ¬ allowed r) : + (run program short s).final.regs r = s.regs r := + run_frame_on_trace program short s allowed + (fun u hu => hw u (run_prefix_mem h hu)) r hout + +theorem emits_preserve_output : ∀ rs, (emitRegs rs).WritesOnly (fun r => r ≠ 3) := by + intro rs + induction rs with + | nil => trivial + | cons r rs ih => + exact ⟨by simp [emitBit, Block.WritesOnly, Action.prim, Prim.destination?], ih⟩ + +theorem repack_preserves_output : repackBlock.WritesOnly (fun r => r ≠ 3) := by + simp [acts, emitBit, forSlots, hornerStepBlock, repackBlock, repackWordBlock, + Block.WritesOnly, Action.prim, Prim.destination?] + +/-- Structural route to the existing metadata reservation, for either leaf. -/ +theorem builder_reserve_path (leaf : Block) : ReservePath 3 (builderSource leaf) := by + unfold builderSource builderBody outputBlock metaEmitBlock + apply ReservePath.right + apply ReservePath.right + apply ReservePath.right + apply ReservePath.right + apply ReservePath.right + apply ReservePath.right + apply ReservePath.left + · apply ReservePath.left + · change ReservePath 3 (.seq (.action (.reserve 3)) _) + exact ReservePath.left .here (by simp [acts, Block.WritesOnly, Action.prim, Prim.destination?]) + · exact emits_preserve_output _ + · exact repack_preserves_output + +/-- Positional producing reservation and the complete following register frame. -/ +def ReservationReceipt (program : List BInstr) (s t : State) (ts : List Transition) + (dst : Operand) : Prop := + ∃ (pre : State) (before after : List Transition), + RunsTo program s pre before ∧ pre.status = .running ∧ + program[pre.pc]? = some ⟨.reserve dst⟩ ∧ + RunsTo program (execPrim (.reserve dst) pre) t after ∧ + ts = before ++ [⟨pre, ⟨.reserve dst⟩, execPrim (.reserve dst) pre⟩] ++ after ∧ + (∀ u ∈ after, WritesOnly (fun r => r ≠ dst.val) u.instruction) ∧ + t.regs dst = pre.extent + +theorem reservation_receipt {W : Nat} {b : Block} {s t : State} {k base : Nat} + {program : List BInstr} (e : SafeEval W b s t k) (hr : t.status = .running) + (entry : s.pc = base) (host : HostedAt program base (b.compileAt base)) + (bound : base+b.size < 2^32) {dst : Operand} (path : ReservePath dst b) : + ∃ ts, RunsTo program s {t with pc := base+b.size} ts ∧ ts.length = k ∧ + ReservationReceipt program s {t with pc := base+b.size} ts dst := by + obtain ⟨pre, before, after, rp, hp, hf, rz, lk, frame⟩ := + reserve_factor path e hr program base host bound + have se : ({s with pc := base} : State) = s := by rw [← entry] + rw [se] at rp + let tr : Transition := ⟨pre, ⟨.reserve dst⟩, execPrim (.reserve dst) pre⟩ + have whole := (rp.trans (RunsTo.instruction hp hf)).trans rz + have val : ({t with pc := base+b.size} : State).regs dst = pre.extent := by + have f := run_frame_on_trace program after.length (execPrim (.reserve dst) pre) + (fun r => r ≠ dst.val) (by rw [show run program after.length _ = _ from rz]; exact frame) + dst (by simp) + rw [show run program after.length _ = _ from rz] at f + simpa [execPrim, State.writeNext, State.next, put] using f + refine ⟨before ++ [tr] ++ after, whole, ?_, + ⟨pre, before, after, rp, hp, hf, rz, rfl, frame, val⟩⟩ + simp only [List.length_append, List.length_singleton] + omega + +/-- A receipt is an indexed actual transition, with a frame through every +remaining prefix of its suffix, not merely membership of a reservation value. -/ +theorem ReservationReceipt.occurrence {program : List BInstr} {s t : State} + {ts : List Transition} {dst : Operand} (h : ReservationReceipt program s t ts dst) : + ∃ (index : Nat) (pre : State) (after : List Transition), + ts[index]? = some ⟨pre, ⟨.reserve dst⟩, execPrim (.reserve dst) pre⟩ ∧ + (run program index s).final = pre ∧ pre.status = .running ∧ + program[pre.pc]? = some ⟨.reserve dst⟩ ∧ + (execPrim (.reserve dst) pre).regs dst = pre.extent ∧ + RunsTo program (execPrim (.reserve dst) pre) t after ∧ + (∀ fuel, fuel ≤ after.length → + (run program fuel (execPrim (.reserve dst) pre)).final.regs dst = pre.extent) ∧ + t.regs dst = pre.extent := by + obtain ⟨pre, before, after, rp, hr, hf, rs, trace, frame, value⟩ := h + refine ⟨before.length, pre, after, ?_, congrArg Run.final rp, hr, hf, ?_, rs, ?_, value⟩ + · rw [trace, List.append_assoc, List.getElem?_append_right (Nat.le_refl _)] + simp + · simp [execPrim, State.writeNext, State.next, put] + · intro fuel hle + have hframe : ∀ u ∈ (run program after.length (execPrim (.reserve dst) pre)).transitions, + WritesOnly (fun r => r ≠ dst.val) u.instruction := by + rw [show run program after.length _ = _ from rs] + exact frame + have out := run_prefix_frame hle (fun r => r ≠ dst.val) hframe dst (by simp) + simpa [execPrim, State.writeNext, State.next, put] using out + +end RMQ.SuccinctFinal.PackedLifecycle.Builder diff --git a/RMQ/Core/WordRAM/Lifecycle/Calculus.lean b/RMQ/Core/WordRAM/Lifecycle/Calculus.lean new file mode 100644 index 00000000..6fc1e652 --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/Calculus.lean @@ -0,0 +1,215 @@ +import RMQ.Core.WordRAM.Lifecycle.Machine + +/-! # Ordered lifecycle execution + +Composition preserves actual pre-states and occurrence indices. The old-prefix +adapter lifts completed transition segments without restarting the old machine. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle + +theorem step_spec {program : List Instruction} {s : State} {t : Transition} + (h : step program s = some t) : + t.before = s ∧ s.core.status = .running ∧ + ∃ i, program[s.core.pc]? = some i ∧ t.action = .instruction i ∧ + t.after = execute i s := by + simp only [step] at h + split at h + next hs => + cases hf : program[s.core.pc]? with + | none => simp [hf] at h + | some i => + simp [hf] at h + subst t + exact ⟨rfl, hs, i, rfl, rfl, rfl⟩ + next => simp at h + +theorem step_of_running {program : List Instruction} {s : State} {i : Instruction} + (hs : s.core.status = .running) (hf : program[s.core.pc]? = some i) : + step program s = some ⟨s, .instruction i, execute i s⟩ := by + simp [step, hs, hf] + +theorem step_none_of_stopped (program : List Instruction) (s : State) + (hs : s.core.status ≠ .running) : step program s = none := by + simp [step, hs] + +theorem run_of_step_none (program : List Instruction) (fuel : Nat) (s : State) + (h : step program s = none) : run program fuel s = ⟨s, []⟩ := by + cases fuel <;> simp [run, h] + +theorem run_of_stopped (program : List Instruction) (fuel : Nat) (s : State) + (hs : s.core.status ≠ .running) : run program fuel s = ⟨s, []⟩ := + run_of_step_none program fuel s (step_none_of_stopped program s hs) + +theorem run_add (program : List Instruction) (a b : Nat) (s : State) : + run program (a + b) s = + let first := run program a s + let second := run program b first.final + ⟨second.final, first.transitions ++ second.transitions⟩ := by + induction a generalizing s with + | zero => simp [run] + | succ a ih => + cases h : step program s with + | none => simp [Nat.succ_add, run, h, run_of_step_none program b s h] + | some t => + simpa [Nat.succ_add, run, h, List.cons_append] using + congrArg (fun r : Run => Run.mk r.final (t :: r.transitions)) (ih t.after) + +def RunsTo (program : List Instruction) (s s' : State) (ts : List Transition) : Prop := + run program ts.length s = ⟨s', ts⟩ + +theorem RunsTo.refl (program : List Instruction) (s : State) : RunsTo program s s [] := rfl + +theorem RunsTo.trans {program : List Instruction} {s₁ s₂ s₃ : State} + {ts₁ ts₂ : List Transition} (h₁ : RunsTo program s₁ s₂ ts₁) + (h₂ : RunsTo program s₂ s₃ ts₂) : RunsTo program s₁ s₃ (ts₁ ++ ts₂) := by + unfold RunsTo at h₁ h₂ ⊢ + rw [List.length_append, run_add, h₁] + simp [h₂] + +theorem RunsTo.instruction {program : List Instruction} {s : State} {i : Instruction} + (hs : s.core.status = .running) (hf : program[s.core.pc]? = some i) : + RunsTo program s (execute i s) [⟨s, .instruction i, execute i s⟩] := by + simp [RunsTo, run, step_of_running hs hf] + +theorem RunsTo.fuel_extension {program : List Instruction} {s s' : State} + {ts : List Transition} (h : RunsTo program s s' ts) + (stopped : s'.core.status ≠ .running) (extra : Nat) : + run program (ts.length + extra) s = ⟨s', ts⟩ := by + unfold RunsTo at h + rw [run_add, h] + dsimp only + rw [run_of_stopped program extra s' stopped] + simp + +theorem run_transition_at {program : List Instruction} {fuel : Nat} {s : State} + {k : Nat} {t : Transition} (h : (run program fuel s).transitions[k]? = some t) : + t.before = (run program k s).final ∧ step program t.before = some t := by + induction fuel generalizing s k with + | zero => simp [run] at h + | succ fuel ih => + cases hs : step program s with + | none => simp [run, hs] at h + | some first => + cases k with + | zero => + simp only [run, hs, List.getElem?_cons_zero, Option.some.injEq] at h + subst t + have hb := (step_spec hs).1 + exact ⟨hb, by simpa [hb] using hs⟩ + | succ k => + simp only [run, hs, List.getElem?_cons_succ] at h + obtain ⟨hb, ht⟩ := ih h + exact ⟨by simpa [run, hs] using hb, ht⟩ + +theorem run_exact_steps (program : List Instruction) (fuel : Nat) (s : State) : + run program (run program fuel s).steps s = run program fuel s := by + induction fuel generalizing s with + | zero => rfl + | succ fuel ih => + cases h : step program s with + | none => simp [run, h, Run.steps] + | some t => + simpa [run, h, Run.steps] using + congrArg (fun r : Run => Run.mk r.final (t :: r.transitions)) (ih t.after) + +def ofCore (s : PackedConstruction.State) (keys keyRegs : Nat) : State := ⟨s, keys, keyRegs⟩ + +def oldInstruction (i : PackedConstruction.BInstr) : Instruction := .old i.primitive + +def oldTransition (keys keyRegs : Nat) (t : PackedConstruction.Transition) : Transition := + ⟨ofCore t.before keys keyRegs, .instruction (oldInstruction t.instruction), + ofCore t.after keys keyRegs⟩ + +def oldRun (keys keyRegs : Nat) (r : PackedConstruction.Run) : Run := + ⟨ofCore r.final keys keyRegs, r.transitions.map (oldTransition keys keyRegs)⟩ + +theorem old_step {program : List PackedConstruction.BInstr} {s : PackedConstruction.State} + {t : PackedConstruction.Transition} (h : PackedConstruction.stepProgram program s = some t) + (tail : List Instruction) (keys keyRegs : Nat) : + step (program.map oldInstruction ++ tail) (ofCore s keys keyRegs) = + some (oldTransition keys keyRegs t) := by + obtain ⟨hb, hs, hf, he⟩ := PackedConstruction.step_spec h + have hi : s.pc < program.length := (List.getElem?_eq_some_iff.mp hf).1 + have fetch : (program.map oldInstruction ++ tail)[s.pc]? = + some (oldInstruction t.instruction) := by + rw [List.getElem?_append_left (by simpa using hi)] + simp [hf] + cases t + simp_all [step, ofCore, oldTransition, oldInstruction, execute] + +theorem old_run_full (program : List PackedConstruction.BInstr) (tail : List Instruction) + (fuel : Nat) (s : PackedConstruction.State) (keys keyRegs : Nat) + (hfull : (PackedConstruction.run program fuel s).transitions.length = fuel) : + run (program.map oldInstruction ++ tail) fuel (ofCore s keys keyRegs) = + oldRun keys keyRegs (PackedConstruction.run program fuel s) := by + induction fuel generalizing s with + | zero => rfl + | succ fuel ih => + cases hs : PackedConstruction.stepProgram program s with + | none => simp [PackedConstruction.run, hs] at hfull + | some t => + have ht : (PackedConstruction.run program fuel t.after).transitions.length = fuel := by + simpa [PackedConstruction.run, hs] using hfull + have hstep := old_step hs tail keys keyRegs + simp only [run, hstep, PackedConstruction.run, hs] + change _ = oldRun keys keyRegs _ + rw [show (oldTransition keys keyRegs t).after = ofCore t.after keys keyRegs from rfl, + ih t.after ht] + rfl + +/-- Every old transition remains the same transition, including its position +and full projected states, inside an old prefix followed by new instructions. -/ +theorem lift_old_prefix {program : List PackedConstruction.BInstr} + {s s' : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (h : PackedConstruction.RunsTo program s s' ts) + (tail : List Instruction) (keys keyRegs : Nat) : + RunsTo (program.map oldInstruction ++ tail) (ofCore s keys keyRegs) + (ofCore s' keys keyRegs) (ts.map (oldTransition keys keyRegs)) := by + unfold RunsTo + rw [List.length_map] + have hh : PackedConstruction.run program ts.length s = ⟨s', ts⟩ := h + rw [old_run_full program tail ts.length s keys keyRegs (by rw [hh]), hh] + rfl + +/-- A stopped old run cannot accidentally fall through into an appended new +instruction. The equality preserves the complete ordered run, not just result. -/ +theorem old_run_of_stopped (program : List PackedConstruction.BInstr) + (tail : List Instruction) (fuel : Nat) (s : PackedConstruction.State) + (keys keyRegs : Nat) + (stopped : (PackedConstruction.run program fuel s).final.status ≠ .running) : + run (program.map oldInstruction ++ tail) fuel (ofCore s keys keyRegs) = + oldRun keys keyRegs (PackedConstruction.run program fuel s) := by + induction fuel generalizing s with + | zero => rfl + | succ fuel ih => + cases hs : PackedConstruction.stepProgram program s with + | none => + have hstop : s.status ≠ .running := by + simpa [PackedConstruction.run, hs] using stopped + have hnew := step_none_of_stopped (program.map oldInstruction ++ tail) + (ofCore s keys keyRegs) hstop + simp [run, hnew, PackedConstruction.run, hs, oldRun] + | some t => + have hrest : (PackedConstruction.run program fuel t.after).final.status ≠ .running := by + simpa [PackedConstruction.run, hs] using stopped + have hstep := old_step hs tail keys keyRegs + simp only [run, hstep, PackedConstruction.run, hs] + rw [show (oldTransition keys keyRegs t).after = ofCore t.after keys keyRegs from rfl, + ih t.after hrest] + rfl + +theorem requestProtocol_exact (entry : PackedConstruction.Operand) (left right answer : Nat) + (s : State) (hs : s.core.status = .halted answer) : + (requestProtocol entry left right s).final = + { s with core := { s.core with + regs := PackedConstruction.put (PackedConstruction.put s.core.regs + requestLeftRegister left) requestRightRegister right, + pc := entry, status := .running } } ∧ + (requestProtocol entry left right s).steps = 4 ∧ + (requestProtocol entry left right s).categories = + [.requestAdmission, .requestAdmission, .controlEntry, .controlEntry] := by + simp [requestProtocol, runBoundary, boundaryStep, executeBoundary, hs, + Run.steps, Run.categories, Action.category] + +end RMQ.SuccinctFinal.PackedLifecycle diff --git a/RMQ/Core/WordRAM/Lifecycle/Capstone.lean b/RMQ/Core/WordRAM/Lifecycle/Capstone.lean new file mode 100644 index 00000000..9cb036d1 --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/Capstone.lean @@ -0,0 +1,197 @@ +import RMQ.Core.WordRAM.Lifecycle.Profile +import RMQ.Core.WordRAM.Lifecycle.Ownership +import RMQ.Core.WordRAM.Lifecycle.Agreement +import RMQ.Core.WordRAM.Lifecycle.CodeFetch + +/-! # Continuous succinct construction and reusable charged queries + +This candidate interface concerns the numeric primitive model and its finite +container refinement. Input materialization precedes execution. Comparison +keys are separately counted arbitrary integers. Logical owned sizes are not +native allocator capacity or external alias claims. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle + +open PackedWordRAM (wordWidth buildMemory) +open PackedWordRAM.Optimization (compactQueryRun) +open Continuous (continuousRun constructionBudget) +set_option maxRecDepth 30000 + +/-- The construction witness retains the actual hosted body and its producing +trace. Neither the retained allocation nor the query answer is a premise. -/ +def ConstructionChain (model : InputModel) (xs : List Int) (left right : Nat) : Prop := + ∃ abstract producer body, + Construction.BuildStage model xs left right abstract producer body ∧ + (Finalization.fullTrace model xs left right producer body).length ≤ constructionBudget xs.length ∧ + Retained.Canonical xs (Finalization.finalState model xs left right producer) ∧ + ServiceSafety.Entered left right (Finalization.finalState model xs left right producer) ∧ + continuousRun model xs left right = + ⟨(Reusable.serviceRun model (Finalization.finalState model xs left right producer)).final, + Finalization.fullTrace model xs left right producer body ++ + (Reusable.serviceRun model (Finalization.finalState model xs left right producer)).transitions⟩ ∧ + ∃ entryTransitions : List Transition, + entryTransitions.length = 4 + QueryEntry.setupCost ∧ + (continuousRun model xs left right).transitions = + Finalization.fullTrace model xs left right producer body ++ entryTransitions ++ + (compactQueryRun (buildMemory xs) xs.length left right).transitions.map + (QuerySafetyBridge.liftTransition (buildMemory xs)) ∧ + (continuousRun model xs left right).steps = + (Finalization.fullTrace model xs left right producer body).length + 4 + QueryEntry.setupCost + + (compactQueryRun (buildMemory xs) xs.length left right).steps + +def ExecutedOwner (model : InputModel) (xs : List Int) (left right : Nat) : Prop := + let es := Ownership.owner model xs left right + es.toState = (continuousRun model xs left right).final ∧ + (Ownership.observations model xs left right).toRun = continuousRun model xs left right ∧ + Ownership.Ready xs es ∧ es.keys = #[] ∧ es.keyRegs = #[] ∧ + Ownership.capacity model es * wordWidth xs.length ≤ 2 * xs.length + retainedRho xs.length + +/-- Re-entry operates on any previously halted retained owner, so the same +statement applies repeatedly without carrying request history. -/ +def ReusableOwner (model : InputModel) (xs : List Int) : Prop := + ∀ (es : Owner) (left right answer : Nat), Ownership.Ready xs es → es.status = .halted answer → + left < 2 ^ wordWidth xs.length → right < 2 ^ wordWidth xs.length → + Ownership.Ready xs (Executable.queryOwner model left right es) ∧ + (Executable.queryOwner model left right es).status = .halted + (PackedWordRAM.optionNatPacket (SuccinctClassic.queryTraceResult xs left right).value) ∧ + (Executable.queryOwner model left right es).memory = es.memory ∧ + (Executable.queryArray model left right es).toRun = Reusable.queryRun model left right es.toState ∧ + (Reusable.queryRun model left right es.toState).steps ≤ Reusable.queryBudget ∧ + (Reusable.queryRun model left right es.toState).reads = (0, some xs.length) :: + (compactQueryRun (buildMemory xs) xs.length left right).reads.map (fun r => (r.address, r.reply)) ∧ + (∀ t ∈ (Reusable.queryRun model left right es.toState).transitions, + t.ActionSafe (wordWidth xs.length) (Layout.program model).length numericBank Layout.serviceEntry.val ∧ + Retained.Canonical xs t.before ∧ Retained.Canonical xs t.after) ∧ + Ownership.capacity model (Executable.queryOwner model left right es) * wordWidth xs.length ≤ + 2 * xs.length + retainedRho xs.length + +def PhysicalRun (model : InputModel) (xs : List Int) (left right : Nat) : Prop := + (Physical.physicalReads model (continuousRun model xs left right).transitions).map Physical.Read.logicalReceipt = + (continuousRun model xs left right).reads ∧ + (∀ fuel, fuel ≤ (continuousRun model xs left right).steps → + let s := (run (Layout.program model) fuel (initialState model xs left right Layout.builderBase)).final + Physical.extent model s < 2 ^ wordWidth xs.length ∧ + ∀ p value, Physical.lookup model s p = some value → value < 2 ^ wordWidth xs.length) ∧ + (∀ index t address reply, (continuousRun model xs left right).transitions[index]? = some t → + t.read? = some (address, reply) → + t.before = (run (Layout.program model) index (initialState model xs left right Layout.builderBase)).final ∧ + (Physical.imageTrace model (continuousRun model xs left right).transitions)[index]? = + some ⟨Physical.view model t.before, t.action, Physical.view model t.after⟩ ∧ + ∃ physical value, Physical.checkedAddress model t.before address = some physical ∧ + reply = some value ∧ Physical.lookup model t.before physical = some value ∧ + physical < 2 ^ wordWidth xs.length ∧ address < 2 ^ wordWidth xs.length ∧ value < 2 ^ wordWidth xs.length) ∧ + ∀ (index : Nat) (t : Transition), (continuousRun model xs left right).transitions[index]? = some t → + ∃ instruction : Instruction, t.action = .instruction instruction ∧ + (Layout.program model)[t.before.core.pc]? = some instruction ∧ + ∀ field word, instruction.encoding[field]? = some word → + Physical.codeOffset (Layout.program model) t.before.core.pc + field < Physical.codeLength model ∧ + Physical.lookup model t.before + (Physical.codeAddress model (Physical.codeOffset (Layout.program model) t.before.core.pc + field)) = some word + +/-- Seven connected interfaces expose the same run, retained owner, fixed code +and width. Proof witnesses carry no executable routing information. -/ +structure ContinuousConstructionQuery (model : InputModel) (xs : List Int) (left right : Nat) : Prop where + construction : ConstructionChain model xs left right + retained : Retained.Canonical xs (continuousRun model xs left right).final ∧ + (continuousRun model xs left right).final.core.status = .halted + (PackedWordRAM.optionNatPacket (SuccinctClassic.queryTraceResult xs left right).value) ∧ + (continuousRun model xs left right).steps ≤ constructionBudget xs.length + 160253 + safety : (∀ fuel, fuel ≤ (continuousRun model xs left right).steps → + Continuous.PrefixProfile model xs + (run (Layout.program model) fuel (initialState model xs left right Layout.builderBase)).final) ∧ + ∀ t ∈ (continuousRun model xs left right).transitions, + t.Safe (wordWidth xs.length) (Layout.program model).length + physical : PhysicalRun model xs left right + executable : ExecutedOwner model xs left right + reusable : ReusableOwner model xs + uniform : SuccinctSpace.LittleOLinear retainedRho ∧ + (Nat.log2 (xs.length + 2) + 1 ≤ wordWidth xs.length ∧ + wordWidth xs.length ≤ 192 * (Nat.log2 (xs.length + 2) + 1)) ∧ + ∀ word ∈ encodedProgram model, word < 2 ^ wordWidth xs.length + +theorem reusableOwner_holds (model : InputModel) (xs : List Int) : ReusableOwner model xs := by + intro es left right answer ready halted hl hr + have outcome := ready.query model left right answer halted hl hr + refine ⟨outcome.1, outcome.2.1, outcome.2.2.1, outcome.2.2.2.1, outcome.2.2.2.2, + Reusable.query_reads model xs left right answer es.toState ready.2 halted hl hr, ?_, + outcome.1.capacity_bound model⟩ + intro t ht + exact ⟨Reusable.query_action_safe model xs left right answer es.toState ready.2 halted hl hr t ht, + Reusable.query_transition_canonical model xs left right answer es.toState ready.2 halted hl hr t ht⟩ + +theorem continuousConstructionQuery_holds (model : InputModel) (xs : List Int) (left right : Nat) + (domain : InputDomain model xs) (hl : left < 2 ^ wordWidth xs.length) + (hr : right < 2 ^ wordWidth xs.length) : ContinuousConstructionQuery model xs left right := by + obtain ⟨abstract, producer, body, built⟩ := Construction.build_stage model xs left right domain hl hr + have produced := Finalization.completed built + obtain ⟨entry, entryLength, suffix⟩ := Continuous.query_suffix built + have ready := Ownership.ready model xs left right domain hl hr + have refines := Ownership.refinement model xs left right domain hl hr + refine { + construction := ⟨abstract, producer, body, built, Finalization.linear_cost built, + produced.2.1, Continuous.entered_of_inputs produced.2.2.1, Continuous.exact_run built, + entry, entryLength, suffix, (Continuous.cost built).1⟩ + retained := ⟨Continuous.canonical built, Continuous.halts built, (Continuous.cost built).2⟩ + safety := ⟨fun fuel within => Continuous.prefix_profile built domain hl hr within, Continuous.safe built⟩ + physical := ⟨Physical.physicalReads_exact model _, + fun fuel within => Continuous.physical_prefix built domain hl hr within, + Continuous.physical_read built domain hl hr, + Physical.run_fetched_words model (Continuous.lifecycleBudget xs.length) + (initialState model xs left right Layout.builderBase)⟩ + executable := ⟨refines.1, refines.2.2, ready, ready.empty_keys.1, ready.empty_keys.2, + ready.capacity_bound model⟩ + reusable := reusableOwner_holds model xs + uniform := ⟨retainedRho_littleO, + ⟨PackedWordRAM.wordWidth_log_lower xs.length, PackedWordRAM.wordWidth_le_log xs.length⟩, + all_encoded_fields_fit model xs.length⟩ + } + +/-- Word-input form: input values are represented at the same query-independent +width as construction, addresses, code, retained data and queries. -/ +theorem wordInputContinuousConstructionQuery (xs : List Int) (left right : Nat) + (domain : PackedConstruction.InputFits (wordWidth xs.length) xs) + (hl : left < 2 ^ wordWidth xs.length) (hr : right < 2 ^ wordWidth xs.length) : + ContinuousConstructionQuery .word xs left right := + continuousConstructionQuery_holds .word xs left right domain hl hr + +/-- Arbitrary signed input keys use the separately counted comparison channel; +their Int magnitudes are not asserted to occupy bounded numeric words. -/ +theorem comparisonInputContinuousConstructionQuery (xs : List Int) (left right : Nat) + (hl : left < 2 ^ wordWidth xs.length) (hr : right < 2 ^ wordWidth xs.length) : + ContinuousConstructionQuery .comparison xs left right := + continuousConstructionQuery_holds .comparison xs left right True.intro hl hr + +theorem ContinuousConstructionQuery.valid {model : InputModel} {xs : List Int} {left right : Nat} + (contract : ContinuousConstructionQuery model xs left right) (valid : ValidRange xs left right) : + (continuousRun model xs left right).final.core.status = .halted (scanWindow xs left (right - left) + 1) ∧ + LeftmostArgMin xs left right (scanWindow xs left (right - left)) := by + have packet := Option.some.inj ((PackedWordRAM.Optimization.compactQueryRun_result xs left right).symm.trans + (PackedWordRAM.Optimization.compactQueryRun_scanWindow xs left right valid)) + exact ⟨by rw [contract.retained.2.1, packet], + PackedWordRAM.Optimization.compactQueryNat_leftmost xs left right _ + (by rw [PackedWordRAM.Optimization.compactQueryNat_exact, if_pos valid])⟩ + +theorem ContinuousConstructionQuery.invalid {model : InputModel} {xs : List Int} {left right : Nat} + (contract : ContinuousConstructionQuery model xs left right) (invalid : ¬ ValidRange xs left right) : + (continuousRun model xs left right).final.core.status = .halted 0 := by + have invalidPacket := PackedWordRAM.Optimization.compactQueryRun_invalid + (buildMemory xs) xs.length left right invalid + have packet := Option.some.inj ((PackedWordRAM.Optimization.compactQueryRun_result xs left right).symm.trans + invalidPacket.1) + rw [contract.retained.2.1, packet] + +/-- Supplied-store agreement is stated on the actual fixed program, with all +guarded replies at matched execution steps. Its conclusion constrains results, +registers, ordered observations and each cost category. -/ +theorem lifecycle_store_determinism (model : InputModel) (fuel : Nat) (s t : State) + (initial : s.Agree t) (reads : DynamicReadsAgree (Layout.program model) fuel s t) : + (run (Layout.program model) fuel s).Agree (run (Layout.program model) fuel t) ∧ + (run (Layout.program model) fuel s).final.core.status = (run (Layout.program model) fuel t).final.core.status ∧ + (run (Layout.program model) fuel s).reads = (run (Layout.program model) fuel t).reads ∧ + ∀ category, (run (Layout.program model) fuel s).categoryCount category = + (run (Layout.program model) fuel t).categoryCount category := by + have agreement := run_agree_of_dynamic_reads (Layout.program model) fuel s t initial reads + exact ⟨agreement, agreement.final_status, agreement.reads, agreement.categoryCount⟩ + +end RMQ.SuccinctFinal.PackedLifecycle diff --git a/RMQ/Core/WordRAM/Lifecycle/CodeFetch.lean b/RMQ/Core/WordRAM/Lifecycle/CodeFetch.lean new file mode 100644 index 00000000..1b4d2c82 --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/CodeFetch.lean @@ -0,0 +1,58 @@ +import RMQ.Core.WordRAM.Lifecycle.Physical + +/-! # Actual instruction fetches in the counted code region + +PCs index instructions. Their checked translation to variable-length encoded +word offsets identifies every opcode and operand in the same numeric view. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle.Physical + +def codeOffset (program : List Instruction) (pc : Nat) : Nat := + ((program.take pc).map Instruction.encoding).flatten.length + +theorem encoded_fetch (program : List Instruction) (pc : Nat) (instruction : Instruction) + (fetch : program[pc]? = some instruction) (field word : Nat) + (encoded : instruction.encoding[field]? = some word) : + ((program.map Instruction.encoding).flatten)[codeOffset program pc + field]? = some word := by + induction program generalizing pc with + | nil => simp at fetch + | cons first rest ih => + cases pc with + | zero => + have heq : first = instruction := Option.some.inj fetch + subst first + have inside := (List.getElem?_eq_some_iff.mp encoded).1 + simpa only [codeOffset, List.take_zero, List.map_nil, List.flatten_nil, List.length_nil, + Nat.zero_add, List.map_cons, List.flatten_cons, List.getElem?_append_left inside] using encoded + | succ pc => + have next : rest[pc]? = some instruction := fetch + have actual := ih pc next + simp only [List.map_cons, List.flatten_cons, codeOffset, List.take_succ_cons, + List.length_append] + rw [List.getElem?_append_right (by omega)] + simpa only [codeOffset, Nat.add_assoc, Nat.add_sub_cancel_left] using actual + +theorem fetched_word (model : InputModel) (s : State) (instruction : Instruction) + (fetch : (Layout.program model)[s.core.pc]? = some instruction) + (field word : Nat) (encoded : instruction.encoding[field]? = some word) : + codeOffset (Layout.program model) s.core.pc + field < codeLength model ∧ + lookup model s (codeAddress model (codeOffset (Layout.program model) s.core.pc + field)) = some word := by + have encodedWord := encoded_fetch (Layout.program model) s.core.pc instruction fetch field word encoded + have bound := (List.getElem?_eq_some_iff.mp encodedWord).1 + exact ⟨bound, (lookup_code model s _ bound).trans encodedWord⟩ + +theorem run_fetched_words (model : InputModel) (fuel : Nat) (s : State) + (index : Nat) (t : Transition) + (occurs : (run (Layout.program model) fuel s).transitions[index]? = some t) : + ∃ instruction, t.action = .instruction instruction ∧ + (Layout.program model)[t.before.core.pc]? = some instruction ∧ + ∀ field word, instruction.encoding[field]? = some word → + codeOffset (Layout.program model) t.before.core.pc + field < codeLength model ∧ + lookup model t.before + (codeAddress model (codeOffset (Layout.program model) t.before.core.pc + field)) = some word := by + obtain ⟨_, step⟩ := run_transition_at occurs + obtain ⟨hb, _, instruction, fetch, action, _⟩ := step_spec step + exact ⟨instruction, action, fetch, fetched_word model t.before instruction fetch⟩ + +end RMQ.SuccinctFinal.PackedLifecycle.Physical diff --git a/RMQ/Core/WordRAM/Lifecycle/Construction.lean b/RMQ/Core/WordRAM/Lifecycle/Construction.lean new file mode 100644 index 00000000..bb8788cf --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/Construction.lean @@ -0,0 +1,276 @@ +import RMQ.Core.WordRAM.Lifecycle.Program + +/-! # Supplied arena to live canonical builder output + +The original builder executes inside the fixed lifecycle program. Its input +assumptions are discharged from the supplied arena, including its two request +cells. Its actual output state provides the charged descriptor's entry facts. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle.Construction + +open PackedConstruction.Proof +open PackedWordRAM (wordWidth buildMemory) + +def suppliedInput (model : InputModel) (xs : List Int) : PackedConstruction.State → Prop := + match model with + | .word => WordInput (wordWidth xs.length) xs + | .comparison => OracleInput xs + +theorem supplied_spec (model : InputModel) (xs : List Int) : + KeySpec (wordWidth xs.length) xs (suppliedInput model xs) model.source := by + cases model + · exact wordLeaf_spec (wordWidth_ge_32 xs.length) xs + · exact keyLeaf_spec (wordWidth_ge_32 xs.length) xs + +theorem source_bank (model : InputModel) : + (PackedConstruction.builderBody model.source).RegsBelow 400 := by + cases model + · exact rb_builderBody_word + · exact rb_builderBody_key + +theorem initial_supplied (model : InputModel) (xs : List Int) (left right : Nat) + (domain : InputDomain model xs) : + suppliedInput model xs (initialState model xs left right Layout.builderBase).core := by + cases model <;> exact initial_input _ xs left right Layout.builderBase domain + +theorem supplied_below (model : InputModel) (xs : List Int) (left right : Nat) : + InpBelow (suppliedInput model xs) + (initialState model xs left right Layout.builderBase).core.extent := by + cases model + · apply wordInput_below + change xs.length+1 ≤ (xs.length+1)+2 + omega + · exact oracleInput_below xs _ + +theorem initial_regs_zero (model : InputModel) (xs : List Int) (left right entry r : Nat) : + (initialState model xs left right entry).core.regs r = 0 := by cases model <;> rfl + +theorem source_bound (model : InputModel) : + Layout.builderBase+(PackedConstruction.builderSource model.source).size < 2^32 := by + rw [Layout.source_size] + decide + +theorem source_inside (model : InputModel) : + Layout.builderBase+(PackedConstruction.builderSource model.source).size < + (Layout.oldPrefix model).length := by + rw [Layout.source_size, Layout.oldPrefix_length] + decide + +theorem initial_pc_fits (xs : List Int) : Layout.builderBase < 2^wordWidth xs.length := by + have hp : 2^32 ≤ 2^wordWidth xs.length := + Nat.pow_le_pow_right (by decide) (wordWidth_ge_32 xs.length) + have small : Layout.builderBase < 2^32 := by decide + omega + +theorem old_program_fits (model : InputModel) (xs : List Int) : + (Layout.oldPrefix model).length < 2^wordWidth xs.length := by + have hp : 2^32 ≤ 2^wordWidth xs.length := + Nat.pow_le_pow_right (by decide) (wordWidth_ge_32 xs.length) + rw [Layout.oldPrefix_length] + have small : Layout.finalizerBase < 2^32 := by decide + omega + +abbrev Body (model : InputModel) (xs : List Int) (left right : Nat) + (abstract final : PackedConstruction.State) (ts : List PackedConstruction.Transition) := + Builder.HostedBody (wordWidth xs.length) (Layout.oldPrefix model) Layout.builderBase + model.source xs (initialState model xs left right Layout.builderBase).core abstract final ts + +theorem body_exists (model : InputModel) (xs : List Int) (left right : Nat) + (domain : InputDomain model xs) (hl : left < 2^wordWidth xs.length) + (hr : right < 2^wordWidth xs.length) : + ∃ abstract final ts, Body model xs left right abstract final ts := by + let s := initialState model xs left right Layout.builderBase + have fit := initial_fits model xs left right Layout.builderBase domain hl hr (initial_pc_fits xs) + exact Builder.hosted_body (wordWidth_ge_32 xs.length) xs (suppliedInput model xs) + model.source (supplied_spec model xs) (source_bank model) + (Layout.oldPrefix model) Layout.builderBase s.core rfl + (by cases model <;> rfl) + (initial_regs_zero model xs left right Layout.builderBase) + (by change 0 < (inputCore model xs).extent+2; omega) + (initial_header model xs left right Layout.builderBase) + (initial_supplied model xs left right domain) (supplied_below model xs left right) + (bankcap_wordWidth xs.length) (initial_capacity model xs left right Layout.builderBase) + (Nat.le_refl _) (Layout.old_builder_host model) (source_bound model) (source_inside model) + (old_program_fits model xs) fit.1 (initial_clean model xs left right Layout.builderBase).1 + +def producedState (model : InputModel) (xs : List Int) (left right : Nat) + (final : PackedConstruction.State) : State := + let initial := initialState model xs left right Layout.builderBase + ofCore final initial.keyExtent initial.keyRegExtent + +def producedTrace (model : InputModel) (xs : List Int) (left right : Nat) + (ts : List PackedConstruction.Transition) : List Transition := + let initial := initialState model xs left right Layout.builderBase + ts.map (oldTransition initial.keyExtent initial.keyRegExtent) + +theorem body_execution {model : InputModel} {xs : List Int} {left right : Nat} + {abstract final : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (body : Body model xs left right abstract final ts) : + RunsTo (Layout.program model) (initialState model xs left right Layout.builderBase) + (producedState model xs left right final) (producedTrace model xs left right ts) := + lift_old_prefix body.execution (Layout.tail model) _ _ + +theorem primitive_safe_mono {W small large : Nat} {s : PackedConstruction.State} + {p : PackedConstruction.Prim} (safe : p.Safe W small s) (hle : small ≤ large) : + p.Safe W large s := by + refine ⟨safe.1, ?_⟩ + have h := safe.2 + cases p <;> simp only [PackedConstruction.Prim.SafeAt] at h ⊢ <;> try exact h + all_goals exact Nat.lt_of_lt_of_le h hle + +theorem body_trace_safe {model : InputModel} {xs : List Int} {left right : Nat} + {abstract final : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (body : Body model xs left right abstract final ts) : + ∀ t ∈ producedTrace model xs left right ts, + t.Safe (wordWidth xs.length) (Layout.program model).length := by + have hlen : (Layout.oldPrefix model).length ≤ (Layout.program model).length := by + rw [Layout.oldPrefix_length, Layout.program_length] + cases model <;> decide + intro u hu + obtain ⟨t, ht, rfl⟩ := List.mem_map.mp hu + refine ⟨oldInstruction t.instruction, rfl, ?_⟩ + exact primitive_safe_mono (body.safe t ht).1 hlen + +theorem body_closed {model : InputModel} {xs : List Int} {left right : Nat} + {abstract final : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (body : Body model xs left right abstract final ts) : + (producedState model xs left right final).Closed := by + have initial := initial_clean model xs left right Layout.builderBase + refine ⟨body.cleanTail, ?_, ?_⟩ + · intro a ha + change final.keys a = none + rw [body.keys] + exact initial.2.1 a ha + · intro r hr + change final.keyRegs r = 0 + cases model with + | word => + rw [Builder.hosted_word_key_frame body] + exact initial.2.2 r hr + | comparison => + rw [Builder.hosted_comparison_key_frame body r (by exact hr)] + exact initial.2.2 r hr + +theorem body_fits {model : InputModel} {xs : List Int} {left right : Nat} + {abstract final : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (body : Body model xs left right abstract final ts) + (domain : InputDomain model xs) (hl : left < 2^wordWidth xs.length) + (hr : right < 2^wordWidth xs.length) : + (producedState model xs left right final).Fits (wordWidth xs.length) := by + have fit := initial_fits model xs left right Layout.builderBase domain hl hr (initial_pc_fits xs) + exact ⟨body.fits, fit.2⟩ + +theorem body_numeric_finite {model : InputModel} {xs : List Int} {left right : Nat} + {abstract final : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (body : Body model xs left right abstract final ts) (r : Nat) (hr : 400 ≤ r) : + final.regs r = 0 := + (body.numericFrame r hr).trans (initial_regs_zero model xs left right Layout.builderBase r) + +theorem body_prefix_length {model : InputModel} {xs : List Int} {left right fuel : Nat} + {abstract final : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (body : Body model xs left right abstract final ts) (hf : fuel ≤ ts.length) : + (PackedConstruction.run (Layout.oldPrefix model) fuel + (initialState model xs left right Layout.builderBase).core).transitions.length = fuel := by + let initial := (initialState model xs left right Layout.builderBase).core + have completed : PackedConstruction.run (Layout.oldPrefix model) ts.length initial = + ⟨final, ts⟩ := body.execution + have split := PackedConstruction.run_add (Layout.oldPrefix model) fuel (ts.length-fuel) initial + rw [Nat.add_sub_of_le hf, completed] at split + have len := congrArg (fun r : PackedConstruction.Run => r.transitions.length) split + dsimp only at len + rw [List.length_append] at len + have first := PackedConstruction.run_steps_le_fuel (Layout.oldPrefix model) fuel initial + have rest := PackedConstruction.run_steps_le_fuel (Layout.oldPrefix model) (ts.length-fuel) + (PackedConstruction.run (Layout.oldPrefix model) fuel initial).final + simp only [PackedConstruction.Run.steps] at first rest + change (PackedConstruction.run (Layout.oldPrefix model) fuel initial).transitions.length = fuel + omega + +/-- Every bounded actual prefix retains the original builder's complete +states and ordered trace, not only its endpoint value. -/ +theorem body_prefix_lift {model : InputModel} {xs : List Int} {left right fuel : Nat} + {abstract final : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (body : Body model xs left right abstract final ts) (hf : fuel ≤ ts.length) : + run (Layout.program model) fuel (initialState model xs left right Layout.builderBase) = + oldRun (initialState model xs left right Layout.builderBase).keyExtent + (initialState model xs left right Layout.builderBase).keyRegExtent + (PackedConstruction.run (Layout.oldPrefix model) fuel + (initialState model xs left right Layout.builderBase).core) := + old_run_full (Layout.oldPrefix model) (Layout.tail model) fuel _ _ _ (body_prefix_length body hf) + +theorem body_peak {model : InputModel} {xs : List Int} {left right fuel : Nat} + {abstract final : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (body : Body model xs left right abstract final ts) (hf : fuel ≤ ts.length) : + (run (Layout.program model) fuel (initialState model xs left right Layout.builderBase)).final.core.extent + ≤ final.extent ∧ + (run (Layout.program model) fuel (initialState model xs left right Layout.builderBase)).final.core.extent + ≤ (initialState model xs left right Layout.builderBase).core.extent + + 3200000*(xs.length+1)+(buildMemory xs).length := by + rw [body_prefix_lift body hf] + exact Builder.hosted_peak body fuel hf + +theorem body_prefix_numeric_finite {model : InputModel} {xs : List Int} {left right fuel : Nat} + {abstract final : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (body : Body model xs left right abstract final ts) (hf : fuel ≤ ts.length) + (r : Nat) (hr : 400 ≤ r) : + (run (Layout.program model) fuel (initialState model xs left right Layout.builderBase)).final.core.regs r = 0 := by + rw [body_prefix_lift body hf] + exact (Builder.hosted_numeric_prefix_frame body rfl (Layout.old_builder_host model) + (source_bound model) (source_bank model) fuel hf r hr).trans + (initial_regs_zero model xs left right Layout.builderBase r) + +theorem requestBase_eq (model : InputModel) (xs : List Int) : + Descriptor.requestBase model xs.length = (inputCore model xs).extent := by cases model <;> rfl + +theorem body_descriptor {model : InputModel} {xs : List Int} {left right : Nat} + {abstract final : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (body : Body model xs left right abstract final ts) : + Descriptor.Entry model Layout.descriptorBase (final.regs 3) xs.length + (buildMemory xs).length left right (producedState model xs left right final) := by + have metadata := Builder.produced_metadata body + have hpc : final.pc = Layout.descriptorBase := by + rw [body.pc, Layout.source_size] + rfl + have req := initial_requests model xs left right Layout.builderBase + have hb := body.baseLower + have he := body.extent + have before : Descriptor.requestBase model xs.length+1 < + (initialState model xs left right Layout.builderBase).core.extent := by + rw [requestBase_eq] + change (inputCore model xs).extent+1 < (inputCore model xs).extent+2 + omega + refine ⟨body.running, hpc, rfl, metadata.2.2, metadata.1, metadata.2.1, ?_, ?_, ?_⟩ + · change Descriptor.requestBase model xs.length+1 < final.extent + omega + · change final.memory (Descriptor.requestBase model xs.length) = some left + rw [body.inputFrame _ (by omega), requestBase_eq] + exact req.1 + · change final.memory (Descriptor.requestBase model xs.length+1) = some right + rw [body.inputFrame _ before, requestBase_eq] + exact req.2 + +/-- The produced state is the actual complete old run embedded in the single +lifecycle execution, and provides the next fragment's live input. -/ +structure BuildStage (model : InputModel) (xs : List Int) (left right : Nat) + (abstract final : PackedConstruction.State) (ts : List PackedConstruction.Transition) : Prop where + body : Body model xs left right abstract final ts + execution : RunsTo (Layout.program model) (initialState model xs left right Layout.builderBase) + (producedState model xs left right final) (producedTrace model xs left right ts) + closed : (producedState model xs left right final).Closed + fits : (producedState model xs left right final).Fits (wordWidth xs.length) + numericFinite : ∀ r, 400 ≤ r → final.regs r = 0 + descriptor : Descriptor.Entry model Layout.descriptorBase (final.regs 3) xs.length + (buildMemory xs).length left right (producedState model xs left right final) + work : (producedTrace model xs left right ts).length ≤ 1000000000*xs.length+1000000000 + +theorem build_stage (model : InputModel) (xs : List Int) (left right : Nat) + (domain : InputDomain model xs) (hl : left < 2^wordWidth xs.length) + (hr : right < 2^wordWidth xs.length) : + ∃ abstract final ts, BuildStage model xs left right abstract final ts := by + obtain ⟨abstract, final, ts, body⟩ := body_exists model xs left right domain hl hr + exact ⟨abstract, final, ts, body, body_execution body, body_closed body, + body_fits body domain hl hr, body_numeric_finite body, body_descriptor body, + by simpa [producedTrace] using Builder.hosted_linear_work body⟩ + +end RMQ.SuccinctFinal.PackedLifecycle.Construction diff --git a/RMQ/Core/WordRAM/Lifecycle/Continuous.lean b/RMQ/Core/WordRAM/Lifecycle/Continuous.lean new file mode 100644 index 00000000..c75d2790 --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/Continuous.lean @@ -0,0 +1,204 @@ +import RMQ.Core.WordRAM.Lifecycle.Finalization +import RMQ.Core.WordRAM.Lifecycle.Reusable + +/-! # Construction and the first query in one uninterrupted run + +The fixed fuel selects a completed trace; completion is derived from the +builder, finalizer and query executions before padding the halted endpoint. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle.Continuous + +open PackedWordRAM (wordWidth buildMemory) +set_option maxRecDepth 30000 + +def constructionBudget (n : Nat) : Nat := 1100000000 * (n + 1) +def lifecycleBudget (n : Nat) : Nat := constructionBudget n + Service.budget + +def continuousRun (model : InputModel) (xs : List Int) (left right : Nat) : Run := + run (Layout.program model) (lifecycleBudget xs.length) + (initialState model xs left right Layout.builderBase) + +theorem entered_of_inputs {left right : Nat} {s : State} + (inputs : Service.Inputs left right (Retained.projectQueryState s)) : + ServiceSafety.Entered left right s := by + refine ⟨?_, inputs.2.1, inputs.2.2.1, inputs.2.2.2.1⟩ + have hs := inputs.1 + change Retained.projectStatus s.core.status = .running at hs + cases status : s.core.status <;> simp_all [Retained.projectStatus] + +theorem service_safe {model : InputModel} {xs : List Int} {left right : Nat} {s : State} + (canonical : Retained.Canonical xs s) (entered : ServiceSafety.Entered left right s) : + ∀ t ∈ (Reusable.serviceRun model s).transitions, + t.Safe (wordWidth xs.length) (Layout.program model).length := by + have h := ServiceSafety.actual_prefix_safe xs (Reusable.continuation model) left right + Service.budget s canonical entered (Nat.le_refl _) + rwa [← Reusable.program_host model] at h + +theorem joined_execution {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) : + RunsTo (Layout.program model) (initialState model xs left right Layout.builderBase) + (Reusable.serviceRun model (Finalization.finalState model xs left right producer)).final + (Finalization.fullTrace model xs left right producer ts ++ + (Reusable.serviceRun model (Finalization.finalState model xs left right producer)).transitions) := + (Finalization.full_execution built).trans + (run_exact_steps (Layout.program model) Service.budget _) + +theorem exact_run {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) : + continuousRun model xs left right = + ⟨(Reusable.serviceRun model (Finalization.finalState model xs left right producer)).final, + Finalization.fullTrace model xs left right producer ts ++ + (Reusable.serviceRun model (Finalization.finalState model xs left right producer)).transitions⟩ := by + let ready := Finalization.finalState model xs left right producer + have hc : Retained.Canonical xs ready := (Finalization.completed built).2.1 + have he := entered_of_inputs (Finalization.completed built).2.2.1 + have stop := Reusable.service_halts model xs left right ready hc he + have work := Finalization.linear_cost built + have queryWork := (Reusable.service_steps model xs left right ready hc he).2 + have total : (Finalization.fullTrace model xs left right producer ts ++ + (Reusable.serviceRun model ready).transitions).length ≤ lifecycleBudget xs.length := by + rw [List.length_append] + change (Finalization.fullTrace model xs left right producer ts).length + + (Reusable.serviceRun model ready).steps ≤ constructionBudget xs.length + Service.budget + rw [Service.budget_eq] + exact Nat.add_le_add work queryWork + have stopped : (Reusable.serviceRun model ready).final.core.status ≠ .running := by rw [stop]; intro h; cases h + have completed := (joined_execution built).fuel_extension stopped + (lifecycleBudget xs.length - (Finalization.fullTrace model xs left right producer ts ++ + (Reusable.serviceRun model ready).transitions).length) + rw [Nat.add_sub_of_le total] at completed + exact completed + +theorem canonical {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) : + Retained.Canonical xs (continuousRun model xs left right).final := by + rw [exact_run built] + exact Reusable.service_canonical model xs left right _ (Finalization.completed built).2.1 + (entered_of_inputs (Finalization.completed built).2.2.1) + +theorem halts {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) : + (continuousRun model xs left right).final.core.status = .halted + (PackedWordRAM.optionNatPacket (SuccinctClassic.queryTraceResult xs left right).value) := by + rw [exact_run built] + exact Reusable.service_halts model xs left right _ (Finalization.completed built).2.1 + (entered_of_inputs (Finalization.completed built).2.2.1) + +theorem safe {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) : + ∀ t ∈ (continuousRun model xs left right).transitions, + t.Safe (wordWidth xs.length) (Layout.program model).length := by + rw [exact_run built] + intro t ht + rcases List.mem_append.mp ht with ht | ht + · exact Finalization.full_safe built t ht + · exact service_safe (Finalization.completed built).2.1 + (entered_of_inputs (Finalization.completed built).2.2.1) t ht + +theorem transition_fits {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) + (domain : InputDomain model xs) (hl : left < 2 ^ wordWidth xs.length) + (hr : right < 2 ^ wordWidth xs.length) : + ∀ t ∈ (continuousRun model xs left right).transitions, + t.before.Fits (wordWidth xs.length) ∧ t.after.Fits (wordWidth xs.length) := + (run_fits (initial_fits model xs left right Layout.builderBase domain hl hr + (Construction.initial_pc_fits xs)) (Reusable.program_fits model xs.length) (safe built)).2 + +theorem prefix_resources {model : InputModel} {xs : List Int} {left right fuel : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) + (within : fuel ≤ (continuousRun model xs left right).steps) : + let s := (run (Layout.program model) fuel (initialState model xs left right Layout.builderBase)).final + s.core.extent ≤ 5000000 * (xs.length + 1) ∧ ∀ r, 8273 ≤ r → s.core.regs r = 0 := by + let construction := Finalization.fullTrace model xs left right producer ts + let ready := Finalization.finalState model xs left right producer + by_cases short : fuel ≤ construction.length + · exact ⟨Finalization.full_prefix_peak built short, Finalization.full_prefix_finite built short⟩ + · have queryWork := (Reusable.service_steps model xs left right ready + (Finalization.completed built).2.1 (entered_of_inputs (Finalization.completed built).2.2.1)).2 + have fuelBound : fuel - construction.length ≤ Service.budget := by + rw [exact_run built] at within + change (fuel : Nat) ≤ (construction ++ (Reusable.serviceRun model ready).transitions).length at within + rw [List.length_append] at within + rw [Service.budget_eq] + change (Reusable.serviceRun model ready).transitions.length ≤ 160253 at queryWork + omega + have hc := ServiceSafety.actual_prefix_canonical xs (Reusable.continuation model) left right + (fuel - construction.length) ready (Finalization.completed built).2.1 + (entered_of_inputs (Finalization.completed built).2.2.1) fuelBound + rw [← Reusable.program_host model] at hc + have whole : run (Layout.program model) construction.length + (initialState model xs left right Layout.builderBase) = ⟨ready, construction⟩ := + Finalization.full_execution built + dsimp only + rw [show fuel = construction.length + (fuel - construction.length) by omega, run_add, whole] + refine ⟨?_, hc.2.1⟩ + rw [hc.1.2.1] + have hm := PackedConstruction.Spec.buildMemory_length_le xs + omega + +theorem transition_resources {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) + {t : Transition} (member : t ∈ (continuousRun model xs left right).transitions) : + t.before.core.extent ≤ 5000000 * (xs.length + 1) ∧ + ∀ r, 8273 ≤ r → t.before.core.regs r = 0 := by + obtain ⟨index, occurs⟩ := List.mem_iff_getElem?.mp member + have within : index ≤ (continuousRun model xs left right).steps := + Nat.le_of_lt (List.getElem?_eq_some_iff.mp occurs).1 + rw [(run_transition_at occurs).1] + exact prefix_resources built within + +/-- Complete accepted transitions, rather than only their read projection, +occur as the suffix after the charged preparation and full finite-bank clear. -/ +theorem query_suffix {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) : + ∃ entryTransitions : List Transition, + entryTransitions.length = 4 + QueryEntry.setupCost ∧ + (continuousRun model xs left right).transitions = + Finalization.fullTrace model xs left right producer ts ++ entryTransitions ++ + (PackedWordRAM.Optimization.compactQueryRun (buildMemory xs) xs.length left right).transitions.map + (QuerySafetyBridge.liftTransition (buildMemory xs)) := by + let ready := Finalization.finalState model xs left right producer + let state := Retained.projectQueryState ready + have inputs : Service.Inputs left right state := (Finalization.completed built).2.2.1 + obtain ⟨setup, execution, length, _⟩ := Service.completed (buildMemory xs) xs.length left right + state (ServiceSafety.canonical_header xs) inputs + have preparation := (Service.prepare_exec (buildMemory xs) xs.length left right state + (ServiceSafety.canonical_header xs) inputs).2.1 + refine ⟨((PackedWordRAM.run (buildMemory xs) Service.program 4 state).transitions ++ setup).map + (QuerySafetyBridge.liftTransition (buildMemory xs)), ?_, ?_⟩ + · rw [List.length_map, List.length_append, ← PackedWordRAM.Run.steps, preparation, length] + · rw [exact_run built, Reusable.service_exact model xs left right ready + (Finalization.completed built).2.1 (entered_of_inputs inputs), execution] + simp only [List.map_append, List.append_assoc] + +theorem cost {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) : + (continuousRun model xs left right).steps = + (Finalization.fullTrace model xs left right producer ts).length + 4 + QueryEntry.setupCost + + (PackedWordRAM.Optimization.compactQueryRun (buildMemory xs) xs.length left right).steps ∧ + (continuousRun model xs left right).steps ≤ constructionBudget xs.length + 160253 := by + have service := Reusable.service_steps model xs left right _ (Finalization.completed built).2.1 + (entered_of_inputs (Finalization.completed built).2.2.1) + have work := Finalization.linear_cost built + rw [exact_run built] + simp only [Run.steps, List.length_append] + change (Finalization.fullTrace model xs left right producer ts).length + + (Reusable.serviceRun model (Finalization.finalState model xs left right producer)).steps = _ ∧ + (Finalization.fullTrace model xs left right producer ts).length + + (Reusable.serviceRun model (Finalization.finalState model xs left right producer)).steps ≤ _ + constructor + · rw [service.1]; omega + · exact Nat.add_le_add work service.2 + +end RMQ.SuccinctFinal.PackedLifecycle.Continuous diff --git a/RMQ/Core/WordRAM/Lifecycle/Controls.lean b/RMQ/Core/WordRAM/Lifecycle/Controls.lean new file mode 100644 index 00000000..59f37497 --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/Controls.lean @@ -0,0 +1,300 @@ +import RMQ.Core.WordRAM.Lifecycle.ArrayRun +import RMQ.Core.WordRAM.Lifecycle.Descriptor +import RMQ.Core.WordRAM.Lifecycle.Finalizer +import RMQ.Core.WordRAM.Lifecycle.Retained + +/-! # Small replayable lifecycle predicate controls + +Every observed transition below comes from `runArray`; the fixture programs use +the production scalar evaluator. These controls check named projections, not the +complete public lifecycle theorem. The real service's dirty second query is a +separate required integration control, not certified by this module. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle.Controls + +open PackedConstruction (Memory Operand) + +/-- Source interval [1,3) overlaps its destination [0,2). -/ +def source : Owner := + { regs := #[1, 0, 2, 0, 0, 0, 0, 0] + memory := #[some 0, some 11, some 22] + keys := #[] + keyRegs := #[] + pc := 0 + status := .running } + +def original : Memory := source.toState.core.memory +def finalizerCode : List Instruction := Finalizer.code 0 (by decide) +def forward : ArrayRun := runArray finalizerCode.toArray (Finalizer.cost 1 2) source + +theorem source_initialized : Finalizer.Initialized original 1 2 := by + intro j hj + have cases : j = 0 ∨ j = 1 := by omega + rcases cases with rfl | rfl + · exact ⟨11, rfl⟩ + · exact ⟨22, rfl⟩ + +theorem source_entry : Finalizer.Entry 0 1 2 source.toState := + ⟨rfl, rfl, rfl, rfl, rfl, source_initialized, source.closed.1⟩ + +theorem forward_accept : Finalizer.FinalOutput original 1 2 forward.final.toState := by + refine ⟨rfl, ?_, forward.final.closed.1⟩ + intro j hj + have cases : j = 0 ∨ j = 1 := by omega + rcases cases with rfl | rfl <;> rfl + +#guard forward.final.memory == #[some 11, some 22] +#guard forward.categoryCount .numericRelease == 1 +#guard forward.reads == [(1, some 11), (2, some 22)] + +/-- Both receipt arguments are actual indexed occurrences, not a fabricated trace. -/ +def copiedAt (r : ArrayRun) (memory : Memory) (i loadIndex storeIndex : Nat) : Prop := + ∃ load store : ArrayTransition, + r.transitions[loadIndex]? = some load ∧ r.transitions[storeIndex]? = some store ∧ + Finalizer.CopyReceipt memory 1 i load.toTransition store.toTransition + +theorem forward_first_copy_accept : copiedAt forward original 0 4 5 := by + refine ⟨forward.transitions[4]'(by decide), forward.transitions[5]'(by decide), + rfl, rfl, ?_⟩ + exact ⟨rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl⟩ + +theorem forward_second_copy_accept : copiedAt forward original 1 11 12 := by + refine ⟨forward.transitions[11]'(by decide), forward.transitions[12]'(by decide), + rfl, rfl, ?_⟩ + exact ⟨rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl⟩ + +/- Wrong output source: receipt identity and the actual destination register. -/ +def outputSource : Owner := { source with regs := #[0, 0, 0, 11, 22, 0, 0, 0] } +def outputGoodRun := runArray #[.old (.move 0 3)] 1 outputSource +def outputBadRun := runArray #[.old (.move 0 4)] 1 outputSource +def outputGood := (outputGoodRun.transitions[0]'(by decide)).toTransition +def outputBad := (outputBadRun.transitions[0]'(by decide)).toTransition + +theorem output_source_accept : Descriptor.OutputReceipt outputGood := by + refine ⟨rfl, ?_, rfl⟩ + exact executeArray_toState (.old (.move 0 3)) outputSource (by change 0 < 8; decide) + +theorem output_source_reject : ¬ Descriptor.OutputReceipt outputBad := by + intro h + have wrong := h.1 + change Action.instruction (.old (.move 0 4)) = .instruction (.old (.move 0 3)) at wrong + cases wrong + +theorem output_source_value_dependency : + outputBad.after.core.regs 0 ≠ outputGood.after.core.regs 0 := by + have mismatch := Descriptor.output_wrong_source outputSource.toState 4 (by decide) + rw [← executeArray_toState (.old (.move 0 4)) outputSource (by change 0 < 8; decide), + ← executeArray_toState (.old (.move 0 3)) outputSource (by change 0 < 8; decide)] at mismatch + exact mismatch + +#guard outputGoodRun.final.regs.getD 0 0 == 11 +#guard outputBadRun.final.regs.getD 0 0 == 22 + +/- Skipping a real producer store leaves a reserved but absent source cell. -/ +def beforeInitialization : Owner := { source with memory := #[some 0, some 11] } +def initialization : Array Instruction := + #[.old (.reserve 6), .old (.constant 5 22), .old (.store 6 5)] +def skippedInitialization : Array Instruction := + #[.old (.reserve 6), .old (.constant 5 22), .old (.constant 7 0)] +def initialized := runOwner initialization 3 beforeInitialization +def skipped := runOwner skippedInitialization 3 beforeInitialization + +theorem initialization_accept : Finalizer.Initialized initialized.toState.core.memory 1 2 := by + intro j hj + have cases : j = 0 ∨ j = 1 := by omega + rcases cases with rfl | rfl + · exact ⟨11, rfl⟩ + · exact ⟨22, rfl⟩ + +theorem initialization_reject : ¬ Finalizer.Initialized skipped.toState.core.memory 1 2 := by + intro h + obtain ⟨v, hv⟩ := h 1 (by decide) + change none = some v at hv + cases hv + +/-- The continuation really executes the same hosted finalizer after either producer. -/ +def initializedProgram : Array Instruction := + (initialization.toList ++ Finalizer.code 3 (by decide)).toArray +def absentProgram : Array Instruction := + (skippedInitialization.toList ++ Finalizer.code 3 (by decide)).toArray +def initializedCopy := runArray initializedProgram 26 beforeInitialization +def absentCopy := runArray absentProgram 26 beforeInitialization + +theorem initialized_copy_reply_accept : + copiedAt initializedCopy initialized.toState.core.memory 1 14 15 := by + refine ⟨initializedCopy.transitions[14]'(by decide), + initializedCopy.transitions[15]'(by decide), rfl, rfl, ?_⟩ + exact ⟨rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl⟩ + +theorem absent_copy_reply_reject : + ¬ copiedAt absentCopy skipped.toState.core.memory 1 14 15 := by + rintro ⟨load, store, _, hs, _⟩ + have noStore : absentCopy.transitions[15]? = none := rfl + rw [noStore] at hs + cases hs + +#guard initializedCopy.final.memory == #[some 11, some 22] +#guard absentCopy.final.status == .fault +#guard absentCopy.reads == [(1, some 11), (2, none)] + +/- A stale owned suffix invalidates the full entry and the same final predicate. -/ +def staleSource : Owner := { source with memory := #[some 0, some 11, some 22, some 99] } +def stale := runArray finalizerCode.toArray (Finalizer.cost 1 2) staleSource + +theorem stale_tail_entry_reject : ¬ Finalizer.Entry 0 1 2 staleSource.toState := by + intro h + have bad := h.2.2.1 + change 4 = 3 at bad + contradiction + +theorem stale_tail_reject : ¬ Finalizer.FinalOutput original 1 2 stale.final.toState := by + intro h + have bad := h.1 + change 3 = 2 at bad + contradiction + +#guard stale.final.memory == #[some 11, some 22, some 22] + +/- Replace only the release instruction. Copying still works; ownership does not. -/ +def omitReleaseCode : Array Instruction := + finalizerCode.toArray.set! 11 (.old (.constant 7 0)) +def omitRelease := runArray omitReleaseCode (Finalizer.cost 1 2) source + +theorem omitted_release_reject : + ¬ Finalizer.FinalOutput original 1 2 omitRelease.final.toState := by + intro h + have bad := h.1 + change 3 = 2 at bad + contradiction + +#guard omitRelease.final.memory == #[some 11, some 22, some 22] +#guard omitRelease.categoryCount .numericRelease == 0 +#guard omitRelease.reads == forward.reads + +/- Reverse the overlapping copy order using scalar loads/stores and one release. -/ +def backwardCode : Array Instruction := #[ + .old (.constant 0 2), .old (.constant 1 1), + .old (.load 5 0), .old (.store 1 5), + .old (.constant 0 1), .old (.constant 1 0), + .old (.load 5 0), .old (.store 1 5), .releaseCell] +def backward := runArray backwardCode 9 source + +theorem backward_copy_reject : + ¬ Finalizer.FinalOutput original 1 2 backward.final.toState := by + intro h + have bad := h.2.1 0 (by decide) + change some 22 = some 11 at bad + contradiction + +#guard backward.final.memory == #[some 22, some 22] +#guard backward.reads == [(2, some 22), (1, some 22)] +#guard backward.categoryCount .numericRelease == 1 + +/- Pointwise default values alone do not retire separately counted key banks. -/ +def emptyValuedBanks : Owner := { source with keys := #[none], keyRegs := #[0] } +def retiredBanks := runArray #[.releaseKey, .releaseKeyRegister] 2 emptyValuedBanks +def retainedBanks := runArray #[.old (.constant 7 0), .old (.constant 7 0)] 2 emptyValuedBanks +def Retired (s : State) : Prop := s.keyExtent = 0 ∧ s.keyRegExtent = 0 + +theorem key_extent_accept : Retired retiredBanks.final.toState := ⟨rfl, rfl⟩ +theorem key_extent_reject : ¬ Retired retainedBanks.final.toState := by + intro h + have bad := h.1 + change 1 = 0 at bad + contradiction + +theorem retained_key_values_empty : + (∀ a, retainedBanks.final.toState.core.keys a = none) ∧ + (∀ r, retainedBanks.final.toState.core.keyRegs r = 0) := by + constructor + · intro a + cases a <;> rfl + · intro r + cases r <;> rfl + +#guard retiredBanks.final.keys.size == 0 && retiredBanks.final.keyRegs.size == 0 +#guard retainedBanks.final.keys.size == 1 && retainedBanks.final.keyRegs.size == 1 + +/- Starting at PC 1 omits the actual base-to-release-counter move. -/ +def wrongEntrySource : Owner := { source with pc := 1 } +def wrongEntry := runArray finalizerCode.toArray (Finalizer.cost 1 2) wrongEntrySource + +theorem wrong_entry_guard_reject : ¬ Finalizer.Entry 0 1 2 wrongEntrySource.toState := by + intro h + have bad := h.2.1 + change 1 = 0 at bad + contradiction + +theorem wrong_entry_result_reject : + ¬ Finalizer.FinalOutput original 1 2 wrongEntry.final.toState := by + intro h + have bad := h.1 + change 3 = 2 at bad + contradiction + +#guard wrongEntry.final.memory == #[some 11, some 22, some 22] + +/- All fields, including dormant fields, use the production encoding predicate. +The fixture width is 8; the production language itself bounds operands by 2^32. -/ +def fittingDormant : List Instruction := [.old (.halt 0), .old (.constant 0 255)] +def overflowingDormant : List Instruction := [.old (.halt 0), .old (.constant 0 256)] + +theorem field_width_accept : ∀ i ∈ fittingDormant, i.Fits 8 := by + intro i hi + simp only [fittingDormant, List.mem_cons, List.not_mem_nil, or_false] at hi + rcases hi with rfl | rfl <;> + simp [Instruction.Fits, Instruction.encoding, PackedConstruction.Prim.constants] + +theorem field_width_reject : ¬ (∀ i ∈ overflowingDormant, i.Fits 8) := by + intro h + have bad := h (.old (.constant 0 256)) (by simp [overflowingDormant]) + have bound := bad 256 (by simp [Instruction.encoding, PackedConstruction.Prim.constants]) + omega + +theorem register_field_width_accept : (Instruction.old (.move 255 0)).Fits 8 := by + simp [Instruction.Fits, Instruction.encoding, PackedConstruction.Prim.constants] + +theorem register_field_width_reject : ¬ (Instruction.old (.move 256 0)).Fits 8 := by + intro h + have bad := h 256 (by simp [Instruction.encoding, PackedConstruction.Prim.constants]) + omega + +theorem branch_field_width_accept : (Instruction.old (.branchZero 0 255)).Fits 8 := by + simp [Instruction.Fits, Instruction.encoding, PackedConstruction.Prim.constants] + +theorem branch_field_width_reject : ¬ (Instruction.old (.branchZero 0 256)).Fits 8 := by + intro h + have bad := h 256 (by simp [Instruction.encoding, PackedConstruction.Prim.constants]) + omega + +#guard (runArray fittingDormant.toArray 2 source).final.status == .halted 1 +#guard (runArray overflowingDormant.toArray 2 source).final.status == .halted 1 +#guard (runArray overflowingDormant.toArray 2 source).steps == 1 + +/-- The runtime dirty-bank control tests this register projection of the same +query-entry ABI established by the real service setup. Its witness is obtained +from an executed first query; no large closed execution is reduced at import. -/ +def entryRegisterClean (owner : Owner) (r : Nat) : Bool := owner.regs.getD r 0 == 0 + +theorem query_entry_implies_clean (owner : Owner) (n left right r : Nat) + (high : 3 ≤ r) + (entry : Retained.projectQueryState owner.toState = + PackedWordRAM.initialState n left right) : entryRegisterClean owner r = true := by + have h := congrArg (fun s : PackedWordRAM.State => s.regs r) entry + have h0 : r ≠ 0 := by omega + have h1 : r ≠ 1 := by omega + have h2 : r ≠ 2 := by omega + simpa [entryRegisterClean, Retained.projectQueryState, Owner.toState, + PackedConstruction.ExecState.abstract, PackedWordRAM.initialState, + PackedWordRAM.inputRegisters, PackedWordRAM.Registers.write, h0, h1, h2] using h + +theorem dirty_register_rejects_entry (owner : Owner) (n left right r : Nat) + (high : 3 ≤ r) (dirty : entryRegisterClean owner r = false) : + Retained.projectQueryState owner.toState ≠ PackedWordRAM.initialState n left right := by + intro entry + have clean := query_entry_implies_clean owner n left right r high entry + rw [dirty] at clean + contradiction + +end RMQ.SuccinctFinal.PackedLifecycle.Controls diff --git a/RMQ/Core/WordRAM/Lifecycle/Descriptor.lean b/RMQ/Core/WordRAM/Lifecycle/Descriptor.lean new file mode 100644 index 00000000..22db7d7e --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/Descriptor.lean @@ -0,0 +1,293 @@ +import RMQ.Core.WordRAM.Lifecycle.Input + +/-! # Charged descriptor and request transfer + +The base is transferred from output register 3. Size and output length are +loaded from its produced metadata; the current request is read from the input +arena before copying or retirement can overwrite its two cells. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle.Descriptor + +open PackedConstruction (Operand Prim execPrim put Arithmetic) +set_option linter.unusedSimpArgs false +set_option linter.unnecessarySimpa false + +def requestBase : InputModel → Nat → Nat + | .word, n => n + 1 + | .comparison, _ => 1 + +def code (model : InputModel) : List Instruction := [ + .old (.move 0 3), + .old (.load 302 0), + .old (.constant 4 7), + .old (.arithmetic .add 4 0 4), + .old (.load 2 4), + .old (match model with | .word => .move 4 302 | .comparison => .constant 4 0), + .old (.constant 5 1), + .old (.arithmetic .add 4 4 5), + .old (.load 300 4), + .old (.arithmetic .add 4 4 5), + .old (.load 301 4)] + +def Hosted (program : List Instruction) (base : Nat) (model : InputModel) : Prop := + ∀ i, i < 11 → program[base + i]? = (code model)[i]? + +def Entry (model : InputModel) (base B n M left right : Nat) (s : State) : Prop := + s.core.status = .running ∧ s.core.pc = base ∧ s.core.regs 3 = B ∧ + B + 7 < s.core.extent ∧ s.core.memory B = some n ∧ + s.core.memory (B + 7) = some M ∧ + requestBase model n + 1 < s.core.extent ∧ + s.core.memory (requestBase model n) = some left ∧ + s.core.memory (requestBase model n + 1) = some right + +def Result (base B n M left right : Nat) (s t : State) : Prop := + t.core.status = .running ∧ t.core.pc = base + 11 ∧ + t.core.regs 0 = B ∧ t.core.regs 2 = M ∧ t.core.regs 302 = n ∧ + t.core.regs 300 = left ∧ t.core.regs 301 = right ∧ + t.core.memory = s.core.memory ∧ t.core.extent = s.core.extent ∧ + t.core.keys = s.core.keys ∧ t.core.keyRegs = s.core.keyRegs ∧ + t.keyExtent = s.keyExtent ∧ t.keyRegExtent = s.keyRegExtent ∧ + (∀ r, 400 ≤ r → t.core.regs r = s.core.regs r) + +theorem transfer {program : List Instruction} {model : InputModel} {base B n M left right : Nat} + {s : State} (host : Hosted program base model) (entry : Entry model base B n M left right s) : + Result base B n M left right s (run program 11 s).final ∧ + (run program 11 s).steps = 11 := by + obtain ⟨hr, hpc, hB, hbound, hn, hM, hreq, hl, hright⟩ := entry + have h0 := host 0 (by decide) + have h1 := host 1 (by decide) + have h2 := host 2 (by decide) + have h3 := host 3 (by decide) + have h4 := host 4 (by decide) + have h5 := host 5 (by decide) + have h6 := host 6 (by decide) + have h7 := host 7 (by decide) + have h8 := host 8 (by decide) + have h9 := host 9 (by decide) + have h10 := host 10 (by decide) + have hBlt : B < s.core.extent := by omega + have hreqlt : requestBase model n < s.core.extent := by omega + cases model <;> + simp only [code, List.getElem?_cons_zero, List.getElem?_cons_succ, Nat.add_zero] at h0 h1 h2 h3 h4 h5 h6 h7 h8 h9 h10 <;> + simp only [requestBase] at hreq hreqlt hl hright <;> + simp [run, step, hpc, hr, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, + execute, execPrim, PackedConstruction.State.writeNext, PackedConstruction.State.next, + put, Arithmetic.eval, hB, hBlt, hbound, hn, hM, hl, hright, hreq, hreqlt, + Nat.add_assoc, Result, Run.steps] <;> + intro r h400 <;> simp [put, show r ≠ 0 by omega, show r ≠ 2 by omega, + show r ≠ 4 by omega, show r ≠ 5 by omega, show r ≠ 300 by omega, + show r ≠ 301 by omega, show r ≠ 302 by omega] + +@[simp] theorem code_length (model : InputModel) : (code model).length = 11 := rfl + +/-- Proof-erased old instruction view of this same static code list. -/ +def coreCode (model : InputModel) : List PackedConstruction.BInstr := + (code model).filterMap (fun i => match i with | .old p => some ⟨p⟩ | _ => none) + +theorem code_eq (model : InputModel) : code model = (coreCode model).map oldInstruction := by + cases model <;> rfl + +@[simp] theorem coreCode_length (model : InputModel) : (coreCode model).length = 11 := by + cases model <;> rfl + +theorem code_fields (model : InputModel) : + (code model)[0]? = some (.old (.move 0 3)) ∧ + (code model)[1]? = some (.old (.load 302 0)) ∧ + (code model)[4]? = some (.old (.load 2 4)) ∧ + (code model)[8]? = some (.old (.load 300 4)) ∧ + (code model)[10]? = some (.old (.load 301 4)) := by simp [code] + +theorem code_encoding (model : InputModel) : + (code model).map Instruction.encoding = + [[2,0,3], [0,302,0], [1,4,7], [3,0,4,0,4], [0,2,4], + (match model with | .word => [2,4,302] | .comparison => [1,4,0]), + [1,5,1], [3,0,4,4,5], [0,300,4], [3,0,4,4,5], [0,301,4]] := by + cases model <;> rfl + +theorem code_fits {model : InputModel} {W : Nat} (hw : 32 ≤ W) + {i : Instruction} (_hi : i ∈ code model) : i.Fits W := by + have hw32 : 2^32 ≤ 2^W := Nat.pow_le_pow_right (by decide) hw + cases i with + | old p => + intro word hword + obtain ⟨v, _, rfl⟩ := List.mem_map.mp hword + exact Nat.lt_of_lt_of_le v.isLt hw32 + | releaseCell => simp [Instruction.Fits, Instruction.encoding]; omega + | releaseKey => simp [Instruction.Fits, Instruction.encoding]; omega + | releaseKeyRegister => simp [Instruction.Fits, Instruction.encoding]; omega + +def Frame (s t : State) : Prop := + t.core.memory = s.core.memory ∧ t.core.extent = s.core.extent ∧ + t.core.keys = s.core.keys ∧ t.core.keyRegs = s.core.keyRegs ∧ + t.keyExtent = s.keyExtent ∧ t.keyRegExtent = s.keyRegExtent ∧ + ∀ r, 400 ≤ r → t.core.regs r = s.core.regs r + +theorem Frame.refl (s : State) : Frame s s := ⟨rfl,rfl,rfl,rfl,rfl,rfl,fun _ _ => rfl⟩ + +theorem Frame.trans {s t u : State} (h : Frame s t) (g : Frame t u) : Frame s u := + ⟨g.1.trans h.1, g.2.1.trans h.2.1, g.2.2.1.trans h.2.2.1, + g.2.2.2.1.trans h.2.2.2.1, g.2.2.2.2.1.trans h.2.2.2.2.1, + g.2.2.2.2.2.1.trans h.2.2.2.2.2.1, + fun r hr => (g.2.2.2.2.2.2 r hr).trans (h.2.2.2.2.2.2 r hr)⟩ + +theorem Frame.closed {s t : State} (frame : Frame s t) (hc : s.Closed) : t.Closed := by + simpa [State.Closed, PackedConstruction.CleanTail, frame.1, frame.2.1, + frame.2.2.1, frame.2.2.2.1, frame.2.2.2.2.1, frame.2.2.2.2.2.1] using hc + +theorem instruction_frame {model : InputModel} {i : Instruction} + (hi : i ∈ code model) (s : State) : Frame s (execute i s) := by + simp only [code, List.mem_cons, List.not_mem_nil, or_false] at hi + rcases hi with rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl + all_goals cases model + all_goals simp [Frame, execute, execPrim, PackedConstruction.State.next, + PackedConstruction.State.writeNext, put] + all_goals + repeat' split + all_goals simp_all [put] + all_goals omega + +def UsesCode (model : InputModel) (r : Run) : Prop := + ∀ t ∈ r.transitions, ∃ i ∈ code model, t.action = .instruction i + +theorem run_frame_of_uses {program : List Instruction} {model : InputModel} + {fuel : Nat} {s : State} (uses : UsesCode model (run program fuel s)) : + Frame s (run program fuel s).final := by + induction fuel generalizing s with + | zero => exact Frame.refl s + | succ fuel ih => + cases hs : step program s with + | none => simpa [run, hs] using Frame.refl s + | some t => + obtain ⟨_, _, i, _, hi, ha⟩ := step_spec hs + obtain ⟨j, hj, hjt⟩ := uses t (by simp [run, hs]) + have heq : j=i := Action.instruction.inj (hjt.symm.trans hi) + subst j + have first : Frame s t.after := by rw [ha]; exact instruction_frame hj s + have rest := ih (s := t.after) (fun u hu => uses u (by simp [run, hs, hu])) + simpa [run, hs] using first.trans rest + +theorem uses_prefix {program : List Instruction} {model : InputModel} + {fuel count : Nat} {s : State} (uses : UsesCode model (run program fuel s)) + (hc : count ≤ fuel) : UsesCode model (run program count s) := by + intro t ht + apply uses t + rw [show fuel=count+(fuel-count) by omega, run_add] + exact List.mem_append_left _ ht + +def categories : List Category := + [.old .register, .old .read, .old .register, .old .arithmetic, .old .read, + .old .register, .old .register, .old .arithmetic, .old .read, .old .arithmetic, .old .read] + +theorem execution_shape {program : List Instruction} {model : InputModel} {base B n M left right : Nat} + {s : State} (host : Hosted program base model) (entry : Entry model base B n M left right s) : + UsesCode model (run program 11 s) ∧ (run program 11 s).categories = categories := by + obtain ⟨hr, hpc, hB, hbound, hn, hM, hreq, hl, hright⟩ := entry + have get : ∀ i, i < 11 → program[base+i]? = (code model)[i]? := host + have h0 : program[base]? = some (.old (.move 0 3)) := by simpa [code] using host 0 (by decide) + have hBlt : B < s.core.extent := by omega + have hreqlt : requestBase model n < s.core.extent := by omega + cases model <;> simp only [requestBase] at hreq hreqlt hl hright <;> + simp [UsesCode, categories, Run.categories, Action.category, Prim.category, + run, step, hpc, hr, h0, get, code, + execute, execPrim, PackedConstruction.State.writeNext, PackedConstruction.State.next, + put, Arithmetic.eval, hB, hBlt, hbound, hn, hM, hl, hright, hreq, hreqlt, Nat.add_assoc] + +theorem transfer_prefix_frame {program : List Instruction} {model : InputModel} {base B n M left right : Nat} + {s : State} (host : Hosted program base model) (entry : Entry model base B n M left right s) + {fuel : Nat} (hf : fuel ≤ 11) : Frame s (run program fuel s).final := + run_frame_of_uses (uses_prefix (execution_shape host entry).1 hf) + +def Good (W : Nat) (program : List Instruction) (r : Run) : Prop := + ∀ t ∈ r.transitions, t.Safe W program.length + +theorem transfer_good {program : List Instruction} {model : InputModel} {base B n M left right W : Nat} + {s : State} (host : Hosted program base model) (entry : Entry model base B n M left right s) + (hw : 32 ≤ W) (fit : s.Fits W) : Good W program (run program 11 s) := by + obtain ⟨hr, hpc, hB, hbound, hn, hM, hreq, hl, hright⟩ := entry + have get : ∀ i, i < 11 → program[base+i]? = (code model)[i]? := host + have h0 : program[base]? = some (.old (.move 0 3)) := by simpa [code] using host 0 (by decide) + have hBlt : B < s.core.extent := by omega + have hreqlt : requestBase model n < s.core.extent := by omega + have he := fit.1.2.2.1 + have hnfit := fit.1.2.2.2.1 B n hn + have hMfit := fit.1.2.2.2.1 (B+7) M hM + have hlfit := fit.1.2.2.2.1 (requestBase model n) left hl + have hrfit := fit.1.2.2.2.1 (requestBase model n+1) right hright + cases model <;> simp only [requestBase] at hreq hreqlt hl hright <;> + simp [Good, run, step, hpc, hr, h0, get, code, + execute, execPrim, PackedConstruction.State.writeNext, PackedConstruction.State.next, + put, Arithmetic.eval, hB, hBlt, hbound, hn, hM, hl, hright, hreq, hreqlt, Nat.add_assoc, + Transition.Safe, Instruction.Safe, Prim.Safe, Prim.SafeAt, Prim.operandsFit_of_width _ hw, + hnfit, hMfit, hlfit, hrfit] <;> omega + +theorem transfer_safe {program : List Instruction} {model : InputModel} {base B n M left right W : Nat} + {s : State} (host : Hosted program base model) (entry : Entry model base B n M left right s) + (hw : 32 ≤ W) (fit : s.Fits W) (plen : program.length < 2^W) : + Good W program (run program 11 s) ∧ (run program 11 s).final.Fits W ∧ + ∀ t ∈ (run program 11 s).transitions, t.before.Fits W ∧ t.after.Fits W := by + have hg := transfer_good host entry hw fit + exact ⟨hg, run_fits fit plen hg⟩ + +def OutputReceipt (t : Transition) : Prop := + t.action = .instruction (.old (.move 0 3)) ∧ + t.after = execute (.old (.move 0 3)) t.before ∧ + t.after.core.regs 0 = t.before.core.regs 3 + +theorem output_projection (s : State) : + (execute (.old (.move 0 3)) s).core.regs 0 = s.core.regs 3 := by + simp [execute, execPrim, PackedConstruction.State.writeNext, PackedConstruction.State.next, put] + +/-- A distinct source value distinguishes the charged transfer from a wrong +source-register move, even if both movements have the same category and cost. -/ +theorem output_wrong_source (s : State) (source : Operand) + (different : s.core.regs source ≠ s.core.regs 3) : + (execute (.old (.move 0 source)) s).core.regs 0 ≠ + (execute (.old (.move 0 3)) s).core.regs 0 := by + simpa [execute, execPrim, PackedConstruction.State.writeNext, + PackedConstruction.State.next, put] using different + +theorem output_transfer_at {program : List Instruction} {model : InputModel} {base B n M left right : Nat} + {s : State} (host : Hosted program base model) (entry : Entry model base B n M left right s) : + ∃ t, (run program 11 s).transitions[0]? = some t ∧ t.before = s ∧ + OutputReceipt t ∧ t.after.core.regs 0 = B := by + have fetch : program[s.core.pc]? = some (.old (.move 0 3)) := by + rw [entry.2.1] + simpa [code] using host 0 (by decide) + have hs := step_of_running entry.1 fetch + refine ⟨⟨s, .instruction (.old (.move 0 3)), execute (.old (.move 0 3)) s⟩, + by simp [run, hs], rfl, ?_, ?_⟩ + · exact ⟨rfl, rfl, output_projection s⟩ + · exact (output_projection s).trans entry.2.2.1 + +def ReadReceipt (dst addr : Operand) (address value : Nat) (t : Transition) : Prop := + t.action = .instruction (.old (.load dst addr)) ∧ + t.before.core.regs addr = address ∧ address < t.before.core.extent ∧ + t.before.core.memory address = some value ∧ + t.after = execute (.old (.load dst addr)) t.before ∧ t.after.core.regs dst = value + +/-- The metadata and request values are read at these four actual occurrences. +The fetched load operands, resolved addresses and pre-state cells are retained. -/ +theorem read_occurrences {program : List Instruction} {model : InputModel} {base B n M left right : Nat} + {s : State} (host : Hosted program base model) (entry : Entry model base B n M left right s) : + (∃ t, (run program 11 s).transitions[1]? = some t ∧ ReadReceipt 302 0 B n t) ∧ + (∃ t, (run program 11 s).transitions[4]? = some t ∧ ReadReceipt 2 4 (B+7) M t) ∧ + (∃ t, (run program 11 s).transitions[8]? = some t ∧ + ReadReceipt 300 4 (requestBase model n) left t) ∧ + (∃ t, (run program 11 s).transitions[10]? = some t ∧ + ReadReceipt 301 4 (requestBase model n+1) right t) := by + obtain ⟨hr, hpc, hB, hbound, hn, hM, hreq, hl, hright⟩ := entry + have get : ∀ i, i < 11 → program[base+i]? = (code model)[i]? := host + have h0 : program[base]? = some (.old (.move 0 3)) := by simpa [code] using host 0 (by decide) + have hBlt : B < s.core.extent := by omega + have hreqlt : requestBase model n < s.core.extent := by omega + cases model <;> simp only [requestBase] at hreq hreqlt hl hright ⊢ <;> + simp [ReadReceipt, run, step, hpc, hr, h0, get, code, + execute, execPrim, PackedConstruction.State.writeNext, PackedConstruction.State.next, + put, Arithmetic.eval, hB, hBlt, hbound, hn, hM, hl, hright, hreq, hreqlt, Nat.add_assoc] + +theorem occurrence_prestate {program : List Instruction} {s : State} {k : Nat} {t : Transition} + (ht : (run program 11 s).transitions[k]? = some t) : + t.before = (run program k s).final ∧ step program t.before = some t := run_transition_at ht + +end RMQ.SuccinctFinal.PackedLifecycle.Descriptor diff --git a/RMQ/Core/WordRAM/Lifecycle/Executable.lean b/RMQ/Core/WordRAM/Lifecycle/Executable.lean new file mode 100644 index 00000000..5aea1c12 --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/Executable.lean @@ -0,0 +1,764 @@ +import RMQ.Core.WordRAM.Lifecycle.ArrayRun +import RMQ.Core.WordRAM.Lifecycle.Input +import RMQ.Core.WordRAM.Lifecycle.QueryBridge +import RMQ.Core.WordRAM.Lifecycle.Finalization +import RMQ.Core.WordRAM.Lifecycle.ServiceSafety +import RMQ.Core.WordRAM.Lifecycle.Reusable + +/-! # Finite supplied owners and executable lifecycle refinement + +Input materialization supplies only the numeric input representation, two +request cells, and the separately counted comparison resources. It does not +construct the final RMQ allocation. Numeric capacity is tracked separately +from the functional abstraction, which erases that capacity. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle.Executable + +open PackedConstruction (Operand Prim BInstr put) +open PackedConstruction.Structured (Block) + +attribute [local irreducible] Layout.program Service.program Service.entry Service.budget + +def inputArray (model : InputModel) (xs : List Int) : Array (Option Nat) := + match model with + | .word => (some xs.length :: xs.map (fun x => some (PackedConstruction.encodeInt + (PackedWordRAM.wordWidth xs.length) x))).toArray + | .comparison => #[some xs.length] + +def initialOwnerAt (model : InputModel) (xs : List Int) (left right entry : Nat) : Owner := + { regs := Array.replicate 8273 0 + memory := ((inputArray model xs).push (some left)).push (some right) + keys := if model = .comparison then (xs.map some).toArray else #[] + keyRegs := if model = .comparison then Array.replicate 2 0 else #[] + pc := entry + status := .running } + +theorem inputArray_size (model : InputModel) (xs : List Int) : + (inputArray model xs).size = (inputCore model xs).extent := by + cases model <;> simp [inputArray, inputCore, PackedConstruction.wordInputState, + PackedConstruction.comparisonInputState, PackedConstruction.inputCellCount] + +theorem inputArray_memory (model : InputModel) (xs : List Int) : + (fun a => (inputArray model xs).getD a none) = (inputCore model xs).memory := by + funext a + cases model with + | comparison => cases a <;> rfl + | word => + cases a with + | zero => simp [inputArray, Array.getD_eq_getD_getElem?, inputCore, + PackedConstruction.wordInputState] + | succ a => + cases h : xs[a]? <;> + simp [inputArray, Array.getD_eq_getD_getElem?, List.getElem?_map, h, + inputCore, PackedConstruction.wordInputState, PackedConstruction.encodeInput] + +private theorem lookup_push {α : Type} (xs : Array α) (v default : α) : + (fun a => (xs.push v).getD a default) = + put (fun a => xs.getD a default) xs.size v := by + funext a + simp only [Array.getD_eq_getD_getElem?, Array.getElem?_push, put] + by_cases ha : a = xs.size + · simp [ha] + · simp [ha] + +theorem initialOwnerAt_toState (model : InputModel) (xs : List Int) + (left right entry : Nat) : + (initialOwnerAt model xs left right entry).toState = + initialState model xs left right entry := by + have hm : (fun a => (initialOwnerAt model xs left right entry).memory.getD a none) = + (initialState model xs left right entry).core.memory := by + change (fun a => (((inputArray model xs).push (some left)).push (some right)).getD a none) = _ + rw [lookup_push, lookup_push, Array.size_push, inputArray_size, inputArray_memory] + rfl + have hr : (fun r => (Array.replicate 8273 (0 : Nat)).getD r 0) = fun _ => 0 := by + funext r + simp [Array.getD_eq_getD_getElem?, Array.getElem?_replicate] + split <;> rfl + have hk : (fun a => ((xs.map some).toArray).getD a none) = fun a => xs[a]? := by + funext a + cases h : xs[a]? <;> simp [Array.getD_eq_getD_getElem?, List.getElem?_map, h] + have hkr : (fun r => (Array.replicate 2 (0 : Int)).getD r 0) = fun _ => 0 := by + funext r + simp [Array.getD_eq_getD_getElem?, Array.getElem?_replicate] + split <;> rfl + cases model <;> + simp only [Owner.toState, PackedConstruction.ExecState.abstract, initialOwnerAt, + initialState, inputCore, PackedConstruction.wordInputState, + PackedConstruction.comparisonInputState, reduceCtorEq, ↓reduceIte, + Array.size_push, Array.size_replicate, List.size_toArray, List.length_map, + inputArray_size, hr, hk, hkr] at hm ⊢ + all_goals simp only [hm] <;> rfl + +theorem initialOwnerAt_regs_size (model : InputModel) (xs : List Int) (left right entry : Nat) : + (initialOwnerAt model xs left right entry).regs.size = 8273 := by + simp [initialOwnerAt] + +theorem initialOwnerAt_memory_size (model : InputModel) (xs : List Int) (left right entry : Nat) : + (initialOwnerAt model xs left right entry).memory.size = (inputCore model xs).extent + 2 := by + simp [initialOwnerAt, inputArray_size, Nat.add_assoc] + +theorem initialOwnerAt_key_sizes (model : InputModel) (xs : List Int) (left right entry : Nat) : + (initialOwnerAt model xs left right entry).keys.size = + (if model = .comparison then xs.length else 0) ∧ + (initialOwnerAt model xs left right entry).keyRegs.size = + (if model = .comparison then 2 else 0) := by + cases model <;> simp [initialOwnerAt] + +/-- Numeric destinations and comparison destinations are distinct static inventories. -/ +def NumericBelow (R : Nat) : Instruction → Prop + | .old p => ∀ d, p.destination? = some d → d.val < R + | _ => True + +def KeyBelow (K : Nat) : Instruction → Prop + | .old (.loadKey dst _) => dst.val < K + | _ => True + +theorem keyBelow_mono {K L : Nat} {i : Instruction} (h : KeyBelow K i) (hle : K ≤ L) : + KeyBelow L i := by + cases i with + | old p => cases p <;> simp_all [KeyBelow] <;> omega + | releaseCell | releaseKey | releaseKeyRegister => trivial + +theorem destinations_of_separate {R : Nat} {i : Instruction} {s : State} + (numeric : NumericBelow R i) (keys : KeyBelow s.keyRegExtent i) : + i.AbstractDestinationsFit R s := by + cases i with + | old p => + cases p <;> simp_all [NumericBelow, KeyBelow, PackedConstruction.Prim.destination?, + Instruction.AbstractDestinationsFit, destinationsBelow] + | releaseCell | releaseKey | releaseKeyRegister => trivial + +theorem numeric_of_registersBelow {R S : Nat} (i : BInstr) + (bound : i.primitive.RegistersBelow R) (le : R ≤ S) : NumericBelow S (oldInstruction i) := by + intro d hd + exact Nat.lt_of_lt_of_le (PackedConstruction.Proof.Prim.dest_lt_of_registersBelow bound d hd) le + +theorem translated_numeric (i : PackedWordRAM.Instruction) {R : Nat} + (writes : i.WritesOnly (fun r => r < R)) : + NumericBelow R (oldInstruction (PackedConstruction.Conservative.translate i)) := by + unfold PackedConstruction.Conservative.translate + split + next fields => + cases i <;> + simp_all [oldInstruction, NumericBelow, PackedConstruction.Prim.destination?, + PackedConstruction.Conservative.instruction, PackedWordRAM.Instruction.WritesOnly] + next => simp [oldInstruction, NumericBelow, PackedConstruction.Prim.destination?] + +theorem translated_key_free (i : PackedWordRAM.Instruction) : + KeyBelow 0 (oldInstruction (PackedConstruction.Conservative.translate i)) := by + unfold PackedConstruction.Conservative.translate + split + next fields => cases i <;> trivial + next => trivial + +theorem compile_keyBelow (block : Block) (base K : Nat) + (bound : Builder.keyRegisterLimit block ≤ K) : + ∀ i ∈ block.compileAt base, KeyBelow K (oldInstruction i) := by + induction block generalizing base with + | skip => simp [Block.compileAt] + | action op => + intro i hi + have eq : i = ⟨op.prim⟩ := List.mem_singleton.mp hi + subst i + cases op <;> simp_all [Builder.keyRegisterLimit, oldInstruction, + PackedConstruction.Structured.Action.prim, KeyBelow] <;> omega + | exit src => + intro i hi + have eq : i = ⟨.halt src⟩ := List.mem_singleton.mp hi + subst i + trivial + | seq a b iha ihb => + intro i hi + rcases List.mem_append.mp hi with ha | hb + · exact iha _ (Nat.le_trans (Nat.le_max_left ..) bound) i ha + · exact ihb _ (Nat.le_trans (Nat.le_max_right ..) bound) i hb + | ifZero c a b iha ihb => + intro i hi + simp only [Block.compileAt, List.mem_append, List.mem_singleton] at hi + rcases hi with ((rfl | hi) | rfl) | hi + · trivial + · exact ihb _ (Nat.le_trans (Nat.le_max_right ..) bound) i hi + · trivial + · exact iha _ (Nat.le_trans (Nat.le_max_left ..) bound) i hi + | loop c body ih => + intro i hi + simp only [Block.compileAt, List.mem_append, List.mem_singleton] at hi + rcases hi with (rfl | hi) | rfl + · trivial + · exact ih _ bound i hi + · trivial + +theorem eval_add_keys {P : PackedConstruction.State → PackedConstruction.Structured.Action → Prop} + {b : Block} {s t : PackedConstruction.State} {steps : Nat} + (e : PackedConstruction.Structured.EvalG P b s t steps) (K : Nat) + (bound : Builder.keyRegisterLimit b ≤ K) : + PackedConstruction.Structured.EvalG + (fun s op => P s op ∧ KeyBelow K (.old op.prim)) b s t steps := by + induction e generalizing K with + | stopped b s h => exact .stopped b s h + | skip s h => exact .skip s h + | action op s h hp => + refine .action op s h ⟨hp, ?_⟩ + cases op <;> simp_all [Builder.keyRegisterLimit, + PackedConstruction.Structured.Action.prim, KeyBelow] <;> omega + | exit src s h => exact .exit src s h + | seq _ _ iha ihb => + exact .seq (iha K (Nat.le_trans (Nat.le_max_left ..) bound)) + (ihb K (Nat.le_trans (Nat.le_max_right ..) bound)) + | ifZeroTaken h hc _ ih => + exact .ifZeroTaken h hc (ih K (Nat.le_trans (Nat.le_max_left ..) bound)) + | ifZeroFallthrough h hc _ hr ih => + exact .ifZeroFallthrough h hc (ih K (Nat.le_trans (Nat.le_max_right ..) bound)) hr + | ifZeroFallthroughStopped h hc _ hr ih => + exact .ifZeroFallthroughStopped h hc (ih K (Nat.le_trans (Nat.le_max_right ..) bound)) hr + | loopExit h hc => exact .loopExit h hc + | loopStep h hc _ hr _ ihb ihr => + exact .loopStep h hc (ihb K bound) hr (ihr K bound) + | loopStopped h hc _ hr ih => exact .loopStopped h hc (ih K bound) hr + +/-- Recompile the same derivation with a structural key-write inventory and +identify the resulting trace with the original execution by determinism. -/ +theorem hosted_key_trace {W base : Nat} {program : List BInstr} {leaf : Block} + {xs : List Int} {s abstract final : PackedConstruction.State} + {ts : List PackedConstruction.Transition} + (body : Builder.HostedBody W program base leaf xs s abstract final ts) + (entry : s.pc = base) + (host : PackedConstruction.Structured.HostedAt program base + ((PackedConstruction.builderSource leaf).compileAt base)) + (bound : base + (PackedConstruction.builderSource leaf).size < 2^32) : + ∀ t ∈ ts, KeyBelow (Builder.keyRegisterLimit (PackedConstruction.builderSource leaf)) + (oldInstruction t.instruction) := by + let K := Builder.keyRegisterLimit (PackedConstruction.builderSource leaf) + have e := eval_add_keys body.evaluation K (Nat.le_refl _) + obtain ⟨mid, us, execution, len, agree, pc, shapes⟩ := e.compile_realizes + (fun _ q _ h => ⟨h.1.pc_set q, h.2⟩) program base host bound + have running : mid.status = .running := by + have ar : abstract.status = .running := by + have hr := body.running + rw [body.intermediate] at hr + exact hr + exact agree.status.trans ar + have finalEq : mid = final := by rw [agree.eq_set, pc running, body.intermediate] + have startEq : ({s with pc := base} : PackedConstruction.State) = s := by rw [← entry] + rw [finalEq, startEq] at execution + have traces : us = ts := by + unfold PackedConstruction.RunsTo at execution + rw [len] at execution + exact congrArg PackedConstruction.Run.transitions (execution.symm.trans body.execution) + subst us + intro t ht + rcases shapes t ht with ⟨op, action, _, keys⟩ | ⟨condition, target, action, _⟩ | + ⟨target, action, _⟩ | ⟨src, action⟩ + · simpa only [action, oldInstruction] using keys + all_goals simp [action, oldInstruction, KeyBelow] + +/-- A property of the actual trace, including its actual pre-state key extent. -/ +def TraceKeysFit (ts : List Transition) : Prop := + ∀ t ∈ ts, ∀ i, t.action = .instruction i → KeyBelow t.before.keyRegExtent i + +theorem traceKeysFit_append {a b : List Transition} + (ha : TraceKeysFit a) (hb : TraceKeysFit b) : TraceKeysFit (a ++ b) := by + intro t ht i hi + exact (List.mem_append.mp ht).elim (fun h => ha t h i hi) (fun h => hb t h i hi) + +theorem traceKeysFit_of_key_free {ts : List Transition} + (free : ∀ t ∈ ts, ∀ i, t.action = .instruction i → KeyBelow 0 i) : TraceKeysFit ts := + fun t ht i hi => keyBelow_mono (free t ht i hi) (Nat.zero_le _) + +theorem traceDestinations_of_keys {program : List Instruction} {fuel : Nat} {s : State} + (numeric : ∀ i ∈ program, NumericBelow 8273 i) + (keys : TraceKeysFit (run program fuel s).transitions) : + TraceDestinationsFit 8273 (run program fuel s).transitions := by + intro k t ht i hi + obtain ⟨_, _, actual, fetch, action, _⟩ := step_spec (run_transition_at ht).2 + have eq : actual = i := by rw [hi] at action; exact (Action.instruction.inj action).symm + subst actual + exact destinations_of_separate (numeric i (List.mem_of_getElem? fetch)) + (keys t (List.mem_of_getElem? ht) i hi) + +def initialOwner (model : InputModel) (xs : List Int) (left right : Nat) : Owner := + initialOwnerAt model xs left right Layout.builderBase + +theorem initialOwner_toState (model : InputModel) (xs : List Int) (left right : Nat) : + (initialOwner model xs left right).toState = + initialState model xs left right Layout.builderBase := + initialOwnerAt_toState model xs left right Layout.builderBase + +theorem initialOwner_regs_size (model : InputModel) (xs : List Int) (left right : Nat) : + (initialOwner model xs left right).regs.size = 8273 := + initialOwnerAt_regs_size model xs left right Layout.builderBase + +theorem initialOwner_memory_size (model : InputModel) (xs : List Int) (left right : Nat) : + (initialOwner model xs left right).memory.size = + (match model with | .word => xs.length + 3 | .comparison => 3) := by + change (initialOwnerAt model xs left right Layout.builderBase).memory.size = _ + rw [initialOwnerAt_memory_size] + cases model <;> rfl + +theorem initialOwner_key_sizes (model : InputModel) (xs : List Int) (left right : Nat) : + (initialOwner model xs left right).keys.size = + (if model = .comparison then xs.length else 0) ∧ + (initialOwner model xs left right).keyRegs.size = + (if model = .comparison then 2 else 0) := + initialOwnerAt_key_sizes model xs left right Layout.builderBase + +theorem builder_numeric (model : InputModel) : + ∀ i ∈ Layout.builderCode model, NumericBelow 8273 (oldInstruction i) := by + have rb : (PackedConstruction.builderSource model.source).RegsBelow 400 := + ⟨by simp [Block.RegsBelow, PackedConstruction.Structured.Action.prim, + Prim.RegistersBelow], Construction.source_bank model⟩ + intro i hi + exact numeric_of_registersBelow i + (Block.compile_regsBelow 400 _ rb Layout.builderBase i hi) (by decide) + +theorem descriptor_numeric (model : InputModel) : + ∀ i ∈ Descriptor.code model, NumericBelow 8273 i := by + cases model <;> simp [Descriptor.code, NumericBelow, Prim.destination?] + +theorem descriptor_key_free (model : InputModel) : + ∀ i ∈ Descriptor.code model, KeyBelow 0 i := by + cases model <;> simp [Descriptor.code, KeyBelow] + +theorem finalizer_numeric (base : Nat) (bound : base+14 < 2^32) : + ∀ i ∈ Finalizer.code base bound, NumericBelow 8273 i := by + simp [Finalizer.code, NumericBelow, Prim.destination?] + +theorem finalizer_key_free (base : Nat) (bound : base+14 < 2^32) : + ∀ i ∈ Finalizer.code base bound, KeyBelow 0 i := by + simp [Finalizer.code, KeyBelow] + +theorem retirement_numeric (base : Nat) (bound : base+8 < 2^32) : + ∀ i ∈ Retirement.code base bound, NumericBelow 8273 i := by + simp [Retirement.code, NumericBelow, Prim.destination?] + +theorem retirement_key_free (base : Nat) (bound : base+8 < 2^32) : + ∀ i ∈ Retirement.code base bound, KeyBelow 0 i := by + simp [Retirement.code, KeyBelow] + +/-- Every canonical instruction has a numeric destination in the actual bank. +The query bound is structural, not a reflection pass over the large program. -/ +theorem program_numeric (model : InputModel) : + ∀ i ∈ Layout.program model, NumericBelow 8273 i := by + intro i hi + rw [Layout.program] at hi + rcases List.mem_append.mp hi with prefixMember | tail + · obtain ⟨old, member, rfl⟩ := List.mem_map.mp prefixMember + rw [Layout.oldPrefix] at member + rcases List.mem_append.mp member with service | rest + · obtain ⟨query, serviceMember, rfl⟩ := List.mem_map.mp service + exact translated_numeric query (ServiceSafety.program_writes query serviceMember) + · rcases List.mem_append.mp rest with builder | descriptor + · exact builder_numeric model old builder + · apply descriptor_numeric model + rw [Descriptor.code_eq] + exact List.mem_map.mpr ⟨old, descriptor, rfl⟩ + · rw [Layout.tail] at tail + rcases List.mem_append.mp tail with finalizer | rest + · exact finalizer_numeric _ _ i finalizer + · rcases List.mem_append.mp rest with retirement | jump + · cases model with + | word => cases retirement + | comparison => exact retirement_numeric Layout.retirementBase (by decide) i retirement + · have equal := List.mem_singleton.mp jump + subst i + simp [NumericBelow, Prim.destination?] + +theorem body_keys_fit {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (body : Construction.Body model xs left right abstract producer ts) : + TraceKeysFit (Construction.producedTrace model xs left right ts) := by + have keys := hosted_key_trace body rfl (Layout.old_builder_host model) + (Construction.source_bound model) + intro t ht i hi + obtain ⟨old, member, rfl⟩ := List.mem_map.mp ht + change Action.instruction (oldInstruction old.instruction) = .instruction i at hi + have eq := Action.instruction.inj hi + subst i + change KeyBelow (if model = .comparison then 2 else 0) (oldInstruction old.instruction) + have bound := keys old member + cases model with + | word => simpa only [InputModel.source, Builder.word_keyRegister_limit] using bound + | comparison => simpa only [InputModel.source, Builder.comparison_keyRegister_limit] using bound + +theorem trace_keys_of_uses {code : List Instruction} {r : Run} + (free : ∀ i ∈ code, KeyBelow 0 i) + (uses : ∀ t ∈ r.transitions, ∃ i ∈ code, t.action = .instruction i) : + TraceKeysFit r.transitions := by + apply traceKeysFit_of_key_free + intro t ht i hi + obtain ⟨actual, member, action⟩ := uses t ht + rw [hi] at action + have eq := Action.instruction.inj action + subst actual + exact free i member + +theorem finalization_keys_fit {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) : + TraceKeysFit (Finalization.finalTrace model xs left right producer) := by + have descriptor : TraceKeysFit (Finalization.descriptorRun model xs left right producer).transitions := + trace_keys_of_uses (descriptor_key_free model) + (Descriptor.execution_shape (Layout.descriptor_host model) built.descriptor).1 + have copy : TraceKeysFit (Finalization.copyRun model xs left right producer).transitions := + trace_keys_of_uses (finalizer_key_free _ _) + (Finalizer.finalizer_uses (Layout.finalizer_host model) + (Finalization.descriptor_to_finalizer built)) + have retirement : TraceKeysFit (Finalization.retirementRun model xs left right producer).transitions := by + cases model with + | word => intro t ht; cases ht + | comparison => + have copied := (Finalization.copy_stage built).1 + have entry : Retirement.Entry Layout.retirementBase xs.length + (Finalization.copyRun .comparison xs left right producer).final := + ⟨copied.running, copied.pc, copied.keyExtent, copied.keyRegExtent, copied.size, copied.closed⟩ + obtain ⟨_, _, _, _, _, _, uses⟩ := Retirement.comparison_run Layout.retirement_host entry + exact trace_keys_of_uses (retirement_key_free _ _) uses + intro t ht i hi + simp only [Finalization.finalTrace, List.mem_append, List.mem_singleton] at ht + rcases ht with ((ht | ht) | ht) | rfl + · exact descriptor t ht i hi + · exact copy t ht i hi + · exact retirement t ht i hi + · cases hi + trivial + +theorem full_keys_fit {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) : + TraceKeysFit (Finalization.fullTrace model xs left right producer ts) := + traceKeysFit_append (body_keys_fit built.body) (finalization_keys_fit built) + +theorem full_destinations_fit {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) : + TraceDestinationsFit 8273 + (run (Layout.program model) (Finalization.fullTrace model xs left right producer ts).length + (initialState model xs left right Layout.builderBase)).transitions := by + apply traceDestinations_of_keys (program_numeric model) + rw [show run (Layout.program model) (Finalization.fullTrace model xs left right producer ts).length + (initialState model xs left right Layout.builderBase) = + ⟨Finalization.finalState model xs left right producer, + Finalization.fullTrace model xs left right producer ts⟩ from Finalization.full_execution built] + exact full_keys_fit built + +/-- Production execution retains only arrays/control. The state equality and +the numeric-array length are both needed, since abstraction forgets capacity. -/ +theorem preparation_owner_refinement {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) : + let fuel := (Finalization.fullTrace model xs left right producer ts).length + let final := runOwner (Layout.program model).toArray fuel (initialOwner model xs left right) + final.toState = Finalization.finalState model xs left right producer ∧ final.regs.size = 8273 := by + have bounds : TraceDestinationsFit 8273 + (run (Layout.program model) (Finalization.fullTrace model xs left right producer ts).length + (initialOwner model xs left right).toState).transitions := by + rw [initialOwner_toState] + exact full_destinations_fit built + have refined := runOwner_toState_of_abstract (Layout.program model) + (Finalization.fullTrace model xs left right producer ts).length (initialOwner model xs left right) + 8273 (initialOwner_regs_size model xs left right) bounds + rw [initialOwner_toState, show run (Layout.program model) + (Finalization.fullTrace model xs left right producer ts).length + (initialState model xs left right Layout.builderBase) = + ⟨Finalization.finalState model xs left right producer, + Finalization.fullTrace model xs left right producer ts⟩ from Finalization.full_execution built] at refined + exact refined + +/-- Optional observations preserve the same complete run, including ordered +states and instructions; the production owner theorem above retains no history. -/ +theorem preparation_array_refinement {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) : + let fuel := (Finalization.fullTrace model xs left right producer ts).length + let actual := runArray (Layout.program model).toArray fuel (initialOwner model xs left right) + actual.toRun = ⟨Finalization.finalState model xs left right producer, + Finalization.fullTrace model xs left right producer ts⟩ ∧ actual.final.regs.size = 8273 := by + have bounds : TraceDestinationsFit 8273 + (run (Layout.program model) (Finalization.fullTrace model xs left right producer ts).length + (initialOwner model xs left right).toState).transitions := by + rw [initialOwner_toState] + exact full_destinations_fit built + have refined := runArray_toState_of_abstract (Layout.program model) + (Finalization.fullTrace model xs left right producer ts).length (initialOwner model xs left right) + 8273 (initialOwner_regs_size model xs left right) bounds + rw [initialOwner_toState, show run (Layout.program model) + (Finalization.fullTrace model xs left right producer ts).length + (initialState model xs left right Layout.builderBase) = + ⟨Finalization.finalState model xs left right producer, + Finalization.fullTrace model xs left right producer ts⟩ from Finalization.full_execution built] at refined + exact refined + +theorem entered_of_inputs (left right : Nat) (s : State) + (inputs : Service.Inputs left right (Retained.projectQueryState s)) : + ServiceSafety.Entered left right s := by + refine ⟨?_, inputs.2.1, inputs.2.2.1, inputs.2.2.2.1⟩ + have hr := inputs.1 + cases status : s.core.status <;> + simp_all [Retained.projectQueryState, Retained.projectStatus] + +theorem service_keys_fit (model : InputModel) (xs : List Int) (left right fuel : Nat) (s : State) + (canonical : Retained.Canonical xs s) (entered : ServiceSafety.Entered left right s) + (within : fuel ≤ Service.budget) : + TraceKeysFit (run (Layout.program model) fuel s).transitions := by + rw [Layout.service_split] + change TraceKeysFit (run (QuerySafetyBridge.host Service.program + ((Layout.builderCode model ++ Descriptor.coreCode model).map oldInstruction ++ Layout.tail model)) + fuel s).transitions + rw [ServiceSafety.actual_prefix xs _ left right fuel s canonical entered within] + intro t ht i hi + obtain ⟨old, member, rfl⟩ := List.mem_map.mp ht + change Action.instruction (oldInstruction (PackedConstruction.Conservative.translate old.instruction)) = + .instruction i at hi + have eq := Action.instruction.inj hi + subst i + exact translated_key_free old.instruction + +theorem service_stopped (model : InputModel) (xs : List Int) (left right : Nat) (s : State) + (canonical : Retained.Canonical xs s) (entered : ServiceSafety.Entered left right s) : + (run (Layout.program model) Service.budget s).final.core.status ≠ .running := by + rw [Layout.service_split] + change (run (QuerySafetyBridge.host Service.program + ((Layout.builderCode model ++ Descriptor.coreCode model).map oldInstruction ++ Layout.tail model)) + Service.budget s).final.core.status ≠ .running + rw [ServiceSafety.actual_prefix xs _ left right Service.budget s canonical entered (Nat.le_refl _)] + have stopped := ServiceSafety.stopped xs left right (Retained.projectQueryState s) + (ServiceSafety.entered_inputs xs left right s canonical entered) + cases status : (PackedWordRAM.run (PackedWordRAM.buildMemory xs) Service.program Service.budget + (Retained.projectQueryState s)).final.status <;> + simp_all [QuerySafetyBridge.embedded, ofCore, PackedConstruction.Conservative.state, + PackedConstruction.Conservative.status] + +theorem first_query_keys_fit {model : InputModel} {xs : List Int} {left right queryFuel : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) + (within : queryFuel ≤ Service.budget) : + TraceKeysFit (run (Layout.program model) + ((Finalization.fullTrace model xs left right producer ts).length + queryFuel) + (initialState model xs left right Layout.builderBase)).transitions := by + rw [run_add, show run (Layout.program model) + (Finalization.fullTrace model xs left right producer ts).length + (initialState model xs left right Layout.builderBase) = + ⟨Finalization.finalState model xs left right producer, + Finalization.fullTrace model xs left right producer ts⟩ from Finalization.full_execution built] + have completed := Finalization.completed built + exact traceKeysFit_append (full_keys_fit built) + (service_keys_fit model xs left right queryFuel _ completed.2.1 + (entered_of_inputs left right _ completed.2.2.1) within) + +theorem first_query_stopped {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) : + (run (Layout.program model) + ((Finalization.fullTrace model xs left right producer ts).length + Service.budget) + (initialState model xs left right Layout.builderBase)).final.core.status ≠ .running := by + rw [run_add, show run (Layout.program model) + (Finalization.fullTrace model xs left right producer ts).length + (initialState model xs left right Layout.builderBase) = + ⟨Finalization.finalState model xs left right producer, + Finalization.fullTrace model xs left right producer ts⟩ from Finalization.full_execution built] + have completed := Finalization.completed built + dsimp only + exact service_stopped model xs left right (Finalization.finalState model xs left right producer) completed.2.1 + (entered_of_inputs left right _ completed.2.2.1) + +theorem trace_keys_prefix (program : List Instruction) (s : State) {fuel total : Nat} + (within : fuel ≤ total) (keys : TraceKeysFit (run program total s).transitions) : + TraceKeysFit (run program fuel s).transitions := by + intro t ht i hi + apply keys t _ i hi + rw [← Nat.add_sub_of_le within, run_add] + exact List.mem_append_left _ ht + +/-- All actual canonical prefixes satisfy their current bank bounds. Once the +first query stops, additional fuel cannot introduce a further instruction. -/ +theorem canonical_keys_fit {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) (fuel : Nat) : + TraceKeysFit (run (Layout.program model) fuel + (initialState model xs left right Layout.builderBase)).transitions := by + let total := (Finalization.fullTrace model xs left right producer ts).length + Service.budget + have keys := first_query_keys_fit built (Nat.le_refl Service.budget) + by_cases within : fuel ≤ total + · exact trace_keys_prefix _ _ within keys + · have split : fuel = total + (fuel-total) := by omega + have stopped : (run (Layout.program model) total + (initialState model xs left right Layout.builderBase)).final.core.status ≠ .running := + first_query_stopped built + rw [split, run_add] + dsimp only + rw [run_of_stopped _ _ _ stopped] + simpa only [List.append_nil] using keys + +theorem canonical_destinations_fit {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) (fuel : Nat) : + TraceDestinationsFit 8273 (run (Layout.program model) fuel + (initialState model xs left right Layout.builderBase)).transitions := + traceDestinations_of_keys (program_numeric model) (canonical_keys_fit built fuel) + +/-- Arbitrary fuel, actual whole program, supplied finite owner, and no +unchecked destination guard in the consumer's assumptions. -/ +theorem canonical_owner_refinement {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) (fuel : Nat) : + (runOwner (Layout.program model).toArray fuel (initialOwner model xs left right)).toState = + (run (Layout.program model) fuel (initialState model xs left right Layout.builderBase)).final ∧ + (runOwner (Layout.program model).toArray fuel (initialOwner model xs left right)).regs.size = 8273 := by + have bounds : TraceDestinationsFit 8273 + (run (Layout.program model) fuel (initialOwner model xs left right).toState).transitions := by + rw [initialOwner_toState] + exact canonical_destinations_fit built fuel + simpa only [initialOwner_toState] using runOwner_toState_of_abstract (Layout.program model) fuel + (initialOwner model xs left right) 8273 (initialOwner_regs_size model xs left right) bounds + +theorem canonical_array_refinement {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) (fuel : Nat) : + (runArray (Layout.program model).toArray fuel (initialOwner model xs left right)).toRun = + run (Layout.program model) fuel (initialState model xs left right Layout.builderBase) ∧ + (runArray (Layout.program model).toArray fuel (initialOwner model xs left right)).final.regs.size = 8273 := by + have bounds : TraceDestinationsFit 8273 + (run (Layout.program model) fuel (initialOwner model xs left right).toState).transitions := by + rw [initialOwner_toState] + exact canonical_destinations_fit built fuel + simpa only [initialOwner_toState] using runArray_toState_of_abstract (Layout.program model) fuel + (initialOwner model xs left right) 8273 (initialOwner_regs_size model xs left right) bounds + +/-- The construction witness and every destination bound are derived from the +represented input contract. No output state, answer, or trace is supplied. -/ +theorem initial_destinations_fit (model : InputModel) (xs : List Int) (left right : Nat) + (domain : InputDomain model xs) + (hl : left < 2^PackedWordRAM.wordWidth xs.length) + (hr : right < 2^PackedWordRAM.wordWidth xs.length) (fuel : Nat) : + TraceDestinationsFit 8273 (run (Layout.program model) fuel + (initialState model xs left right Layout.builderBase)).transitions := by + obtain ⟨abstract, producer, ts, built⟩ := Construction.build_stage model xs left right domain hl hr + exact canonical_destinations_fit built fuel + +theorem initial_owner_refinement (model : InputModel) (xs : List Int) (left right : Nat) + (domain : InputDomain model xs) + (hl : left < 2^PackedWordRAM.wordWidth xs.length) + (hr : right < 2^PackedWordRAM.wordWidth xs.length) (fuel : Nat) : + (runOwner (Layout.program model).toArray fuel (initialOwner model xs left right)).toState = + (run (Layout.program model) fuel (initialState model xs left right Layout.builderBase)).final ∧ + (runOwner (Layout.program model).toArray fuel (initialOwner model xs left right)).regs.size = 8273 := by + obtain ⟨abstract, producer, ts, built⟩ := Construction.build_stage model xs left right domain hl hr + exact canonical_owner_refinement built fuel + +theorem initial_array_refinement (model : InputModel) (xs : List Int) (left right : Nat) + (domain : InputDomain model xs) + (hl : left < 2^PackedWordRAM.wordWidth xs.length) + (hr : right < 2^PackedWordRAM.wordWidth xs.length) (fuel : Nat) : + (runArray (Layout.program model).toArray fuel (initialOwner model xs left right)).toRun = + run (Layout.program model) fuel (initialState model xs left right Layout.builderBase) ∧ + (runArray (Layout.program model).toArray fuel (initialOwner model xs left right)).final.regs.size = 8273 := by + obtain ⟨abstract, producer, ts, built⟩ := Construction.build_stage model xs left right domain hl hr + exact canonical_array_refinement built fuel + +theorem service_keys_all_fuel (model : InputModel) (xs : List Int) (left right fuel : Nat) (s : State) + (canonical : Retained.Canonical xs s) (entered : ServiceSafety.Entered left right s) : + TraceKeysFit (run (Layout.program model) fuel s).transitions := by + by_cases within : fuel ≤ Service.budget + · exact service_keys_fit model xs left right fuel s canonical entered within + · have split : fuel = Service.budget + (fuel-Service.budget) := by omega + rw [split, run_add] + dsimp only + rw [run_of_stopped _ _ _ (service_stopped model xs left right s canonical entered)] + simpa only [List.append_nil] using + service_keys_fit model xs left right Service.budget s canonical entered (Nat.le_refl _) + +/-- The retained finite owner may come from any prior query. Its bank capacity, +canonical data and charged entry state suffice; its other registers may be dirty. -/ +theorem service_owner_refinement (model : InputModel) (xs : List Int) (left right fuel : Nat) + (owner : Owner) (bank : owner.regs.size = 8273) + (canonical : Retained.Canonical xs owner.toState) + (entered : ServiceSafety.Entered left right owner.toState) : + (runOwner (Layout.program model).toArray fuel owner).toState = + (run (Layout.program model) fuel owner.toState).final ∧ + (runOwner (Layout.program model).toArray fuel owner).regs.size = 8273 := + runOwner_toState_of_abstract (Layout.program model) fuel owner 8273 bank + (traceDestinations_of_keys (program_numeric model) + (service_keys_all_fuel model xs left right fuel owner.toState canonical entered)) + +theorem service_array_refinement (model : InputModel) (xs : List Int) (left right fuel : Nat) + (owner : Owner) (bank : owner.regs.size = 8273) + (canonical : Retained.Canonical xs owner.toState) + (entered : ServiceSafety.Entered left right owner.toState) : + (runArray (Layout.program model).toArray fuel owner).toRun = + run (Layout.program model) fuel owner.toState ∧ + (runArray (Layout.program model).toArray fuel owner).final.regs.size = 8273 := + runArray_toState_of_abstract (Layout.program model) fuel owner 8273 bank + (traceDestinations_of_keys (program_numeric model) + (service_keys_all_fuel model xs left right fuel owner.toState canonical entered)) + +def queryOwner (model : InputModel) (left right : Nat) (owner : Owner) : Owner := + runOwner (Layout.program model).toArray Service.budget + (requestProtocolOwner Layout.serviceEntry left right owner) + +def queryArray (model : InputModel) (left right : Nat) (owner : Owner) : ArrayRun := + let admission := requestProtocolArray Layout.serviceEntry left right owner + let service := runArray (Layout.program model).toArray Service.budget admission.final + ⟨service.final, admission.transitions ++ service.transitions⟩ + +theorem queryOwner_projection (model : InputModel) (left right : Nat) (owner : Owner) : + queryOwner model left right owner = (queryArray model left right owner).final := by + unfold queryOwner queryArray requestProtocolOwner requestProtocolArray + rw [runBoundaryOwner_projection, runOwner_projection] + +private theorem append_array_toRun (first second : ArrayRun) : + (⟨second.final, first.transitions ++ second.transitions⟩ : ArrayRun).toRun = + ⟨second.toRun.final, first.toRun.transitions ++ second.toRun.transitions⟩ := by + simp [ArrayRun.toRun, List.map_append] + +/-- The exact four charged boundary transitions are preserved along with the +same subsequent scalar service trace, even when the incoming bank is dirty. -/ +theorem query_array_refinement (model : InputModel) (xs : List Int) (left right answer : Nat) + (owner : Owner) (bank : owner.regs.size = 8273) + (canonical : Retained.Canonical xs owner.toState) + (halted : owner.status = .halted answer) + (hl : left < 2^PackedWordRAM.wordWidth xs.length) + (hr : right < 2^PackedWordRAM.wordWidth xs.length) : + (queryArray model left right owner).toRun = Reusable.queryRun model left right owner.toState ∧ + (queryArray model left right owner).final.regs.size = 8273 := by + have hleft : requestLeftRegister < owner.regs.size := by rw [bank]; decide + have hright : requestRightRegister < owner.regs.size := by rw [bank]; decide + have admission := requestProtocolArray_toState Layout.serviceEntry left right owner hleft hright + have admittedState : (requestProtocolArray Layout.serviceEntry left right owner).final.toState = + (requestProtocol Layout.serviceEntry left right owner.toState).final := + congrArg Run.final admission + have width : Layout.serviceEntry.val < 2^PackedWordRAM.wordWidth xs.length := + Nat.lt_trans (Reusable.entry_inside model) (Reusable.program_fits model xs.length) + have admittedCanonical : Retained.Canonical xs + (requestProtocolArray Layout.serviceEntry left right owner).final.toState := by + rw [admittedState] + exact canonical.requestProtocol Layout.serviceEntry left right (Layout.program model).length + hl hr (Reusable.entry_inside model) width + have entered : ServiceSafety.Entered left right + (requestProtocolArray Layout.serviceEntry left right owner).final.toState := by + rw [admittedState] + exact Reusable.entered_after_admission left right answer owner.toState halted + have admittedBank : (requestProtocolArray Layout.serviceEntry left right owner).final.regs.size = 8273 := + (requestProtocolArray_regs_size Layout.serviceEntry left right owner).trans bank + have service := service_array_refinement model xs left right Service.budget + (requestProtocolArray Layout.serviceEntry left right owner).final admittedBank admittedCanonical entered + refine ⟨?_, service.2⟩ + unfold queryArray + rw [append_array_toRun, service.1, admittedState, admission] + rfl + +/-- The production query runner retains only its final arrays/control. -/ +theorem query_owner_refinement (model : InputModel) (xs : List Int) (left right answer : Nat) + (owner : Owner) (bank : owner.regs.size = 8273) + (canonical : Retained.Canonical xs owner.toState) + (halted : owner.status = .halted answer) + (hl : left < 2^PackedWordRAM.wordWidth xs.length) + (hr : right < 2^PackedWordRAM.wordWidth xs.length) : + (queryOwner model left right owner).toState = + (Reusable.queryRun model left right owner.toState).final ∧ + (queryOwner model left right owner).regs.size = 8273 := by + have full := query_array_refinement model xs left right answer owner bank canonical halted hl hr + rw [queryOwner_projection] + exact ⟨congrArg Run.final full.1, full.2⟩ + +end RMQ.SuccinctFinal.PackedLifecycle.Executable diff --git a/RMQ/Core/WordRAM/Lifecycle/Finalization.lean b/RMQ/Core/WordRAM/Lifecycle/Finalization.lean new file mode 100644 index 00000000..49e18b6e --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/Finalization.lean @@ -0,0 +1,508 @@ +import RMQ.Core.WordRAM.Lifecycle.Construction +import RMQ.Core.WordRAM.Lifecycle.Retained + +/-! # Actual construction continuation into retained service state + +The descriptor, scalar copy/release loop, key retirement, and service jump are +composed as ordered executions of the same lifecycle program and state. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle.Finalization + +open PackedWordRAM (wordWidth buildMemory) +open PackedConstruction.Proof + +def descriptorRun (model : InputModel) (xs : List Int) (left right : Nat) + (producer : PackedConstruction.State) : Run := + run (Layout.program model) 11 (Construction.producedState model xs left right producer) + +def copyRun (model : InputModel) (xs : List Int) (left right : Nat) + (producer : PackedConstruction.State) : Run := + run (Layout.program model) (Finalizer.cost (producer.regs 3) (buildMemory xs).length) + (descriptorRun model xs left right producer).final + +def retirementCost : InputModel → Nat → Nat + | .word, _ => 0 + | .comparison, n => Retirement.cost n + +def retirementRun (model : InputModel) (xs : List Int) (left right : Nat) + (producer : PackedConstruction.State) : Run := + run (Layout.program model) (retirementCost model xs.length) + (copyRun model xs left right producer).final + +def finalState (model : InputModel) (xs : List Int) (left right : Nat) + (producer : PackedConstruction.State) : State := + execute (.old (.jump Layout.serviceEntry)) (retirementRun model xs left right producer).final + +def finalTrace (model : InputModel) (xs : List Int) (left right : Nat) + (producer : PackedConstruction.State) : List Transition := + (descriptorRun model xs left right producer).transitions ++ + (copyRun model xs left right producer).transitions ++ + (retirementRun model xs left right producer).transitions ++ + [⟨(retirementRun model xs left right producer).final, .instruction (.old (.jump Layout.serviceEntry)), + finalState model xs left right producer⟩] + +def continuationCost (model : InputModel) (n B M : Nat) : Nat := + 11 + Finalizer.cost B M + retirementCost model n + 1 + +theorem program_fits (model : InputModel) (xs : List Int) : + (Layout.program model).length < 2^wordWidth xs.length := + Nat.lt_of_lt_of_le (Layout.program_length_lt32 model) + (Nat.pow_le_pow_right (by decide) (wordWidth_ge_32 xs.length)) + +theorem finalizer_continuation (model : InputModel) : + Layout.finalizerBase+14 < (Layout.program model).length := by + rw [Layout.program_length] + cases model <;> decide + +theorem retirement_continuation : Layout.retirementBase+8 < (Layout.program .comparison).length := by + rw [Layout.program_length] + decide + +structure Copied (model : InputModel) (xs : List Int) (left right : Nat) (s : State) : Prop where + memory : s.core.memory = (fun a => (buildMemory xs)[a]?) + extent : s.core.extent = (buildMemory xs).length + running : s.core.status = .running + pc : s.core.pc = Layout.retirementBase + left : s.core.regs 300 = left + right : s.core.regs 301 = right + size : s.core.regs 302 = xs.length + keyExtent : s.keyExtent = if model = .comparison then xs.length else 0 + keyRegExtent : s.keyRegExtent = if model = .comparison then 2 else 0 + closed : s.Closed + fits : s.Fits (wordWidth xs.length) + finite : ∀ r, 400 ≤ r → s.core.regs r = 0 + +theorem descriptor_to_finalizer {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) : + Finalizer.Entry Layout.finalizerBase (producer.regs 3) (buildMemory xs).length + (descriptorRun model xs left right producer).final := by + have delivered := (Descriptor.transfer (Layout.descriptor_host model) built.descriptor).1 + obtain ⟨hr, hpc, hB, hM, _, _, _, hm, he, _, _, _, _, _⟩ := delivered + change (descriptorRun model xs left right producer).final.core.memory = producer.memory at hm + have closed := (Descriptor.transfer_prefix_frame (Layout.descriptor_host model) + built.descriptor (Nat.le_refl 11)).closed built.closed + refine ⟨hr, ?_, he.trans built.body.extent, hB, hM, ?_, closed.1⟩ + · exact hpc + · intro i hi + refine ⟨(buildMemory xs).getD i 0, ?_⟩ + rw [hm] + exact built.body.cells i hi + +theorem copy_stage {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) : + Copied model xs left right (copyRun model xs left right producer).final ∧ + (descriptorRun model xs left right producer).steps = 11 ∧ + (copyRun model xs left right producer).steps = + Finalizer.cost (producer.regs 3) (buildMemory xs).length ∧ + Descriptor.Good (wordWidth xs.length) (Layout.program model) + (descriptorRun model xs left right producer) ∧ + Finalizer.Good (wordWidth xs.length) (Layout.program model) + (copyRun model xs left right producer) := by + have entry := descriptor_to_finalizer built + have desc := Descriptor.transfer (Layout.descriptor_host model) built.descriptor + obtain ⟨_, _, _, _, hn, hl, hr, hm, _, _, _, hk, hkr, htail⟩ := desc.1 + change (descriptorRun model xs left right producer).final.core.memory = producer.memory at hm + have descClosed := (Descriptor.transfer_prefix_frame (Layout.descriptor_host model) + built.descriptor (Nat.le_refl 11)).closed built.closed + change (descriptorRun model xs left right producer).final.Closed at descClosed + have descSafe := Descriptor.transfer_safe (Layout.descriptor_host model) built.descriptor + (wordWidth_ge_32 xs.length) built.fits (program_fits model xs) + have safe := Finalizer.finalizer_safe (Layout.finalizer_host model) (wordWidth_ge_32 xs.length) + (finalizer_continuation model) (program_fits model xs) descSafe.2.1 entry + have output := Finalizer.finalizer (Layout.finalizer_host model) entry + have frame := (Finalizer.finalizer_frame (Layout.finalizer_host model) entry).1 + change Finalizer.Frame (descriptorRun model xs left right producer).final + (copyRun model xs left right producer).final at frame + have exactMemory := Finalizer.finalizer_memory (Layout.finalizer_host model) (buildMemory xs) + entry (by + intro i hi + rw [hm] + simpa [List.getD, List.getElem?_eq_getElem hi] using built.body.cells i hi) + have closed : (copyRun model xs left right producer).final.Closed := by + refine ⟨output.1.2.2, ?_, ?_⟩ + · intro a ha + rw [frame.2.2.1] + apply descClosed.2.1 a + rw [← frame.1] + exact ha + · intro r hr + rw [frame.2.2.2.1] + apply descClosed.2.2 r + rw [← frame.2.1] + exact hr + refine ⟨⟨exactMemory.1, exactMemory.2.1, exactMemory.2.2.1, exactMemory.2.2.2, + (frame.2.2.2.2.2 300 (by decide)).trans hl, + (frame.2.2.2.2.2 301 (by decide)).trans hr, + (frame.2.2.2.2.2 302 (by decide)).trans hn, + frame.1.trans hk, frame.2.1.trans hkr, closed, safe.2.1, ?_⟩, + desc.2, output.2.2.2, descSafe.1, safe.1⟩ + intro r h400 + exact ((frame.2.2.2.2.2 r (by omega)).trans (htail r h400)).trans (built.numericFinite r h400) + +structure Retired (model : InputModel) (xs : List Int) (left right : Nat) (s : State) : Prop where + data : Retained.Data (buildMemory xs) s + running : s.core.status = .running + pc : s.core.pc = Layout.jumpBase model + left : s.core.regs 300 = left + right : s.core.regs 301 = right + fits : s.Fits (wordWidth xs.length) + finite : ∀ r, 400 ≤ r → s.core.regs r = 0 + +theorem retire_copied {model : InputModel} {xs : List Int} {left right : Nat} {s : State} + (copied : Copied model xs left right s) : + Retired model xs left right (run (Layout.program model) (retirementCost model xs.length) s).final ∧ + (run (Layout.program model) (retirementCost model xs.length) s).steps = retirementCost model xs.length ∧ + Retirement.Good (wordWidth xs.length) (Layout.program model) + (run (Layout.program model) (retirementCost model xs.length) s) := by + cases model with + | word => + have empty := empty_keys_of_closed s copied.closed copied.keyExtent copied.keyRegExtent + exact ⟨⟨⟨copied.memory, copied.extent, empty.1, empty.2, copied.keyExtent, copied.keyRegExtent⟩, + copied.running, copied.pc, copied.left, copied.right, copied.fits, copied.finite⟩, + rfl, by simp [Retirement.Good, retirementCost, run]⟩ + | comparison => + have entry : Retirement.Entry Layout.retirementBase xs.length s := + ⟨copied.running, copied.pc, copied.keyExtent, copied.keyRegExtent, copied.size, copied.closed⟩ + have retired := Retirement.comparison_retired Layout.retirement_host entry + obtain ⟨_, running, pc, hk, hkr, keys, keyRegs, _, frame, steps, _⟩ := retired + have safe := Retirement.comparison_safe Layout.retirement_host (wordWidth_ge_32 xs.length) + retirement_continuation (program_fits .comparison xs) copied.fits entry + refine ⟨⟨⟨frame.1.trans copied.memory, frame.2.1.trans copied.extent, keys, keyRegs, hk, hkr⟩, + running, pc, (frame.2.2 300 (by decide) (by decide)).trans copied.left, + (frame.2.2 301 (by decide) (by decide)).trans copied.right, safe.2.1, ?_⟩, steps, safe.1⟩ + intro r h400 + exact (frame.2.2 r (by omega) (by omega)).trans (copied.finite r h400) + +theorem actual_runsTo (program : List Instruction) (fuel : Nat) (s : State) : + RunsTo program s (run program fuel s).final (run program fuel s).transitions := + run_exact_steps program fuel s + +theorem retired_jump {model : InputModel} {xs : List Int} {left right : Nat} {s : State} + (retired : Retired model xs left right s) : + let after := execute (.old (.jump Layout.serviceEntry)) s + RunsTo (Layout.program model) s after [⟨s, .instruction (.old (.jump Layout.serviceEntry)), after⟩] ∧ + Retained.Canonical xs after ∧ Service.Inputs left right (Retained.projectQueryState after) ∧ + Transition.Safe (wordWidth xs.length) (Layout.program model).length + ⟨s, .instruction (.old (.jump Layout.serviceEntry)), after⟩ := by + have fetch : (Layout.program model)[s.core.pc]? = some (.old (.jump Layout.serviceEntry)) := by + rw [retired.pc] + exact Layout.jump_fetch model + have safe : Instruction.Safe (wordWidth xs.length) (Layout.program model).length s + (.old (.jump Layout.serviceEntry)) := by + refine ⟨PackedConstruction.Prim.operandsFit_of_width _ (wordWidth_ge_32 xs.length), ?_⟩ + change Layout.serviceEntry.val < (Layout.program model).length + rw [Layout.program_length] + cases model <;> decide + have fit := execute_safe_fits retired.fits safe (List.getElem?_eq_some_iff.mp fetch).1 (program_fits model xs) + have data : Retained.Data (buildMemory xs) (execute (.old (.jump Layout.serviceEntry)) s) := by + simpa only [Retained.Data, execute, PackedConstruction.execPrim] using retired.data + refine ⟨RunsTo.instruction retired.running fetch, ⟨data, ?_, fit⟩, ?_, + ⟨.old (.jump Layout.serviceEntry), rfl, safe⟩⟩ + · intro r hr + exact retired.finite r (by omega) + · refine ⟨?_, ?_, retired.left, retired.right, ?_⟩ + · change Retained.projectStatus s.core.status = .running + rw [retired.running] + rfl + · change (212964 : Nat) = Service.entry + exact Service.entry_eq.symm + · intro r hr + exact retired.finite r (by omega) + +theorem completed {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) : + RunsTo (Layout.program model) (Construction.producedState model xs left right producer) + (finalState model xs left right producer) (finalTrace model xs left right producer) ∧ + Retained.Canonical xs (finalState model xs left right producer) ∧ + Service.Inputs left right (Retained.projectQueryState (finalState model xs left right producer)) ∧ + (finalTrace model xs left right producer).length = + continuationCost model xs.length (producer.regs 3) (buildMemory xs).length ∧ + ∀ t ∈ finalTrace model xs left right producer, + t.Safe (wordWidth xs.length) (Layout.program model).length := by + obtain ⟨copied, dlen, clen, dsafe, csafe⟩ := copy_stage built + obtain ⟨retired, rlen, rsafe⟩ := retire_copied copied + change (retirementRun model xs left right producer).steps = retirementCost model xs.length at rlen + obtain ⟨jump, canonical, inputs, jsafe⟩ := retired_jump retired + have d := actual_runsTo (Layout.program model) 11 + (Construction.producedState model xs left right producer) + have c := actual_runsTo (Layout.program model) + (Finalizer.cost (producer.regs 3) (buildMemory xs).length) + (descriptorRun model xs left right producer).final + have r := actual_runsTo (Layout.program model) (retirementCost model xs.length) + (copyRun model xs left right producer).final + refine ⟨?_, canonical, inputs, ?_, ?_⟩ + · simpa only [finalTrace, List.append_assoc] using ((d.trans c).trans r).trans jump + · simp only [finalTrace, List.length_append, List.length_cons, List.length_nil] + change (descriptorRun model xs left right producer).steps + + (copyRun model xs left right producer).steps+ + (retirementRun model xs left right producer).steps+1 = _ + rw [dlen, clen, rlen] + simp [continuationCost, Nat.add_assoc] + · intro t ht + simp only [finalTrace, List.mem_append, List.mem_singleton, or_assoc] at ht + rcases ht with ht | ht | ht | ht + · exact dsafe t ht + · exact csafe t ht + · exact rsafe t ht + · subst t + exact jsafe + +def fullTrace (model : InputModel) (xs : List Int) (left right : Nat) + (producer : PackedConstruction.State) (ts : List PackedConstruction.Transition) : List Transition := + Construction.producedTrace model xs left right ts ++ finalTrace model xs left right producer + +theorem full_execution {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) : + RunsTo (Layout.program model) (initialState model xs left right Layout.builderBase) + (finalState model xs left right producer) (fullTrace model xs left right producer ts) := + built.execution.trans (completed built).1 + +theorem full_safe {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) : + ∀ t ∈ fullTrace model xs left right producer ts, + t.Safe (wordWidth xs.length) (Layout.program model).length := by + intro t ht + rcases List.mem_append.mp ht with hbody | hcontinuation + · exact Construction.body_trace_safe built.body t hbody + · exact (completed built).2.2.2.2 t hcontinuation + +theorem full_prefix_fits {model : InputModel} {xs : List Int} {left right fuel : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) + (domain : InputDomain model xs) (hl : left < 2^wordWidth xs.length) + (hr : right < 2^wordWidth xs.length) + (hf : fuel ≤ (fullTrace model xs left right producer ts).length) : + (run (Layout.program model) fuel (initialState model xs left right Layout.builderBase)).final.Fits + (wordWidth xs.length) := by + have initial := initial_fits model xs left right Layout.builderBase domain hl hr + (Construction.initial_pc_fits xs) + apply (run_fits initial (program_fits model xs) ?_).1 + intro t ht + have member : t ∈ (run (Layout.program model) (fullTrace model xs left right producer ts).length + (initialState model xs left right Layout.builderBase)).transitions := by + rw [← Nat.add_sub_of_le hf, run_add] + exact List.mem_append_left _ ht + have whole : run (Layout.program model) (fullTrace model xs left right producer ts).length + (initialState model xs left right Layout.builderBase) = + ⟨finalState model xs left right producer, fullTrace model xs left right producer ts⟩ := + full_execution built + rw [whole] at member + exact full_safe built t member + +def ArenaFrame (s t : State) : Prop := + t.core.extent ≤ s.core.extent ∧ ∀ r, 400 ≤ r → t.core.regs r = s.core.regs r + +theorem ArenaFrame.refl (s : State) : ArenaFrame s s := ⟨Nat.le_refl _, fun _ _ => rfl⟩ + +theorem ArenaFrame.trans {s t u : State} (a : ArenaFrame s t) (b : ArenaFrame t u) : ArenaFrame s u := + ⟨Nat.le_trans b.1 a.1, fun r hr => (b.2 r hr).trans (a.2 r hr)⟩ + +def PrefixFrame (program : List Instruction) (s : State) (ts : List Transition) : Prop := + ∀ fuel, fuel ≤ ts.length → ArenaFrame s (run program fuel s).final + +theorem prefixFrame_append {program : List Instruction} {s middle : State} + {first second : List Transition} (execution : RunsTo program s middle first) + (hfirst : PrefixFrame program s first) (hsecond : PrefixFrame program middle second) : + PrefixFrame program s (first++second) := by + intro fuel hf + by_cases hp : fuel ≤ first.length + · exact hfirst fuel hp + · have hm : ArenaFrame s middle := by + have h := hfirst first.length (Nat.le_refl _) + rw [show run program first.length s = ⟨middle, first⟩ from execution] at h + exact h + have remain : fuel-first.length ≤ second.length := by rw [List.length_append] at hf; omega + rw [show fuel=first.length+(fuel-first.length) by omega, run_add, + show run program first.length s = ⟨middle, first⟩ from execution] + exact hm.trans (hsecond _ remain) + +theorem retirement_prefix_frame {model : InputModel} {xs : List Int} {left right fuel : Nat} {s : State} + (copied : Copied model xs left right s) (hf : fuel ≤ retirementCost model xs.length) : + ArenaFrame s (run (Layout.program model) fuel s).final := by + cases model with + | word => + have hz : fuel=0 := by change fuel ≤ 0 at hf; omega + subst fuel + exact ArenaFrame.refl s + | comparison => + have entry : Retirement.Entry Layout.retirementBase xs.length s := + ⟨copied.running, copied.pc, copied.keyExtent, copied.keyRegExtent, copied.size, copied.closed⟩ + have whole := (Retirement.comparison_run Layout.retirement_host entry).2.2.2.2.2.2 + have used : Retirement.UsesCode Layout.retirementBase (by decide) + (run (Layout.program .comparison) fuel s) := by + intro t ht + apply whole t + rw [show Retirement.cost xs.length=fuel+(Retirement.cost xs.length-fuel) by + change fuel ≤ Retirement.cost xs.length at hf; omega, run_add] + exact List.mem_append_left _ ht + have frame := (Retirement.run_frame_closed copied.closed used).1 + exact ⟨Nat.le_of_eq frame.2.1, fun r hr => frame.2.2 r (by omega) (by omega)⟩ + +theorem jump_prefix_frame {model : InputModel} {xs : List Int} {left right fuel : Nat} {s : State} + (retired : Retired model xs left right s) (hf : fuel ≤ 1) : + ArenaFrame s (run (Layout.program model) fuel s).final := by + by_cases hz : fuel=0 + · subst fuel + exact ArenaFrame.refl s + · have one : fuel=1 := by omega + subst fuel + have hj : run (Layout.program model) 1 s = + ⟨execute (.old (.jump Layout.serviceEntry)) s, + [⟨s, .instruction (.old (.jump Layout.serviceEntry)), execute (.old (.jump Layout.serviceEntry)) s⟩]⟩ := + (retired_jump retired).1 + rw [hj] + exact ArenaFrame.refl s + +theorem continuation_prefix_frame {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) : + PrefixFrame (Layout.program model) (Construction.producedState model xs left right producer) + (finalTrace model xs left right producer) := by + obtain ⟨copied, dlen, clen, _, _⟩ := copy_stage built + obtain ⟨retired, rlen, _⟩ := retire_copied copied + change (retirementRun model xs left right producer).steps = retirementCost model xs.length at rlen + have d := actual_runsTo (Layout.program model) 11 + (Construction.producedState model xs left right producer) + have c := actual_runsTo (Layout.program model) + (Finalizer.cost (producer.regs 3) (buildMemory xs).length) + (descriptorRun model xs left right producer).final + have r := actual_runsTo (Layout.program model) (retirementCost model xs.length) + (copyRun model xs left right producer).final + have fd : PrefixFrame (Layout.program model) (Construction.producedState model xs left right producer) + (descriptorRun model xs left right producer).transitions := by + intro fuel hf + change fuel ≤ (descriptorRun model xs left right producer).steps at hf + rw [dlen] at hf + have frame := Descriptor.transfer_prefix_frame (Layout.descriptor_host model) built.descriptor hf + exact ⟨Nat.le_of_eq frame.2.1, frame.2.2.2.2.2.2⟩ + have fc : PrefixFrame (Layout.program model) (descriptorRun model xs left right producer).final + (copyRun model xs left right producer).transitions := by + intro fuel hf + change fuel ≤ (copyRun model xs left right producer).steps at hf + rw [clen] at hf + have frame := (Finalizer.finalizer_frame (Layout.finalizer_host model) + (descriptor_to_finalizer built)).2 fuel hf + exact ⟨frame.2.2.2.2.1, fun r hr => frame.2.2.2.2.2 r (by omega)⟩ + have fr : PrefixFrame (Layout.program model) (copyRun model xs left right producer).final + (retirementRun model xs left right producer).transitions := by + intro fuel hf + change fuel ≤ (retirementRun model xs left right producer).steps at hf + rw [rlen] at hf + exact retirement_prefix_frame copied hf + have fj : PrefixFrame (Layout.program model) (retirementRun model xs left right producer).final + [⟨(retirementRun model xs left right producer).final, .instruction (.old (.jump Layout.serviceEntry)), + finalState model xs left right producer⟩] := by + intro fuel hf + exact jump_prefix_frame retired hf + exact prefixFrame_append ((d.trans c).trans r) + (prefixFrame_append (d.trans c) (prefixFrame_append d fd fc) fr) fj + +theorem full_prefix_resources {model : InputModel} {xs : List Int} {left right fuel : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) + (hf : fuel ≤ (fullTrace model xs left right producer ts).length) : + (run (Layout.program model) fuel (initialState model xs left right Layout.builderBase)).final.core.extent + ≤ producer.extent ∧ + ∀ r, 400 ≤ r → + (run (Layout.program model) fuel (initialState model xs left right Layout.builderBase)).final.core.regs r = 0 := by + have bodyLength : (Construction.producedTrace model xs left right ts).length = ts.length := by + simp [Construction.producedTrace] + by_cases short : fuel ≤ ts.length + · exact ⟨(Construction.body_peak built.body short).1, + Construction.body_prefix_numeric_finite built.body short⟩ + · have remain : fuel-ts.length ≤ (finalTrace model xs left right producer).length := by + rw [fullTrace, List.length_append, bodyLength] at hf + omega + have whole : run (Layout.program model) ts.length (initialState model xs left right Layout.builderBase) = + ⟨Construction.producedState model xs left right producer, Construction.producedTrace model xs left right ts⟩ := by + have h := built.execution + unfold RunsTo at h + rw [bodyLength] at h + exact h + rw [show fuel=ts.length+(fuel-ts.length) by omega, run_add, whole] + have frame := continuation_prefix_frame built (fuel-ts.length) remain + exact ⟨frame.1, fun r hr => (frame.2 r hr).trans (built.numericFinite r hr)⟩ + +theorem full_prefix_peak {model : InputModel} {xs : List Int} {left right fuel : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) + (hf : fuel ≤ (fullTrace model xs left right producer ts).length) : + (run (Layout.program model) fuel (initialState model xs left right Layout.builderBase)).final.core.extent + ≤ 5000000*(xs.length+1) := by + have peak := (full_prefix_resources built hf).1 + have base := built.body.baseUpper + have extent := built.body.extent + have memory := PackedConstruction.Spec.buildMemory_length_le xs + have inputBound : (initialState model xs left right Layout.builderBase).core.extent ≤ xs.length+3 := by + cases model <;> simp [initialState, inputCore, PackedConstruction.wordInputState, + PackedConstruction.comparisonInputState, PackedConstruction.inputCellCount] <;> omega + omega + +theorem full_prefix_finite {model : InputModel} {xs : List Int} {left right fuel : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) + (hf : fuel ≤ (fullTrace model xs left right producer ts).length) (r : Nat) (hr : 8273 ≤ r) : + (run (Layout.program model) fuel (initialState model xs left right Layout.builderBase)).final.core.regs r = 0 := + (full_prefix_resources built hf).2 r (by omega) + +theorem full_transition_resources {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) + {t : Transition} (ht : t ∈ fullTrace model xs left right producer ts) : + t.before.core.extent ≤ 5000000*(xs.length+1) ∧ ∀ r, 8273 ≤ r → t.before.core.regs r = 0 := by + obtain ⟨index, occurrence⟩ := List.mem_iff_getElem?.mp ht + have within : index ≤ (fullTrace model xs left right producer ts).length := + Nat.le_of_lt (List.getElem?_eq_some_iff.mp occurrence).1 + have whole : run (Layout.program model) (fullTrace model xs left right producer ts).length + (initialState model xs left right Layout.builderBase) = + ⟨finalState model xs left right producer, fullTrace model xs left right producer ts⟩ := full_execution built + have actual : (run (Layout.program model) (fullTrace model xs left right producer ts).length + (initialState model xs left right Layout.builderBase)).transitions[index]? = some t := by + rw [whole] + exact occurrence + rw [(run_transition_at actual).1] + exact ⟨full_prefix_peak built within, full_prefix_finite built within⟩ + +theorem exact_cost {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) : + (fullTrace model xs left right producer ts).length = ts.length + 11 + + Finalizer.cost (producer.regs 3) (buildMemory xs).length + retirementCost model xs.length + 1 := by + rw [fullTrace, List.length_append, (completed built).2.2.2.1] + simp [Construction.producedTrace, continuationCost, Nat.add_assoc] + +theorem linear_cost {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) : + (fullTrace model xs left right producer ts).length ≤ 1100000000*(xs.length+1) := by + have work := Builder.hosted_linear_work built.body + have base := built.body.baseUpper + have memory := PackedConstruction.Spec.buildMemory_length_le xs + have inputBound : (initialState model xs left right Layout.builderBase).core.extent ≤ xs.length+3 := by + cases model <;> simp [initialState, inputCore, PackedConstruction.wordInputState, + PackedConstruction.comparisonInputState, PackedConstruction.inputCellCount] <;> omega + have retireBound : retirementCost model xs.length ≤ 4*xs.length+5 := by + cases model <;> simp [retirementCost, Retirement.cost] + rw [exact_cost built, Finalizer.cost] + omega + +/-- The endpoint is generated by the complete actual trace and satisfies the +retained-data and service-entry predicates without a supplied answer premise. -/ +theorem construction_complete (model : InputModel) (xs : List Int) (left right : Nat) + (domain : InputDomain model xs) (hl : left < 2^wordWidth xs.length) + (hr : right < 2^wordWidth xs.length) : + ∃ final ts, RunsTo (Layout.program model) + (initialState model xs left right Layout.builderBase) final ts ∧ + Retained.Canonical xs final ∧ Service.Inputs left right (Retained.projectQueryState final) ∧ + ts.length ≤ 1100000000*(xs.length+1) := by + obtain ⟨abstract, producer, ts, built⟩ := Construction.build_stage model xs left right domain hl hr + exact ⟨finalState model xs left right producer, fullTrace model xs left right producer ts, + full_execution built, (completed built).2.1, (completed built).2.2.1, linear_cost built⟩ + +end RMQ.SuccinctFinal.PackedLifecycle.Finalization diff --git a/RMQ/Core/WordRAM/Lifecycle/Finalizer.lean b/RMQ/Core/WordRAM/Lifecycle/Finalizer.lean new file mode 100644 index 00000000..69ee3460 --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/Finalizer.lean @@ -0,0 +1,826 @@ +import RMQ.Core.WordRAM.Lifecycle.Safety + +/-! # Hosted scalar arena finalization + +This fragment copies the produced source forward, including overlap, and then +retires exactly its old base offset in single-cell releases. It ends running +at the continuation PC. Functional memory equality is not a native-capacity +or alias-freedom claim. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle.Finalizer + +open PackedConstruction (Memory Operand Prim execPrim put Arithmetic) +set_option linter.unusedSimpArgs false +set_option linter.unnecessarySimpa false + +@[simp] theorem operand_zero : (0 : Operand).val = 0 := rfl +@[simp] theorem operand_one : (1 : Operand).val = 1 := rfl +@[simp] theorem operand_two : (2 : Operand).val = 2 := rfl +@[simp] theorem operand_three : (3 : Operand).val = 3 := rfl +@[simp] theorem operand_four : (4 : Operand).val = 4 := rfl +@[simp] theorem operand_five : (5 : Operand).val = 5 := rfl + +/-- Fourteen fixed scalar instructions, relocated only by their host offset. -/ +def code (base : Nat) (bound : base + 14 < 2 ^ 32) : List Instruction := [ + .old (.move 3 0), + .old (.constant 1 0), + .old (.constant 4 1), + .old (.branchZero 2 ⟨base + 10, by omega⟩), + .old (.load 5 0), + .old (.store 1 5), + .old (.arithmetic .add 0 0 4), + .old (.arithmetic .add 1 1 4), + .old (.arithmetic .sub 2 2 4), + .old (.jump ⟨base + 3, by omega⟩), + .old (.branchZero 3 ⟨base + 14, bound⟩), + .releaseCell, + .old (.arithmetic .sub 3 3 4), + .old (.jump ⟨base + 10, by omega⟩)] + +def Hosted (program : List Instruction) (base : Nat) (bound : base + 14 < 2 ^ 32) : Prop := + ∀ i, i < 14 → program[base + i]? = (code base bound)[i]? + +theorem fetch_zero {program : List Instruction} {base : Nat} {bound : base + 14 < 2 ^ 32} + (host : Hosted program base bound) : program[base]? = some (.old (.move 3 0)) := by + simpa [code] using host 0 (by decide) + +def Initialized (original : Memory) (B M : Nat) : Prop := + ∀ j, j < M → ∃ v, original (B + j) = some v + +abbrev CleanTail (s : State) : Prop := PackedConstruction.CleanTail s.core + +def FinalOutput (original : Memory) (B M : Nat) (s : State) : Prop := + s.core.extent = M ∧ (∀ j, j < M → s.core.memory j = original (B + j)) ∧ CleanTail s + +def CopyInv (base : Nat) (original : Memory) (B M i : Nat) (s : State) : Prop := + s.core.status = .running ∧ s.core.pc = base + 3 ∧ s.core.extent = B + M ∧ + s.core.regs 0 = B + i ∧ s.core.regs 1 = i ∧ s.core.regs 2 = M - i ∧ + s.core.regs 3 = B ∧ s.core.regs 4 = 1 ∧ + (∀ j, j < i → s.core.memory j = original (B + j)) ∧ + (∀ a, i ≤ a → s.core.memory a = original a) + +def ReleaseInv (base : Nat) (original : Memory) (B M left : Nat) (s : State) : Prop := + s.core.status = .running ∧ s.core.pc = base + 10 ∧ s.core.extent = M + left ∧ + s.core.regs 1 = M ∧ s.core.regs 3 = left ∧ s.core.regs 4 = 1 ∧ + (∀ j, j < M → s.core.memory j = original (B + j)) ∧ CleanTail s + +def cost (B M : Nat) : Nat := 7 * M + 4 * B + 5 + +def copyCategories : List Category := + [.old .branch, .old .read, .old .write, .old .arithmetic, + .old .arithmetic, .old .arithmetic, .old .branch] + +def releaseCategories : List Category := + [.old .branch, .numericRelease, .old .arithmetic, .old .branch] + +def expectedCategories (B M : Nat) : List Category := + [.old .register, .old .register, .old .register] ++ + (List.replicate M copyCategories).flatten ++ [.old .branch] ++ + (List.replicate B releaseCategories).flatten ++ [.old .branch] + +def Entry (base B M : Nat) (s : State) : Prop := + s.core.status = .running ∧ s.core.pc = base ∧ s.core.extent = B + M ∧ + s.core.regs 0 = B ∧ s.core.regs 2 = M ∧ Initialized s.core.memory B M ∧ CleanTail s + +def Good (W : Nat) (program : List Instruction) (r : Run) : Prop := + ∀ t ∈ r.transitions, t.Safe W program.length + +def UsesCode (base : Nat) (bound : base + 14 < 2 ^ 32) (r : Run) : Prop := + ∀ t ∈ r.transitions, ∃ i ∈ code base bound, t.action = .instruction i + +def Frame (before after : State) : Prop := + after.keyExtent = before.keyExtent ∧ after.keyRegExtent = before.keyRegExtent ∧ + after.core.keys = before.core.keys ∧ after.core.keyRegs = before.core.keyRegs ∧ + after.core.extent ≤ before.core.extent ∧ + (∀ r, 6 ≤ r → after.core.regs r = before.core.regs r) + +def CopyReceipt (original : Memory) (B i : Nat) (load store : Transition) : Prop := + load.action = .instruction (.old (.load 5 0)) ∧ + store.action = .instruction (.old (.store 1 5)) ∧ + load.before.core.regs 0 = B + i ∧ store.before.core.regs 1 = i ∧ + load.before.core.memory (B + i) = original (B + i) ∧ + some (load.after.core.regs 5) = original (B + i) ∧ store.before = load.after ∧ + store.after.core.memory i = original (B + i) ∧ + load.read? = some (B + i, original (B + i)) ∧ + store.write? = some (i, load.after.core.regs 5) + +def ReleaseReceipt (a : Nat) (t : Transition) : Prop := + t.action = .instruction .releaseCell ∧ t.before.core.extent = a + 1 ∧ + t.after.core.extent = a ∧ t.after.core.memory a = none ∧ + (∀ other, other ≠ a → t.after.core.memory other = t.before.core.memory other) ∧ + t.after = execute .releaseCell t.before + +theorem run_prefix_at {program : List Instruction} {s : State} {a b c k : Nat} {t : Transition} + (ha : (run program a s).transitions.length = a) + (hk : (run program b (run program a s).final).transitions[k]? = some t) : + (run program (a + (b + c)) s).transitions[a + k]? = some t := by + simp only [run_add] + rw [List.getElem?_append_right (by omega), ha, Nat.add_sub_cancel_left] + have hlt : k < (run program b (run program a s).final).transitions.length := + (List.getElem?_eq_some_iff.mp hk).1 + rw [List.getElem?_append_left hlt] + exact hk + +theorem Frame.refl (s : State) : Frame s s := by simp [Frame] + +theorem Frame.trans {a b c : State} (hab : Frame a b) (hbc : Frame b c) : Frame a c := + ⟨hbc.1.trans hab.1, hbc.2.1.trans hab.2.1, + hbc.2.2.1.trans hab.2.2.1, hbc.2.2.2.1.trans hab.2.2.2.1, + Nat.le_trans hbc.2.2.2.2.1 hab.2.2.2.2.1, + fun r hr => (hbc.2.2.2.2.2 r hr).trans (hab.2.2.2.2.2 r hr)⟩ + +theorem instruction_frame (s : State) (base : Nat) (bound : base + 14 < 2 ^ 32) + (i : Instruction) (hi : i ∈ code base bound) : Frame s (execute i s) := by + simp only [code, List.mem_cons, List.mem_singleton, List.not_mem_nil, or_false] at hi + rcases hi with rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl + all_goals + simp [Frame, execute, execPrim, PackedConstruction.State.next, PackedConstruction.State.writeNext, put] + all_goals + repeat' split + all_goals simp_all [put] + all_goals omega + +theorem run_frame_of_uses {program : List Instruction} {base : Nat} {bound : base + 14 < 2 ^ 32} + {fuel : Nat} {s : State} (uses : UsesCode base bound (run program fuel s)) : + Frame s (run program fuel s).final := by + induction fuel generalizing s with + | zero => exact Frame.refl s + | succ fuel ih => + cases hs : step program s with + | none => simpa [run, hs] using Frame.refl s + | some t => + obtain ⟨hb, _, i, _, hi, ha⟩ := step_spec hs + obtain ⟨j, hj, hjaction⟩ := uses t (by simp [run, hs]) + have hij : i = j := Action.instruction.inj (hi.symm.trans hjaction) + subst j + have first : Frame s t.after := by rw [ha]; exact instruction_frame s base bound i hj + have tail : UsesCode base bound (run program fuel t.after) := by + intro u hu; exact uses u (by simp [run, hs, hu]) + simpa [run, hs] using first.trans (ih tail) + +theorem uses_prefix {program : List Instruction} {base : Nat} {bound : base + 14 < 2 ^ 32} + {fuel preFuel : Nat} {s : State} (uses : UsesCode base bound (run program fuel s)) + (le : preFuel ≤ fuel) : UsesCode base bound (run program preFuel s) := by + intro t ht + have split : fuel = preFuel + (fuel - preFuel) := by omega + apply uses t + rw [split, run_add] + exact List.mem_append_left _ ht + +section HostedExecution + +variable {program : List Instruction} {base : Nat} {bound : base + 14 < 2 ^ 32} +variable (host : Hosted program base bound) +include host + +theorem setup {s : State} {B M : Nat} + (hr : s.core.status = .running) (hpc : s.core.pc = base) (he : s.core.extent = B + M) + (hb : s.core.regs 0 = B) (hm : s.core.regs 2 = M) : + CopyInv base s.core.memory B M 0 (run program 3 s).final ∧ + (run program 3 s).transitions.length = 3 := by + have get : ∀ i, i < 14 → program[base + i]? = (code base bound)[i]? := host + simp [run, step, fetch_zero host, get, code, execute, execPrim, hr, hpc, he, hb, hm, + PackedConstruction.State.writeNext, PackedConstruction.State.next, put, CopyInv, Nat.add_assoc] + +theorem copy_step {s : State} {original : Memory} {B M i : Nat} + (hi : i < M) (hinv : CopyInv base original B M i s) + (hinit : Initialized original B M) : + CopyInv base original B M (i + 1) (run program 7 s).final ∧ + (run program 7 s).transitions.length = 7 := by + obtain ⟨hr, hpc, he, h0, h1, h2, h3, h4, hdone, hfuture⟩ := hinv + obtain ⟨v, hv⟩ := hinit i hi + have hm : s.core.memory (B + i) = some v := (hfuture _ (by omega)).trans hv + have hz : M - i ≠ 0 := by omega + have hin : B + i < B + M := by omega + have hdst : i < B + M := by omega + have hdec : M - i - 1 = M - (i + 1) := by omega + have get : ∀ j, j < 14 → program[base + j]? = (code base bound)[j]? := host + simp [run, step, get, code, execute, execPrim, hr, hpc, he, h0, h1, h2, + h3, h4, hz, hin, hdst, hm, PackedConstruction.State.writeNext, PackedConstruction.State.next, + put, Arithmetic.eval, CopyInv, hdec, Nat.add_assoc] + constructor + · intro j hj + by_cases hji : j = i + · subst j; simp [hv] + · simp [hji, hdone j (by omega)] + · intro a ha + simp [show a ≠ i by omega, hfuture a (by omega)] + +theorem copy_exit {s : State} {original : Memory} {B M : Nat} + (hinv : CopyInv base original B M M s) + (htail : ∀ a, B + M ≤ a → original a = none) : + ReleaseInv base original B M B (run program 1 s).final ∧ + (run program 1 s).transitions.length = 1 := by + obtain ⟨hr, hpc, he, h0, h1, h2, h3, h4, hdone, hfuture⟩ := hinv + have get : ∀ j, j < 14 → program[base + j]? = (code base bound)[j]? := host + simp [ReleaseInv, run, step, get, code, execute, execPrim, hr, hpc, he, h0, h1, h2, + h3, h4, hdone, Nat.add_comm, CleanTail, PackedConstruction.CleanTail] + refine ⟨hdone, ?_⟩ + intro a ha + exact (hfuture a (by omega)).trans (htail a (by omega)) + +theorem release_step {s : State} {original : Memory} {B M left : Nat} + (hl : 0 < left) (hinv : ReleaseInv base original B M left s) : + ReleaseInv base original B M (left - 1) (run program 4 s).final ∧ + (run program 4 s).transitions.length = 4 := by + obtain ⟨hr, hpc, he, h1, h3, h4, hdone, htail⟩ := hinv + have hz : left ≠ 0 := by omega + have hez : M + left ≠ 0 := by omega + have get : ∀ j, j < 14 → program[base + j]? = (code base bound)[j]? := host + simp [ReleaseInv, run, step, get, code, execute, execPrim, hr, hpc, he, h1, h3, h4, + hz, hez, PackedConstruction.State.next, PackedConstruction.State.writeNext, put, + Arithmetic.eval, CleanTail, PackedConstruction.CleanTail, Nat.add_assoc] + refine ⟨by omega, ?_, ?_⟩ + · intro j hj + simp [show j ≠ M + left - 1 by omega, hdone j hj] + · intro a ha hne + exact htail a (by omega) + +theorem release_continue {s : State} {original : Memory} {B M : Nat} + (hinv : ReleaseInv base original B M 0 s) : + FinalOutput original B M (run program 1 s).final ∧ + (run program 1 s).final.core.status = .running ∧ + (run program 1 s).final.core.pc = base + 14 ∧ + (run program 1 s).transitions.length = 1 := by + obtain ⟨hr, hpc, he, h1, h3, h4, hdone, htail⟩ := hinv + have get : ∀ j, j < 14 → program[base + j]? = (code base bound)[j]? := host + simpa [FinalOutput, run, step, get, code, execute, execPrim, hr, hpc, he, h1, h3, + CleanTail, PackedConstruction.CleanTail] using And.intro hdone htail + +theorem copy_prefix {n i B M : Nat} {s : State} {original : Memory} + (hcount : i + n ≤ M) (hinv : CopyInv base original B M i s) + (hinit : Initialized original B M) : + CopyInv base original B M (i + n) (run program (7 * n) s).final ∧ + (run program (7 * n) s).transitions.length = 7 * n := by + induction n generalizing i s with + | zero => exact ⟨by simpa [run] using hinv, rfl⟩ + | succ n ih => + have hi : i < M := by omega + obtain ⟨hnext, hlen⟩ := copy_step host hi hinv hinit + obtain ⟨hin, hlen'⟩ := ih (by omega) hnext + rw [show 7 * (n + 1) = 7 + 7 * n by omega, run_add] + exact ⟨by simpa [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using hin, + by simp only [List.length_append, hlen, hlen']⟩ + +theorem release_prefix {n left B M : Nat} {s : State} {original : Memory} + (hn : n ≤ left) (hinv : ReleaseInv base original B M left s) : + ReleaseInv base original B M (left - n) (run program (4 * n) s).final ∧ + (run program (4 * n) s).transitions.length = 4 * n := by + induction n generalizing left s with + | zero => exact ⟨by simpa [run] using hinv, rfl⟩ + | succ n ih => + obtain ⟨hnext, hlen⟩ := release_step host (by omega : 0 < left) hinv + obtain ⟨hin, hlen'⟩ := ih (by omega) hnext + rw [show 4 * (n + 1) = 4 + 4 * n by omega, run_add] + exact ⟨by simpa [Nat.sub_sub, Nat.add_comm] using hin, + by simp only [List.length_append, hlen, hlen']⟩ + +theorem release_entry {s : State} {B M : Nat} (entry : Entry base B M s) : + ReleaseInv base s.core.memory B M B (run program (4 + 7 * M) s).final ∧ + (run program (4 + 7 * M) s).transitions.length = 4 + 7 * M := by + obtain ⟨hr, hpc, he, hb, hm, hinit, htail⟩ := entry + obtain ⟨hinv0, hlen0⟩ := setup host hr hpc he hb hm + obtain ⟨hinv1, hlen1⟩ := copy_prefix host (by omega : 0 + M ≤ M) hinv0 hinit + simp only [Nat.zero_add] at hinv1 + obtain ⟨hinv2, hlen2⟩ := copy_exit host hinv1 (by simpa [CleanTail, PackedConstruction.CleanTail, he] using htail) + rw [show 4 + 7 * M = 3 + (7 * M + 1) by omega] + simp only [run_add] + exact ⟨hinv2, by simp [hlen0, hlen1, hlen2]⟩ + +/-- Completion is reached by execution, before any continuation instruction runs. -/ +theorem finalizer {s : State} {B M : Nat} (entry : Entry base B M s) : + let actual := run program (cost B M) s + FinalOutput s.core.memory B M actual.final ∧ actual.final.core.status = .running ∧ + actual.final.core.pc = base + 14 ∧ actual.transitions.length = cost B M := by + obtain ⟨hinv, hlen⟩ := release_entry host entry + obtain ⟨hinv0, hlen0⟩ := release_prefix host (Nat.le_refl B) hinv + obtain ⟨hout, hr, hpc, hlen1⟩ := release_continue host (by simpa using hinv0) + rw [show cost B M = (4 + 7 * M) + (4 * B + 1) by simp [cost]; omega] + rw [run_add program (4 + 7 * M) (4 * B + 1)] + dsimp only + rw [run_add program (4 * B) 1] + exact ⟨hout, hr, hpc, by simp [hlen, hlen0, hlen1]⟩ + +theorem setup_good {s : State} {B M W : Nat} + (hw : 32 ≤ W) (hr : s.core.status = .running) (hpc : s.core.pc = base) + (hb : s.core.regs 0 = B) (_hm : s.core.regs 2 = M) : + Good W program (run program 3 s) := by + have get : ∀ j, j < 14 → program[base + j]? = (code base bound)[j]? := host + simp [Good, run, step, fetch_zero host, get, code, execute, execPrim, hr, hpc, hb, + PackedConstruction.State.writeNext, PackedConstruction.State.next, put, Transition.Safe, + Instruction.Safe, Prim.Safe, Prim.SafeAt, Prim.operandsFit_of_width _ hw, Nat.add_assoc] + +theorem copy_good {s : State} {original : Memory} {B M i W : Nat} + (hw : 32 ≤ W) (cont : base + 14 < program.length) + (hcap : B + M < 2 ^ W) (hfit : s.Fits W) + (hi : i < M) (hinv : CopyInv base original B M i s) + (hinit : Initialized original B M) : Good W program (run program 7 s) := by + obtain ⟨hr, hpc, he, h0, h1, h2, h3, h4, _, hfuture⟩ := hinv + obtain ⟨v, hv⟩ := hinit i hi + have hm : s.core.memory (B + i) = some v := (hfuture _ (by omega)).trans hv + have hvw := hfit.1.2.2.2.1 _ _ hm + have hz : M - i ≠ 0 := by omega + have hin : B + i < B + M := by omega + have hdst : i < B + M := by omega + have get : ∀ j, j < 14 → program[base + j]? = (code base bound)[j]? := host + simp [Good, run, step, get, code, execute, execPrim, hr, hpc, he, h0, h1, h2, + h3, h4, hz, hin, hdst, hm, PackedConstruction.State.writeNext, PackedConstruction.State.next, put, + Arithmetic.eval, Transition.Safe, Instruction.Safe, Prim.Safe, Prim.SafeAt, + Prim.operandsFit_of_width _ hw, Nat.add_assoc] + omega + +theorem copy_exit_good {s : State} {original : Memory} {B M W : Nat} + (hw : 32 ≤ W) (cont : base + 14 < program.length) + (hinv : CopyInv base original B M M s) : Good W program (run program 1 s) := by + obtain ⟨hr, hpc, _, _, _, h2, _, _, _, _⟩ := hinv + have get : ∀ j, j < 14 → program[base + j]? = (code base bound)[j]? := host + simp [Good, run, step, get, code, execute, execPrim, hr, hpc, h2, + Transition.Safe, Instruction.Safe, Prim.Safe, Prim.SafeAt, Prim.operandsFit_of_width _ hw] + omega + +theorem release_good {s : State} {original : Memory} {B M left W : Nat} + (hw : 32 ≤ W) (cont : base + 14 < program.length) (hfit : s.Fits W) + (hl : 0 < left) (hinv : ReleaseInv base original B M left s) : + Good W program (run program 4 s) := by + obtain ⟨hr, hpc, he, h1, h3, h4, _, _⟩ := hinv + have hz : left ≠ 0 := by omega + have hez : M + left ≠ 0 := by omega + have hw32 : 2 ^ 32 ≤ 2 ^ W := Nat.pow_le_pow_right (by decide) hw + have hleft := hfit.1.1 3 + rw [h3] at hleft + have get : ∀ j, j < 14 → program[base + j]? = (code base bound)[j]? := host + simp [Good, run, step, get, code, execute, execPrim, hr, hpc, he, h1, h3, h4, + hz, hez, PackedConstruction.State.next, PackedConstruction.State.writeNext, put, Arithmetic.eval, + Transition.Safe, Instruction.Safe, Prim.Safe, Prim.SafeAt, Prim.operandsFit_of_width _ hw, + Nat.add_assoc] + omega + +theorem release_continue_good {s : State} {original : Memory} {B M W : Nat} + (hw : 32 ≤ W) (cont : base + 14 < program.length) + (hinv : ReleaseInv base original B M 0 s) : Good W program (run program 1 s) := by + obtain ⟨hr, hpc, _, _, h3, _, _, _⟩ := hinv + have get : ∀ j, j < 14 → program[base + j]? = (code base bound)[j]? := host + simp [Good, run, step, get, code, execute, execPrim, hr, hpc, h3, + Transition.Safe, Instruction.Safe, Prim.Safe, Prim.SafeAt, Prim.operandsFit_of_width _ hw, cont] + +theorem copy_prefix_good {n i B M W : Nat} {s : State} {original : Memory} + (hw : 32 ≤ W) (cont : base + 14 < program.length) (plen : program.length < 2 ^ W) + (hcap : B + M < 2 ^ W) (hfit : s.Fits W) + (hcount : i + n ≤ M) (hinv : CopyInv base original B M i s) + (hinit : Initialized original B M) : Good W program (run program (7 * n) s) := by + induction n generalizing i s with + | zero => simp [Good, run] + | succ n ih => + have hi : i < M := by omega + have hnext := (copy_step host hi hinv hinit).1 + have hg := copy_good host hw cont hcap hfit hi hinv hinit + have hf := (run_fits hfit plen hg).1 + have hg' := ih hf (by omega) hnext + rw [show 7 * (n + 1) = 7 + 7 * n by omega, run_add] + exact fun t ht => (List.mem_append.mp ht).elim (hg t) (hg' t) + +theorem release_prefix_good {n left B M W : Nat} {s : State} {original : Memory} + (hw : 32 ≤ W) (cont : base + 14 < program.length) (plen : program.length < 2 ^ W) + (hfit : s.Fits W) (hn : n ≤ left) (hinv : ReleaseInv base original B M left s) : + Good W program (run program (4 * n) s) := by + induction n generalizing left s with + | zero => simp [Good, run] + | succ n ih => + have hl : 0 < left := by omega + have hnext := (release_step host hl hinv).1 + have hg := release_good host hw cont hfit hl hinv + have hf := (run_fits hfit plen hg).1 + have hg' := ih hf (by omega) hnext + rw [show 4 * (n + 1) = 4 + 4 * n by omega, run_add] + exact fun t ht => (List.mem_append.mp ht).elim (hg t) (hg' t) + +theorem finalizer_safe {s : State} {B M W : Nat} + (hw : 32 ≤ W) (cont : base + 14 < program.length) (plen : program.length < 2 ^ W) + (hfit : s.Fits W) (entry : Entry base B M s) : + Good W program (run program (cost B M) s) ∧ + (run program (cost B M) s).final.Fits W ∧ + ∀ t ∈ (run program (cost B M) s).transitions, t.before.Fits W ∧ t.after.Fits W := by + obtain ⟨hr, hpc, he, hb, hm, hinit, htail⟩ := entry + have hcap : B + M < 2 ^ W := he ▸ hfit.1.2.2.1 + obtain ⟨hi0, _⟩ := setup host hr hpc he hb hm + have hg0 := setup_good host hw hr hpc hb hm + have hf0 := (run_fits hfit plen hg0).1 + have hi1 := (copy_prefix host (by omega : 0 + M ≤ M) hi0 hinit).1 + have hg1 := copy_prefix_good host hw cont plen hcap hf0 (by omega : 0 + M ≤ M) hi0 hinit + have hf1 := (run_fits hf0 plen hg1).1 + simp only [Nat.zero_add] at hi1 + have hi2 := (copy_exit host hi1 (by simpa [CleanTail, PackedConstruction.CleanTail, he] using htail)).1 + have hg2 := copy_exit_good host hw cont hi1 + have hf2 := (run_fits hf1 plen hg2).1 + have hi3 := (release_prefix host (Nat.le_refl B) hi2).1 + have hg3 := release_prefix_good host hw cont plen hf2 (Nat.le_refl B) hi2 + have hf3 := (run_fits hf2 plen hg3).1 + have hg4 := release_continue_good host hw cont (by simpa using hi3) + have hg : Good W program (run program (cost B M) s) := by + rw [show cost B M = 3 + (7 * M + (1 + (4 * B + 1))) by simp [cost]; omega] + simp only [run_add] + intro t ht + simp only [List.mem_append] at ht + rcases ht with ht | ht | ht | ht | ht + · exact hg0 t ht + · exact hg1 t ht + · exact hg2 t ht + · exact hg3 t ht + · exact hg4 t ht + exact ⟨hg, run_fits hfit plen hg⟩ + +theorem setup_uses {s : State} + (hr : s.core.status = .running) (hpc : s.core.pc = base) : + UsesCode base bound (run program 3 s) := by + have get : ∀ j, j < 14 → program[base + j]? = (code base bound)[j]? := host + simp [UsesCode, run, step, fetch_zero host, get, code, execute, execPrim, hr, hpc, + PackedConstruction.State.writeNext, PackedConstruction.State.next, put, Nat.add_assoc] + +theorem copy_uses {s : State} {original : Memory} {B M i : Nat} + (hi : i < M) (hinv : CopyInv base original B M i s) (hinit : Initialized original B M) : + UsesCode base bound (run program 7 s) := by + obtain ⟨hr, hpc, he, h0, h1, h2, h3, h4, _, hfuture⟩ := hinv + obtain ⟨v, hv⟩ := hinit i hi + have hm : s.core.memory (B + i) = some v := (hfuture _ (by omega)).trans hv + have hz : M - i ≠ 0 := by omega + have hin : B + i < B + M := by omega + have hdst : i < B + M := by omega + have get : ∀ j, j < 14 → program[base + j]? = (code base bound)[j]? := host + simp [UsesCode, run, step, get, code, execute, execPrim, hr, hpc, he, h0, h1, h2, + h3, h4, hz, hin, hdst, hm, PackedConstruction.State.writeNext, PackedConstruction.State.next, + put, Arithmetic.eval, Nat.add_assoc] + +theorem copy_exit_uses {s : State} {original : Memory} {B M : Nat} + (hinv : CopyInv base original B M M s) : UsesCode base bound (run program 1 s) := by + obtain ⟨hr, hpc, _, _, _, h2, _, _, _, _⟩ := hinv + have get : ∀ j, j < 14 → program[base + j]? = (code base bound)[j]? := host + simp [UsesCode, run, step, get, code, execute, execPrim, hr, hpc, h2] + +theorem release_uses {s : State} {original : Memory} {B M left : Nat} + (hl : 0 < left) (hinv : ReleaseInv base original B M left s) : + UsesCode base bound (run program 4 s) := by + obtain ⟨hr, hpc, he, h1, h3, h4, _, _⟩ := hinv + have hz : left ≠ 0 := by omega + have hez : M + left ≠ 0 := by omega + have get : ∀ j, j < 14 → program[base + j]? = (code base bound)[j]? := host + simp [UsesCode, run, step, get, code, execute, execPrim, hr, hpc, he, h1, h3, h4, + hz, hez, PackedConstruction.State.next, PackedConstruction.State.writeNext, put, + Arithmetic.eval, Nat.add_assoc] + +theorem release_continue_uses {s : State} {original : Memory} {B M : Nat} + (hinv : ReleaseInv base original B M 0 s) : UsesCode base bound (run program 1 s) := by + obtain ⟨hr, hpc, _, _, h3, _, _, _⟩ := hinv + have get : ∀ j, j < 14 → program[base + j]? = (code base bound)[j]? := host + simp [UsesCode, run, step, get, code, execute, execPrim, hr, hpc, h3] + +theorem copy_prefix_uses {n i B M : Nat} {s : State} {original : Memory} + (hcount : i + n ≤ M) (hinv : CopyInv base original B M i s) + (hinit : Initialized original B M) : UsesCode base bound (run program (7 * n) s) := by + induction n generalizing i s with + | zero => simp [UsesCode, run] + | succ n ih => + have hi : i < M := by omega + have hnext := (copy_step host hi hinv hinit).1 + have hg := copy_uses host hi hinv hinit + have hg' := ih (by omega) hnext + rw [show 7 * (n + 1) = 7 + 7 * n by omega, run_add] + exact fun t ht => (List.mem_append.mp ht).elim (hg t) (hg' t) + +theorem release_prefix_uses {n left B M : Nat} {s : State} {original : Memory} + (hn : n ≤ left) (hinv : ReleaseInv base original B M left s) : + UsesCode base bound (run program (4 * n) s) := by + induction n generalizing left s with + | zero => simp [UsesCode, run] + | succ n ih => + have hl : 0 < left := by omega + have hnext := (release_step host hl hinv).1 + have hg := release_uses host hl hinv + have hg' := ih (by omega) hnext + rw [show 4 * (n + 1) = 4 + 4 * n by omega, run_add] + exact fun t ht => (List.mem_append.mp ht).elim (hg t) (hg' t) + +theorem finalizer_uses {s : State} {B M : Nat} (entry : Entry base B M s) : + UsesCode base bound (run program (cost B M) s) := by + obtain ⟨hr, hpc, he, hb, hm, hinit, htail⟩ := entry + have hi0 := (setup host hr hpc he hb hm).1 + have hi1 := (copy_prefix host (by omega : 0 + M ≤ M) hi0 hinit).1 + simp only [Nat.zero_add] at hi1 + have hi2 := (copy_exit host hi1 (by simpa [CleanTail, PackedConstruction.CleanTail, he] using htail)).1 + have hi3 := (release_prefix host (Nat.le_refl B) hi2).1 + have h0 := setup_uses host hr hpc + have h1 := copy_prefix_uses host (by omega : 0 + M ≤ M) hi0 hinit + have h2 := copy_exit_uses host hi1 + have h3 := release_prefix_uses host (Nat.le_refl B) hi2 + have h4 := release_continue_uses host (by simpa using hi3) + rw [show cost B M = 3 + (7 * M + (1 + (4 * B + 1))) by simp [cost]; omega] + simp only [run_add] + intro t ht + simp only [List.mem_append] at ht + rcases ht with ht | ht | ht | ht | ht + · exact h0 t ht + · exact h1 t ht + · exact h2 t ht + · exact h3 t ht + · exact h4 t ht + +theorem finalizer_frame {s : State} {B M : Nat} (entry : Entry base B M s) : + Frame s (run program (cost B M) s).final ∧ + ∀ fuel, fuel ≤ cost B M → Frame s (run program fuel s).final := by + have uses := finalizer_uses host entry + exact ⟨run_frame_of_uses uses, fun _ le => run_frame_of_uses (uses_prefix uses le)⟩ + +/-- The whole memory function is identified, including every absent tail address. -/ +theorem finalizer_memory (cells : List Nat) {s : State} {B : Nat} + (entry : Entry base B cells.length s) + (producer : ∀ i, i < cells.length → s.core.memory (B + i) = cells[i]?) : + (run program (cost B cells.length) s).final.core.memory = (fun a => cells[a]?) ∧ + (run program (cost B cells.length) s).final.core.extent = cells.length ∧ + (run program (cost B cells.length) s).final.core.status = .running ∧ + (run program (cost B cells.length) s).final.core.pc = base + 14 := by + obtain ⟨output, running, pc, _⟩ := finalizer host entry + refine ⟨?_, output.1, running, pc⟩ + funext a + by_cases ha : a < cells.length + · exact (output.2.1 a ha).trans (producer a ha) + · rw [output.2.2 a (by rw [output.1]; omega)] + exact (List.getElem?_eq_none_iff.mpr (by omega)).symm + +theorem copy_step_receipts {s : State} {original : Memory} {B M i : Nat} + (hi : i < M) (hinv : CopyInv base original B M i s) (hinit : Initialized original B M) : + ∃ load store, (run program 7 s).transitions[1]? = some load ∧ + (run program 7 s).transitions[2]? = some store ∧ CopyReceipt original B i load store := by + obtain ⟨hr, hpc, he, h0, h1, h2, h3, h4, _, hfuture⟩ := hinv + obtain ⟨v, hv⟩ := hinit i hi + have hm : s.core.memory (B + i) = some v := (hfuture _ (by omega)).trans hv + have hz : M - i ≠ 0 := by omega + have hin : B + i < B + M := by omega + have hdst : i < B + M := by omega + have get : ∀ j, j < 14 → program[base + j]? = (code base bound)[j]? := host + let pre : State := { s with core := { s.core with pc := base + 4 } } + let loaded := execute (.old (.load 5 0)) pre + let stored := execute (.old (.store 1 5)) loaded + refine ⟨⟨pre, .instruction (.old (.load 5 0)), loaded⟩, + ⟨loaded, .instruction (.old (.store 1 5)), stored⟩, ?_⟩ + simp [run, step, get, code, execute, execPrim, hr, hpc, he, h0, h1, h2, + h3, h4, hz, hin, hdst, hm, PackedConstruction.State.writeNext, PackedConstruction.State.next, put, + Arithmetic.eval, CopyReceipt, Transition.read?, Transition.write?, hv, pre, loaded, stored, Nat.add_assoc] + +/-- Occurrence indices retain repeated values and the load-to-store dependence. -/ +theorem ordered_copy {s : State} {B M : Nat} (entry : Entry base B M s) : + ∀ i, i < M → ∃ load store, + (run program (cost B M) s).transitions[4 + 7 * i]? = some load ∧ + (run program (cost B M) s).transitions[5 + 7 * i]? = some store ∧ + CopyReceipt s.core.memory B i load store ∧ + load.before = (run program (4 + 7 * i) s).final ∧ step program load.before = some load ∧ + store.before = (run program (5 + 7 * i) s).final ∧ step program store.before = some store := by + obtain ⟨hr, hpc, he, hb, hm, hinit, _⟩ := entry + intro i hi + obtain ⟨hinv0, hlen0⟩ := setup host hr hpc he hb hm + obtain ⟨hinvi, hleni⟩ := copy_prefix host (by omega : 0 + i ≤ M) hinv0 hinit + simp only [Nat.zero_add] at hinvi + obtain ⟨load, store, hl, hs, hc⟩ := copy_step_receipts host hi hinvi hinit + have hprefix : (run program (3 + 7 * i) s).transitions.length = 3 + 7 * i := by + rw [run_add]; simp [hlen0, hleni] + have hl' : (run program 7 (run program (3 + 7 * i) s).final).transitions[1]? = some load := by + simpa only [run_add] using hl + have hs' : (run program 7 (run program (3 + 7 * i) s).final).transitions[2]? = some store := by + simpa only [run_add] using hs + have hsplit : cost B M = (3 + 7 * i) + (7 + (cost B M - (3 + 7 * i + 7))) := by simp [cost]; omega + have hload : (run program (cost B M) s).transitions[4 + 7 * i]? = some load := by + rw [hsplit] + have hp := run_prefix_at (c := cost B M - (3 + 7 * i + 7)) hprefix hl' + rwa [show 3 + 7 * i + 1 = 4 + 7 * i by omega] at hp + have hstore : (run program (cost B M) s).transitions[5 + 7 * i]? = some store := by + rw [hsplit] + have hp := run_prefix_at (c := cost B M - (3 + 7 * i + 7)) hprefix hs' + rwa [show 3 + 7 * i + 2 = 5 + 7 * i by omega] at hp + exact ⟨load, store, hload, hstore, hc, (run_transition_at hload).1, + (run_transition_at hload).2, run_transition_at hstore⟩ + +theorem release_step_receipt {s : State} {original : Memory} {B M left : Nat} + (hl : 0 < left) (hinv : ReleaseInv base original B M left s) : + ∃ t, (run program 4 s).transitions[1]? = some t ∧ ReleaseReceipt (M + left - 1) t := by + obtain ⟨hr, hpc, he, h1, h3, h4, _, _⟩ := hinv + have hz : left ≠ 0 := by omega + have hez : M + left ≠ 0 := by omega + have get : ∀ j, j < 14 → program[base + j]? = (code base bound)[j]? := host + let pre : State := { s with core := { s.core with pc := base + 11 } } + refine ⟨⟨pre, .instruction .releaseCell, execute .releaseCell pre⟩, ?_⟩ + simp [run, step, get, code, execute, execPrim, hr, hpc, he, h1, h3, h4, + hz, hez, PackedConstruction.State.next, PackedConstruction.State.writeNext, put, Arithmetic.eval, + ReleaseReceipt, pre, Nat.add_assoc] + exact ⟨by omega, fun _ hne heq => False.elim (hne heq)⟩ + +theorem ordered_release {s : State} {B M : Nat} (entry : Entry base B M s) : + ∀ k, k < B → ∃ t, + (run program (cost B M) s).transitions[5 + 7 * M + 4 * k]? = some t ∧ + ReleaseReceipt (M + (B - k) - 1) t ∧ + t.before = (run program (5 + 7 * M + 4 * k) s).final ∧ step program t.before = some t := by + intro k hk + obtain ⟨hinv, hlen⟩ := release_entry host entry + obtain ⟨hinvk, hlenk⟩ := release_prefix host (by omega : k ≤ B) hinv + obtain ⟨t, ht, hc⟩ := release_step_receipt host (by omega : 0 < B - k) hinvk + have hprefix : (run program ((4 + 7 * M) + 4 * k) s).transitions.length = (4 + 7 * M) + 4 * k := by + rw [run_add]; simp [hlen, hlenk] + have ht' : (run program 4 (run program ((4 + 7 * M) + 4 * k) s).final).transitions[1]? = some t := by + simpa only [run_add] using ht + have hsplit : cost B M = ((4 + 7 * M) + 4 * k) + (4 + (cost B M - ((4 + 7 * M) + 4 * k + 4))) := by + simp [cost]; omega + have occurrence : (run program (cost B M) s).transitions[5 + 7 * M + 4 * k]? = some t := by + rw [hsplit] + have hp := run_prefix_at (c := cost B M - ((4 + 7 * M) + 4 * k + 4)) hprefix ht' + rwa [show 4 + 7 * M + 4 * k + 1 = 5 + 7 * M + 4 * k by omega] at hp + exact ⟨t, occurrence, hc, run_transition_at occurrence⟩ + +theorem setup_categories {s : State} + (hr : s.core.status = .running) (hpc : s.core.pc = base) : + (run program 3 s).categories = [.old .register, .old .register, .old .register] := by + have get : ∀ j, j < 14 → program[base + j]? = (code base bound)[j]? := host + simp [Run.categories, Action.category, Prim.category, run, step, fetch_zero host, get, code, + execute, execPrim, hr, hpc, PackedConstruction.State.writeNext, PackedConstruction.State.next, + put, Nat.add_assoc] + +theorem copy_categories {s : State} {original : Memory} {B M i : Nat} + (hi : i < M) (hinv : CopyInv base original B M i s) (hinit : Initialized original B M) : + (run program 7 s).categories = copyCategories := by + obtain ⟨hr, hpc, he, h0, h1, h2, h3, h4, _, hfuture⟩ := hinv + obtain ⟨v, hv⟩ := hinit i hi + have hm : s.core.memory (B + i) = some v := (hfuture _ (by omega)).trans hv + have hz : M - i ≠ 0 := by omega + have hin : B + i < B + M := by omega + have hdst : i < B + M := by omega + have get : ∀ j, j < 14 → program[base + j]? = (code base bound)[j]? := host + simp [Run.categories, Action.category, Prim.category, copyCategories, run, step, get, code, + execute, execPrim, hr, hpc, he, h0, h1, h2, h3, h4, hz, hin, hdst, hm, + PackedConstruction.State.writeNext, PackedConstruction.State.next, put, Arithmetic.eval, Nat.add_assoc] + +theorem copy_exit_categories {s : State} {original : Memory} {B M : Nat} + (hinv : CopyInv base original B M M s) : (run program 1 s).categories = [.old .branch] := by + obtain ⟨hr, hpc, _, _, _, h2, _, _, _, _⟩ := hinv + have get : ∀ j, j < 14 → program[base + j]? = (code base bound)[j]? := host + simp [Run.categories, Action.category, Prim.category, run, step, get, code, execute, execPrim, + hr, hpc, h2] + +theorem release_categories {s : State} {original : Memory} {B M left : Nat} + (hl : 0 < left) (hinv : ReleaseInv base original B M left s) : + (run program 4 s).categories = releaseCategories := by + obtain ⟨hr, hpc, he, h1, h3, h4, _, _⟩ := hinv + have hz : left ≠ 0 := by omega + have hez : M + left ≠ 0 := by omega + have get : ∀ j, j < 14 → program[base + j]? = (code base bound)[j]? := host + simp [Run.categories, Action.category, Prim.category, releaseCategories, run, step, get, code, + execute, execPrim, hr, hpc, he, h1, h3, h4, hz, hez, + PackedConstruction.State.next, PackedConstruction.State.writeNext, put, Arithmetic.eval, Nat.add_assoc] + +theorem release_continue_categories {s : State} {original : Memory} {B M : Nat} + (hinv : ReleaseInv base original B M 0 s) : (run program 1 s).categories = [.old .branch] := by + obtain ⟨hr, hpc, _, _, h3, _, _, _⟩ := hinv + have get : ∀ j, j < 14 → program[base + j]? = (code base bound)[j]? := host + simp [Run.categories, Action.category, Prim.category, run, step, get, code, execute, execPrim, + hr, hpc, h3] + +theorem copy_prefix_categories {n i B M : Nat} {s : State} {original : Memory} + (hcount : i + n ≤ M) (hinv : CopyInv base original B M i s) + (hinit : Initialized original B M) : + (run program (7 * n) s).categories = (List.replicate n copyCategories).flatten := by + induction n generalizing i s with + | zero => rfl + | succ n ih => + have hi : i < M := by omega + have hnext := (copy_step host hi hinv hinit).1 + have hg := copy_categories host hi hinv hinit + have hg' := ih (by omega) hnext + rw [show 7 * (n + 1) = 7 + 7 * n by omega, run_add] + simp only [Run.categories, List.map_append] at hg hg' ⊢ + rw [hg, hg', List.replicate_succ, List.flatten_cons] + +theorem release_prefix_categories {n left B M : Nat} {s : State} {original : Memory} + (hn : n ≤ left) (hinv : ReleaseInv base original B M left s) : + (run program (4 * n) s).categories = (List.replicate n releaseCategories).flatten := by + induction n generalizing left s with + | zero => rfl + | succ n ih => + have hl : 0 < left := by omega + have hnext := (release_step host hl hinv).1 + have hg := release_categories host hl hinv + have hg' := ih (by omega) hnext + rw [show 4 * (n + 1) = 4 + 4 * n by omega, run_add] + simp only [Run.categories, List.map_append] at hg hg' ⊢ + rw [hg, hg', List.replicate_succ, List.flatten_cons] + +/-- The category sequence is computed from the same actual transitions. -/ +theorem finalizer_categories {s : State} {B M : Nat} (entry : Entry base B M s) : + (run program (cost B M) s).categories = expectedCategories B M := by + obtain ⟨hr, hpc, he, hb, hm, hinit, htail⟩ := entry + have hi0 := (setup host hr hpc he hb hm).1 + have hi1 := (copy_prefix host (by omega : 0 + M ≤ M) hi0 hinit).1 + simp only [Nat.zero_add] at hi1 + have hi2 := (copy_exit host hi1 (by simpa [CleanTail, PackedConstruction.CleanTail, he] using htail)).1 + have hi3 := (release_prefix host (Nat.le_refl B) hi2).1 + have h0 := setup_categories host hr hpc + have h1 := copy_prefix_categories host (by omega : 0 + M ≤ M) hi0 hinit + have h2 := copy_exit_categories host hi1 + have h3 := release_prefix_categories host (Nat.le_refl B) hi2 + have h4 := release_continue_categories host (by simpa using hi3) + rw [show cost B M = 3 + (7 * M + (1 + (4 * B + 1))) by simp [cost]; omega] + simp only [run_add, Run.categories, List.map_append] at h0 h1 h2 h3 h4 ⊢ + simp only [h0, h1, h2, h3, h4, expectedCategories, List.append_assoc] + +omit host in +theorem count_replicated_flatten (pattern : List Category) (n : Nat) (category : Category) : + ((List.replicate n pattern).flatten).count category = n * pattern.count category := by + induction n with + | zero => simp + | succ n ih => + simp [List.replicate_succ, List.flatten_cons, List.count_append, ih, Nat.succ_mul, Nat.add_comm] + +theorem finalizer_category_counts {s : State} {B M : Nat} (entry : Entry base B M s) : + let actual := run program (cost B M) s + actual.categoryCount .numericRelease = B ∧ + actual.categoryCount (.old .read) = M ∧ actual.categoryCount (.old .write) = M ∧ + actual.categoryCount (.old .register) = 3 ∧ + actual.categoryCount (.old .arithmetic) = 3 * M + B ∧ + actual.categoryCount (.old .branch) = 2 * M + 2 * B + 2 := by + dsimp only + simp only [Run.categoryCount, finalizer_categories host entry] + simp [expectedCategories, List.count_append, count_replicated_flatten, + copyCategories, releaseCategories, Nat.mul_comm, Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] + omega + +theorem zero_base_has_no_releases {s : State} {M : Nat} (entry : Entry base 0 M s) : + (run program (cost 0 M) s).categoryCount .numericRelease = 0 ∧ + (run program (cost 0 M) s).final.core.extent = M := + ⟨(finalizer_category_counts host entry).1, (finalizer host entry).1.1⟩ + +theorem zero_length_has_no_copy {s : State} {B : Nat} (entry : Entry base B 0 s) : + (run program (cost B 0) s).categoryCount (.old .read) = 0 ∧ + (run program (cost B 0) s).categoryCount (.old .write) = 0 ∧ + (run program (cost B 0) s).final.core.extent = 0 := + ⟨(finalizer_category_counts host entry).2.1, (finalizer_category_counts host entry).2.2.1, + (finalizer host entry).1.1⟩ + +theorem finalizer_prefix_fits {s : State} {B M W : Nat} + (hw : 32 ≤ W) (cont : base + 14 < program.length) (plen : program.length < 2 ^ W) + (hfit : s.Fits W) (entry : Entry base B M s) : + ∀ fuel, fuel ≤ cost B M → (run program fuel s).final.Fits W := by + obtain ⟨_, finalFit, each⟩ := finalizer_safe host hw cont plen hfit entry + have length := (finalizer host entry).2.2.2 + intro fuel le + by_cases lt : fuel < cost B M + · have within : fuel < (run program (cost B M) s).transitions.length := by rw [length]; exact lt + let t := (run program (cost B M) s).transitions[fuel] + have occurrence : (run program (cost B M) s).transitions[fuel]? = some t := + List.getElem?_eq_getElem within + rw [← (run_transition_at occurrence).1] + exact (each t (List.mem_of_getElem? occurrence)).1 + · have equal : fuel = cost B M := by omega + subst fuel + exact finalFit + +end HostedExecution + +theorem code_inventory (base : Nat) (bound : base + 14 < 2 ^ 32) : + (code base bound).length = 14 ∧ + ((code base bound).map Instruction.encoding).flatten.length = 46 := by + exact ⟨rfl, rfl⟩ + +theorem code_fields (base : Nat) (bound : base + 14 < 2 ^ 32) (W : Nat) (hw : 32 ≤ W) : + ∀ i ∈ code base bound, i.Fits W := by + have cap : 2 ^ 32 ≤ 2 ^ W := Nat.pow_le_pow_right (by decide) hw + intro i _ + cases i with + | old p => + intro word member + simp only [Instruction.encoding, List.mem_map] at member + obtain ⟨operand, _, rfl⟩ := member + exact Nat.lt_of_lt_of_le operand.isLt cap + | releaseCell => simp [Instruction.Fits, Instruction.encoding]; omega + | releaseKey => simp [Instruction.Fits, Instruction.encoding]; omega + | releaseKeyRegister => simp [Instruction.Fits, Instruction.encoding]; omega + +/-- A zero-extent release faults and preserves every other state component. -/ +theorem release_zero_control (s : State) (zero : s.core.extent = 0) : + execute .releaseCell s = { s with core := { s.core with status := .fault } } ∧ + (execute .releaseCell s).core.extent = 0 ∧ + (execute .releaseCell s).core.memory = s.core.memory ∧ + (execute .releaseCell s).core.pc = s.core.pc := by + rw [releaseCell_zero s zero] + exact ⟨rfl, zero, rfl, rfl⟩ + +theorem exact_domain {original : Memory} {B M : Nat} {s : State} + (initialized : Initialized original B M) (output : FinalOutput original B M s) : + ∀ a, s.core.memory a ≠ none ↔ a < M := by + intro a + obtain ⟨extent, values, tail⟩ := output + constructor + · intro present + by_cases lt : a < M + · exact lt + · exact False.elim (present (tail a (by omega))) + · intro lt + obtain ⟨value, source⟩ := initialized a lt + rw [values a lt, source] + simp + +end RMQ.SuccinctFinal.PackedLifecycle.Finalizer diff --git a/RMQ/Core/WordRAM/Lifecycle/Input.lean b/RMQ/Core/WordRAM/Lifecycle/Input.lean new file mode 100644 index 00000000..2df3df36 --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/Input.lean @@ -0,0 +1,153 @@ +import RMQ.Core.WordRAM.Lifecycle.Safety +import RMQ.Core.WordRAM.Lifecycle.Builder + +/-! # Supplied lifecycle input and bounded request storage + +Materialization is an explicit input boundary. The word route supplies encoded +keys, the comparison route supplies separate Int cells, and both place exactly +two request words after their numeric input in the same owned arena. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle + +open PackedConstruction (Operand put) +open PackedWordRAM (wordWidth) + +inductive InputModel where + | word | comparison +deriving DecidableEq, Repr + +def InputModel.source : InputModel → PackedConstruction.Structured.Block + | .word => PackedConstruction.wordLeaf + | .comparison => PackedConstruction.keyLeaf + +def inputCore (model : InputModel) (xs : List Int) : PackedConstruction.State := + match model with + | .word => PackedConstruction.wordInputState (wordWidth xs.length) xs + | .comparison => PackedConstruction.comparisonInputState xs + +def initialState (model : InputModel) (xs : List Int) (left right entry : Nat) : State := + let s := inputCore model xs + { core := { s with + memory := put (put s.memory s.extent (some left)) (s.extent + 1) (some right) + extent := s.extent + 2 + pc := entry } + keyExtent := if model = .comparison then xs.length else 0 + keyRegExtent := if model = .comparison then 2 else 0 } + +def InputDomain (model : InputModel) (xs : List Int) : Prop := + match model with + | .word => PackedConstruction.InputFits (wordWidth xs.length) xs + | .comparison => True + +theorem inputCore_extent_pos (model : InputModel) (xs : List Int) : + 0 < (inputCore model xs).extent := by + cases model <;> simp [inputCore, PackedConstruction.wordInputState, + PackedConstruction.comparisonInputState, PackedConstruction.inputCellCount] + +theorem initial_memory_below (model : InputModel) (xs : List Int) (left right entry a : Nat) + (ha : a < (inputCore model xs).extent) : + (initialState model xs left right entry).core.memory a = (inputCore model xs).memory a := by + simp [initialState, put, show a ≠ (inputCore model xs).extent by omega, + show a ≠ (inputCore model xs).extent + 1 by omega] + +theorem initial_requests (model : InputModel) (xs : List Int) (left right entry : Nat) : + (initialState model xs left right entry).core.memory (inputCore model xs).extent = some left ∧ + (initialState model xs left right entry).core.memory ((inputCore model xs).extent + 1) = + some right := by + simp [initialState, put] + +theorem initial_header (model : InputModel) (xs : List Int) (left right entry : Nat) : + (initialState model xs left right entry).core.memory 0 = some xs.length := by + rw [initial_memory_below model xs left right entry 0 (inputCore_extent_pos model xs)] + cases model <;> simp [inputCore, PackedConstruction.wordInputState, + PackedConstruction.comparisonInputState] + +theorem initial_clean (model : InputModel) (xs : List Int) (left right entry : Nat) : + (initialState model xs left right entry).Closed := by + have ht : PackedConstruction.CleanTail (inputCore model xs) := by + cases model + · exact PackedConstruction.wordInputState_cleanTail _ _ + · exact PackedConstruction.comparisonInputState_cleanTail _ + refine ⟨?_, ?_, ?_⟩ + · intro a ha + change (inputCore model xs).extent + 2 ≤ a at ha + simp [initialState, put, show a ≠ (inputCore model xs).extent by omega, + show a ≠ (inputCore model xs).extent + 1 by omega, ht a (by omega)] + · intro a ha + cases model with + | word => rfl + | comparison => + change xs.length ≤ a at ha + exact List.getElem?_eq_none_iff.mpr ha + · intro r _ + cases model <;> rfl + +theorem initial_input (model : InputModel) (xs : List Int) (left right entry : Nat) + (domain : InputDomain model xs) : + match model with + | .word => PackedConstruction.Proof.WordInput (wordWidth xs.length) xs + (initialState model xs left right entry).core + | .comparison => PackedConstruction.Proof.OracleInput xs + (initialState model xs left right entry).core := by + cases model with + | comparison => rfl + | word => + refine ⟨domain, ?_, ?_⟩ + · change xs.length + 1 ≤ (xs.length + 1) + 2 + omega + · intro k hk + rw [initial_memory_below .word xs left right entry (k+1) (by + change k + 1 < xs.length + 1; omega)] + exact PackedConstruction.encodeInput_key + (PackedConstruction.Proof.getD_eq_of_getElem? hk) + +/-- The original width has ample slack for two supplied request cells as well +as the original construction envelope. -/ +theorem initial_capacity (model : InputModel) (xs : List Int) (left right entry : Nat) : + (initialState model xs left right entry).core.extent + + 64 * (400000 * (xs.length + 1)) < 2 ^ wordWidth xs.length := by + have h := PackedConstruction.Proof.bankcap_wordWidth xs.length + have hp : 2 * xs.length + 4 ≤ (2 * xs.length + 4) ^ 8 := + Nat.le_self_pow (by decide) _ + have h32 : (2 : Nat) ^ 32 = 4294967296 := by decide + rw [h32] at h + cases model <;> + simp only [initialState, inputCore, PackedConstruction.wordInputState, + PackedConstruction.comparisonInputState, PackedConstruction.inputCellCount] <;> omega + +theorem initial_fits (model : InputModel) (xs : List Int) (left right entry : Nat) + (domain : InputDomain model xs) (hl : left < 2 ^ wordWidth xs.length) + (hr : right < 2 ^ wordWidth xs.length) (he : entry < 2 ^ wordWidth xs.length) : + (initialState model xs left right entry).Fits (wordWidth xs.length) := by + have cap := initial_capacity model xs left right entry + have hn : xs.length < 2 ^ wordWidth xs.length := by + have h := PackedConstruction.Proof.cap_wordWidth xs.length + omega + have hpos : 0 < 2 ^ wordWidth xs.length := Nat.two_pow_pos _ + refine ⟨⟨?_, he, by omega, ?_, ?_⟩, ?_, ?_⟩ + · intro r + cases model <;> exact hpos + · intro a v hv + simp only [initialState, put] at hv + split at hv + · cases hv; exact hr + · split at hv + · cases hv; exact hl + · cases model with + | word => exact PackedConstruction.encodeInput_word_fits domain hv + | comparison => + simp only [inputCore, PackedConstruction.comparisonInputState] at hv + split at hv + · cases hv; exact hn + · cases hv + · intro v hv + cases model <;> cases hv + · cases model <;> simp only [initialState, reduceCtorEq, ↓reduceIte] + · exact hpos + · exact hn + · have hw := PackedConstruction.Proof.wordWidth_ge_32 xs.length + have hp := Nat.pow_le_pow_right (by decide : 0 < 2) hw + cases model <;> simp only [initialState, reduceCtorEq, ↓reduceIte] <;> omega + +end RMQ.SuccinctFinal.PackedLifecycle diff --git a/RMQ/Core/WordRAM/Lifecycle/Machine.lean b/RMQ/Core/WordRAM/Lifecycle/Machine.lean new file mode 100644 index 00000000..f4dca383 --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/Machine.lean @@ -0,0 +1,179 @@ +import RMQ.Core.WordRAM.Construction.Compiler + +/-! # Scalar lifecycle machine + +The old numeric machine is an exact projection. The two additional extents +account for separately owned comparison resources; they are not bounds on Int +values. Every release retires one tail cell. External request admission is a +separate charged protocol on a halted state, with one scalar update per event. +No request tape or observation history is stored in the machine state. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle + +open PackedConstruction (Operand Prim execPrim put) + +structure State where + core : PackedConstruction.State + keyExtent : Nat + keyRegExtent : Nat + +inductive Instruction where + | old (primitive : Prim) + | releaseCell + | releaseKey + | releaseKeyRegister +deriving DecidableEq, Repr + +def execute : Instruction → State → State + | .old p, s => { s with core := execPrim p s.core } + | .releaseCell, s => + if s.core.extent = 0 then { s with core := { s.core with status := .fault } } + else { s with core := { s.core.next with extent := s.core.extent - 1, memory := put s.core.memory (s.core.extent - 1) none } } + | .releaseKey, s => + if s.keyExtent = 0 then { s with core := { s.core with status := .fault } } + else { s with keyExtent := s.keyExtent - 1, core := { s.core.next with keys := put s.core.keys (s.keyExtent - 1) none } } + | .releaseKeyRegister, s => + if s.keyRegExtent = 0 then { s with core := { s.core with status := .fault } } + else { s with keyRegExtent := s.keyRegExtent - 1, core := { s.core.next with keyRegs := put s.core.keyRegs (s.keyRegExtent - 1) 0 } } + +@[simp] theorem execute_old (p : Prim) (s : State) : + execute (.old p) s = { s with core := execPrim p s.core } := rfl + +theorem releaseCell_zero (s : State) (h : s.core.extent = 0) : + execute .releaseCell s = { s with core := { s.core with status := .fault } } := by + simp [execute, h] + +theorem releaseKey_zero (s : State) (h : s.keyExtent = 0) : + execute .releaseKey s = { s with core := { s.core with status := .fault } } := by + simp [execute, h] + +theorem releaseKeyRegister_zero (s : State) (h : s.keyRegExtent = 0) : + execute .releaseKeyRegister s = { s with core := { s.core with status := .fault } } := by + simp [execute, h] + +def requestLeftRegister : Nat := 300 +def requestRightRegister : Nat := 301 + +/-- The environment supplies only the current two request words. Entry and +activation are separately charged scalar control changes. -/ +inductive Boundary where + | left (value : Nat) + | right (value : Nat) + | entry (target : Operand) + | activate +deriving DecidableEq, Repr + +def executeBoundary : Boundary → State → State + | .left v, s => { s with core := { s.core with regs := put s.core.regs requestLeftRegister v } } + | .right v, s => { s with core := { s.core with regs := put s.core.regs requestRightRegister v } } + | .entry target, s => { s with core := { s.core with pc := target } } + | .activate, s => { s with core := { s.core with status := .running } } + +inductive Action where + | instruction (i : Instruction) + | boundary (b : Boundary) +deriving DecidableEq, Repr + +inductive Category where + | old (category : PackedConstruction.Category) + | numericRelease | keyRelease | keyRegisterRelease | requestAdmission | controlEntry +deriving DecidableEq, Repr + +def Action.category : Action → Category + | .instruction (.old p) => .old p.category + | .instruction .releaseCell => .numericRelease + | .instruction .releaseKey => .keyRelease + | .instruction .releaseKeyRegister => .keyRegisterRelease + | .boundary (.left _) | .boundary (.right _) => .requestAdmission + | .boundary (.entry _) | .boundary .activate => .controlEntry + +structure Transition where + before : State + action : Action + after : State + +def step (program : List Instruction) (s : State) : Option Transition := + if s.core.status = .running then + (program[s.core.pc]?).map fun i => ⟨s, .instruction i, execute i s⟩ + else none + +/-- Old instruction execution stays stopped. Only this named external boundary +can accept a new request after a query has halted. Faulted states do not re-enter. -/ +def boundaryStep (b : Boundary) (s : State) : Option Transition := + match s.core.status with + | .halted _ => some ⟨s, .boundary b, executeBoundary b s⟩ + | _ => none + +structure Run where + final : State + transitions : List Transition + +def run (program : List Instruction) : Nat → State → Run + | 0, s => ⟨s, []⟩ + | fuel + 1, s => + match step program s with + | none => ⟨s, []⟩ + | some t => let rest := run program fuel t.after + ⟨rest.final, t :: rest.transitions⟩ + +def runBoundary : List Boundary → State → Run + | [], s => ⟨s, []⟩ + | b :: bs, s => + match boundaryStep b s with + | none => ⟨s, []⟩ + | some t => let rest := runBoundary bs t.after + ⟨rest.final, t :: rest.transitions⟩ + +def requestProtocol (entry : Operand) (left right : Nat) (s : State) : Run := + runBoundary [.left left, .right right, .entry entry, .activate] s + +def Run.steps (r : Run) : Nat := r.transitions.length +def Run.categories (r : Run) : List Category := r.transitions.map (·.action.category) +def Run.categoryCount (r : Run) (c : Category) : Nat := r.categories.count c + +/-- Attempted numeric reads include absent replies and preserve repetitions. -/ +def Transition.read? (t : Transition) : Option (Nat × Option Nat) := + match t.action with + | .instruction (.old (.load _ address)) => + let a := t.before.core.regs address + some (a, if a < t.before.core.extent then t.before.core.memory a else none) + | _ => none + +def Transition.write? (t : Transition) : Option (Nat × Nat) := + match t.action with + | .instruction (.old (.store address value)) => + if t.before.core.regs address < t.before.core.extent then + some (t.before.core.regs address, t.before.core.regs value) else none + | _ => none + +def Run.reads (r : Run) : List (Nat × Option Nat) := r.transitions.filterMap Transition.read? +def Run.writes (r : Run) : List (Nat × Nat) := r.transitions.filterMap Transition.write? + +/-- Logical ownership includes absence outside each separately counted bank. -/ +def State.Closed (s : State) : Prop := + PackedConstruction.CleanTail s.core ∧ + (∀ a, s.keyExtent ≤ a → s.core.keys a = none) ∧ + (∀ r, s.keyRegExtent ≤ r → s.core.keyRegs r = 0) + +def State.Fits (W : Nat) (s : State) : Prop := + s.core.Fits W ∧ s.keyExtent < 2 ^ W ∧ s.keyRegExtent < 2 ^ W + +def Instruction.encoding : Instruction → List Nat + | .old p => p.constants.map Fin.val + | .releaseCell => [13] + | .releaseKey => [14] + | .releaseKeyRegister => [15] + +def Instruction.Fits (W : Nat) (i : Instruction) : Prop := + ∀ word ∈ i.encoding, word < 2 ^ W + +/-- Old safety is reused verbatim; new operations have scalar nonempty-bank +preconditions. External admission has its own represented-input boundary. -/ +def Instruction.Safe (W len : Nat) (s : State) : Instruction → Prop + | .old p => p.Safe W len s.core + | .releaseCell => 13 < 2 ^ W ∧ 0 < s.core.extent + | .releaseKey => 14 < 2 ^ W ∧ 0 < s.keyExtent + | .releaseKeyRegister => 15 < 2 ^ W ∧ 0 < s.keyRegExtent + +end RMQ.SuccinctFinal.PackedLifecycle diff --git a/RMQ/Core/WordRAM/Lifecycle/Ownership.lean b/RMQ/Core/WordRAM/Lifecycle/Ownership.lean new file mode 100644 index 00000000..adbcae8f --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/Ownership.lean @@ -0,0 +1,113 @@ +import RMQ.Core.WordRAM.Lifecycle.Continuous +import RMQ.Core.WordRAM.Lifecycle.Executable +import RMQ.Core.WordRAM.Lifecycle.Accounting + +/-! # The executed retained owner and its complete numeric capacity + +The production endpoint has arrays and scalar control only. Observation traces +are separately returned by the validation evaluator and are not owner fields. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle.Ownership + +open PackedWordRAM (wordWidth buildMemory) +set_option maxRecDepth 30000 + +def owner (model : InputModel) (xs : List Int) (left right : Nat) : Owner := + runOwner (Layout.program model).toArray (Continuous.lifecycleBudget xs.length) + (Executable.initialOwner model xs left right) + +def observations (model : InputModel) (xs : List Int) (left right : Nat) : ArrayRun := + runArray (Layout.program model).toArray (Continuous.lifecycleBudget xs.length) + (Executable.initialOwner model xs left right) + +attribute [local irreducible] owner observations + +def Ready (xs : List Int) (es : Owner) : Prop := + es.regs.size = numericBank ∧ Retained.Canonical xs es.toState + +def capacity (model : InputModel) (es : Owner) : Nat := + es.memory.size + (encodedProgram model).length + es.regs.size + controlWords + +theorem ready_of_projection {xs : List Int} {es : Owner} {s : State} + (bank : es.regs.size = numericBank) (projection : es.toState = s) + (canonical : Retained.Canonical xs s) : Ready xs es := by + refine ⟨bank, ?_⟩ + rw [projection] + exact canonical + +theorem status_of_projection {es : Owner} {s : State} {status : PackedConstruction.Status} + (projection : es.toState = s) (halted : s.core.status = status) : es.status = status := + (congrArg (fun t : State => t.core.status) projection).trans halted + +theorem refinement (model : InputModel) (xs : List Int) (left right : Nat) + (domain : InputDomain model xs) (hl : left < 2 ^ wordWidth xs.length) + (hr : right < 2 ^ wordWidth xs.length) : + (owner model xs left right).toState = (Continuous.continuousRun model xs left right).final ∧ + (owner model xs left right).regs.size = numericBank ∧ + (observations model xs left right).toRun = Continuous.continuousRun model xs left right := by + have production := Executable.initial_owner_refinement model xs left right domain hl hr + (Continuous.lifecycleBudget xs.length) + have observed := Executable.initial_array_refinement model xs left right domain hl hr + (Continuous.lifecycleBudget xs.length) + unfold owner observations Continuous.continuousRun + exact ⟨production.1, production.2, observed.1⟩ + +theorem ready (model : InputModel) (xs : List Int) (left right : Nat) + (domain : InputDomain model xs) (hl : left < 2 ^ wordWidth xs.length) + (hr : right < 2 ^ wordWidth xs.length) : Ready xs (owner model xs left right) := by + obtain ⟨abstract, producer, ts, built⟩ := Construction.build_stage model xs left right domain hl hr + have refines := refinement model xs left right domain hl hr + exact ready_of_projection refines.2.1 refines.1 (Continuous.canonical built) + +theorem halted (model : InputModel) (xs : List Int) (left right : Nat) + (domain : InputDomain model xs) (hl : left < 2 ^ wordWidth xs.length) + (hr : right < 2 ^ wordWidth xs.length) : + (owner model xs left right).status = .halted + (PackedWordRAM.optionNatPacket (SuccinctClassic.queryTraceResult xs left right).value) := by + obtain ⟨abstract, producer, ts, built⟩ := Construction.build_stage model xs left right domain hl hr + exact status_of_projection (refinement model xs left right domain hl hr).1 (Continuous.halts built) + +theorem Ready.empty_keys {xs : List Int} {es : Owner} (ready : Ready xs es) : + es.keys = #[] ∧ es.keyRegs = #[] := + Owner.key_banks_empty es ready.2.1.2.2.2.2.1 ready.2.1.2.2.2.2.2 + +theorem Ready.memory_size {xs : List Int} {es : Owner} (ready : Ready xs es) : + es.memory.size = (buildMemory xs).length := ready.2.1.2.1 + +theorem Ready.capacity_bound {xs : List Int} {es : Owner} (ready : Ready xs es) + (model : InputModel) : + capacity model es * wordWidth xs.length ≤ 2 * xs.length + retainedRho xs.length := by + unfold capacity + rw [ready.memory_size, ready.1] + exact retained_capacity model xs + +theorem Ready.query {xs : List Int} {es : Owner} (ready : Ready xs es) + (model : InputModel) (left right answer : Nat) (halted : es.status = .halted answer) + (hl : left < 2 ^ wordWidth xs.length) (hr : right < 2 ^ wordWidth xs.length) : + Ready xs (Executable.queryOwner model left right es) ∧ + (Executable.queryOwner model left right es).status = .halted + (PackedWordRAM.optionNatPacket (SuccinctClassic.queryTraceResult xs left right).value) ∧ + (Executable.queryOwner model left right es).memory = es.memory ∧ + (Executable.queryArray model left right es).toRun = Reusable.queryRun model left right es.toState ∧ + (Reusable.queryRun model left right es.toState).steps ≤ Reusable.queryBudget := by + have refines := Executable.query_owner_refinement model xs left right answer es ready.1 ready.2 halted hl hr + have observed := Executable.query_array_refinement model xs left right answer es ready.1 ready.2 halted hl hr + have correct := Reusable.query_correct model xs left right answer es.toState ready.2 halted hl hr + refine ⟨⟨refines.2, ?_⟩, + (congrArg (fun s : State => s.core.status) refines.1).trans correct.2.1, ?_, observed.1, + correct.2.2.2.2.2⟩ + · rw [refines.1]; exact correct.1 + · + apply Array.ext + · change (Executable.queryOwner model left right es).toState.core.extent = es.toState.core.extent + rw [refines.1] + exact correct.2.2.2.1 + · intro i hleft hright + have memory := (congrArg (fun s : State => s.core.memory i) refines.1).trans + (congrFun correct.2.2.1 i) + change (Executable.queryOwner model left right es).memory.getD i none = es.memory.getD i none at memory + simpa only [Array.getD_eq_getD_getElem?, Array.getElem?_eq_getElem hleft, + Array.getElem?_eq_getElem hright, Option.getD_some] using memory + +end RMQ.SuccinctFinal.PackedLifecycle.Ownership diff --git a/RMQ/Core/WordRAM/Lifecycle/Physical.lean b/RMQ/Core/WordRAM/Lifecycle/Physical.lean new file mode 100644 index 00000000..e6aa6e48 --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/Physical.lean @@ -0,0 +1,727 @@ +import RMQ.Core.WordRAM.Lifecycle.Accounting +import RMQ.Core.WordRAM.Lifecycle.ArrayRun +import RMQ.Core.WordRAM.Lifecycle.Retained + +/-! # One numeric physical view of the lifecycle state + +The fixed code, numeric bank, eight controls, and currently owned arena occupy +disjoint consecutive ranges. This is a finite observation of the existing +machine, not another interpreter. `Option Nat` retains its uninitialized-cell +meaning; initialization is a proof predicate, not a stored bitmap. Comparison +keys remain separately counted Int resources. Logical array ownership is not a +claim about native allocation capacity or external aliases. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle.Physical + +open PackedConstruction (Operand Prim put execPrim) +set_option maxRecDepth 30000 + +def codeLength (model : InputModel) : Nat := (encodedProgram model).length +def registerBase (model : InputModel) : Nat := codeLength model +def controlBase (model : InputModel) : Nat := registerBase model + numericBank +def arenaBase (model : InputModel) : Nat := controlBase model + controlWords + +def codeAddress (_model : InputModel) (i : Nat) : Nat := i +def registerAddress (model : InputModel) (r : Nat) : Nat := registerBase model + r +def controlAddress (model : InputModel) (i : Nat) : Nat := controlBase model + i +def arenaAddress (model : InputModel) (a : Nat) : Nat := arenaBase model + a + +def extent (model : InputModel) (s : State) : Nat := arenaBase model + s.core.extent + +def statusTag : PackedConstruction.Status → Nat + | .running => 0 + | .halted _ => 1 + | .fault => 2 + +def haltValue : PackedConstruction.Status → Nat + | .halted value => value + | _ => 0 + +/-- PC, status, halted result, arena extent, numeric-bank extent, key extent, +key-register extent, and one reserved zero control word, in this order. -/ +def control (s : State) : Nat → Nat + | 0 => s.core.pc + | 1 => statusTag s.core.status + | 2 => haltValue s.core.status + | 3 => s.core.extent + | 4 => numericBank + | 5 => s.keyExtent + | 6 => s.keyRegExtent + | _ => 0 + +def lookup (model : InputModel) (s : State) (p : Nat) : Option Nat := + if p < codeLength model then (encodedProgram model)[p]? + else if p < controlBase model then some (s.core.regs (p - registerBase model)) + else if p < arenaBase model then some (control s (p - controlBase model)) + else if p < extent model s then s.core.memory (p - arenaBase model) + else none + +/-- A finite specification view. Producing this list is not a charged machine +operation and is not an executable implementation of an instruction. -/ +def view (model : InputModel) (s : State) : List (Option Nat) := + List.ofFn (fun p : Fin (extent model s) => lookup model s p.val) + +theorem view_length (model : InputModel) (s : State) : + (view model s).length = extent model s := by simp [view] + +theorem lookup_code (model : InputModel) (s : State) (i : Nat) (hi : i < codeLength model) : + lookup model s (codeAddress model i) = (encodedProgram model)[i]? := by + simp [lookup, codeAddress, hi] + +theorem lookup_register (model : InputModel) (s : State) (r : Nat) (hr : r < numericBank) : + lookup model s (registerAddress model r) = some (s.core.regs r) := by + simp only [lookup, registerAddress, registerBase, controlBase] + rw [if_neg (by omega), if_pos (by omega), Nat.add_sub_cancel_left] + +theorem lookup_control (model : InputModel) (s : State) (i : Nat) (hi : i < controlWords) : + lookup model s (controlAddress model i) = some (control s i) := by + have hc : codeLength model ≤ controlBase model := by unfold controlBase registerBase; omega + simp only [lookup, controlAddress] + rw [if_neg (by omega), if_neg (by omega), if_pos (by unfold arenaBase; omega), + Nat.add_sub_cancel_left] + +theorem lookup_arena (model : InputModel) (s : State) (a : Nat) : + lookup model s (arenaAddress model a) = + if a < s.core.extent then s.core.memory a else none := by + have hc : codeLength model ≤ arenaBase model := by + unfold arenaBase controlBase registerBase; omega + have hr : controlBase model ≤ arenaBase model := by unfold arenaBase; omega + simp only [lookup, arenaAddress] + rw [if_neg (by omega), if_neg (by omega), if_neg (by omega)] + simp only [extent, Nat.add_lt_add_iff_left, Nat.add_sub_cancel_left] + +theorem lookup_arena_closed (model : InputModel) (s : State) (closed : s.Closed) (a : Nat) : + lookup model s (arenaAddress model a) = s.core.memory a := by + rw [lookup_arena] + split + · rfl + · exact (closed.1 a (by omega)).symm + +theorem lookup_outside (model : InputModel) (s : State) (p : Nat) + (outside : extent model s ≤ p) : lookup model s p = none := by + have hb : arenaBase model ≤ p := by unfold extent at outside; omega + have hc : codeLength model ≤ arenaBase model := by unfold arenaBase controlBase registerBase; omega + have hr : controlBase model ≤ arenaBase model := by unfold arenaBase; omega + simp [lookup, show ¬p < codeLength model by omega, + show ¬p < controlBase model by omega, show ¬p < arenaBase model by omega, + show ¬p < extent model s by omega] + +private theorem finite_lookup (n : Nat) (f : Nat → Option Nat) + (outside : ∀ p, n ≤ p → f p = none) (p : Nat) : + ((List.ofFn (fun i : Fin n => f i.val))[p]?).join = f p := by + by_cases hp : p < n + · simp [hp] + · rw [List.getElem?_eq_none_iff.mpr (by simp; omega)] + exact (outside p (by omega)).symm + +theorem view_lookup (model : InputModel) (s : State) (p : Nat) : + ((view model s)[p]?).join = lookup model s p := + finite_lookup (extent model s) (lookup model s) (lookup_outside model s) p + +inductive Slot (model : InputModel) where + | code (i : Fin (codeLength model)) + | register (r : Fin numericBank) + | control (i : Fin controlWords) + | arena (a : Nat) + +def address {model : InputModel} : Slot model → Nat + | .code i => codeAddress model i + | .register r => registerAddress model r + | .control i => controlAddress model i + | .arena a => arenaAddress model a + +theorem address_injective (model : InputModel) : + ∀ x y : Slot model, address x = address y → x = y := by + intro x y equal + cases x with + | code i => + have hi := i.isLt + cases y with + | code j => exact congrArg Slot.code (Fin.ext equal) + | register j => simp only [address, codeAddress, registerAddress, registerBase] at equal; omega + | control j => simp only [address, codeAddress, controlAddress, controlBase, registerBase] at equal; omega + | arena a => simp only [address, codeAddress, arenaAddress, arenaBase, controlBase, registerBase] at equal; omega + | register r => + have hr := r.isLt + cases y with + | code j => have hj := j.isLt; simp only [address, codeAddress, registerAddress, registerBase] at equal; omega + | register j => apply congrArg Slot.register; apply Fin.ext; simp only [address, registerAddress] at equal; omega + | control j => simp only [address, registerAddress, controlAddress, controlBase] at equal; omega + | arena a => simp only [address, registerAddress, arenaAddress, arenaBase, controlBase] at equal; omega + | control i => + have hi := i.isLt + cases y with + | code j => have hj := j.isLt; simp only [address, codeAddress, controlAddress, controlBase, registerBase] at equal; omega + | register j => have hj := j.isLt; simp only [address, controlAddress, registerAddress, controlBase] at equal; omega + | control j => apply congrArg Slot.control; apply Fin.ext; simp only [address, controlAddress] at equal; omega + | arena a => simp only [address, controlAddress, arenaAddress, arenaBase] at equal; omega + | arena a => + cases y with + | code j => have hj := j.isLt; simp only [address, codeAddress, arenaAddress, arenaBase, controlBase, registerBase] at equal; omega + | register j => have hj := j.isLt; simp only [address, registerAddress, arenaAddress, arenaBase, controlBase] at equal; omega + | control j => have hj := j.isLt; simp only [address, controlAddress, arenaAddress, arenaBase] at equal; omega + | arena b => apply congrArg Slot.arena; simp only [address, arenaAddress] at equal; omega + +/-- Finite-bank reads use the same zero default as the existing array owner. -/ +def registerRead (model : InputModel) (s : State) (r : Nat) : Option Nat := + if r < numericBank then lookup model s (registerAddress model r) else some 0 + +theorem registerRead_complete (model : InputModel) (s : State) + (bank : ∀ r, numericBank ≤ r → s.core.regs r = 0) (r : Nat) : + registerRead model s r = some (s.core.regs r) := by + unfold registerRead + split + · exact lookup_register model s r ‹_› + · rw [bank r (by omega)] + +def Initialized (s : State) : Prop := + ∀ a, a < s.core.extent → ∃ value, s.core.memory a = some value + +theorem canonical_initialized {xs : List Int} {s : State} + (canonical : Retained.Canonical xs s) : Initialized s := by + intro a ha + rw [canonical.1.2.1] at ha + rw [canonical.1.1] + exact ⟨(PackedWordRAM.buildMemory xs)[a], List.getElem?_eq_getElem ha⟩ + +theorem lookup_initialized (model : InputModel) (s : State) (initialized : Initialized s) + (p : Nat) (inside : p < extent model s) : ∃ value, lookup model s p = some value := by + unfold lookup + split + · exact ⟨(encodedProgram model)[p], List.getElem?_eq_getElem ‹_›⟩ + · split + · exact ⟨_, rfl⟩ + · split + · exact ⟨_, rfl⟩ + · exact initialized _ (by unfold extent at inside; omega) + +def wordView (model : InputModel) (s : State) : List Nat := + (view model s).map (fun value => value.getD 0) + +/-- Once initialized, the entire owned view is exactly a list of Nat words. +There is no retained initialization mask in this statement or in the owner. -/ +theorem wordView_exact (model : InputModel) (s : State) (initialized : Initialized s) : + (wordView model s).map some = view model s := by + unfold wordView + rw [List.map_map] + refine Eq.trans ?_ (List.map_id (view model s)) + apply List.map_congr_left + intro cell member + obtain ⟨p, hp⟩ := List.mem_iff_getElem?.mp member + have inside : p < extent model s := by + have h := (List.getElem?_eq_some_iff.mp hp).1 + simpa only [view_length] using h + have lookupCell : lookup model s p = cell := by + have h := view_lookup model s p + rw [hp] at h + exact h.symm + obtain ⟨value, hv⟩ := lookup_initialized model s initialized p inside + rw [← lookupCell, hv] + rfl + +theorem arenaBase_le (model : InputModel) : arenaBase model ≤ 1125176 := by + have h := encodedProgram_length_le model + change (encodedProgram model).length ≤ 1116895 at h + unfold arenaBase controlBase registerBase codeLength numericBank controlWords + omega + +/-- Static layout overhead plus the declared allocation peak fits the existing, +query-independent word width. The endpoint itself is representable. -/ +theorem peak_address_fit (model : InputModel) (n a : Nat) (bound : a ≤ 5000000 * (n + 1)) : + arenaAddress model a < 2 ^ PackedWordRAM.wordWidth n := by + have cap := PackedConstruction.Proof.bankcap_wordWidth n + have power : 2 * n + 4 ≤ (2 * n + 4) ^ 8 := Nat.le_self_pow (by decide) _ + have overhead := arenaBase_le model + have h32 : (2 : Nat) ^ 32 = 4294967296 := by decide + rw [h32] at cap + unfold arenaAddress + omega + +theorem extent_fit (model : InputModel) (n : Nat) (s : State) + (peak : s.core.extent ≤ 5000000 * (n + 1)) : + extent model s < 2 ^ PackedWordRAM.wordWidth n := + peak_address_fit model n s.core.extent peak + +theorem owned_address_fit (model : InputModel) (n : Nat) (s : State) + (peak : s.core.extent ≤ 5000000 * (n + 1)) (p : Nat) (owned : p < extent model s) : + p < 2 ^ PackedWordRAM.wordWidth n := Nat.lt_trans owned (extent_fit model n s peak) + +theorem control_fits (s : State) (W : Nat) (fit : s.Fits W) (bank : numericBank < 2 ^ W) + (i : Nat) (hi : i < controlWords) : control s i < 2 ^ W := by + have cases : i = 0 ∨ i = 1 ∨ i = 2 ∨ i = 3 ∨ i = 4 ∨ i = 5 ∨ i = 6 ∨ i = 7 := by + change i < 8 at hi; omega + rcases cases with rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl + · exact fit.1.2.1 + · cases hs : s.core.status <;> simp only [control, hs, statusTag] <;> + change 8273 < 2 ^ W at bank <;> omega + · cases hs : s.core.status with + | running => simpa only [control, hs, haltValue] using Nat.two_pow_pos W + | fault => simpa only [control, hs, haltValue] using Nat.two_pow_pos W + | halted value => simpa only [control, hs, haltValue] using fit.1.2.2.2.2 value hs + · exact fit.1.2.2.1 + · exact bank + · exact fit.2.1 + · exact fit.2.2 + · exact Nat.two_pow_pos _ + +theorem lookup_word_fits (model : InputModel) (n : Nat) (s : State) + (fit : s.Fits (PackedWordRAM.wordWidth n)) (p value : Nat) + (reply : lookup model s p = some value) : value < 2 ^ PackedWordRAM.wordWidth n := by + unfold lookup at reply + split at reply + · exact all_encoded_fields_fit model n value (List.mem_of_getElem? reply) + · split at reply + · rw [← Option.some.inj reply]; exact fit.1.1 _ + · split at reply + · rw [← Option.some.inj reply] + apply control_fits s _ fit + · have h := PackedWordRAM.query_small_fields_fit n; change 8273 < _; omega + · unfold arenaBase at *; omega + · split at reply + · exact fit.1.2.2.2.1 _ _ reply + · cases reply + +theorem code_unchanged (model : InputModel) (s t : State) (i : Nat) (hi : i < codeLength model) : + lookup model t (codeAddress model i) = lookup model s (codeAddress model i) := by + rw [lookup_code model t i hi, lookup_code model s i hi] + +theorem store_extent (model : InputModel) (s : State) (a v : Operand) : + extent model (execute (.old (.store a v)) s) = extent model s := by + simp only [execute, execPrim] + split <;> rfl + +theorem store_registers (s : State) (a v : Operand) : + (execute (.old (.store a v)) s).core.regs = s.core.regs := by + simp only [execute, execPrim] + split <;> rfl + +theorem store_arena (model : InputModel) (s : State) (a v : Operand) + (inside : s.core.regs a < s.core.extent) (j : Nat) : + lookup model (execute (.old (.store a v)) s) (arenaAddress model j) = + if j = s.core.regs a then some (s.core.regs v) + else lookup model s (arenaAddress model j) := by + rw [lookup_arena, lookup_arena] + simp only [execute, execPrim, if_pos inside, PackedConstruction.State.next, put] + by_cases hj : j = s.core.regs a + · simp [hj, inside] + · simp [hj] + +theorem store_control (s : State) (a v : Operand) (inside : s.core.regs a < s.core.extent) + (i : Nat) (hi : i < controlWords) : + control (execute (.old (.store a v)) s) i = + if i = 0 then s.core.pc + 1 else control s i := by + have cases : i = 0 ∨ i = 1 ∨ i = 2 ∨ i = 3 ∨ i = 4 ∨ i = 5 ∨ i = 6 ∨ i = 7 := by + change i < 8 at hi; omega + rcases cases with rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl <;> + simp [control, execute, execPrim, inside, PackedConstruction.State.next] + +theorem reserve_extent (model : InputModel) (s : State) (dst : Operand) : + extent model (execute (.old (.reserve dst)) s) = extent model s + 1 := by + change arenaBase model + (s.core.extent + 1) = arenaBase model + s.core.extent + 1 + omega + +/-- Reservation changes ownership and its destination register. The newly +owned arena cell stays uninitialized, exactly as in the existing evaluator. -/ +theorem reserve_arena (model : InputModel) (s : State) (dst : Operand) + (closed : s.Closed) (a : Nat) : + lookup model (execute (.old (.reserve dst)) s) (arenaAddress model a) = + lookup model s (arenaAddress model a) := by + rw [lookup_arena, lookup_arena] + change (if a < s.core.extent + 1 then s.core.memory a else none) = _ + by_cases ha : a < s.core.extent + · simp [ha, show a < s.core.extent + 1 by omega] + · rw [if_neg ha] + split + · exact closed.1 a (by omega) + · rfl + +theorem reserve_register (model : InputModel) (s : State) (dst : Operand) + (r : Nat) (hr : r < numericBank) : + lookup model (execute (.old (.reserve dst)) s) (registerAddress model r) = + some (if r = dst.val then s.core.extent else s.core.regs r) := by + rw [lookup_register model _ r hr] + rfl + +theorem reserve_control (s : State) (dst : Operand) (i : Nat) (hi : i < controlWords) : + control (execute (.old (.reserve dst)) s) i = + if i = 0 then s.core.pc + 1 else if i = 3 then s.core.extent + 1 else control s i := by + have cases : i = 0 ∨ i = 1 ∨ i = 2 ∨ i = 3 ∨ i = 4 ∨ i = 5 ∨ i = 6 ∨ i = 7 := by + change i < 8 at hi; omega + rcases cases with rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl <;> + simp [control, execute, execPrim, PackedConstruction.State.writeNext, PackedConstruction.State.next] + +theorem release_extent (model : InputModel) (s : State) (positive : 0 < s.core.extent) : + extent model (execute .releaseCell s) + 1 = extent model s := by + simp only [execute, if_neg (by omega : s.core.extent ≠ 0), extent, + PackedConstruction.State.next] + omega + +theorem release_registers (s : State) : (execute .releaseCell s).core.regs = s.core.regs := by + simp only [execute] + split <;> rfl + +theorem release_arena (model : InputModel) (s : State) (positive : 0 < s.core.extent) (a : Nat) : + lookup model (execute .releaseCell s) (arenaAddress model a) = + if a = s.core.extent - 1 then none else lookup model s (arenaAddress model a) := by + rw [lookup_arena, lookup_arena] + simp only [execute, if_neg (by omega : s.core.extent ≠ 0), PackedConstruction.State.next, put] + by_cases ha : a = s.core.extent - 1 + · simp [ha] + · by_cases small : a < s.core.extent - 1 + · simp [ha, small, show a < s.core.extent by omega] + · simp [ha, small, show ¬ a < s.core.extent by omega] + +theorem release_control (s : State) (positive : 0 < s.core.extent) + (i : Nat) (hi : i < controlWords) : + control (execute .releaseCell s) i = + if i = 0 then s.core.pc + 1 else if i = 3 then s.core.extent - 1 else control s i := by + have cases : i = 0 ∨ i = 1 ∨ i = 2 ∨ i = 3 ∨ i = 4 ∨ i = 5 ∨ i = 6 ∨ i = 7 := by + change i < 8 at hi; omega + rcases cases with rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl <;> + simp [control, execute, show s.core.extent ≠ 0 by omega, PackedConstruction.State.next] + +/-- Comparison retirement changes its separately counted resources and the +control bank; it preserves every numeric arena cell and numeric register. -/ +theorem releaseKey_numeric (model : InputModel) (s : State) : + extent model (execute .releaseKey s) = extent model s ∧ + (execute .releaseKey s).core.regs = s.core.regs ∧ + ∀ a, lookup model (execute .releaseKey s) (arenaAddress model a) = + lookup model s (arenaAddress model a) := by + simp only [execute] + split <;> refine ⟨rfl, rfl, ?_⟩ <;> intro a <;> + rw [lookup_arena, lookup_arena] <;> rfl + +theorem releaseKeyRegister_numeric (model : InputModel) (s : State) : + extent model (execute .releaseKeyRegister s) = extent model s ∧ + (execute .releaseKeyRegister s).core.regs = s.core.regs ∧ + ∀ a, lookup model (execute .releaseKeyRegister s) (arenaAddress model a) = + lookup model s (arenaAddress model a) := by + simp only [execute] + split <;> refine ⟨rfl, rfl, ?_⟩ <;> intro a <;> + rw [lookup_arena, lookup_arena] <;> rfl + +theorem releaseKey_control (s : State) (positive : 0 < s.keyExtent) + (i : Nat) (hi : i < controlWords) : + control (execute .releaseKey s) i = + if i = 0 then s.core.pc + 1 else if i = 5 then s.keyExtent - 1 else control s i := by + have cases : i = 0 ∨ i = 1 ∨ i = 2 ∨ i = 3 ∨ i = 4 ∨ i = 5 ∨ i = 6 ∨ i = 7 := by + change i < 8 at hi; omega + rcases cases with rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl <;> + simp [control, execute, show s.keyExtent ≠ 0 by omega, PackedConstruction.State.next] + +theorem releaseKeyRegister_control (s : State) (positive : 0 < s.keyRegExtent) + (i : Nat) (hi : i < controlWords) : + control (execute .releaseKeyRegister s) i = + if i = 0 then s.core.pc + 1 else if i = 6 then s.keyRegExtent - 1 else control s i := by + have cases : i = 0 ∨ i = 1 ∨ i = 2 ∨ i = 3 ∨ i = 4 ∨ i = 5 ∨ i = 6 ∨ i = 7 := by + change i < 8 at hi; omega + rcases cases with rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl <;> + simp [control, execute, show s.keyRegExtent ≠ 0 by omega, PackedConstruction.State.next] + +theorem boundary_arena (model : InputModel) (s : State) (b : Boundary) (a : Nat) : + lookup model (executeBoundary b s) (arenaAddress model a) = + lookup model s (arenaAddress model a) := by + rw [lookup_arena, lookup_arena] + cases b <;> rfl + +theorem boundary_extent (model : InputModel) (s : State) (b : Boundary) : + extent model (executeBoundary b s) = extent model s := by cases b <;> rfl + +theorem boundary_register (model : InputModel) (s : State) (b : Boundary) + (r : Nat) (hr : r < numericBank) : + lookup model (executeBoundary b s) (registerAddress model r) = some + (match b with + | .left value => if r = requestLeftRegister then value else s.core.regs r + | .right value => if r = requestRightRegister then value else s.core.regs r + | _ => s.core.regs r) := by + rw [lookup_register model _ r hr] + cases b <;> rfl + +theorem boundary_control (s : State) (b : Boundary) (i : Nat) (hi : i < controlWords) : + control (executeBoundary b s) i = + match b with + | .entry target => if i = 0 then target.val else control s i + | .activate => if i = 1 ∨ i = 2 then 0 else control s i + | _ => control s i := by + have cases : i = 0 ∨ i = 1 ∨ i = 2 ∨ i = 3 ∨ i = 4 ∨ i = 5 ∨ i = 6 ∨ i = 7 := by + change i < 8 at hi; omega + rcases cases with rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl <;> + cases b <;> simp [control, executeBoundary, statusTag, haltValue] + +/-- Only an in-extent logical attempt is translated into a physical fetch. +An out-of-extent attempt retains its logical address but performs no fetch. -/ +def checkedAddress (model : InputModel) (s : State) (a : Nat) : Option Nat := + if a < s.core.extent then some (arenaAddress model a) else none + +theorem checkedAddress_none (model : InputModel) (s : State) (a : Nat) : + checkedAddress model s a = none ↔ s.core.extent ≤ a := by + simp [checkedAddress] + +theorem checkedAddress_some (model : InputModel) (s : State) (a p : Nat) : + checkedAddress model s a = some p ↔ a < s.core.extent ∧ p = arenaAddress model a := by + by_cases h : a < s.core.extent + · simp [checkedAddress, h, eq_comm] + · simp [checkedAddress, h] + +theorem read_source (t : Transition) (a : Nat) (reply : Option Nat) + (read : t.read? = some (a, reply)) : + ∃ dst address, t.action = .instruction (.old (.load dst address)) ∧ + a = t.before.core.regs address ∧ + reply = (if a < t.before.core.extent then t.before.core.memory a else none) := by + cases ha : t.action with + | boundary b => simp [Transition.read?, ha] at read + | instruction i => + cases i with + | old p => + cases p <;> simp [Transition.read?, ha] at read + case load dst address => + obtain ⟨rfl, rfl⟩ := read + exact ⟨dst, address, rfl, rfl, rfl⟩ + | releaseCell => simp [Transition.read?, ha] at read + | releaseKey => simp [Transition.read?, ha] at read + | releaseKeyRegister => simp [Transition.read?, ha] at read + +theorem read_provenance (model : InputModel) (t : Transition) (a : Nat) (reply : Option Nat) + (read : t.read? = some (a, reply)) : + reply = lookup model t.before (arenaAddress model a) ∧ + (∀ p, checkedAddress model t.before a = some p → lookup model t.before p = reply) ∧ + (checkedAddress model t.before a = none ↔ t.before.core.extent ≤ a) := by + obtain ⟨_, _, _, _, backed⟩ := read_source t a reply read + have lookupEq : reply = lookup model t.before (arenaAddress model a) := by + rw [lookup_arena]; exact backed + refine ⟨lookupEq, ?_, checkedAddress_none model t.before a⟩ + intro p hp + rw [(checkedAddress_some model t.before a p).mp hp |>.2] + exact lookupEq.symm + +/-- Failed extent checks are the existing evaluator's one scalar fault step; +they change neither arena allocation nor backing and perform no physical fetch. -/ +theorem failed_load (model : InputModel) (s : State) (dst address : Operand) + (outside : s.core.extent ≤ s.core.regs address) : + checkedAddress model s (s.core.regs address) = none ∧ + execute (.old (.load dst address)) s = + { s with core := { s.core with status := .fault } } := by + exact ⟨(checkedAddress_none model s _).mpr outside, + by simp [execute, execPrim, show ¬s.core.regs address < s.core.extent by omega]⟩ + +theorem read_width (model : InputModel) (n : Nat) (t : Transition) (a : Nat) (reply : Option Nat) + (read : t.read? = some (a, reply)) (fit : t.before.Fits (PackedWordRAM.wordWidth n)) + (peak : t.before.core.extent ≤ 5000000 * (n + 1)) : + a < 2 ^ PackedWordRAM.wordWidth n ∧ + (∀ p, checkedAddress model t.before a = some p → p < 2 ^ PackedWordRAM.wordWidth n) ∧ + (∀ value, reply = some value → value < 2 ^ PackedWordRAM.wordWidth n) := by + obtain ⟨dst, address, _, source, backed⟩ := read_source t a reply read + refine ⟨by rw [source]; exact fit.1.1 address, ?_, ?_⟩ + · intro p hp + obtain ⟨inside, rfl⟩ := (checkedAddress_some model t.before a p).mp hp + exact peak_address_fit model n a (by omega) + · intro value hv + exact lookup_word_fits model n t.before fit _ value + ((read_provenance model t a reply read).1.symm.trans hv) + +/-- Strong actual primitive safety supplies the physical-fetch guard and +successful backing; no separate address or answer assumption is required. -/ +theorem safe_read (model : InputModel) (n len : Nat) (t : Transition) (a : Nat) (reply : Option Nat) + (read : t.read? = some (a, reply)) (safe : t.Safe (PackedWordRAM.wordWidth n) len) + (fit : t.before.Fits (PackedWordRAM.wordWidth n)) + (peak : t.before.core.extent ≤ 5000000 * (n + 1)) : + ∃ p value, checkedAddress model t.before a = some p ∧ reply = some value ∧ + lookup model t.before p = some value ∧ p < 2 ^ PackedWordRAM.wordWidth n ∧ + a < 2 ^ PackedWordRAM.wordWidth n ∧ value < 2 ^ PackedWordRAM.wordWidth n := by + obtain ⟨dst, address, action, source, backed⟩ := read_source t a reply read + obtain ⟨i, hi, hs⟩ := safe + have same : i = .old (.load dst address) := by + rw [action] at hi + exact Action.instruction.inj hi.symm + subst i + have loaded : t.before.core.regs address < t.before.core.extent ∧ + ∃ value, t.before.core.memory (t.before.core.regs address) = some value ∧ + value < 2 ^ PackedWordRAM.wordWidth n := hs.2 + obtain ⟨inside, value, valueAt, valueFit⟩ := loaded + have ha : a < t.before.core.extent := by rw [source]; exact inside + have hv : reply = some value := by rw [backed, if_pos ha, source]; exact valueAt + have checked : checkedAddress model t.before a = some (arenaAddress model a) := by + simp [checkedAddress, ha] + have widths := read_width model n t a reply read fit peak + exact ⟨arenaAddress model a, value, checked, hv, + ((read_provenance model t a reply read).2.1 _ checked).trans hv, + widths.2.1 _ checked, widths.1, valueFit⟩ + +structure Read where + logical : Nat + physical : Option Nat + reply : Option Nat + +def Read.logicalReceipt (r : Read) : Nat × Option Nat := (r.logical, r.reply) + +def translateRead (model : InputModel) (s : State) (r : Nat × Option Nat) : Read := + ⟨r.1, checkedAddress model s r.1, r.2⟩ + +def physicalRead (model : InputModel) (t : Transition) : Option Read := + t.read?.map (translateRead model t.before) + +def physicalReads (model : InputModel) (ts : List Transition) : List Read := + ts.filterMap (physicalRead model) + +/-- Logical receipts are preserved for the entire list, in order and with +multiplicity. Rejected attempts are not dropped from the observation. -/ +theorem physicalReads_exact (model : InputModel) (ts : List Transition) : + (physicalReads model ts).map Read.logicalReceipt = ts.filterMap Transition.read? := by + induction ts with + | nil => rfl + | cons t ts ih => + unfold physicalReads at ih ⊢ + simp only [List.filterMap_cons, physicalRead] + cases hr : t.read? with + | none => simpa [hr] using ih + | some r => + cases r + simpa [hr, translateRead, Read.logicalReceipt] using ih + +structure ImageTransition where + before : List (Option Nat) + action : Action + after : List (Option Nat) + +def imageTransition (model : InputModel) (t : Transition) : ImageTransition := + ⟨view model t.before, t.action, view model t.after⟩ + +def imageTrace (model : InputModel) (ts : List Transition) : List ImageTransition := + ts.map (imageTransition model) + +theorem imageTrace_length (model : InputModel) (ts : List Transition) : + (imageTrace model ts).length = ts.length := by simp [imageTrace] + +theorem imageTrace_actions (model : InputModel) (ts : List Transition) : + (imageTrace model ts).map (·.action) = ts.map (·.action) := by + simp [imageTrace, List.map_map, imageTransition] + +theorem image_occurrence (model : InputModel) (ts : List Transition) (k : Nat) (t : Transition) + (occurs : ts[k]? = some t) : + (imageTrace model ts)[k]? = some ⟨view model t.before, t.action, view model t.after⟩ := by + simp [imageTrace, List.getElem?_map, occurs, imageTransition] + +/-- The whole actual instruction run supplies the producing prefix state; +there is no restart or suffix-only replay in this positional statement. -/ +theorem run_read_at (model : InputModel) (program : List Instruction) (fuel : Nat) (s : State) + (k : Nat) (t : Transition) (a : Nat) (reply : Option Nat) + (occurs : (run program fuel s).transitions[k]? = some t) + (read : t.read? = some (a, reply)) : + t.before = (run program k s).final ∧ + (imageTrace model (run program fuel s).transitions)[k]? = + some ⟨view model (run program k s).final, t.action, view model t.after⟩ ∧ + reply = lookup model (run program k s).final (arenaAddress model a) ∧ + physicalRead model t = some (translateRead model (run program k s).final (a, reply)) := by + have before := (PackedLifecycle.run_transition_at occurs).1 + refine ⟨before, ?_, ?_, ?_⟩ + · simpa only [← before] using image_occurrence model _ k t occurs + · rw [← before]; exact (read_provenance model t a reply read).1 + · simp [physicalRead, read, before] + +theorem whole_trace_width (model : InputModel) (n : Nat) (ts : List Transition) + (fits : ∀ t ∈ ts, t.before.Fits (PackedWordRAM.wordWidth n) ∧ + t.after.Fits (PackedWordRAM.wordWidth n)) + (peak : ∀ t ∈ ts, t.before.core.extent ≤ 5000000 * (n + 1) ∧ + t.after.core.extent ≤ 5000000 * (n + 1)) : + ∀ (k : Nat) (t : Transition), ts[k]? = some t → + (view model t.before).length < 2 ^ PackedWordRAM.wordWidth n ∧ + (view model t.after).length < 2 ^ PackedWordRAM.wordWidth n ∧ + (∀ p value, lookup model t.before p = some value → value < 2 ^ PackedWordRAM.wordWidth n) ∧ + (∀ p value, lookup model t.after p = some value → value < 2 ^ PackedWordRAM.wordWidth n) ∧ + (∀ a reply, t.read? = some (a, reply) → + a < 2 ^ PackedWordRAM.wordWidth n ∧ + (∀ p, checkedAddress model t.before a = some p → p < 2 ^ PackedWordRAM.wordWidth n) ∧ + (∀ value, reply = some value → value < 2 ^ PackedWordRAM.wordWidth n)) := by + intro k t occurs + have member := List.mem_of_getElem? occurs + have hf := fits t member + have hp := peak t member + refine ⟨?_, ?_, lookup_word_fits model n t.before hf.1, + lookup_word_fits model n t.after hf.2, ?_⟩ + · rw [view_length]; exact extent_fit model n t.before hp.1 + · rw [view_length]; exact extent_fit model n t.after hp.2 + · intro a reply read; exact read_width model n t a reply read hf.1 hp.1 + +/-- The actual finite array owner has exactly the same arena lookup, including +absent and uninitialized cells. Comparison bank sizes remain separate. -/ +theorem owner_closed (owner : Owner) : owner.toState.Closed := by + refine ⟨?_, ?_, ?_⟩ + · intro a ha + change owner.memory.getD a none = none + change owner.memory.size ≤ a at ha + simp [Array.getD_eq_getD_getElem?, Array.getElem?_eq_none ha] + · intro a ha + change owner.keys.getD a none = none + change owner.keys.size ≤ a at ha + simp [Array.getD_eq_getD_getElem?, Array.getElem?_eq_none ha] + · intro r hr + change owner.keyRegs.getD r 0 = 0 + change owner.keyRegs.size ≤ r at hr + simp [Array.getD_eq_getD_getElem?, Array.getElem?_eq_none hr] + +theorem owner_arena (model : InputModel) (owner : Owner) (a : Nat) : + lookup model owner.toState (arenaAddress model a) = owner.memory.getD a none := + lookup_arena_closed model owner.toState (owner_closed owner) a + +theorem owner_numeric_bank (owner : Owner) (size : owner.regs.size = numericBank) : + ∀ r, numericBank ≤ r → owner.toState.core.regs r = 0 := by + intro r hr + change owner.regs.getD r 0 = 0 + have outside : owner.regs.size ≤ r := by omega + simp [Array.getD_eq_getD_getElem?, Array.getElem?_eq_none outside] + +theorem executeArray_image (model : InputModel) (i : Instruction) (owner : Owner) + (fits : i.DestinationsFit owner) : + view model (executeArray i owner).toState = view model (execute i owner.toState) := by + rw [executeArray_toState i owner fits] + +theorem executeBoundaryArray_image (model : InputModel) (b : Boundary) (owner : Owner) + (fits : b.DestinationsFit owner) : + view model (executeBoundaryArray b owner).toState = view model (executeBoundary b owner.toState) := by + rw [executeBoundaryArray_toState b owner fits] + +theorem runArray_image (model : InputModel) (program : List Instruction) (fuel : Nat) (owner : Owner) + (fits : RunDestinationsFit program.toArray fuel owner) : + imageTrace model ((runArray program.toArray fuel owner).toRun.transitions) = + imageTrace model (run program fuel owner.toState).transitions ∧ + view model (runArray program.toArray fuel owner).final.toState = + view model (run program fuel owner.toState).final := by + have exactRun := runArray_toState program fuel owner fits + refine ⟨by rw [exactRun], ?_⟩ + exact congrArg (fun r : Run => view model r.final) exactRun + +/-- Int comparison values are deliberately not recoded as numeric W-bit words. +Only their separately owned extents occupy numeric control words. -/ +theorem oracle_values_irrelevant (model : InputModel) (s : State) + (keys : Nat → Option Int) (keyRegs : Nat → Int) : + view model { s with core := { s.core with keys := keys, keyRegs := keyRegs } } = view model s := by + have controls : control { s with core := { s.core with keys := keys, keyRegs := keyRegs } } = + control s := by + funext i + unfold control + split <;> rfl + have lookups : lookup model { s with core := { s.core with keys := keys, keyRegs := keyRegs } } = + lookup model s := by + funext p + unfold lookup + rw [controls] + rfl + exact congrArg (fun f : Fin (extent model s) → Option Nat => List.ofFn f) + (funext (fun p => congrFun lookups p.val)) + +theorem canonical_capacity (model : InputModel) (xs : List Int) (s : State) + (canonical : Retained.Canonical xs s) : + (wordView model s).map some = view model s ∧ + (wordView model s).length * PackedWordRAM.wordWidth xs.length ≤ + 2 * xs.length + retainedRho xs.length := by + refine ⟨wordView_exact model s (canonical_initialized canonical), ?_⟩ + have count : (wordView model s).length = (PackedWordRAM.buildMemory xs).length + + (encodedProgram model).length + numericBank + controlWords := by + simp only [wordView, List.length_map, view_length, extent, arenaBase, controlBase, + registerBase, codeLength, canonical.1.2.1] + omega + rw [count] + exact retained_capacity model xs + +end RMQ.SuccinctFinal.PackedLifecycle.Physical diff --git a/RMQ/Core/WordRAM/Lifecycle/Profile.lean b/RMQ/Core/WordRAM/Lifecycle/Profile.lean new file mode 100644 index 00000000..7f876238 --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/Profile.lean @@ -0,0 +1,81 @@ +import RMQ.Core.WordRAM.Lifecycle.Continuous +import RMQ.Core.WordRAM.Lifecycle.Resources +import RMQ.Core.WordRAM.Lifecycle.Physical + +/-! # Bounds and physical reads on the completed continuous run -/ + +namespace RMQ.SuccinctFinal.PackedLifecycle.Continuous + +open PackedWordRAM (wordWidth buildMemory) +set_option maxRecDepth 30000 + +def PrefixProfile (model : InputModel) (xs : List Int) (s : State) : Prop := + s.Fits (wordWidth xs.length) ∧ PackedConstruction.CleanTail s.core ∧ + Retained.FiniteBank s ∧ s.core.extent ≤ 5000000 * (xs.length + 1) ∧ + s.keyExtent ≤ (if model = .comparison then xs.length else 0) ∧ + s.keyRegExtent ≤ (if model = .comparison then 2 else 0) + +theorem prefix_profile {model : InputModel} {xs : List Int} {left right fuel : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) + (domain : InputDomain model xs) (hl : left < 2 ^ wordWidth xs.length) + (hr : right < 2 ^ wordWidth xs.length) + (within : fuel ≤ (continuousRun model xs left right).steps) : + PrefixProfile model xs + (run (Layout.program model) fuel (initialState model xs left right Layout.builderBase)).final := by + have resources := prefix_resources built within + have clean := (Resources.run_numeric_closed (Layout.program model) fuel + (initialState model xs left right Layout.builderBase) (initial_clean model xs left right _).1).1 + have keys := (Resources.run_key_extents (Layout.program model) fuel + (initialState model xs left right Layout.builderBase)).1 + have bound := Resources.run_steps_le_fuel (Layout.program model) (lifecycleBudget xs.length) + (initialState model xs left right Layout.builderBase) + have hle : fuel ≤ lifecycleBudget xs.length := Nat.le_trans within bound + have fits := (run_fits (initial_fits model xs left right Layout.builderBase domain hl hr + (Construction.initial_pc_fits xs)) (Reusable.program_fits model xs.length) + (show ∀ t ∈ (run (Layout.program model) fuel + (initialState model xs left right Layout.builderBase)).transitions, + t.Safe (wordWidth xs.length) (Layout.program model).length from by + intro t ht + apply safe built t + unfold continuousRun + rw [← Nat.add_sub_of_le hle, run_add] + exact List.mem_append_left _ ht)).1 + exact ⟨fits, clean, resources.2, resources.1, keys⟩ + +theorem physical_read {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) + (domain : InputDomain model xs) (hl : left < 2 ^ wordWidth xs.length) + (hr : right < 2 ^ wordWidth xs.length) + (index : Nat) (t : Transition) (address : Nat) (reply : Option Nat) + (occurs : (continuousRun model xs left right).transitions[index]? = some t) + (read : t.read? = some (address, reply)) : + t.before = (run (Layout.program model) index (initialState model xs left right Layout.builderBase)).final ∧ + (Physical.imageTrace model (continuousRun model xs left right).transitions)[index]? = + some ⟨Physical.view model t.before, t.action, Physical.view model t.after⟩ ∧ + ∃ physical value, Physical.checkedAddress model t.before address = some physical ∧ + reply = some value ∧ Physical.lookup model t.before physical = some value ∧ + physical < 2 ^ wordWidth xs.length ∧ address < 2 ^ wordWidth xs.length ∧ + value < 2 ^ wordWidth xs.length := by + have member : t ∈ (continuousRun model xs left right).transitions := List.mem_of_getElem? occurs + exact ⟨(run_transition_at occurs).1, + Physical.image_occurrence model _ index t occurs, + Physical.safe_read model xs.length (Layout.program model).length t address reply read + (safe built t member) (transition_fits built domain hl hr t member).1 + (transition_resources built member).1⟩ + +theorem physical_prefix {model : InputModel} {xs : List Int} {left right fuel : Nat} + {abstract producer : PackedConstruction.State} {ts : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer ts) + (domain : InputDomain model xs) (hl : left < 2 ^ wordWidth xs.length) + (hr : right < 2 ^ wordWidth xs.length) + (within : fuel ≤ (continuousRun model xs left right).steps) : + let s := (run (Layout.program model) fuel (initialState model xs left right Layout.builderBase)).final + Physical.extent model s < 2 ^ wordWidth xs.length ∧ + (∀ p value, Physical.lookup model s p = some value → value < 2 ^ wordWidth xs.length) := by + have profile := prefix_profile built domain hl hr within + exact ⟨Physical.extent_fit model xs.length _ profile.2.2.2.1, + Physical.lookup_word_fits model xs.length _ profile.1⟩ + +end RMQ.SuccinctFinal.PackedLifecycle.Continuous diff --git a/RMQ/Core/WordRAM/Lifecycle/Program.lean b/RMQ/Core/WordRAM/Lifecycle/Program.lean new file mode 100644 index 00000000..02f4dc48 --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/Program.lean @@ -0,0 +1,175 @@ +import RMQ.Core.WordRAM.Lifecycle.Service +import RMQ.Core.WordRAM.Lifecycle.Descriptor +import RMQ.Core.WordRAM.Lifecycle.Finalizer +import RMQ.Core.WordRAM.Lifecycle.Retirement + +/-! # The two fixed continuous lifecycle programs + +The compact service is an old-instruction prefix. The builder starts at a +nonzero fixed offset, continues through charged descriptor transfer, and then +executes scalar finalization and retirement before jumping to the service. +Neither program depends on an input, its size, or a request. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle.Layout + +open PackedConstruction (BInstr Operand) +open PackedConstruction.Structured (Block HostedAt) +open PackedConstruction.Proof + +set_option maxRecDepth 30000 + +def builderBase : Nat := 221239 +def descriptorBase : Nat := 223345 +def finalizerBase : Nat := 223356 +def retirementBase : Nat := 223370 + +def builderCode (model : InputModel) : List BInstr := + (PackedConstruction.builderSource model.source).compileAt builderBase + +def oldPrefix (model : InputModel) : List BInstr := + Service.program.map PackedConstruction.Conservative.translate ++ + (builderCode model ++ Descriptor.coreCode model) + +def retirementCode : InputModel → List Instruction + | .word => [] + | .comparison => Retirement.code retirementBase (by decide) + +def jumpBase : InputModel → Nat + | .word => 223370 + | .comparison => 223378 + +def serviceEntry : Operand := ⟨212964, by decide⟩ + +def tail (model : InputModel) : List Instruction := + Finalizer.code finalizerBase (by decide) ++ + (retirementCode model ++ [.old (.jump serviceEntry)]) + +def program (model : InputModel) : List Instruction := + (oldPrefix model).map oldInstruction ++ tail model + +theorem source_size (model : InputModel) : + (PackedConstruction.builderSource model.source).size = 2106 := by + cases model + · exact builderSource_size_wordLeaf_eq + · exact builderSource_size_keyLeaf_eq + +theorem builderCode_length (model : InputModel) : (builderCode model).length = 2106 := by + rw [builderCode, Block.compile_length, source_size] + +theorem oldPrefix_length (model : InputModel) : (oldPrefix model).length = finalizerBase := by + rw [oldPrefix, List.length_append, List.length_map, Service.program_length, + List.length_append, builderCode_length, Descriptor.coreCode_length] + rfl + +theorem retirementCode_length (model : InputModel) : + (retirementCode model).length = jumpBase model - retirementBase := by + cases model <;> rfl + +theorem tail_length (model : InputModel) : (tail model).length = + 14 + (jumpBase model - retirementBase) + 1 := by + have h14 : (Finalizer.code finalizerBase (by decide)).length = 14 := rfl + rw [tail, List.length_append, List.length_append, retirementCode_length] + rw [h14] + simp only [List.length_cons, List.length_nil] + omega + +theorem program_length (model : InputModel) : (program model).length = jumpBase model + 1 := by + rw [program, List.length_append, List.length_map, oldPrefix_length, tail_length] + cases model <;> rfl + +theorem program_length_lt32 (model : InputModel) : (program model).length < 2^32 := by + rw [program_length] + cases model <;> decide + +theorem service_split (model : InputModel) : program model = + (Service.program.map PackedConstruction.Conservative.translate).map oldInstruction ++ + ((builderCode model ++ Descriptor.coreCode model).map oldInstruction ++ tail model) := by + rw [program, oldPrefix, List.map_append, List.append_assoc] + +theorem old_builder_host (model : InputModel) : HostedAt (oldPrefix model) builderBase + ((PackedConstruction.builderSource model.source).compileAt builderBase) := by + have hlen : (Service.program.map PackedConstruction.Conservative.translate).length = + builderBase := by rw [List.length_map, Service.program_length]; rfl + intro i hi + change (Service.program.map PackedConstruction.Conservative.translate ++ + (builderCode model ++ Descriptor.coreCode model))[builderBase+i]? = _ + change i < (builderCode model).length at hi + rw [List.getElem?_append_right (by rw [hlen]; omega), hlen, Nat.add_sub_cancel_left, + List.getElem?_append_left hi] + rw [builderCode] + +theorem map_host {α β : Type} (f : α → β) (p : List α) (base : Nat) (fragment : List α) + (host : ∀ i, i < fragment.length → p[base+i]? = fragment[i]?) : + ∀ i, i < (fragment.map f).length → (p.map f)[base+i]? = (fragment.map f)[i]? := by + intro i hi + rw [List.getElem?_map, List.getElem?_map, host i (by simpa only [List.length_map] using hi)] + +theorem append_host {α : Type} (p fragment suffix : List α) (base : Nat) + (host : ∀ i, i < fragment.length → p[base+i]? = fragment[i]?) + (bound : base+fragment.length ≤ p.length) : + ∀ i, i < fragment.length → (p++suffix)[base+i]? = fragment[i]? := by + intro i hi + rw [List.getElem?_append_left (by omega), host i hi] + +theorem descriptor_host (model : InputModel) : + Descriptor.Hosted (program model) descriptorBase model := by + have oldHost : HostedAt (oldPrefix model) descriptorBase (Descriptor.coreCode model) := by + have hlen : (Service.program.map PackedConstruction.Conservative.translate).length + + (builderCode model).length = descriptorBase := by + rw [List.length_map, Service.program_length, builderCode_length]; rfl + intro i hi + change (Service.program.map PackedConstruction.Conservative.translate ++ + (builderCode model ++ Descriptor.coreCode model))[descriptorBase+i]? = _ + rw [← hlen, Nat.add_assoc, List.getElem?_append_right (by omega), Nat.add_sub_cancel_left, + List.getElem?_append_right (by omega), Nat.add_sub_cancel_left] + have h := map_host oldInstruction _ descriptorBase _ oldHost + rw [← Descriptor.code_eq] at h + have hb : descriptorBase + (Descriptor.code model).length ≤ + ((oldPrefix model).map oldInstruction).length := by + rw [List.length_map, oldPrefix_length, Descriptor.code_eq, List.length_map, + Descriptor.coreCode_length] + decide + exact append_host _ _ _ _ h hb + +theorem finalizer_host (model : InputModel) : + Finalizer.Hosted (program model) finalizerBase (by decide) := by + intro i hi + change ((oldPrefix model).map oldInstruction ++ + (Finalizer.code finalizerBase _ ++ _))[finalizerBase+i]? = _ + have hlen : ((oldPrefix model).map oldInstruction).length = finalizerBase := by + rw [List.length_map, oldPrefix_length] + rw [List.getElem?_append_right (by rw [hlen]; omega), hlen, Nat.add_sub_cancel_left, + List.getElem?_append_left (by exact hi)] + +theorem retirement_host : Retirement.Hosted (program .comparison) retirementBase (by decide) := by + intro i hi + change ((oldPrefix .comparison).map oldInstruction ++ + (Finalizer.code finalizerBase (by decide) ++ + (Retirement.code retirementBase (by decide) ++ [.old (.jump serviceEntry)])))[retirementBase+i]? = _ + have hlen : ((oldPrefix .comparison).map oldInstruction).length = finalizerBase := by + rw [List.length_map, oldPrefix_length] + have h14 : (Finalizer.code finalizerBase (by decide)).length = 14 := rfl + have hpc : retirementBase+i = finalizerBase+(14+i) := by + change 223370+i = 223356+(14+i) + omega + rw [hpc, List.getElem?_append_right (by rw [hlen]; omega), hlen, + Nat.add_sub_cancel_left, List.getElem?_append_right (by rw [h14]; omega), h14, + Nat.add_sub_cancel_left, List.getElem?_append_left (by exact hi)] + +theorem jump_fetch (model : InputModel) : + (program model)[jumpBase model]? = some (.old (.jump serviceEntry)) := by + have hlen : ((oldPrefix model).map oldInstruction).length = finalizerBase := by + rw [List.length_map, oldPrefix_length] + have h14 : (Finalizer.code finalizerBase (by decide)).length = 14 := rfl + have hret := retirementCode_length model + have hp : jumpBase model = finalizerBase + (14 + (retirementCode model).length) := by + rw [hret]; cases model <;> rfl + change ((oldPrefix model).map oldInstruction ++ + (Finalizer.code finalizerBase _ ++ (retirementCode model ++ _)))[jumpBase model]? = _ + rw [hp, List.getElem?_append_right (by rw [hlen]; omega), hlen, Nat.add_sub_cancel_left, + List.getElem?_append_right (by rw [h14]; omega), h14, Nat.add_sub_cancel_left, + List.getElem?_append_right (by omega), Nat.sub_self] + rfl + +end RMQ.SuccinctFinal.PackedLifecycle.Layout diff --git a/RMQ/Core/WordRAM/Lifecycle/Provenance.lean b/RMQ/Core/WordRAM/Lifecycle/Provenance.lean new file mode 100644 index 00000000..4c878fa3 --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/Provenance.lean @@ -0,0 +1,209 @@ +import RMQ.Core.WordRAM.Lifecycle.Capstone + +/-! # Producing occurrences in the continuous lifecycle trace + +Component receipts retain their exact indices after lifting into the defined +continuous run. The output reservation and transfer share the actual producer; +metadata, request, copy and release receipts use that same construction witness. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle.Provenance + +open PackedWordRAM (buildMemory) +open Continuous (continuousRun) +set_option maxRecDepth 30000 + +def Occurrence (model : InputModel) (xs : List Int) (left right index : Nat) + (t : Transition) : Prop := + (continuousRun model xs left right).transitions[index]? = some t ∧ + t.before = (run (Layout.program model) index + (initialState model xs left right Layout.builderBase)).final ∧ + step (Layout.program model) t.before = some t + +theorem occurrence_of_index {model : InputModel} {xs : List Int} {left right index : Nat} + {t : Transition} (atIndex : (continuousRun model xs left right).transitions[index]? = some t) : + Occurrence model xs left right index t := ⟨atIndex, run_transition_at atIndex⟩ + +theorem append_occurrence {α : Type} (before middle after : List α) {index : Nat} {item : α} + (atIndex : middle[index]? = some item) : + (before ++ middle ++ after)[before.length + index]? = some item := by + rw [List.append_assoc, List.getElem?_append_right (by omega), Nat.add_sub_cancel_left, + List.getElem?_append_left (List.getElem?_eq_some_iff.mp atIndex).1] + exact atIndex + +theorem body_occurrence {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {body : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer body) + {index : Nat} {t : PackedConstruction.Transition} (atIndex : body[index]? = some t) : + Occurrence model xs left right index + (oldTransition (initialState model xs left right Layout.builderBase).keyExtent + (initialState model xs left right Layout.builderBase).keyRegExtent t) := by + apply occurrence_of_index + rw [Continuous.exact_run built] + change (Construction.producedTrace model xs left right body ++ + Finalization.finalTrace model xs left right producer ++ _)[index]? = _ + rw [List.append_assoc, List.getElem?_append_left] + · simp [Construction.producedTrace, List.getElem?_map, atIndex] + · simpa [Construction.producedTrace] using (List.getElem?_eq_some_iff.mp atIndex).1 + +theorem descriptor_occurrence {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {body : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer body) + {index : Nat} {t : Transition} + (atIndex : (Finalization.descriptorRun model xs left right producer).transitions[index]? = some t) : + Occurrence model xs left right (body.length + index) t := by + apply occurrence_of_index + rw [Continuous.exact_run built] + simp only [Finalization.fullTrace, Finalization.finalTrace, List.append_assoc] + have lifted := append_occurrence (Construction.producedTrace model xs left right body) + (Finalization.descriptorRun model xs left right producer).transitions + ((Finalization.copyRun model xs left right producer).transitions ++ + (Finalization.retirementRun model xs left right producer).transitions ++ + [⟨(Finalization.retirementRun model xs left right producer).final, + .instruction (.old (.jump Layout.serviceEntry)), Finalization.finalState model xs left right producer⟩] ++ + (Reusable.serviceRun model (Finalization.finalState model xs left right producer)).transitions) atIndex + simpa only [Construction.producedTrace, List.length_map, List.append_assoc] using lifted + +theorem copy_occurrence {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {body : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer body) + {index : Nat} {t : Transition} + (atIndex : (Finalization.copyRun model xs left right producer).transitions[index]? = some t) : + Occurrence model xs left right (body.length + 11 + index) t := by + apply occurrence_of_index + rw [Continuous.exact_run built] + simp only [Finalization.fullTrace, Finalization.finalTrace, List.append_assoc] + have length := (Descriptor.transfer (Layout.descriptor_host model) built.descriptor).2 + change (Finalization.descriptorRun model xs left right producer).transitions.length = 11 at length + have lifted := append_occurrence + (Construction.producedTrace model xs left right body ++ + (Finalization.descriptorRun model xs left right producer).transitions) + (Finalization.copyRun model xs left right producer).transitions + ((Finalization.retirementRun model xs left right producer).transitions ++ + [⟨(Finalization.retirementRun model xs left right producer).final, + .instruction (.old (.jump Layout.serviceEntry)), Finalization.finalState model xs left right producer⟩] ++ + (Reusable.serviceRun model (Finalization.finalState model xs left right producer)).transitions) atIndex + simpa only [List.length_append, Construction.producedTrace, List.length_map, length, List.append_assoc] using lifted + +/-- The producer register keeps its actual reserved extent until the transfer. -/ +theorem reserve_output {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {body : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer body) : + ∃ (index : Nat) (pre : PackedConstruction.State), index < body.length ∧ + Occurrence model xs left right index + (oldTransition (initialState model xs left right Layout.builderBase).keyExtent + (initialState model xs left right Layout.builderBase).keyRegExtent + ⟨pre, ⟨.reserve 3⟩, PackedConstruction.execPrim (.reserve 3) pre⟩) ∧ + producer.regs 3 = pre.extent ∧ + ∀ fuel, index + 1 ≤ fuel → fuel ≤ body.length → + (run (Layout.program model) fuel + (initialState model xs left right Layout.builderBase)).final.core.regs 3 = pre.extent := by + obtain ⟨pre, before, after, first, running, fetch, rest, trace, frame, value⟩ := built.body.reservation + have prefixRun := first.trans (PackedConstruction.RunsTo.instruction running fetch) + have prefixExact : PackedConstruction.run (Layout.oldPrefix model) (before.length+1) + (initialState model xs left right Layout.builderBase).core = + ⟨PackedConstruction.execPrim (.reserve 3) pre, + before ++ [⟨pre, ⟨.reserve 3⟩, PackedConstruction.execPrim (.reserve 3) pre⟩]⟩ := by + simpa only [PackedConstruction.RunsTo, List.length_append, List.length_singleton] using prefixRun + have length : body.length = before.length + 1 + after.length := by + rw [trace, List.length_append, List.length_append, List.length_singleton] + have atIndex : body[before.length]? = + some ⟨pre, ⟨.reserve 3⟩, PackedConstruction.execPrim (.reserve 3) pre⟩ := by + rw [trace, List.append_assoc, List.getElem?_append_right (Nat.le_refl _)] + simp + refine ⟨before.length, pre, by omega, body_occurrence built atIndex, value, ?_⟩ + intro fuel lower upper + have remaining : fuel - (before.length+1) ≤ after.length := by omega + have allowed : ∀ t ∈ (PackedConstruction.run (Layout.oldPrefix model) after.length + (PackedConstruction.execPrim (.reserve 3) pre)).transitions, + PackedConstruction.WritesOnly (fun r => r ≠ 3) t.instruction := by + rw [show PackedConstruction.run (Layout.oldPrefix model) after.length _ = _ from rest] + exact frame + have stable := Builder.run_prefix_frame remaining (fun r => r ≠ 3) allowed 3 (by simp) + rw [Construction.body_prefix_lift built.body upper] + change (PackedConstruction.run (Layout.oldPrefix model) fuel + (initialState model xs left right Layout.builderBase).core).final.regs 3 = pre.extent + rw [show fuel = (before.length+1) + (fuel-(before.length+1)) by omega, + PackedConstruction.run_add, prefixExact] + simpa [PackedConstruction.execPrim, PackedConstruction.State.writeNext, + PackedConstruction.State.next, PackedConstruction.put] using stable + +structure ProductionReceipts (model : InputModel) (xs : List Int) (left right : Nat) + (producer : PackedConstruction.State) (body : List PackedConstruction.Transition) : Prop where + output : ∃ (index : Nat) (pre : PackedConstruction.State) (transfer : Transition), + index < body.length ∧ + Occurrence model xs left right index + (oldTransition (initialState model xs left right Layout.builderBase).keyExtent + (initialState model xs left right Layout.builderBase).keyRegExtent + ⟨pre, ⟨.reserve 3⟩, PackedConstruction.execPrim (.reserve 3) pre⟩) ∧ + producer.regs 3 = pre.extent ∧ + (∀ fuel, index+1 ≤ fuel → fuel ≤ body.length → + (run (Layout.program model) fuel + (initialState model xs left right Layout.builderBase)).final.core.regs 3 = pre.extent) ∧ + Occurrence model xs left right body.length transfer ∧ + transfer.before = Construction.producedState model xs left right producer ∧ + Descriptor.OutputReceipt transfer ∧ transfer.after.core.regs 0 = pre.extent + metadata : + (∃ t, Occurrence model xs left right (body.length+1) t ∧ + Descriptor.ReadReceipt 302 0 (producer.regs 3) xs.length t) ∧ + (∃ t, Occurrence model xs left right (body.length+4) t ∧ + Descriptor.ReadReceipt 2 4 (producer.regs 3+7) (buildMemory xs).length t) ∧ + (∃ t, Occurrence model xs left right (body.length+8) t ∧ + Descriptor.ReadReceipt 300 4 (Descriptor.requestBase model xs.length) left t) ∧ + (∃ t, Occurrence model xs left right (body.length+10) t ∧ + Descriptor.ReadReceipt 301 4 (Descriptor.requestBase model xs.length+1) right t) + copy : ∀ i, i < (buildMemory xs).length → ∃ load store, + Occurrence model xs left right (body.length+11+(4+7*i)) load ∧ + Occurrence model xs left right (body.length+11+(5+7*i)) store ∧ + Finalizer.CopyReceipt producer.memory (producer.regs 3) i load store ∧ + load.after.core.regs 5 = (buildMemory xs).getD i 0 ∧ + store.after.core.memory i = (buildMemory xs)[i]? + releases : ∀ k, k < producer.regs 3 → ∃ t, + Occurrence model xs left right + (body.length+11+(5+7*(buildMemory xs).length+4*k)) t ∧ + Finalizer.ReleaseReceipt ((buildMemory xs).length+(producer.regs 3-k)-1) t + +theorem production_receipts {model : InputModel} {xs : List Int} {left right : Nat} + {abstract producer : PackedConstruction.State} {body : List PackedConstruction.Transition} + (built : Construction.BuildStage model xs left right abstract producer body) : + ProductionReceipts model xs left right producer body := by + have entry := Finalization.descriptor_to_finalizer built + have memory := (Descriptor.transfer (Layout.descriptor_host model) built.descriptor).1.2.2.2.2.2.2.2.1 + change (Finalization.descriptorRun model xs left right producer).final.core.memory = producer.memory at memory + refine ⟨?_, ?_, ?_, ?_⟩ + · obtain ⟨index, pre, inside, reserve, value, stable⟩ := reserve_output built + obtain ⟨transfer, position, before, receipt, output⟩ := + Descriptor.output_transfer_at (Layout.descriptor_host model) built.descriptor + refine ⟨index, pre, transfer, inside, reserve, value, stable, ?_, before, receipt, output.trans value⟩ + simpa only [Nat.add_zero] using descriptor_occurrence built position + · obtain ⟨⟨a, ha, ra⟩, ⟨b, hb, rb⟩, ⟨c, hc, rc⟩, ⟨d, hd, rd⟩⟩ := + Descriptor.read_occurrences (Layout.descriptor_host model) built.descriptor + exact ⟨⟨a, descriptor_occurrence built ha, ra⟩, ⟨b, descriptor_occurrence built hb, rb⟩, + ⟨c, descriptor_occurrence built hc, rc⟩, ⟨d, descriptor_occurrence built hd, rd⟩⟩ + · intro i hi + obtain ⟨load, store, atLoad, atStore, receipt, _⟩ := + Finalizer.ordered_copy (Layout.finalizer_host model) entry i hi + rw [memory] at receipt + have cell := built.body.cells i hi + have loaded : load.after.core.regs 5 = (buildMemory xs).getD i 0 := + Option.some.inj (receipt.2.2.2.2.2.1.trans cell) + have stored := receipt.2.2.2.2.2.2.2.1.trans cell + refine ⟨load, store, copy_occurrence built atLoad, copy_occurrence built atStore, + receipt, loaded, ?_⟩ + rw [List.getElem?_eq_getElem hi] + simpa only [List.getD_eq_getElem?_getD, List.getElem?_eq_getElem hi, Option.getD_some] using stored + · intro k hk + obtain ⟨t, position, receipt, _⟩ := + Finalizer.ordered_release (Layout.finalizer_host model) entry k hk + exact ⟨t, copy_occurrence built position, receipt⟩ + +/-- The public contract supplies one actual producer shared by every receipt. -/ +theorem continuous_production {model : InputModel} {xs : List Int} {left right : Nat} + (contract : ContinuousConstructionQuery model xs left right) : + ∃ abstract producer body, + Construction.BuildStage model xs left right abstract producer body ∧ + ProductionReceipts model xs left right producer body := by + obtain ⟨abstract, producer, body, built, _⟩ := contract.construction + exact ⟨abstract, producer, body, built, production_receipts built⟩ + +end RMQ.SuccinctFinal.PackedLifecycle.Provenance diff --git a/RMQ/Core/WordRAM/Lifecycle/QueryBridge.lean b/RMQ/Core/WordRAM/Lifecycle/QueryBridge.lean new file mode 100644 index 00000000..54b8e510 --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/QueryBridge.lean @@ -0,0 +1,162 @@ +import RMQ.Core.WordRAM.Optimization.Query +import RMQ.Core.WordRAM.Construction.Proof.Lift + +/-! # Exact compact-query translation + +The existing conservative instruction translation preserves complete states, +ordered transitions and every attempted read. The embedding has canonical +numeric extent and empty key channels; lifecycle producers must establish +those facts before invoking this adapter. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle.QueryBridge + +open RMQ.SuccinctFinal +open PackedWordRAM PackedWordRAM.Structured PackedWordRAM.Optimization + +theorem compact_fields32 : ∀ i ∈ compactQueryProgram, i.Fits 32 := by + apply compactAt_fits compactQuerySource 32 compactQueryFresh 0 0 + · refine ⟨?_, ?_⟩ + · apply Block.fieldsFit_of_maxEncodedField + rw [querySource_maxEncodedField] + decide + · change (Instruction.halt 3).Fits 32 + simp [Instruction.Fits, Instruction.encoding, Instruction.operands] + · rw [compactQuery_maxCount] + decide + · decide + · simp only [compactQueryFresh, queryRegisterCount_eq, compactQuery_depth] + decide + · rw [Nat.zero_add, compactQuerySize_eq] + decide + +theorem oversized_literal_rejected : ¬ (Instruction.constant 0 (2^32)).Fits 32 := by + intro h + have hbad := h (2^32) (by simp [Instruction.encoding, Instruction.operands]) + omega + + +open PackedConstruction PackedConstruction.Conservative + +def liftTransition (memory : PackedWordRAM.Memory) + (t : PackedWordRAM.Transition) : PackedConstruction.Transition := + ⟨state memory t.before, translate t.instruction, state memory t.after⟩ + +def readReply (t : PackedConstruction.Transition) : Option PackedWordRAM.Receipt := + match t.instruction.primitive with + | .load _ address => + let a := t.before.regs address + some ⟨a, if a < t.before.extent then t.before.memory a else none⟩ + | _ => none + +theorem readReply_execute (memory : PackedWordRAM.Memory) + (i : OldInstruction) (hi : OperandsFit32 i) (s : OldState) : + readReply ⟨state memory s, translate i, + state memory (PackedWordRAM.execute memory i s).1⟩ = + (PackedWordRAM.execute memory i s).2 := by + rw [translate_of_fits i hi] + cases i with + | load dst address => + simp only [readReply, instruction, state, PackedWordRAM.execute] + by_cases ha : s.regs address < memory.length + · simp [ha] + · have hm : memory[s.regs address]? = none := + List.getElem?_eq_none_iff.mpr (by omega) + simp [ha] + | constant dst value => rfl + | move dst src => rfl + | arithmetic op dst lhs rhs => rfl + | comparison op dst lhs rhs => rfl + | jump target => rfl + | jumpRegister src => rfl + | branchZero condition target => rfl + | halt src => rfl + +theorem translated_run_all (memory : PackedWordRAM.Memory) + (program : PackedWordRAM.Program) + (fit : ∀ i ∈ program, OperandsFit32 i) : + ∀ (fuel : Nat) (s : OldState), + (PackedConstruction.run (program.map translate) fuel (state memory s)).final = + state memory (PackedWordRAM.run memory program fuel s).final ∧ + (PackedConstruction.run (program.map translate) fuel (state memory s)).transitions = + (PackedWordRAM.run memory program fuel s).transitions.map (liftTransition memory) ∧ + (PackedConstruction.run (program.map translate) fuel (state memory s)).transitions.filterMap readReply = + (PackedWordRAM.run memory program fuel s).reads := by + intro fuel + induction fuel with + | zero => intro s; exact ⟨rfl, rfl, rfl⟩ + | succ fuel ih => + intro s + cases hs : s.status with + | halted v => + have hnew : stepProgram (program.map translate) (state memory s) = none := by + apply stepProgram_none_of_stopped + simp [state, hs, status] + have hold : PackedWordRAM.step memory program s = none := by + simp [PackedWordRAM.step, hs] + simp only [PackedConstruction.run, hnew, PackedWordRAM.run, hold] + exact ⟨trivial, rfl, rfl⟩ + | fault => + have hnew : stepProgram (program.map translate) (state memory s) = none := by + apply stepProgram_none_of_stopped + simp [state, hs, status] + have hold : PackedWordRAM.step memory program s = none := by + simp [PackedWordRAM.step, hs] + simp only [PackedConstruction.run, hnew, PackedWordRAM.run, hold] + exact ⟨trivial, rfl, rfl⟩ + | running => + cases hf : program[s.pc]? with + | none => + have hnew : stepProgram (program.map translate) (state memory s) = none := by + simp [stepProgram, fetch, state, hf] + have hold : PackedWordRAM.step memory program s = none := by + simp [PackedWordRAM.step, hs, hf] + simp only [PackedConstruction.run, hnew, PackedWordRAM.run, hold] + exact ⟨trivial, rfl, rfl⟩ + | some i => + have hfit := fit i (List.mem_of_getElem? hf) + have hexec := execute_eq memory i hfit s hs + have hnew : stepProgram (program.map translate) (state memory s) = + some ⟨state memory s, ⟨instruction i hfit⟩, + state memory (PackedWordRAM.execute memory i s).1⟩ := by + have hfetch : fetch (program.map translate) (state memory s) = + some ⟨instruction i hfit⟩ := by + simp [fetch, state, hf, translate_of_fits i hfit] + have hrun : (state memory s).status = .running := by + simp [state, hs, status] + simp only [stepProgram, hfetch, checkedStep, hrun, bstep, hexec] + have hold : PackedWordRAM.step memory program s = + some ⟨s, i, (PackedWordRAM.execute memory i s).1, + (PackedWordRAM.execute memory i s).2⟩ := by + simp [PackedWordRAM.step, hs, hf] + obtain ⟨hfinal, htrace, hreads⟩ := ih (PackedWordRAM.execute memory i s).1 + simp only [PackedConstruction.run, hnew, PackedWordRAM.run, hold] + refine ⟨hfinal, ?_, ?_⟩ + · simp only [List.map_cons, liftTransition, translate_of_fits i hfit] + exact congrArg (fun tail => _ :: tail) htrace + · simp only [PackedWordRAM.Run.reads] at hreads ⊢ + simp only [List.filterMap_cons] + rw [hreads] + have hr := readReply_execute memory i hfit s + rw [translate_of_fits i hfit] at hr + rw [hr] + +theorem compact_translated_run (memory : PackedWordRAM.Memory) (fuel : Nat) (s : OldState) : + (PackedConstruction.run (compactQueryProgram.map translate) fuel (state memory s)).final = + state memory (PackedWordRAM.run memory compactQueryProgram fuel s).final ∧ + (PackedConstruction.run (compactQueryProgram.map translate) fuel (state memory s)).transitions = + (PackedWordRAM.run memory compactQueryProgram fuel s).transitions.map (liftTransition memory) ∧ + (PackedConstruction.run (compactQueryProgram.map translate) fuel (state memory s)).transitions.filterMap readReply = + (PackedWordRAM.run memory compactQueryProgram fuel s).reads := + translated_run_all memory compactQueryProgram + (fun i hi => operandsFit32_of_fits i (compact_fields32 i hi)) fuel s + +theorem translated_steps (memory : PackedWordRAM.Memory) (program : PackedWordRAM.Program) + (fit : ∀ i ∈ program, OperandsFit32 i) (fuel : Nat) (s : OldState) : + (PackedConstruction.run (program.map translate) fuel (state memory s)).steps = + (PackedWordRAM.run memory program fuel s).steps := by + have h := congrArg List.length (translated_run_all memory program fit fuel s).2.1 + simpa only [PackedConstruction.Run.steps, PackedWordRAM.Run.steps, List.length_map] using h + + +end RMQ.SuccinctFinal.PackedLifecycle.QueryBridge diff --git a/RMQ/Core/WordRAM/Lifecycle/QueryEntry.lean b/RMQ/Core/WordRAM/Lifecycle/QueryEntry.lean new file mode 100644 index 00000000..d385098f --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/QueryEntry.lean @@ -0,0 +1,477 @@ +import RMQ.Core.WordRAM.Optimization.QuerySafety +import RMQ.Core.WordRAM.Optimization.QueryProof + +/-! # Charged compact-query entry in an arbitrary host + +Each finite-bank clear and the final jump is an actual packed instruction. +The caller supplies already produced ABI values and running control; these +lemmas do not implement or assume a free external request-admission step. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle.QueryEntry +open PackedWordRAM PackedWordRAM.Structured PackedWordRAM.Optimization +set_option maxRecDepth 30000 + +/- A successful old fetch is unchanged by append. No confinement assumption. -/ +theorem step_append_of_some {memory : Memory} {program suffix : Program} + {s : State} {t : Transition} (h : step memory program s = some t) : + step memory (program ++ suffix) s = some t := by + obtain ⟨hb, hs, hf, he⟩ := step_spec h + have bound : s.pc < program.length := (List.getElem?_eq_some_iff.mp hf).choose + have fetch : (program ++ suffix)[s.pc]? = some t.instruction := by + rw [List.getElem?_append_left bound, hf] + cases t + simp_all [step] + +theorem run_append_of_stopped (memory : Memory) (program suffix : Program) + (fuel : Nat) (s : State) + (stopped : (run memory program fuel s).final.status ≠ .running) : + run memory (program ++ suffix) fuel s = run memory program fuel s := by + induction fuel generalizing s with + | zero => rfl + | succ fuel ih => + cases hs : step memory program s with + | none => + have hn : s.status ≠ .running := by simpa [run, hs] using stopped + have he : step memory (program ++ suffix) s = none := by + cases hstatus : s.status <;> simp_all [step] + simp [run, hs, he] + | some t => + have he := step_append_of_some (suffix := suffix) hs + have ht : (run memory program fuel t.after).final.status ≠ .running := by + simpa [run, hs] using stopped + simp only [run, hs, he] + rw [ih t.after ht] + +/-- The compiler-derived stop closes the append proof, even on arbitrary memory. -/ +theorem compactQuery_prefix (memory : Memory) (n left right : Nat) (suffix : Program) : + run memory (compactQueryProgram ++ suffix) compactQueryBudget + (initialState n left right) = compactQueryRun memory n left right := + run_append_of_stopped memory compactQueryProgram suffix compactQueryBudget + (initialState n left right) (compactQueryRun_stopped memory n left right) + +/-- Every preserved occurrence fetched an instruction from the old prefix. -/ +theorem compactQuery_fetch_confined (memory : Memory) (n left right : Nat) + (suffix : Program) (k : Nat) (t : Transition) + (occurrence : (run memory (compactQueryProgram ++ suffix) compactQueryBudget + (initialState n left right)).transitions[k]? = some t) : + t.before.pc < compactQueryProgram.length ∧ + compactQueryProgram[t.before.pc]? = some t.instruction := by + rw [compactQuery_prefix] at occurrence + have fetch := (run_transition_spec occurrence).2.2.1 + exact ⟨(List.getElem?_eq_some_iff.mp fetch).choose, fetch⟩ + +def clearCode (first : Nat) : Nat → Program + | 0 => [] + | count + 1 => .constant first 0 :: clearCode (first + 1) count + +theorem clearCode_length (first count : Nat) : (clearCode first count).length = count := by + induction count generalizing first with + | zero => rfl + | succ count ih => simp [clearCode, ih] + +def cleared (s : State) (first count : Nat) : State := + ⟨fun r => if first ≤ r ∧ r < first + count then 0 else s.regs r, + s.pc + count, .running⟩ + +theorem cleared_zero (s : State) (first : Nat) (hs : s.status = .running) : + cleared s first 0 = s := by + cases s with + | mk regs pc status => + cases hs + simp only [cleared, Nat.add_zero] + congr 1 + funext r + rw [if_neg (show ¬ (first ≤ r ∧ r < first) by omega)] + +theorem cleared_succ (s : State) (first count : Nat) : + cleared (s.writeNext first 0) (first + 1) count = cleared s first (count + 1) := by + simp only [cleared, State.writeNext] + congr 1 + · funext r + simp only [Registers.write] + split <;> split <;> (try split) <;> simp_all <;> omega + · omega + +theorem hosted_cons_tail {program : Program} {base : Nat} {i : Instruction} + {code : Program} (host : HostedAt program base (i :: code)) : + HostedAt program (base + 1) code := by + intro j hj + have h := host (j + 1) (by simp; omega) + simpa [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using h + +/-- Each zeroing assignment is one actual primitive, with its actual prestate. -/ +theorem clearCode_exec (memory : Memory) (program : Program) (s : State) + (first count : Nat) (hs : s.status = .running) + (host : HostedAt program s.pc (clearCode first count)) : + ∃ ts, RunsTo memory program s (cleared s first count) ts ∧ + ts.length = count ∧ ts.filterMap (·.receipt) = [] := by + induction count generalizing first s with + | zero => + refine ⟨[], ?_, rfl, rfl⟩ + rw [cleared_zero s first hs] + exact RunsTo.refl memory program s + | succ count ih => + let t : Transition := ⟨s, .constant first 0, s.writeNext first 0, none⟩ + have hstep : RunsTo memory program s (s.writeNext first 0) [t] := + RunsTo.instruction hs host.head + obtain ⟨ts, hexec, hlen, hreads⟩ := ih (s.writeNext first 0) (first + 1) rfl + (hosted_cons_tail host) + refine ⟨[t] ++ ts, ?_, by simp [hlen], by simp [t, hreads]⟩ + rw [← cleared_succ] + exact hstep.trans hexec + +def clearCount : Nat := compactQueryRegisterCount - 3 +def setupCode : Program := clearCode 3 clearCount ++ [.jump 0] +def setupCost : Nat := clearCount + 1 + +theorem clearCount_eq : clearCount = 8270 := by + rw [clearCount, compactQueryRegisterCount_eq] + +theorem setupCost_eq : setupCost = 8271 := by rw [setupCost, clearCount_eq] + +theorem setupCode_length : setupCode.length = setupCost := by + simp [setupCode, clearCode_length, setupCost] + +/-- The caller derives these values and finite support from its actual handoff. +There is no assumed entry PC: hosting below is at the caller's actual PC. -/ +def SetupInputs (n left right : Nat) (s : State) : Prop := + s.status = .running ∧ s.regs 0 = left ∧ s.regs 1 = right ∧ s.regs 2 = n ∧ + (∀ r, compactQueryRegisterCount ≤ r → s.regs r = 0) + +theorem cleared_setup_regs (n left right : Nat) (s : State) + (inputs : SetupInputs n left right s) : + (cleared s 3 clearCount).regs = (initialState n left right).regs := by + funext r + obtain ⟨_, h0, h1, h2, outside⟩ := inputs + simp only [cleared, initialState, inputRegisters, Registers.write] + rw [clearCount_eq] + split + · split <;> (try split) <;> (try split) <;> omega + · by_cases r0 : r = 0 + · subst r; simp_all + by_cases r1 : r = 1 + · subst r; simp_all + by_cases r2 : r = 2 + · subst r; simp_all + simp only [if_neg r0, if_neg r1, if_neg r2] + apply outside + rw [compactQueryRegisterCount_eq] + omega + +theorem clearJump_exec (memory : Memory) (program : Program) (s : State) + (first count : Nat) (hs : s.status = .running) + (host : HostedAt program s.pc (clearCode first count ++ [.jump 0])) : + ∃ ts, run memory program (count + 1) s = ⟨{ cleared s first count with pc := 0 }, ts⟩ ∧ + ts.length = count + 1 ∧ ts.filterMap (·.receipt) = [] := by + obtain ⟨ts, hx, hlen, hreads⟩ := clearCode_exec memory program s first count hs host.append_left + let c := cleared s first count + have hfetch : program[c.pc]? = some (.jump 0) := by + have h := host.append_right.head + simpa [c, cleared, clearCode_length] using h + let j : Transition := ⟨c, .jump 0, { c with pc := 0 }, none⟩ + have hj : RunsTo memory program c { c with pc := 0 } [j] := + RunsTo.instruction rfl hfetch + have both := hx.trans hj + refine ⟨ts ++ [j], ?_, by simp [hlen], by simp [j, hreads]⟩ + have len : (ts ++ [j]).length = count + 1 := by simp [hlen] + simpa only [RunsTo, len] using both + +/-- Exact complete ABI state follows from scalar clears and one real jump. -/ +theorem setup_exec (memory : Memory) (program : Program) (n left right : Nat) (s : State) + (inputs : SetupInputs n left right s) (host : HostedAt program s.pc setupCode) : + ∃ ts, run memory program setupCost s = ⟨initialState n left right, ts⟩ ∧ + ts.length = setupCost ∧ ts.filterMap (·.receipt) = [] := by + have hfinal : { cleared s 3 clearCount with pc := 0 } = initialState n left right := by + have hregs := cleared_setup_regs n left right s inputs + change State.mk (cleared s 3 clearCount).regs 0 .running = initialState n left right + rw [hregs] + rfl + simpa only [hfinal, setupCost] using + clearJump_exec memory program s 3 clearCount inputs.1 host + +/-- The setup is hosted anywhere in the suffix; the fixed compact code stays at zero. -/ +theorem chargedEntry_compactQuery (memory : Memory) (suffix : Program) + (n left right : Nat) (s : State) (inputs : SetupInputs n left right s) + (host : HostedAt (compactQueryProgram ++ suffix) s.pc setupCode) : + ∃ setupTransitions, + run memory (compactQueryProgram ++ suffix) setupCost s = + ⟨initialState n left right, setupTransitions⟩ ∧ + setupTransitions.length = setupCost ∧ setupTransitions.filterMap (·.receipt) = [] ∧ + run memory (compactQueryProgram ++ suffix) (setupCost + compactQueryBudget) s = + ⟨(compactQueryRun memory n left right).final, + setupTransitions ++ (compactQueryRun memory n left right).transitions⟩ := by + obtain ⟨ts, hs, hc, hr⟩ := setup_exec memory (compactQueryProgram ++ suffix) n left right s inputs host + refine ⟨ts, hs, hc, hr, ?_⟩ + rw [run_add, hs] + dsimp only + rw [compactQuery_prefix] + +theorem chargedEntry_observations (memory : Memory) (suffix : Program) + (n left right : Nat) (s : State) (inputs : SetupInputs n left right s) + (host : HostedAt (compactQueryProgram ++ suffix) s.pc setupCode) : + let actual := run memory (compactQueryProgram ++ suffix) (setupCost + compactQueryBudget) s + let core := compactQueryRun memory n left right + actual.final = core.final ∧ actual.result = core.result ∧ actual.reads = core.reads ∧ + actual.steps = setupCost + core.steps := by + obtain ⟨ts, _, hc, hr, he⟩ := chargedEntry_compactQuery memory suffix n left right s inputs host + dsimp only + rw [he] + simp [Run.result, Run.reads, Run.steps, hc, hr] + +theorem chargedEntry_bound (memory : Memory) (suffix : Program) + (n left right : Nat) (s : State) (inputs : SetupInputs n left right s) + (host : HostedAt (compactQueryProgram ++ suffix) s.pc setupCode) : + (run memory (compactQueryProgram ++ suffix) (setupCost + compactQueryBudget) s).steps ≤ 160249 ∧ + (run memory (compactQueryProgram ++ suffix) (setupCost + compactQueryBudget) s).final.status ≠ .running := by + have obs := chargedEntry_observations memory suffix n left right s inputs host + have bound := compactQueryRun_steps_le memory n left right + dsimp only at obs + constructor + · rw [obs.2.2.2, setupCost_eq] + rw [compactQueryBudget_eq] at bound + omega + · rw [obs.1] + exact compactQueryRun_stopped memory n left right + +theorem chargedEntry_canonical (xs : List Int) (suffix : Program) (left right : Nat) (s : State) + (inputs : SetupInputs xs.length left right s) + (host : HostedAt (compactQueryProgram ++ suffix) s.pc setupCode) : + (run (buildMemory xs) (compactQueryProgram ++ suffix) (setupCost + compactQueryBudget) s).final.status = + .halted (optionNatPacket (SuccinctClassic.queryTraceResult xs left right).value) := by + rw [(chargedEntry_observations (buildMemory xs) suffix xs.length left right s inputs host).1] + exact compactQueryRun_halts xs left right + +theorem chargedEntry_invalid (memory : Memory) (suffix : Program) (n left right : Nat) (s : State) + (inputs : SetupInputs n left right s) + (host : HostedAt (compactQueryProgram ++ suffix) s.pc setupCode) + (invalid : ¬ (left < right ∧ right ≤ n)) : + (run memory (compactQueryProgram ++ suffix) (setupCost + compactQueryBudget) s).result = some 0 ∧ + (run memory (compactQueryProgram ++ suffix) (setupCost + compactQueryBudget) s).reads = [] := by + have obs := chargedEntry_observations memory suffix n left right s inputs host + have h := compactQueryRun_invalid memory n left right invalid + exact ⟨obs.2.1.trans h.1, obs.2.2.1.trans h.2⟩ + +/-- Every query occurrence remains at its precise shifted position in the host. -/ +theorem chargedEntry_read_occurrence (memory : Memory) (suffix : Program) + (n left right : Nat) (s : State) (inputs : SetupInputs n left right s) + (host : HostedAt (compactQueryProgram ++ suffix) s.pc setupCode) + (k : Nat) (t : Transition) (receipt : Receipt) + (coreOccurrence : (compactQueryRun memory n left right).transitions[k]? = some t) + (read : t.receipt = some receipt) : + (run memory (compactQueryProgram ++ suffix) (setupCost + compactQueryBudget) s).transitions[setupCost + k]? = some t ∧ + t.before = (run memory (compactQueryProgram ++ suffix) (setupCost + k) s).final ∧ + t.before.status = .running ∧ (compactQueryProgram ++ suffix)[t.before.pc]? = some t.instruction ∧ + execute memory t.instruction t.before = (t.after, t.receipt) ∧ + ∃ dst addrReg, t.instruction = .load dst addrReg ∧ + receipt.address = t.before.regs addrReg ∧ receipt.reply = memory[receipt.address]? := by + obtain ⟨ts, _, hlen, _, hrun⟩ := chargedEntry_compactQuery memory suffix n left right s inputs host + have occurrence : (run memory (compactQueryProgram ++ suffix) (setupCost + compactQueryBudget) s).transitions[setupCost + k]? = some t := by + rw [hrun] + simp only + rw [List.getElem?_append_right (by omega), hlen, Nat.add_sub_cancel_left] + exact coreOccurrence + exact ⟨occurrence, run_read_at occurrence read⟩ + +/-- The general finite-bank frame needed by a subsequent charged admission. -/ +theorem chargedEntry_zero_tail (memory : Memory) (suffix : Program) + (n left right : Nat) (s : State) (inputs : SetupInputs n left right s) + (host : HostedAt (compactQueryProgram ++ suffix) s.pc setupCode) + (r : Nat) (outside : compactQueryRegisterCount ≤ r) : + (run memory (compactQueryProgram ++ suffix) (setupCost + compactQueryBudget) s).final.regs r = 0 := by + rw [(chargedEntry_observations memory suffix n left right s inputs host).1] + exact compactQuery_finite_registers memory n left right compactQueryBudget r outside + +theorem clearCode_fields (width first count : Nat) (tag : 1 < 2 ^ width) + (bound : first + count ≤ 2 ^ width) : + ∀ i ∈ clearCode first count, i.Fits width := by + induction count generalizing first with + | zero => simp [clearCode] + | succ count ih => + intro i hi + simp only [clearCode, List.mem_cons] at hi + rcases hi with rfl | hi + · intro operand mem + simp only [Instruction.encoding, Instruction.operands, List.mem_append, + List.mem_cons, List.not_mem_nil, or_false] at mem + rcases mem with rfl | rfl | rfl <;> omega + · exact ih (first + 1) (by omega) i hi + +theorem clearCode_encoding (first count : Nat) : + ((clearCode first count).map Instruction.encoding).flatten.length = 3 * count := by + induction count generalizing first with + | zero => rfl + | succ count ih => + simp [clearCode, Instruction.encoding, Instruction.operands, ih] + omega + +theorem setupCode_encoding : (setupCode.map Instruction.encoding).flatten.length = 24812 := by + simp only [setupCode, List.map_append, List.flatten_append, List.length_append, + clearCode_encoding, clearCount_eq] + rfl + +theorem clearCode_safe (memory : Memory) (program : Program) (s : State) + (width first count : Nat) (hs : s.status = .running) + (host : HostedAt program s.pc (clearCode first count)) + (fit : s.Fits width) (tag : 1 < 2 ^ width) + (fields : first + count ≤ 2 ^ width) (pc : s.pc + count < 2 ^ width) : + TraceSafe width (run memory program count s).transitions := by + induction count generalizing first s with + | zero => intro t ht; simp [run] at ht + | succ count ih => + have hf : program[s.pc]? = some (.constant first 0) := host.head + let t : Transition := ⟨s, .constant first 0, s.writeNext first 0, none⟩ + have stepEq : step memory program s = some t := by simp [step, hs, hf, execute, t] + have ifit : (Instruction.constant first 0).Fits width := by + intro operand mem + simp only [Instruction.encoding, Instruction.operands, List.mem_append, + List.mem_cons, List.not_mem_nil, or_false] at mem + rcases mem with rfl | rfl | rfl <;> omega + have safe := Action.execute_safe memory width (.constant first 0) s fit ifit + (by change 0 < 2 ^ width; omega) (by omega) + have tail := ih (s.writeNext first 0) (first + 1) rfl (hosted_cons_tail host) + safe.2 (by omega) (by change s.pc + 1 + count < 2 ^ width; omega) + intro u hu + simp only [run, stepEq, List.mem_cons] at hu + rcases hu with rfl | hu + · exact safe + · exact tail u hu + +theorem clearJump_safe (memory : Memory) (program : Program) (s : State) + (width first count : Nat) (hs : s.status = .running) + (host : HostedAt program s.pc (clearCode first count ++ [.jump 0])) + (fit : s.Fits width) (tag : 5 < 2 ^ width) + (fields : first + count ≤ 2 ^ width) (pc : s.pc + count < 2 ^ width) : + TraceSafe width (run memory program (count + 1) s).transitions := by + obtain ⟨ts, hx, hlen, _⟩ := clearCode_exec memory program s first count hs host.append_left + have execClear : run memory program count s = ⟨cleared s first count, ts⟩ := by + simpa only [RunsTo, hlen] using hx + have safeClear := clearCode_safe memory program s width first count hs host.append_left + fit (by omega) fields pc + have cfit := run_prefix_fits memory program width count s fit safeClear count (Nat.le_refl _) + rw [execClear] at safeClear cfit + let c := cleared s first count + have hf : program[c.pc]? = some (.jump 0) := by + simpa [c, cleared, clearCode_length] using host.append_right.head + let j : Transition := ⟨c, .jump 0, { c with pc := 0 }, none⟩ + have js : step memory program c = some j := by + have cs : c.status = .running := rfl + simp only [step, cs, hf, execute] + rfl + have jumpFit : (Instruction.jump 0).Fits width := by + simp [Instruction.Fits, Instruction.encoding, Instruction.operands] + omega + have safeJump : TraceSafe width [j] := by + intro t ht + have he := List.mem_singleton.mp ht + subst t + exact ⟨⟨jumpFit, cfit, trivial⟩, + show ({ c with pc := 0 } : State).Fits width from ⟨by change 0 < 2 ^ width; omega, cfit.2⟩⟩ + rw [run_add, execClear] + change TraceSafe width (ts ++ (run memory program 1 c).transitions) + simpa only [run, js] using compact_traceSafe_append safeClear safeJump + +theorem setupCode_fields (n : Nat) : ∀ i ∈ setupCode, i.Fits (wordWidth n) := by + have cap := query_small_fields_fit n + intro i hi + rcases List.mem_append.mp hi with hi | hi + · exact clearCode_fields (wordWidth n) 3 clearCount (by omega) + (by rw [clearCount_eq]; omega) i hi + · have he : i = .jump 0 := List.mem_singleton.mp hi + rw [he] + simp [Instruction.Fits, Instruction.encoding, Instruction.operands] + omega + +theorem setup_trace_safe (memory : Memory) (program : Program) (n left right : Nat) (s : State) + (inputs : SetupInputs n left right s) (host : HostedAt program s.pc setupCode) + (fit : s.Fits (wordWidth n)) (pcBound : s.pc + clearCount < 2 ^ wordWidth n) : + TraceSafe (wordWidth n) (run memory program setupCost s).transitions := by + apply clearJump_safe memory program s (wordWidth n) 3 clearCount inputs.1 host fit + · have cap := query_small_fields_fit n; omega + · rw [clearCount_eq]; have cap := query_small_fields_fit n; omega + · exact pcBound + +/-- Whole-program field fit is explicit: dormant host instructions are not omitted. -/ +theorem chargedEntry_execution_safe (xs : List Int) (suffix : Program) + (left right : Nat) (s : State) (inputs : SetupInputs xs.length left right s) + (host : HostedAt (compactQueryProgram ++ suffix) s.pc setupCode) + (fit : s.Fits (wordWidth xs.length)) + (pcBound : s.pc + clearCount < 2 ^ wordWidth xs.length) + (fields : ∀ i ∈ compactQueryProgram ++ suffix, i.Fits (wordWidth xs.length)) + (hl : left < 2 ^ wordWidth xs.length) (hr : right < 2 ^ wordWidth xs.length) : + RankExecutionSafety (buildMemory xs) (wordWidth xs.length) + (compactQueryProgram ++ suffix) (setupCost + compactQueryBudget) s := by + obtain ⟨ts, hsetup, _, _, hrun⟩ := + chargedEntry_compactQuery (buildMemory xs) suffix xs.length left right s inputs host + have sq := compactQueryRun_execution_safe xs left right hl hr + have ss := setup_trace_safe (buildMemory xs) (compactQueryProgram ++ suffix) + xs.length left right s inputs host fit pcBound + rw [hsetup] at ss + have queryTrace : TraceSafe (wordWidth xs.length) + (compactQueryRun (buildMemory xs) xs.length left right).transitions := by + intro t ht + obtain ⟨i, hi⟩ := List.mem_iff_getElem?.mp ht + exact sq.2.2.1 i t hi + have allTrace : TraceSafe (wordWidth xs.length) + (run (buildMemory xs) (compactQueryProgram ++ suffix) (setupCost + compactQueryBudget) s).transitions := by + rw [hrun] + exact compact_traceSafe_append ss queryTrace + refine ⟨fields, ?_, ?_, ?_, ?_⟩ + · rw [hrun]; exact sq.2.1 + · intro i t hi; exact allTrace t (List.mem_of_getElem? hi) + · exact run_prefix_fits (buildMemory xs) (compactQueryProgram ++ suffix) + (wordWidth xs.length) (setupCost + compactQueryBudget) s fit allTrace + · intro i t receipt hi hr + have st := allTrace t (List.mem_of_getElem? hi) + exact run_read_fits hi hr st.1 st.2 + +theorem clearCode_categories (memory : Memory) (program : Program) (s : State) + (first count : Nat) (hs : s.status = .running) + (host : HostedAt program s.pc (clearCode first count)) : + (run memory program count s).categories = List.replicate count .registerWrite := by + induction count generalizing first s with + | zero => rfl + | succ count ih => + have hf : program[s.pc]? = some (.constant first 0) := host.head + have he : step memory program s = + some ⟨s, .constant first 0, s.writeNext first 0, none⟩ := by + simp [step, hs, hf, execute] + have tail := ih (s.writeNext first 0) (first + 1) rfl (hosted_cons_tail host) + simp only [run, he, Run.categories, List.map_cons, Instruction.category] + change Category.registerWrite :: (run memory program count (s.writeNext first 0)).categories = _ + rw [tail, List.replicate_succ] + +/-- Category accounting distinguishes the zero writes from the jump. -/ +theorem setup_categories (memory : Memory) (program : Program) (s : State) + (hs : s.status = .running) (host : HostedAt program s.pc setupCode) : + (run memory program setupCost s).categories = + List.replicate clearCount .registerWrite ++ [.branch] := by + obtain ⟨ts, hx, hlen, _⟩ := clearCode_exec memory program s 3 clearCount hs host.append_left + have he : run memory program clearCount s = ⟨cleared s 3 clearCount, ts⟩ := by + simpa only [RunsTo, hlen] using hx + have cats := clearCode_categories memory program s 3 clearCount hs host.append_left + rw [he] at cats + have hf : program[(cleared s 3 clearCount).pc]? = some (.jump 0) := by + simpa [cleared, clearCode_length] using host.append_right.head + have hj : step memory program (cleared s 3 clearCount) = + some ⟨cleared s 3 clearCount, .jump 0, { cleared s 3 clearCount with pc := 0 }, none⟩ := by + have hc : (cleared s 3 clearCount).status = .running := rfl + simp only [step, hc, hf, execute] + rw [setupCost, run_add, he] + simpa [run, hj, Run.categories, Instruction.category] using + congrArg (fun tail => tail ++ [Category.branch]) cats + +theorem chargedEntry_categories (memory : Memory) (suffix : Program) + (n left right : Nat) (s : State) (inputs : SetupInputs n left right s) + (host : HostedAt (compactQueryProgram ++ suffix) s.pc setupCode) : + (run memory (compactQueryProgram ++ suffix) (setupCost + compactQueryBudget) s).categories = + List.replicate clearCount .registerWrite ++ [.branch] ++ + (compactQueryRun memory n left right).categories := by + obtain ⟨ts, hs, _, _, hrun⟩ := chargedEntry_compactQuery memory suffix n left right s inputs host + have cats := setup_categories memory (compactQueryProgram ++ suffix) s inputs.1 host + rw [hs] at cats + rw [hrun] + simp only [Run.categories, List.map_append] at cats ⊢ + rw [cats] + +end RMQ.SuccinctFinal.PackedLifecycle.QueryEntry diff --git a/RMQ/Core/WordRAM/Lifecycle/QuerySafetyBridge.lean b/RMQ/Core/WordRAM/Lifecycle/QuerySafetyBridge.lean new file mode 100644 index 00000000..245e77ea --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/QuerySafetyBridge.lean @@ -0,0 +1,456 @@ +import RMQ.Core.WordRAM.Lifecycle.QueryBridge +import RMQ.Core.WordRAM.Lifecycle.QueryEntry +import RMQ.Core.WordRAM.Lifecycle.Finalizer +import RMQ.Core.WordRAM.Lifecycle.Safety + +/-! # Packed-query safety on the retained lifecycle state + +Packed width safety permits failed reads; construction primitive safety also +requires successful backing and in-program direct targets. These additional +obligations are explicit. Full transition simulation remains valid without +them, including failed reads and stopped initial states. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle.QuerySafetyBridge + +open PackedConstruction.Conservative +open PackedWordRAM.Structured PackedWordRAM.Optimization + +abbrev QueryState := PackedWordRAM.State +abbrev QueryInstruction := PackedWordRAM.Instruction +abbrev QueryProgram := PackedWordRAM.Program +abbrev QueryMemory := PackedWordRAM.Memory + +def ControlBound (len : Nat) : QueryInstruction → Prop + | .jump target | .branchZero _ target => target < len + | .jumpRegister _ => False + | _ => True + +def LoadPresent (memory : QueryMemory) (s : QueryState) : QueryInstruction → Prop + | .load _ address => ∃ value, memory[s.regs address]? = some value + | _ => True + +theorem instruction_encoding (i : QueryInstruction) (fields : OperandsFit32 i) : + (instruction i fields).constants.map Fin.val = i.encoding := by + cases i <;> try rfl + case arithmetic op dst lhs rhs => cases op <;> rfl + case comparison op dst lhs rhs => cases op <;> rfl + +theorem instruction_operands (i : QueryInstruction) (fields : OperandsFit32 i) + (W : Nat) (fit : i.Fits W) : (instruction i fields).OperandsFit W := by + intro operand member + apply fit operand.val + rw [← instruction_encoding i fields] + exact List.mem_map.mpr ⟨operand, member, rfl⟩ + +/-- No answer or routing premise appears: each extra premise describes this +primitive's actual backing or encoded control field. -/ +theorem instruction_safe (memory : QueryMemory) (s : QueryState) (i : QueryInstruction) + (fields : OperandsFit32 i) (W len : Nat) + (safe : i.Safe W s) (control : ControlBound len i) (present : LoadPresent memory s i) + (words : ∀ word ∈ memory, word < 2 ^ W) : + (instruction i fields).Safe W len (state memory s) := by + refine ⟨instruction_operands i fields W safe.1, ?_⟩ + cases i with + | load dst address => + obtain ⟨value, reply⟩ := present + have inside := (List.getElem?_eq_some_iff.mp reply).1 + exact ⟨inside, value, reply, words value (List.mem_of_getElem? reply)⟩ + | constant dst value => trivial + | move dst src => trivial + | arithmetic op dst lhs rhs => + have arithmeticSafe := safe.2.2 + cases op <;> + simpa [instruction, PackedConstruction.Prim.SafeAt, state, arithmetic, + PackedWordRAM.Instruction.Safe, PackedWordRAM.Arithmetic.eval, + PackedConstruction.Arithmetic.eval] using arithmeticSafe + | comparison op dst lhs rhs => trivial + | jump target => exact control + | jumpRegister src => exact control.elim + | branchZero condition target => exact control + | halt src => trivial + +theorem translate_safe (memory : QueryMemory) (s : QueryState) (i : QueryInstruction) + (fields : OperandsFit32 i) (W len : Nat) + (safe : i.Safe W s) (control : ControlBound len i) (present : LoadPresent memory s i) + (words : ∀ word ∈ memory, word < 2 ^ W) : + (translate i).primitive.Safe W len (state memory s) := by + rw [translate_of_fits i fields] + exact instruction_safe memory s i fields W len safe control present words + +/-- The structured compact emitter has only direct, statically bounded jumps. +The bound covers the target even when its branch is not taken. -/ +theorem compactAt_controlBound (block : Block) (fresh depth base len : Nat) + (last : base + compactSize block < len) : + ∀ i ∈ compactAt block fresh depth base, ControlBound len i := by + induction block generalizing depth base with + | skip => simp [compactAt] + | action op => + intro i member + have equal : i = op.instruction := by simpa [compactAt] using member + subst i + cases op <;> trivial + | exit src => simp [compactAt, ControlBound] + | seq a b iha ihb => + intro i member + rcases List.mem_append.mp member with member | member + · exact iha depth base (by simp only [compactSize] at last; omega) i member + · exact ihb depth (base + compactSize a) (by simp only [compactSize] at last; omega) i member + | ifZero condition zero nonzero ihz ihn => + intro i member + simp only [compactAt, List.mem_append, List.mem_cons, List.not_mem_nil, or_false] at member + simp only [compactSize] at last + rcases member with ((rfl | member) | rfl) | member + · simp only [ControlBound]; omega + · exact ihn depth (base + 1) (by omega) i member + · simp only [ControlBound]; omega + · exact ihz depth (base + 1 + compactSize nonzero + 1) (by omega) i member + | «repeat» count body ih => + cases count with + | zero => simp [compactAt] + | succ count => + intro i member + simp only [compactAt, List.mem_append, List.mem_cons, List.not_mem_nil, or_false] at member + simp only [compactSize] at last + rcases member with ((rfl | rfl | rfl) | member) | (rfl | rfl) + · trivial + · trivial + · simp only [ControlBound]; omega + · exact ih (depth + 1) (base + 3) (by omega) i member + · trivial + · simp only [ControlBound]; omega + +theorem compact_controlBound (len : Nat) (last : compactQueryProgram.length < len) : + ∀ i ∈ compactQueryProgram, ControlBound len i := by + apply compactAt_controlBound compactQuerySource compactQueryFresh 0 0 len + simpa only [Nat.zero_add, compactQueryProgram_length] using last + +theorem clearCode_controlBound (first count len : Nat) : + ∀ i ∈ QueryEntry.clearCode first count, ControlBound len i := by + induction count generalizing first with + | zero => simp [QueryEntry.clearCode] + | succ count ih => + intro i member + simp only [QueryEntry.clearCode, List.mem_cons] at member + rcases member with rfl | member + · trivial + · exact ih (first + 1) i member + +theorem setupCode_controlBound (len : Nat) (positive : 0 < len) : + ∀ i ∈ QueryEntry.setupCode, ControlBound len i := by + intro i member + rcases List.mem_append.mp member with member | member + · exact clearCode_controlBound 3 QueryEntry.clearCount len i member + · have equal : i = .jump 0 := List.mem_singleton.mp member + subst i + exact positive + +def embedded (memory : QueryMemory) (s : QueryState) : State := ofCore (state memory s) 0 0 + +theorem core_fits (memory : QueryMemory) (s : QueryState) (W : Nat) + (fit : s.Fits W) (extent : memory.length < 2 ^ W) + (words : ∀ word ∈ memory, word < 2 ^ W) : (state memory s).Fits W := by + refine ⟨fit.2.1, fit.1, extent, ?_, ?_⟩ + · intro address value reply + exact words value (List.mem_of_getElem? reply) + · intro value halted + have oldHalted : s.status = .halted value := by + cases hs : s.status <;> simp_all [state, status] + exact fit.2.2 value oldHalted + +theorem embedded_fits (memory : QueryMemory) (s : QueryState) (W : Nat) + (fit : s.Fits W) (extent : memory.length < 2 ^ W) + (words : ∀ word ∈ memory, word < 2 ^ W) : (embedded memory s).Fits W := + ⟨core_fits memory s W fit extent words, Nat.two_pow_pos _, Nat.two_pow_pos _⟩ + +/-- Finite list backing and zero resource extents make retirement explicit. -/ +theorem embedded_closed (memory : QueryMemory) (s : QueryState) : + (embedded memory s).Closed ∧ (embedded memory s).keyExtent = 0 ∧ + (embedded memory s).keyRegExtent = 0 := by + refine ⟨⟨?_, ?_, ?_⟩, rfl, rfl⟩ + · intro address outside + exact List.getElem?_eq_none_iff.mpr outside + · intro address _; rfl + · intro r _; rfl + +theorem embedded_finite_bank (memory : QueryMemory) (s : QueryState) (bank : Nat) + (finite : ∀ r, bank ≤ r → s.regs r = 0) : + ∀ r, bank ≤ r → (embedded memory s).core.regs r = 0 := finite + +/-- Successful receipt backing is recovered from the same executed occurrence. -/ +theorem loadPresent_of_reads {memory : QueryMemory} {program : QueryProgram} + {fuel : Nat} {s : QueryState} {index : Nat} {t : PackedWordRAM.Transition} + (occurs : (PackedWordRAM.run memory program fuel s).transitions[index]? = some t) + (reads : ∀ receipt ∈ (PackedWordRAM.run memory program fuel s).reads, + ∃ value, receipt.reply = some value) : LoadPresent memory t.before t.instruction := by + have exec := (PackedWordRAM.run_transition_spec occurs).2.2.2 + cases hi : t.instruction <;> try trivial + case load dst address => + have receipt : t.receipt = some ⟨t.before.regs address, memory[t.before.regs address]?⟩ := by + have h := congrArg Prod.snd exec + simpa [hi, PackedWordRAM.execute] using h.symm + have member : (⟨t.before.regs address, memory[t.before.regs address]?⟩ : + PackedWordRAM.Receipt) ∈ (PackedWordRAM.run memory program fuel s).reads := + List.mem_filterMap.mpr ⟨t, List.mem_of_getElem? occurs, receipt⟩ + exact reads _ member + +def host (program : QueryProgram) (tail : List Instruction) : List Instruction := + (program.map translate).map oldInstruction ++ tail + +def liftTransition (memory : QueryMemory) (t : PackedWordRAM.Transition) : Transition := + oldTransition 0 0 (QueryBridge.liftTransition memory t) + +private theorem old_prefix_of_stopped (program : List PackedConstruction.BInstr) + (tail : List Instruction) (fuel budget : Nat) (s : PackedConstruction.State) + (within : fuel ≤ budget) + (stopped : (PackedConstruction.run program budget s).final.status ≠ .running) : + run (program.map oldInstruction ++ tail) fuel (ofCore s 0 0) = + oldRun 0 0 (PackedConstruction.run program fuel s) := by + induction fuel generalizing budget s with + | zero => rfl + | succ fuel ih => + cases budget with + | zero => omega + | succ budget => + cases hs : PackedConstruction.stepProgram program s with + | none => + have hstop : s.status ≠ .running := by + simpa [PackedConstruction.run, hs] using stopped + have hn := step_none_of_stopped (program.map oldInstruction ++ tail) + (ofCore s 0 0) hstop + simp [run, hn, PackedConstruction.run, hs, oldRun] + | some t => + have hrest : (PackedConstruction.run program budget t.after).final.status ≠ .running := by + simpa [PackedConstruction.run, hs] using stopped + have hn := old_step hs tail 0 0 + simp only [run, hn, PackedConstruction.run, hs] + rw [show (oldTransition 0 0 t).after = ofCore t.after 0 0 from rfl, + ih budget t.after (by omega) hrest] + rfl + +/-- Appending a lifecycle continuation preserves every prefix of a stopped +packed run, including faults and early halts. Full states and order are exact. -/ +theorem prefix_run (memory : QueryMemory) (program : QueryProgram) + (tail : List Instruction) (fields : ∀ i ∈ program, OperandsFit32 i) + (fuel budget : Nat) (s : QueryState) (within : fuel ≤ budget) + (stopped : (PackedWordRAM.run memory program budget s).final.status ≠ .running) : + run (host program tail) fuel (embedded memory s) = + ⟨embedded memory (PackedWordRAM.run memory program fuel s).final, + (PackedWordRAM.run memory program fuel s).transitions.map (liftTransition memory)⟩ := by + have all := QueryBridge.translated_run_all memory program fields budget s + have coreStopped : (PackedConstruction.run (program.map translate) budget + (state memory s)).final.status ≠ .running := by + rw [all.1] + cases hs : (PackedWordRAM.run memory program budget s).final.status <;> + simp_all [state, status] + rw [show host program tail = (program.map translate).map oldInstruction ++ tail from rfl, + show embedded memory s = ofCore (state memory s) 0 0 from rfl, + old_prefix_of_stopped _ tail fuel budget _ within coreStopped] + have sim := QueryBridge.translated_run_all memory program fields fuel s + simp only [oldRun, sim.1, sim.2.1, List.map_map] + rfl + +theorem prefix_fits (memory : QueryMemory) (program : QueryProgram) + (tail : List Instruction) (fields : ∀ i ∈ program, OperandsFit32 i) + (fuel budget W : Nat) (s : QueryState) (within : fuel ≤ budget) + (stopped : (PackedWordRAM.run memory program budget s).final.status ≠ .running) + (safe : PackedWordRAM.RankExecutionSafety memory W program budget s) + (extent : memory.length < 2 ^ W) (words : ∀ word ∈ memory, word < 2 ^ W) : + (run (host program tail) fuel (embedded memory s)).final.Fits W := by + rw [prefix_run memory program tail fields fuel budget s within stopped] + exact embedded_fits memory _ W (safe.2.2.2.1 fuel within) extent words + +theorem prefix_closed (memory : QueryMemory) (program : QueryProgram) + (tail : List Instruction) (fields : ∀ i ∈ program, OperandsFit32 i) + (fuel budget : Nat) (s : QueryState) (within : fuel ≤ budget) + (stopped : (PackedWordRAM.run memory program budget s).final.status ≠ .running) : + (run (host program tail) fuel (embedded memory s)).final.Closed ∧ + (run (host program tail) fuel (embedded memory s)).final.keyExtent = 0 ∧ + (run (host program tail) fuel (embedded memory s)).final.keyRegExtent = 0 := by + rw [prefix_run memory program tail fields fuel budget s within stopped] + exact embedded_closed memory _ + +theorem prefix_finite_bank (memory : QueryMemory) (program : QueryProgram) + (tail : List Instruction) (fields : ∀ i ∈ program, OperandsFit32 i) + (fuel budget bank : Nat) (s : QueryState) (within : fuel ≤ budget) + (stopped : (PackedWordRAM.run memory program budget s).final.status ≠ .running) + (writes : ∀ i ∈ program, i.WritesOnly (fun r => r < bank)) + (finite : ∀ r, bank ≤ r → s.regs r = 0) : + ∀ r, bank ≤ r → (run (host program tail) fuel (embedded memory s)).final.core.regs r = 0 := by + rw [prefix_run memory program tail fields fuel budget s within stopped] + intro r outside + change (PackedWordRAM.run memory program fuel s).final.regs r = 0 + rw [PackedWordRAM.run_frame memory program fuel s _ writes r (by omega)] + exact finite r outside + +/-- Strong safety is obtained only after successful backing is established for +the actual load occurrences; dormant jump targets are checked independently. -/ +theorem run_safe (memory : QueryMemory) (program : QueryProgram) + (tail : List Instruction) (fields : ∀ i ∈ program, OperandsFit32 i) + (budget W : Nat) (s : QueryState) + (stopped : (PackedWordRAM.run memory program budget s).final.status ≠ .running) + (safe : PackedWordRAM.RankExecutionSafety memory W program budget s) + (control : ∀ i ∈ program, ControlBound (host program tail).length i) + (reads : ∀ receipt ∈ (PackedWordRAM.run memory program budget s).reads, + ∃ value, receipt.reply = some value) + (words : ∀ word ∈ memory, word < 2 ^ W) : + ∀ t ∈ (run (host program tail) budget (embedded memory s)).transitions, + t.Safe W (host program tail).length := by + rw [prefix_run memory program tail fields budget budget s (Nat.le_refl _) stopped] + intro t member + change t ∈ (PackedWordRAM.run memory program budget s).transitions.map (liftTransition memory) at member + obtain ⟨old, oldMember, rfl⟩ := List.mem_map.mp member + obtain ⟨index, occurrence⟩ := List.mem_iff_getElem?.mp oldMember + have fetched := (PackedWordRAM.run_transition_spec occurrence).2.2.1 + have im := List.mem_of_getElem? fetched + refine ⟨oldInstruction (translate old.instruction), rfl, ?_⟩ + exact translate_safe memory old.before old.instruction (fields _ im) W _ + (safe.2.2.1 index old occurrence).1 (control _ im) + (loadPresent_of_reads occurrence reads) words + +theorem prefix_occurrence (memory : QueryMemory) (program : QueryProgram) + (tail : List Instruction) (fields : ∀ i ∈ program, OperandsFit32 i) + (fuel budget : Nat) (s : QueryState) (within : fuel ≤ budget) + (stopped : (PackedWordRAM.run memory program budget s).final.status ≠ .running) + (index : Nat) (t : Transition) + (occurs : (run (host program tail) fuel (embedded memory s)).transitions[index]? = some t) : + ∃ old, (PackedWordRAM.run memory program fuel s).transitions[index]? = some old ∧ + t = liftTransition memory old := by + rw [prefix_run memory program tail fields fuel budget s within stopped] at occurs + simp only [List.getElem?_map] at occurs + cases ho : (PackedWordRAM.run memory program fuel s).transitions[index]? with + | none => simp [ho] at occurs + | some old => + refine ⟨old, rfl, ?_⟩ + simpa [ho] using occurs.symm + +theorem lift_read (memory : QueryMemory) (t : PackedWordRAM.Transition) + (fields : OperandsFit32 t.instruction) + (exec : PackedWordRAM.execute memory t.instruction t.before = (t.after, t.receipt)) : + (liftTransition memory t).read? = t.receipt.map (fun r => (r.address, r.reply)) := by + have hr := QueryBridge.readReply_execute memory t.instruction fields t.before + have he := congrArg Prod.snd exec + have read : QueryBridge.readReply (QueryBridge.liftTransition memory t) = t.receipt := + hr.trans he + have same : (liftTransition memory t).read? = + (QueryBridge.readReply (QueryBridge.liftTransition memory t)).map + (fun r => (r.address, r.reply)) := by + unfold liftTransition oldTransition oldInstruction QueryBridge.liftTransition + unfold Transition.read? QueryBridge.readReply + cases (translate t.instruction).primitive <;> rfl + rw [same, read] + +/-- The numeric read theorem includes absent replies. Its address and successful +value bounds come from the producing packed occurrence at the same width. -/ +theorem run_read_width (memory : QueryMemory) (program : QueryProgram) + (tail : List Instruction) (fields : ∀ i ∈ program, OperandsFit32 i) + (budget W : Nat) (s : QueryState) + (stopped : (PackedWordRAM.run memory program budget s).final.status ≠ .running) + (safe : PackedWordRAM.RankExecutionSafety memory W program budget s) + (index : Nat) (t : Transition) (address : Nat) (reply : Option Nat) + (occurs : (run (host program tail) budget (embedded memory s)).transitions[index]? = some t) + (read : t.read? = some (address, reply)) : + address < 2 ^ W ∧ reply = memory[address]? ∧ + (∀ value, reply = some value → value < 2 ^ W) := by + obtain ⟨old, ho, rfl⟩ := prefix_occurrence memory program tail fields budget budget s + (Nat.le_refl _) stopped index t occurs + have spec := PackedWordRAM.run_transition_spec ho + rw [lift_read memory old (fields _ (List.mem_of_getElem? spec.2.2.1)) spec.2.2.2] at read + cases hr : old.receipt with + | none => simp [hr] at read + | some receipt => + have equal : (receipt.address, receipt.reply) = (address, reply) := by simpa [hr] using read + have h := safe.2.2.2.2 index old receipt ho hr + cases equal + exact h + +/-- Full before/after width transport does not need successful loads. -/ +theorem run_transition_fits (memory : QueryMemory) (program : QueryProgram) + (tail : List Instruction) (fields : ∀ i ∈ program, OperandsFit32 i) + (budget W : Nat) (s : QueryState) + (stopped : (PackedWordRAM.run memory program budget s).final.status ≠ .running) + (safe : PackedWordRAM.RankExecutionSafety memory W program budget s) + (extent : memory.length < 2 ^ W) (words : ∀ word ∈ memory, word < 2 ^ W) : + ∀ t ∈ (run (host program tail) budget (embedded memory s)).transitions, + t.before.Fits W ∧ t.after.Fits W := by + intro t member + obtain ⟨index, occurrence⟩ := List.mem_iff_getElem?.mp member + obtain ⟨old, ho, rfl⟩ := prefix_occurrence memory program tail fields budget budget s + (Nat.le_refl _) stopped index t occurrence + have oldSafe := safe.2.2.1 index old ho + exact ⟨embedded_fits memory _ W oldSafe.1.2.1 extent words, + embedded_fits memory _ W oldSafe.2 extent words⟩ + +theorem host_fields (program : QueryProgram) (tail : List Instruction) + (fields : ∀ i ∈ program, OperandsFit32 i) (W : Nat) + (source : ∀ i ∈ program, i.Fits W) (suffix : ∀ i ∈ tail, i.Fits W) : + ∀ i ∈ host program tail, i.Fits W := by + intro i member + rcases List.mem_append.mp member with prefixMember | tailMember + · obtain ⟨translated, translatedMember, rfl⟩ := List.mem_map.mp prefixMember + obtain ⟨old, oldMember, rfl⟩ := List.mem_map.mp translatedMember + rw [translate_of_fits old (fields _ oldMember)] + change ∀ word ∈ (instruction old (fields _ oldMember)).constants.map Fin.val, word < 2 ^ W + rw [instruction_encoding] + exact source old oldMember + · exact suffix i tailMember + +private theorem lift_reads_list (memory : QueryMemory) (ts : List PackedWordRAM.Transition) + (equal : ∀ t ∈ ts, (liftTransition memory t).read? = + t.receipt.map (fun r => (r.address, r.reply))) : + (ts.map (liftTransition memory)).filterMap Transition.read? = + (ts.filterMap (·.receipt)).map (fun r => (r.address, r.reply)) := by + induction ts with + | nil => rfl + | cons t ts ih => + have head := equal t (List.mem_cons_self ..) + have tail := ih (fun u hu => equal u (List.mem_cons_of_mem _ hu)) + simp only [List.map_cons, List.filterMap_cons] + rw [head, tail] + cases t.receipt <;> rfl + +/-- Every attempted read, in order and with multiplicity, is preserved through +the two existing execution adapters. -/ +theorem prefix_reads (memory : QueryMemory) (program : QueryProgram) + (tail : List Instruction) (fields : ∀ i ∈ program, OperandsFit32 i) + (fuel budget : Nat) (s : QueryState) (within : fuel ≤ budget) + (stopped : (PackedWordRAM.run memory program budget s).final.status ≠ .running) : + (run (host program tail) fuel (embedded memory s)).reads = + (PackedWordRAM.run memory program fuel s).reads.map (fun r => (r.address, r.reply)) := by + rw [prefix_run memory program tail fields fuel budget s within stopped] + apply lift_reads_list + intro t member + obtain ⟨index, occurrence⟩ := List.mem_iff_getElem?.mp member + have spec := PackedWordRAM.run_transition_spec occurrence + exact lift_read memory t (fields _ (List.mem_of_getElem? spec.2.2.1)) spec.2.2.2 + +theorem prefix_safe (memory : QueryMemory) (program : QueryProgram) + (tail : List Instruction) (fields : ∀ i ∈ program, OperandsFit32 i) + (fuel budget W : Nat) (s : QueryState) (within : fuel ≤ budget) + (stopped : (PackedWordRAM.run memory program budget s).final.status ≠ .running) + (safe : PackedWordRAM.RankExecutionSafety memory W program budget s) + (control : ∀ i ∈ program, ControlBound (host program tail).length i) + (reads : ∀ receipt ∈ (PackedWordRAM.run memory program budget s).reads, + ∃ value, receipt.reply = some value) + (words : ∀ word ∈ memory, word < 2 ^ W) : + ∀ t ∈ (run (host program tail) fuel (embedded memory s)).transitions, + t.Safe W (host program tail).length := by + intro t member + apply run_safe memory program tail fields budget W s stopped safe control reads words t + rw [show budget = fuel + (budget - fuel) by omega, run_add] + exact List.mem_append.mpr (Or.inl member) + +/-- Numeric backing and all retired resource channels are invariant throughout +query service. This states actual function equality, not footprint agreement. -/ +theorem prefix_storage (memory : QueryMemory) (program : QueryProgram) + (tail : List Instruction) (fields : ∀ i ∈ program, OperandsFit32 i) + (fuel budget : Nat) (s : QueryState) (within : fuel ≤ budget) + (stopped : (PackedWordRAM.run memory program budget s).final.status ≠ .running) : + let final := (run (host program tail) fuel (embedded memory s)).final + final.core.memory = (fun a => memory[a]?) ∧ final.core.extent = memory.length ∧ + final.core.keys = (fun _ => none) ∧ final.core.keyRegs = (fun _ => 0) ∧ + final.keyExtent = 0 ∧ final.keyRegExtent = 0 := by + rw [prefix_run memory program tail fields fuel budget s within stopped] + exact ⟨rfl, rfl, rfl, rfl, rfl, rfl⟩ + +end RMQ.SuccinctFinal.PackedLifecycle.QuerySafetyBridge diff --git a/RMQ/Core/WordRAM/Lifecycle/Resources.lean b/RMQ/Core/WordRAM/Lifecycle/Resources.lean new file mode 100644 index 00000000..a23a9004 --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/Resources.lean @@ -0,0 +1,130 @@ +import RMQ.Core.WordRAM.Lifecycle.BoundarySafety + +/-! # Resource laws for actual scalar execution + +The separately owned comparison banks never grow under an instruction or +request event. Numeric clean tails are preserved even by faulting execution. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle.Resources + +theorem execute_key_extents (i : Instruction) (s : State) : + (execute i s).keyExtent ≤ s.keyExtent ∧ + (execute i s).keyRegExtent ≤ s.keyRegExtent := by + cases i <;> simp only [execute] + · exact ⟨Nat.le_refl _, Nat.le_refl _⟩ + all_goals split <;> simp only <;> omega + +theorem execute_numeric_closed (i : Instruction) (s : State) + (closed : PackedConstruction.CleanTail s.core) : + PackedConstruction.CleanTail (execute i s).core := by + cases i with + | old p => exact PackedConstruction.execPrim_cleanTail p s.core closed + | releaseCell => + by_cases hz : s.core.extent = 0 + · simpa [execute, hz, PackedConstruction.CleanTail] using closed + · simp only [execute, hz, ↓reduceIte, PackedConstruction.CleanTail, + PackedConstruction.State.next] + intro a ha + by_cases he : a = s.core.extent - 1 + · simp [PackedConstruction.put, he] + · simp [PackedConstruction.put, he, closed a (by omega)] + | releaseKey => + simp only [execute] + split <;> exact closed + | releaseKeyRegister => + simp only [execute] + split <;> exact closed + +theorem run_preserves (P : State → Prop) (program : List Instruction) (fuel : Nat) (s : State) + (initial : P s) (preserves : ∀ i t, P t → P (execute i t)) : + P (run program fuel s).final ∧ + ∀ t ∈ (run program fuel s).transitions, P t.before ∧ P t.after := by + induction fuel generalizing s with + | zero => exact ⟨initial, fun _ h => by cases h⟩ + | succ fuel ih => + cases hs : step program s with + | none => simpa [run, hs] using And.intro initial (show ∀ t ∈ ([] : List Transition), + P t.before ∧ P t.after from fun _ h => by cases h) + | some first => + obtain ⟨hb, _, i, _, _, ha⟩ := step_spec hs + have next : P first.after := ha ▸ preserves i s initial + have rest := ih first.after next + refine ⟨by simpa [run, hs] using rest.1, ?_⟩ + intro t ht + simp only [run, hs, List.mem_cons] at ht + rcases ht with rfl | ht + · exact ⟨hb ▸ initial, next⟩ + · exact rest.2 t ht + +theorem run_key_extents (program : List Instruction) (fuel : Nat) (s : State) : + ((run program fuel s).final.keyExtent ≤ s.keyExtent ∧ + (run program fuel s).final.keyRegExtent ≤ s.keyRegExtent) ∧ + ∀ t ∈ (run program fuel s).transitions, + (t.before.keyExtent ≤ s.keyExtent ∧ t.before.keyRegExtent ≤ s.keyRegExtent) ∧ + (t.after.keyExtent ≤ s.keyExtent ∧ t.after.keyRegExtent ≤ s.keyRegExtent) := by + apply run_preserves (fun t => t.keyExtent ≤ s.keyExtent ∧ t.keyRegExtent ≤ s.keyRegExtent) + program fuel s ⟨Nat.le_refl _, Nat.le_refl _⟩ + intro i t ht + have step := execute_key_extents i t + exact ⟨Nat.le_trans step.1 ht.1, Nat.le_trans step.2 ht.2⟩ + +theorem run_numeric_closed (program : List Instruction) (fuel : Nat) (s : State) + (closed : PackedConstruction.CleanTail s.core) : + PackedConstruction.CleanTail (run program fuel s).final.core ∧ + ∀ t ∈ (run program fuel s).transitions, + PackedConstruction.CleanTail t.before.core ∧ PackedConstruction.CleanTail t.after.core := + run_preserves (fun t => PackedConstruction.CleanTail t.core) program fuel s closed + execute_numeric_closed + +theorem run_steps_le_fuel (program : List Instruction) (fuel : Nat) (s : State) : + (run program fuel s).steps ≤ fuel := by + induction fuel generalizing s with + | zero => exact Nat.le_refl _ + | succ fuel ih => + cases hs : step program s with + | none => simp [run, hs, Run.steps] + | some t => simpa [run, hs, Run.steps] using Nat.succ_le_succ (ih t.after) + +theorem run_transition_after {program : List Instruction} {fuel : Nat} {s : State} + {index : Nat} {t : Transition} + (occurs : (run program fuel s).transitions[index]? = some t) : + t.after = (run program (index + 1) s).final := by + obtain ⟨before, step⟩ := run_transition_at occurs + rw [run_add] + simp [← before, run, step] + +theorem runBoundary_preserves (P : State → Prop) (bs : List Boundary) (s : State) + (initial : P s) (preserves : ∀ b ∈ bs, ∀ t, P t → P (executeBoundary b t)) : + P (runBoundary bs s).final ∧ + ∀ t ∈ (runBoundary bs s).transitions, P t.before ∧ P t.after := by + induction bs generalizing s with + | nil => exact ⟨initial, fun _ h => by cases h⟩ + | cons b bs ih => + cases status : s.core.status with + | running => simp [runBoundary, boundaryStep, status]; exact initial + | fault => simp [runBoundary, boundaryStep, status]; exact initial + | halted value => + have next := preserves b (by simp) s initial + have rest := ih (executeBoundary b s) next (fun c hc => preserves c (by simp [hc])) + simp only [runBoundary, boundaryStep, status] + refine ⟨rest.1, ?_⟩ + intro t ht + simp only [List.mem_cons] at ht + rcases ht with rfl | ht + · exact ⟨initial, next⟩ + · exact rest.2 t ht + +theorem runBoundary_reads (bs : List Boundary) (s : State) : + (runBoundary bs s).reads = [] := by + induction bs generalizing s with + | nil => rfl + | cons b bs ih => + cases status : s.core.status with + | running => simp [runBoundary, boundaryStep, status, Run.reads] + | fault => simp [runBoundary, boundaryStep, status, Run.reads] + | halted value => + simp only [runBoundary, boundaryStep, status, Run.reads, List.filterMap_cons, Transition.read?] + exact ih (executeBoundary b s) + +end RMQ.SuccinctFinal.PackedLifecycle.Resources diff --git a/RMQ/Core/WordRAM/Lifecycle/Retained.lean b/RMQ/Core/WordRAM/Lifecycle/Retained.lean new file mode 100644 index 00000000..154cedad --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/Retained.lean @@ -0,0 +1,101 @@ +import RMQ.Core.WordRAM.Lifecycle.QuerySafetyBridge +import RMQ.Core.WordRAM.Lifecycle.BoundarySafety + +/-! # Canonical retained data after construction + +This is a data invariant on the actual lifecycle state. The projection preserves +every numeric register, the current program counter, and every status; no query +answer or execution certificate is included. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle.Retained + +def projectStatus : PackedConstruction.Status → PackedWordRAM.Status + | .running => .running + | .halted value => .halted value + | .fault => .fault + +def projectQueryState (s : State) : PackedWordRAM.State := + ⟨s.core.regs, s.core.pc, projectStatus s.core.status⟩ + +def Data (memory : PackedWordRAM.Memory) (s : State) : Prop := + s.core.memory = (fun a => memory[a]?) ∧ s.core.extent = memory.length ∧ + s.core.keys = (fun _ => none) ∧ s.core.keyRegs = (fun _ => 0) ∧ + s.keyExtent = 0 ∧ s.keyRegExtent = 0 + +def FiniteBank (s : State) : Prop := ∀ r, 8273 ≤ r → s.core.regs r = 0 + +def Canonical (xs : List Int) (s : State) : Prop := + Data (PackedWordRAM.buildMemory xs) s ∧ FiniteBank s ∧ + s.Fits (PackedWordRAM.wordWidth xs.length) + +theorem projectStatus_roundtrip (status : PackedConstruction.Status) : + PackedConstruction.Conservative.status (projectStatus status) = status := by + cases status <;> rfl + +theorem project_embedded (memory : PackedWordRAM.Memory) (s : PackedWordRAM.State) : + projectQueryState (QuerySafetyBridge.embedded memory s) = s := by + cases s with + | mk regs pc status => cases status <;> rfl + +theorem Data.roundtrip {memory : PackedWordRAM.Memory} {s : State} (data : Data memory s) : + s = QuerySafetyBridge.embedded memory (projectQueryState s) := by + cases s with + | mk core keys keyRegs => + cases core with + | mk regs backing extent keyValues keyRegisters pc status => + rcases data with ⟨hm, he, hk, hkr, hke, hkre⟩ + simp only at hm he hk hkr hke hkre + subst backing; subst extent; subst keyValues; subst keyRegisters; subst keys; subst keyRegs + cases status <;> rfl + +theorem Data.closed {memory : PackedWordRAM.Memory} {s : State} (data : Data memory s) : + s.Closed := by + rw [data.roundtrip] + exact (QuerySafetyBridge.embedded_closed memory _).1 + +theorem project_fits {s : State} {W : Nat} (fit : s.Fits W) : + (projectQueryState s).Fits W := by + refine ⟨fit.1.2.1, fit.1.1, ?_⟩ + intro value h + apply fit.1.2.2.2.2 value + cases hs : s.core.status <;> simp_all [projectQueryState, projectStatus] + +theorem Canonical.closed {xs : List Int} {s : State} (canonical : Canonical xs s) : + s.Closed := canonical.1.closed + +theorem Data.boundary (memory : PackedWordRAM.Memory) (s : State) (b : Boundary) + (data : Data memory s) : Data memory (executeBoundary b s) := by + cases b <;> exact data + +theorem Canonical.boundary {xs : List Int} {s : State} {b : Boundary} + {len entry : Nat} (canonical : Canonical xs s) + (safe : b.Safe (PackedWordRAM.wordWidth xs.length) len 8273 entry) : + Canonical xs (executeBoundary b s) := + ⟨canonical.1.boundary _ _ _, boundary_execute_tail safe canonical.2.1, + boundary_execute_fits canonical.2.2 safe⟩ + +theorem Data.runBoundary (memory : PackedWordRAM.Memory) (s : State) (bs : List Boundary) + (data : Data memory s) : Data memory (runBoundary bs s).final := by + induction bs generalizing s with + | nil => exact data + | cons b bs ih => + cases hs : boundaryStep b s with + | none => simpa [PackedLifecycle.runBoundary, hs] using data + | some t => + have eq : t.after = executeBoundary b s := by + cases hstatus : s.core.status <;> simp [boundaryStep, hstatus] at hs + exact (congrArg Transition.after hs).symm + simpa [PackedLifecycle.runBoundary, hs, eq] using ih (executeBoundary b s) (data.boundary _ _ _) + +theorem Canonical.requestProtocol {xs : List Int} {s : State} + (canonical : Canonical xs s) (entry : PackedConstruction.Operand) (left right len : Nat) + (hl : left < 2 ^ PackedWordRAM.wordWidth xs.length) + (hr : right < 2 ^ PackedWordRAM.wordWidth xs.length) + (he : entry.val < len) (hw : entry.val < 2 ^ PackedWordRAM.wordWidth xs.length) : + Canonical xs (requestProtocol entry left right s).final := by + have safe := requestProtocol_safe entry left right s hl hr he hw (by decide) + canonical.2.2 canonical.closed canonical.2.1 + exact ⟨canonical.1.runBoundary _ _ _, safe.2.2.1, safe.1⟩ + +end RMQ.SuccinctFinal.PackedLifecycle.Retained diff --git a/RMQ/Core/WordRAM/Lifecycle/Retirement.lean b/RMQ/Core/WordRAM/Lifecycle/Retirement.lean new file mode 100644 index 00000000..08495761 --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/Retirement.lean @@ -0,0 +1,450 @@ +import RMQ.Core.WordRAM.Lifecycle.Safety + +/-! # Charged retirement of comparison resources + +This hosted fragment retires the separate input-key bank one cell at a time, +then retires its two key registers. Numeric allocation and request/metadata +registers survive unchanged. The word route already owns no comparison bank. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle.Retirement + +open PackedConstruction (Operand Prim execPrim put Arithmetic) +set_option linter.unusedSimpArgs false +set_option linter.unnecessarySimpa false + +@[simp] theorem operand_six : (6 : Operand).val = 6 := rfl +@[simp] theorem operand_seven : (7 : Operand).val = 7 := rfl +@[simp] theorem operand_metadata : (302 : Operand).val = 302 := rfl + +def code (base : Nat) (bound : base+8 < 2^32) : List Instruction := [ + .old (.move 6 302), + .old (.constant 7 1), + .old (.branchZero 6 ⟨base+6, by omega⟩), + .releaseKey, + .old (.arithmetic .sub 6 6 7), + .old (.jump ⟨base+2, by omega⟩), + .releaseKeyRegister, + .releaseKeyRegister] + +def Hosted (program : List Instruction) (base : Nat) (bound : base+8 < 2^32) : Prop := + ∀ i, i < 8 → program[base+i]? = (code base bound)[i]? + +def Entry (base n : Nat) (s : State) : Prop := + s.core.status = .running ∧ s.core.pc = base ∧ + s.keyExtent = n ∧ s.keyRegExtent = 2 ∧ s.core.regs 302 = n ∧ s.Closed + +def LoopInv (base left : Nat) (s : State) : Prop := + s.core.status = .running ∧ s.core.pc = base+2 ∧ + s.keyExtent = left ∧ s.keyRegExtent = 2 ∧ s.core.regs 6 = left ∧ s.core.regs 7 = 1 + +def cost (n : Nat) : Nat := 4*n+5 + +def Good (W : Nat) (program : List Instruction) (r : Run) : Prop := + ∀ t ∈ r.transitions, t.Safe W program.length + +def UsesCode (base : Nat) (bound : base+8 < 2^32) (r : Run) : Prop := + ∀ t ∈ r.transitions, ∃ i ∈ code base bound, t.action = .instruction i + +def cycleCategories : List Category := + [.old .branch, .keyRelease, .old .arithmetic, .old .branch] + +def categories (n : Nat) : List Category := + [.old .register, .old .register] ++ + (List.replicate n cycleCategories).flatten ++ + [.old .branch, .keyRegisterRelease, .keyRegisterRelease] + +section HostedExecution + +variable {program : List Instruction} {base : Nat} {bound : base+8 < 2^32} +variable (host : Hosted program base bound) +include host + +theorem fetch_zero : program[base]? = some (.old (.move 6 302)) := by + simpa [code] using host 0 (by decide) + +theorem setup {s : State} {n : Nat} (entry : Entry base n s) : + LoopInv base n (run program 2 s).final ∧ + (run program 2 s).transitions.length = 2 ∧ + (run program 2 s).categories = [.old .register, .old .register] ∧ + UsesCode base bound (run program 2 s) := by + obtain ⟨hr, hpc, hk, hkr, hn, _⟩ := entry + have get : ∀ j, j < 8 → program[base+j]? = (code base bound)[j]? := host + simp [run, step, fetch_zero host, get, code, execute, execPrim, hr, hpc, hk, hkr, hn, + PackedConstruction.State.writeNext, PackedConstruction.State.next, put, LoopInv, + Run.categories, Action.category, Prim.category, UsesCode, Nat.add_assoc] + +theorem loop_step {s : State} {left : Nat} (hl : 0 < left) (inv : LoopInv base left s) : + LoopInv base (left-1) (run program 4 s).final ∧ + (run program 4 s).transitions.length = 4 ∧ + (run program 4 s).categories = cycleCategories ∧ + UsesCode base bound (run program 4 s) := by + obtain ⟨hr, hpc, hk, hkr, h6, h7⟩ := inv + have hz : left ≠ 0 := by omega + have get : ∀ j, j < 8 → program[base+j]? = (code base bound)[j]? := host + simp [run, step, get, code, execute, execPrim, hr, hpc, hk, hkr, h6, h7, hz, + PackedConstruction.State.writeNext, PackedConstruction.State.next, put, Arithmetic.eval, + LoopInv, Run.categories, Action.category, Prim.category, cycleCategories, UsesCode, + Nat.add_assoc] + +theorem finish {s : State} (inv : LoopInv base 0 s) : + (run program 3 s).final.core.status = .running ∧ + (run program 3 s).final.core.pc = base+8 ∧ + (run program 3 s).final.keyExtent = 0 ∧ + (run program 3 s).final.keyRegExtent = 0 ∧ + (run program 3 s).transitions.length = 3 ∧ + (run program 3 s).categories = [.old .branch, .keyRegisterRelease, .keyRegisterRelease] ∧ + UsesCode base bound (run program 3 s) := by + obtain ⟨hr, hpc, hk, hkr, h6, _⟩ := inv + have get : ∀ j, j < 8 → program[base+j]? = (code base bound)[j]? := host + simp [run, step, get, code, execute, execPrim, hr, hpc, hk, hkr, h6, + PackedConstruction.State.writeNext, PackedConstruction.State.next, put, + Run.categories, Action.category, Prim.category, UsesCode, Nat.add_assoc] + +theorem loop_prefix {s : State} {count left : Nat} + (hc : count ≤ left) (inv : LoopInv base left s) : + LoopInv base (left-count) (run program (4*count) s).final ∧ + (run program (4*count) s).transitions.length = 4*count ∧ + (run program (4*count) s).categories = (List.replicate count cycleCategories).flatten ∧ + UsesCode base bound (run program (4*count) s) := by + induction count generalizing left s with + | zero => exact ⟨by simpa [run] using inv, rfl, rfl, by simp [UsesCode, run]⟩ + | succ count ih => + have hl : 0 < left := by omega + obtain ⟨next, len, cats, used⟩ := loop_step host hl inv + obtain ⟨out, len', cats', used'⟩ := ih (by omega) next + rw [show 4*(count+1)=4+4*count by omega, run_add] + refine ⟨by simpa [Nat.sub_sub, Nat.add_comm] using out, by simp [len, len'], ?_, ?_⟩ + · simp only [Run.categories, List.map_append] at cats cats' ⊢ + rw [cats, cats'] + simp [List.replicate_succ, List.flatten_cons] + · exact fun t ht => (List.mem_append.mp ht).elim (used t) (used' t) + +theorem comparison_run {s : State} {n : Nat} (entry : Entry base n s) : + let actual := run program (cost n) s + actual.final.core.status = .running ∧ actual.final.core.pc = base+8 ∧ + actual.final.keyExtent = 0 ∧ actual.final.keyRegExtent = 0 ∧ + actual.transitions.length = cost n ∧ actual.categories = categories n ∧ + UsesCode base bound actual := by + obtain ⟨init, len0, cats0, uses0⟩ := setup host entry + obtain ⟨inv, len1, cats1, uses1⟩ := loop_prefix host (Nat.le_refl n) init + obtain ⟨hr, hpc, hk, hkr, len2, cats2, uses2⟩ := finish host (by simpa using inv) + rw [show cost n=2+(4*n+3) by simp [cost]; omega] + simp only [run_add] + refine ⟨hr, hpc, hk, hkr, ?_, ?_, ?_⟩ + · simp [List.length_append, len0, len1, len2] + · simp only [Run.categories, List.map_append] at cats0 cats1 cats2 ⊢ + rw [cats0, cats1, cats2] + simp [categories, List.append_assoc] + · intro t ht + rcases List.mem_append.mp ht with ht | ht + · exact uses0 t ht + · exact (List.mem_append.mp ht).elim (uses1 t) (uses2 t) + +theorem setup_good {s : State} {n W : Nat} (hw : 32 ≤ W) (entry : Entry base n s) : + Good W program (run program 2 s) := by + obtain ⟨hr, hpc, _, _, hn, _⟩ := entry + have get : ∀ j, j < 8 → program[base+j]? = (code base bound)[j]? := host + simp [Good, run, step, fetch_zero host, get, code, execute, execPrim, hr, hpc, hn, + PackedConstruction.State.writeNext, PackedConstruction.State.next, put, Transition.Safe, + Instruction.Safe, Prim.Safe, Prim.SafeAt, Prim.operandsFit_of_width _ hw, Nat.add_assoc] + +theorem loop_good {s : State} {left W : Nat} (hw : 32 ≤ W) + (cont : base+8 < program.length) (fit : s.Fits W) + (hl : 0 < left) (inv : LoopInv base left s) : Good W program (run program 4 s) := by + obtain ⟨hr, hpc, hk, hkr, h6, h7⟩ := inv + have hz : left ≠ 0 := by omega + have cap : left < 2^W := hk ▸ fit.2.1 + have hw32 : 2^32 ≤ 2^W := Nat.pow_le_pow_right (by decide) hw + have get : ∀ j, j < 8 → program[base+j]? = (code base bound)[j]? := host + simp [Good, run, step, get, code, execute, execPrim, hr, hpc, hk, hkr, h6, h7, hz, + PackedConstruction.State.writeNext, PackedConstruction.State.next, put, Arithmetic.eval, + Transition.Safe, Instruction.Safe, Prim.Safe, Prim.SafeAt, + Prim.operandsFit_of_width _ hw, Nat.add_assoc] + omega + +theorem finish_good {s : State} {W : Nat} (hw : 32 ≤ W) + (cont : base+8 < program.length) (inv : LoopInv base 0 s) : + Good W program (run program 3 s) := by + obtain ⟨hr, hpc, hk, hkr, h6, _⟩ := inv + have hw32 : 2^32 ≤ 2^W := Nat.pow_le_pow_right (by decide) hw + have get : ∀ j, j < 8 → program[base+j]? = (code base bound)[j]? := host + simp [Good, run, step, get, code, execute, execPrim, hr, hpc, hk, hkr, h6, + PackedConstruction.State.next, put, Transition.Safe, Instruction.Safe, + Prim.Safe, Prim.SafeAt, Prim.operandsFit_of_width _ hw, Nat.add_assoc] + omega + +theorem loop_prefix_good {s : State} {count left W : Nat} (hw : 32 ≤ W) + (cont : base+8 < program.length) (plen : program.length < 2^W) + (fit : s.Fits W) (hc : count ≤ left) (inv : LoopInv base left s) : + Good W program (run program (4*count) s) := by + induction count generalizing left s with + | zero => simp [Good, run] + | succ count ih => + have hl : 0 < left := by omega + have next := (loop_step host hl inv).1 + have hg := loop_good host hw cont fit hl inv + have nextFit := (run_fits fit plen hg).1 + have rest := ih nextFit (by omega) next + rw [show 4*(count+1)=4+4*count by omega, run_add] + exact fun t ht => (List.mem_append.mp ht).elim (hg t) (rest t) + +theorem comparison_safe {s : State} {n W : Nat} (hw : 32 ≤ W) + (cont : base+8 < program.length) (plen : program.length < 2^W) + (fit : s.Fits W) (entry : Entry base n s) : + Good W program (run program (cost n) s) ∧ + (run program (cost n) s).final.Fits W ∧ + ∀ t ∈ (run program (cost n) s).transitions, t.before.Fits W ∧ t.after.Fits W := by + have init := (setup host entry).1 + have hg0 := setup_good host hw entry + have hf0 := (run_fits fit plen hg0).1 + have inv := (loop_prefix host (Nat.le_refl n) init).1 + have hg1 := loop_prefix_good host hw cont plen hf0 (Nat.le_refl n) init + have hg2 := finish_good host hw cont (by simpa using inv) + have good : Good W program (run program (cost n) s) := by + rw [show cost n=2+(4*n+3) by simp [cost]; omega] + simp only [run_add] + intro t ht + rcases List.mem_append.mp ht with ht | ht + · exact hg0 t ht + · exact (List.mem_append.mp ht).elim (hg1 t) (hg2 t) + exact ⟨good, run_fits fit plen good⟩ + +theorem setup_loop_prefix {s : State} {n count : Nat} + (entry : Entry base n s) (hc : count ≤ n) : + LoopInv base (n-count) (run program (2+4*count) s).final ∧ + (run program (2+4*count) s).transitions.length = 2+4*count := by + obtain ⟨init, len0, _, _⟩ := setup host entry + obtain ⟨inv, len, _, _⟩ := loop_prefix host hc init + rw [run_add] + exact ⟨inv, by simp [len0, len]⟩ + +end HostedExecution + +def KeyReleaseReceipt (a : Nat) (t : Transition) : Prop := + t.action = .instruction .releaseKey ∧ t.before.keyExtent = a+1 ∧ + t.after.keyExtent = a ∧ t.after.core.keys a = none ∧ + (∀ other, other ≠ a → t.after.core.keys other = t.before.core.keys other) ∧ + t.after = execute .releaseKey t.before + +def KeyRegisterReleaseReceipt (r : Nat) (t : Transition) : Prop := + t.action = .instruction .releaseKeyRegister ∧ t.before.keyRegExtent = r+1 ∧ + t.after.keyRegExtent = r ∧ t.after.core.keyRegs r = 0 ∧ + (∀ other, other ≠ r → t.after.core.keyRegs other = t.before.core.keyRegs other) ∧ + t.after = execute .releaseKeyRegister t.before + +theorem run_prefix_at {program : List Instruction} {s : State} {a b c k : Nat} + {t : Transition} (ha : (run program a s).transitions.length = a) + (hk : (run program b (run program a s).final).transitions[k]? = some t) : + (run program (a+(b+c)) s).transitions[a+k]? = some t := by + simp only [run_add] + rw [List.getElem?_append_right (by omega), ha, Nat.add_sub_cancel_left] + have hlt := (List.getElem?_eq_some_iff.mp hk).1 + rw [List.getElem?_append_left hlt] + exact hk + +section ReleasePositions + +variable {program : List Instruction} {base : Nat} {bound : base+8 < 2^32} +variable (host : Hosted program base bound) +include host + +theorem loop_release {s : State} {left : Nat} (hl : 0 < left) + (inv : LoopInv base left s) : + ∃ t, (run program 4 s).transitions[1]? = some t ∧ KeyReleaseReceipt (left-1) t := by + obtain ⟨hr, hpc, hk, hkr, h6, h7⟩ := inv + have hz : left ≠ 0 := by omega + have hleft : left-1+1 = left := by omega + have get : ∀ j, j < 8 → program[base+j]? = (code base bound)[j]? := host + let before := execute (.old (.branchZero 6 ⟨base+6, by omega⟩)) s + refine ⟨⟨before, .instruction .releaseKey, execute .releaseKey before⟩, ?_, ?_⟩ + · simp [before, run, step, get, code, execute, execPrim, hr, hpc, hk, hkr, h6, h7, + hz, PackedConstruction.State.next, Nat.add_assoc] + · simp (config := {contextual := true}) [KeyReleaseReceipt, before, execute, execPrim, + hk, h6, hz, hleft, PackedConstruction.State.next, put] + +theorem finish_release {s : State} {j : Nat} (hj : j < 2) (inv : LoopInv base 0 s) : + ∃ t, (run program 3 s).transitions[1+j]? = some t ∧ KeyRegisterReleaseReceipt (1-j) t := by + obtain ⟨hr, hpc, hk, hkr, h6, _⟩ := inv + have get : ∀ k, k < 8 → program[base+k]? = (code base bound)[k]? := host + let before := execute (.old (.branchZero 6 ⟨base+6, by omega⟩)) s + have cases : j=0 ∨ j=1 := by omega + rcases cases with rfl | rfl + · refine ⟨⟨before, .instruction .releaseKeyRegister, + execute .releaseKeyRegister before⟩, ?_, ?_⟩ + · simp [before, run, step, get, code, execute, execPrim, hr, hpc, hk, hkr, h6, + PackedConstruction.State.next, Nat.add_assoc] + · simp (config := {contextual := true}) [KeyRegisterReleaseReceipt, before, execute, execPrim, hkr, h6, + PackedConstruction.State.next, put] + · let second := execute .releaseKeyRegister before + refine ⟨⟨second, .instruction .releaseKeyRegister, + execute .releaseKeyRegister second⟩, ?_, ?_⟩ + · simp [second, before, run, step, get, code, execute, execPrim, hr, hpc, hk, hkr, h6, + PackedConstruction.State.next, Nat.add_assoc] + · simp (config := {contextual := true}) [KeyRegisterReleaseReceipt, second, before, execute, execPrim, hkr, h6, + PackedConstruction.State.next, put] + +/-- Reverse extent order and trace position of every key-cell retirement. -/ +theorem key_release_at {s : State} {n k : Nat} (entry : Entry base n s) (hk : k < n) : + ∃ t, (run program (cost n) s).transitions[3+4*k]? = some t ∧ + t.before = (run program (3+4*k) s).final ∧ KeyReleaseReceipt (n-k-1) t := by + obtain ⟨inv, len⟩ := setup_loop_prefix host entry (by omega : k ≤ n) + obtain ⟨t, ht, receipt⟩ := loop_release host (by omega : 0 < n-k) inv + have full := run_prefix_at (c := cost n-((2+4*k)+4)) len ht + have hcost : (2+4*k)+(4+(cost n-((2+4*k)+4)))=cost n := by simp [cost]; omega + have hindex : (2+4*k)+1=3+4*k := by omega + rw [hcost, hindex] at full + exact ⟨t, full, (run_transition_at full).1, receipt⟩ + +/-- Exactly the final two positions retire key registers one and zero. -/ +theorem key_register_release_at {s : State} {n j : Nat} (entry : Entry base n s) + (hj : j < 2) : + ∃ t, (run program (cost n) s).transitions[4*n+3+j]? = some t ∧ + t.before = (run program (4*n+3+j) s).final ∧ KeyRegisterReleaseReceipt (1-j) t := by + obtain ⟨inv, len⟩ := setup_loop_prefix host entry (Nat.le_refl n) + obtain ⟨t, ht, receipt⟩ := finish_release host hj (by simpa using inv) + have full := run_prefix_at (c := 0) len ht + have hcost : (2+4*n)+(3+0)=cost n := by simp [cost]; omega + have hindex : (2+4*n)+(1+j)=4*n+3+j := by omega + rw [hcost, hindex] at full + exact ⟨t, full, (run_transition_at full).1, receipt⟩ + +end ReleasePositions + +@[simp] theorem code_length (base : Nat) (bound : base+8 < 2^32) : + (code base bound).length = 8 := rfl + +theorem code_fits {base W : Nat} {bound : base+8 < 2^32} (hw : 32 ≤ W) + {i : Instruction} (_hi : i ∈ code base bound) : i.Fits W := by + have hw32 : 2^32 ≤ 2^W := Nat.pow_le_pow_right (by decide) hw + cases i with + | old p => + intro word hword + obtain ⟨v, _, rfl⟩ := List.mem_map.mp hword + exact Nat.lt_of_lt_of_le v.isLt hw32 + | releaseCell => simp [Instruction.Fits, Instruction.encoding]; omega + | releaseKey => simp [Instruction.Fits, Instruction.encoding]; omega + | releaseKeyRegister => simp [Instruction.Fits, Instruction.encoding]; omega + +def Frame (before after : State) : Prop := + after.core.memory = before.core.memory ∧ after.core.extent = before.core.extent ∧ + (∀ r, r ≠ 6 → r ≠ 7 → after.core.regs r = before.core.regs r) + +theorem Frame.refl (s : State) : Frame s s := ⟨rfl, rfl, fun _ _ _ => rfl⟩ + +theorem Frame.trans {a b c : State} (h : Frame a b) (g : Frame b c) : Frame a c := + ⟨g.1.trans h.1, g.2.1.trans h.2.1, fun r h6 h7 => (g.2.2 r h6 h7).trans (h.2.2 r h6 h7)⟩ + +theorem Frame.descriptor {a b : State} (h : Frame a b) : + b.core.regs 300 = a.core.regs 300 ∧ b.core.regs 301 = a.core.regs 301 ∧ + b.core.regs 302 = a.core.regs 302 := + ⟨h.2.2 300 (by decide) (by decide), h.2.2 301 (by decide) (by decide), + h.2.2 302 (by decide) (by decide)⟩ + +theorem Frame.tail {a b : State} (h : Frame a b) {r : Nat} (hr : 400 ≤ r) : + b.core.regs r = a.core.regs r := h.2.2 r (by omega) (by omega) + +theorem instruction_frame {base : Nat} {bound : base+8 < 2^32} + {i : Instruction} (hi : i ∈ code base bound) (s : State) : Frame s (execute i s) := by + simp only [code, List.mem_cons, List.not_mem_nil, or_false] at hi + rcases hi with rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl + all_goals simp [Frame, execute, execPrim, PackedConstruction.State.writeNext, + PackedConstruction.State.next, put] <;> (try split) <;> (try intros) <;> simp_all + +theorem instruction_closed {base : Nat} {bound : base+8 < 2^32} + {i : Instruction} (hi : i ∈ code base bound) {s : State} (hc : s.Closed) : + (execute i s).Closed := by + simp only [code, List.mem_cons, List.not_mem_nil, or_false] at hi + rcases hi with rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl + · simpa [execute, execPrim, State.Closed, PackedConstruction.CleanTail, + PackedConstruction.State.writeNext, PackedConstruction.State.next] using hc + · simpa [execute, execPrim, State.Closed, PackedConstruction.CleanTail, + PackedConstruction.State.writeNext, PackedConstruction.State.next] using hc + · by_cases h : s.core.regs 6 = 0 + all_goals simpa [execute, execPrim, State.Closed, PackedConstruction.CleanTail, + h, PackedConstruction.State.next] using hc + · exact releaseKey_closed s hc + · simpa [execute, execPrim, State.Closed, PackedConstruction.CleanTail, + PackedConstruction.State.writeNext, PackedConstruction.State.next] using hc + · simpa [execute, execPrim, State.Closed, PackedConstruction.CleanTail] using hc + · exact releaseKeyRegister_closed s hc + · exact releaseKeyRegister_closed s hc + +theorem run_frame_closed {program : List Instruction} {base fuel : Nat} + {bound : base+8 < 2^32} {s : State} (hc : s.Closed) + (used : UsesCode base bound (run program fuel s)) : + Frame s (run program fuel s).final ∧ (run program fuel s).final.Closed := by + induction fuel generalizing s with + | zero => exact ⟨Frame.refl s, hc⟩ + | succ fuel ih => + cases hs : step program s with + | none => simpa [run, hs] using (show Frame s s ∧ s.Closed from ⟨Frame.refl s, hc⟩) + | some t => + obtain ⟨hb, _, i, _, hi, ha⟩ := step_spec hs + obtain ⟨j, hj, hjt⟩ := used t (by simp [run, hs]) + have heq : j = i := Action.instruction.inj (hjt.symm.trans hi) + subst j + have hf : Frame s t.after := ha ▸ instruction_frame hj s + have hclosed : t.after.Closed := ha ▸ instruction_closed hj hc + have rest := ih hclosed (fun u hu => used u (by simp [run, hs, hu])) + exact ⟨by simpa [run, hs] using hf.trans rest.1, by simpa [run, hs] using rest.2⟩ + +/-- The actual completed retirement keeps the numeric arena and its descriptor +registers, and clears both comparison resources in their logical extents. -/ +theorem comparison_retired {program : List Instruction} {base n : Nat} + {bound : base+8 < 2^32} (host : Hosted program base bound) + {s : State} (entry : Entry base n s) : + let actual := run program (cost n) s + RunsTo program s actual.final actual.transitions ∧ + actual.final.core.status = .running ∧ actual.final.core.pc = base+8 ∧ + actual.final.keyExtent = 0 ∧ actual.final.keyRegExtent = 0 ∧ + actual.final.core.keys = (fun _ => none) ∧ + actual.final.core.keyRegs = (fun _ => 0) ∧ + actual.final.Closed ∧ Frame s actual.final ∧ + actual.steps = cost n ∧ actual.categories = categories n := by + obtain ⟨hr, hpc, hk, hkr, len, cats, used⟩ := comparison_run host entry + obtain ⟨frame, closed⟩ := run_frame_closed entry.2.2.2.2.2 used + obtain ⟨keys, keyRegs⟩ := empty_keys_of_closed _ closed hk hkr + exact ⟨by simpa [RunsTo, Run.steps] using run_exact_steps program (cost n) s, + hr, hpc, hk, hkr, keys, keyRegs, closed, frame, len, cats⟩ + +theorem word_retired (program : List Instruction) (s : State) (closed : s.Closed) + (keys : s.keyExtent = 0) (keyRegs : s.keyRegExtent = 0) : + run program 0 s = ⟨s, []⟩ ∧ s.core.keys = (fun _ => none) ∧ + s.core.keyRegs = (fun _ => 0) := ⟨rfl, empty_keys_of_closed s closed keys keyRegs⟩ + +theorem category_counts (n : Nat) : + (categories n).count .keyRelease = n ∧ + (categories n).count .keyRegisterRelease = 2 ∧ + (categories n).count (.old .register) = 2 ∧ + (categories n).count (.old .arithmetic) = n ∧ + (categories n).count (.old .branch) = 2*n+1 := by + have cycleCount (m : Nat) : + ((List.replicate m cycleCategories).flatten).count .keyRelease = m ∧ + ((List.replicate m cycleCategories).flatten).count .keyRegisterRelease = 0 ∧ + ((List.replicate m cycleCategories).flatten).count (.old .register) = 0 ∧ + ((List.replicate m cycleCategories).flatten).count (.old .arithmetic) = m ∧ + ((List.replicate m cycleCategories).flatten).count (.old .branch) = 2*m := by + induction m with + | zero => simp + | succ m ih => + obtain ⟨hk, hkr, hr, ha, hb⟩ := ih + simp only [List.replicate_succ, List.flatten_cons, List.count_append, + hk, hkr, hr, ha, hb] + simp [cycleCategories] + omega + obtain ⟨hk, hkr, hr, ha, hb⟩ := cycleCount n + simp [categories, List.count_append, hk, hkr, hr, ha, hb] + +theorem comparison_category_counts {program : List Instruction} {base n : Nat} + {bound : base+8 < 2^32} (host : Hosted program base bound) + {s : State} (entry : Entry base n s) : + let actual := run program (cost n) s + actual.categoryCount .keyRelease = n ∧ actual.categoryCount .keyRegisterRelease = 2 ∧ + actual.categoryCount (.old .register) = 2 ∧ + actual.categoryCount (.old .arithmetic) = n ∧ + actual.categoryCount (.old .branch) = 2*n+1 := by + have cats := (comparison_run host entry).2.2.2.2.2.1 + simpa only [Run.categoryCount, cats] using category_counts n + +end RMQ.SuccinctFinal.PackedLifecycle.Retirement diff --git a/RMQ/Core/WordRAM/Lifecycle/Reusable.lean b/RMQ/Core/WordRAM/Lifecycle/Reusable.lean new file mode 100644 index 00000000..2d0de18d --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/Reusable.lean @@ -0,0 +1,432 @@ +import RMQ.Core.WordRAM.Lifecycle.Program +import RMQ.Core.WordRAM.Lifecycle.ServiceSafety +import RMQ.Core.WordRAM.Lifecycle.Resources + +/-! # Reusable charged queries on the same retained owner + +One request is admitted after a halted query. The four boundary events and +the following scalar service execution are both retained in the actual trace. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle.Reusable + +open PackedWordRAM.Optimization +open PackedWordRAM (buildMemory wordWidth) +set_option maxRecDepth 30000 + +def continuation (model : InputModel) : List Instruction := + (Layout.builderCode model ++ Descriptor.coreCode model).map oldInstruction ++ Layout.tail model + +theorem program_host (model : InputModel) : Layout.program model = + QuerySafetyBridge.host Service.program (continuation model) := Layout.service_split model + +def serviceRun (model : InputModel) (s : State) : Run := + run (Layout.program model) Service.budget s + +def queryRun (model : InputModel) (left right : Nat) (s : State) : Run := + let admission := requestProtocol Layout.serviceEntry left right s + let service := serviceRun model admission.final + ⟨service.final, admission.transitions ++ service.transitions⟩ + +def queryBudget : Nat := 160257 + +theorem serviceEntry_eq : Layout.serviceEntry.val = Service.entry := by + rw [Service.entry_eq] + rfl + +theorem program_fits (model : InputModel) (n : Nat) : + (Layout.program model).length < 2 ^ wordWidth n := + Nat.lt_of_lt_of_le (Layout.program_length_lt32 model) + (Nat.pow_le_pow_right (by decide) (PackedConstruction.Proof.wordWidth_ge_32 n)) + +theorem entry_inside (model : InputModel) : Layout.serviceEntry.val < (Layout.program model).length := by + rw [Layout.program_length] + cases model <;> decide + +theorem entered_after_admission (left right answer : Nat) (s : State) + (halted : s.core.status = .halted answer) : + ServiceSafety.Entered left right (requestProtocol Layout.serviceEntry left right s).final := by + rw [(requestProtocol_exact Layout.serviceEntry left right answer s halted).1] + exact ⟨rfl, serviceEntry_eq, by simp [PackedConstruction.put, requestLeftRegister, requestRightRegister], + by simp [PackedConstruction.put, requestRightRegister]⟩ + +theorem service_exact (model : InputModel) (xs : List Int) (left right : Nat) (s : State) + (canonical : Retained.Canonical xs s) (entered : ServiceSafety.Entered left right s) : + serviceRun model s = + ⟨QuerySafetyBridge.embedded (buildMemory xs) + (compactQueryRun (buildMemory xs) xs.length left right).final, + (PackedWordRAM.run (buildMemory xs) Service.program Service.budget + (Retained.projectQueryState s)).transitions.map + (QuerySafetyBridge.liftTransition (buildMemory xs))⟩ := by + have actual := ServiceSafety.actual_prefix xs (continuation model) left right Service.budget s + canonical entered (Nat.le_refl _) + have obs := Service.observations (buildMemory xs) xs.length left right (Retained.projectQueryState s) + (ServiceSafety.canonical_header xs) (ServiceSafety.entered_inputs xs left right s canonical entered) + rw [← program_host model] at actual + rw [obs.1] at actual + exact actual + +theorem service_canonical (model : InputModel) (xs : List Int) (left right : Nat) (s : State) + (canonical : Retained.Canonical xs s) (entered : ServiceSafety.Entered left right s) : + Retained.Canonical xs (serviceRun model s).final := by + have h := ServiceSafety.actual_prefix_canonical xs (continuation model) left right Service.budget s + canonical entered (Nat.le_refl _) + rwa [← program_host model] at h + +theorem service_steps (model : InputModel) (xs : List Int) (left right : Nat) (s : State) + (canonical : Retained.Canonical xs s) (entered : ServiceSafety.Entered left right s) : + (serviceRun model s).steps = 4 + QueryEntry.setupCost + + (compactQueryRun (buildMemory xs) xs.length left right).steps ∧ + (serviceRun model s).steps ≤ 160253 := by + have obs := Service.observations (buildMemory xs) xs.length left right (Retained.projectQueryState s) + (ServiceSafety.canonical_header xs) (ServiceSafety.entered_inputs xs left right s canonical entered) + rw [service_exact model xs left right s canonical entered] + simpa only [Run.steps, List.length_map, PackedWordRAM.Run.steps] using + (show (PackedWordRAM.run (buildMemory xs) Service.program Service.budget + (Retained.projectQueryState s)).steps = 4 + QueryEntry.setupCost + + (compactQueryRun (buildMemory xs) xs.length left right).steps ∧ + (PackedWordRAM.run (buildMemory xs) Service.program Service.budget + (Retained.projectQueryState s)).steps ≤ 160253 from ⟨obs.2.2.2.1, obs.2.2.2.2.1⟩) + +theorem service_halts (model : InputModel) (xs : List Int) (left right : Nat) (s : State) + (canonical : Retained.Canonical xs s) (entered : ServiceSafety.Entered left right s) : + (serviceRun model s).final.core.status = .halted + (PackedWordRAM.optionNatPacket (SuccinctClassic.queryTraceResult xs left right).value) := by + rw [service_exact model xs left right s canonical entered] + change PackedConstruction.Conservative.status + (compactQueryRun (buildMemory xs) xs.length left right).final.status = _ + rw [compactQueryRun_halts] + rfl + +theorem service_reads (model : InputModel) (xs : List Int) (left right : Nat) (s : State) + (canonical : Retained.Canonical xs s) (entered : ServiceSafety.Entered left right s) : + (serviceRun model s).reads = (0, some xs.length) :: + (compactQueryRun (buildMemory xs) xs.length left right).reads.map (fun r => (r.address, r.reply)) := by + have h := ServiceSafety.actual_prefix_reads xs (continuation model) left right Service.budget s + canonical entered (Nat.le_refl _) + rw [← program_host model] at h + rw [serviceRun, h] + have obs := Service.observations (buildMemory xs) xs.length left right (Retained.projectQueryState s) + (ServiceSafety.canonical_header xs) (ServiceSafety.entered_inputs xs left right s canonical entered) + rw [obs.2.2.1] + rfl + +theorem query_correct (model : InputModel) (xs : List Int) (left right answer : Nat) (s : State) + (canonical : Retained.Canonical xs s) (halted : s.core.status = .halted answer) + (hl : left < 2 ^ wordWidth xs.length) (hr : right < 2 ^ wordWidth xs.length) : + Retained.Canonical xs (queryRun model left right s).final ∧ + (queryRun model left right s).final.core.status = .halted + (PackedWordRAM.optionNatPacket (SuccinctClassic.queryTraceResult xs left right).value) ∧ + (queryRun model left right s).final.core.memory = s.core.memory ∧ + (queryRun model left right s).final.core.extent = s.core.extent ∧ + (queryRun model left right s).steps = 4 + 4 + QueryEntry.setupCost + + (compactQueryRun (buildMemory xs) xs.length left right).steps ∧ + (queryRun model left right s).steps ≤ queryBudget := by + let admitted := (requestProtocol Layout.serviceEntry left right s).final + have width : Layout.serviceEntry.val < 2 ^ wordWidth xs.length := + Nat.lt_trans (entry_inside model) (program_fits model xs.length) + have hc : Retained.Canonical xs admitted := canonical.requestProtocol Layout.serviceEntry + left right (Layout.program model).length hl hr (entry_inside model) width + have he : ServiceSafety.Entered left right admitted := entered_after_admission left right answer s halted + have out := service_canonical model xs left right admitted hc he + have stop := service_halts model xs left right admitted hc he + have cost := service_steps model xs left right admitted hc he + have admissionCost := (requestProtocol_exact Layout.serviceEntry left right answer s halted).2.1 + refine ⟨out, stop, out.1.1.trans canonical.1.1.symm, out.1.2.1.trans canonical.1.2.1.symm, ?_, ?_⟩ + · change ((requestProtocol Layout.serviceEntry left right s).transitions ++ + (serviceRun model admitted).transitions).length = _ + rw [List.length_append] + change (requestProtocol Layout.serviceEntry left right s).steps + + (serviceRun model admitted).steps = _ + rw [admissionCost, cost.1] + omega + · change ((requestProtocol Layout.serviceEntry left right s).transitions ++ + (serviceRun model admitted).transitions).length ≤ _ + rw [List.length_append] + change (requestProtocol Layout.serviceEntry left right s).steps + + (serviceRun model admitted).steps ≤ 160257 + rw [admissionCost] + omega + +theorem service_transition_canonical (model : InputModel) (xs : List Int) + (left right : Nat) (s : State) (canonical : Retained.Canonical xs s) + (entered : ServiceSafety.Entered left right s) : + ∀ t ∈ (serviceRun model s).transitions, + Retained.Canonical xs t.before ∧ Retained.Canonical xs t.after := by + intro t member + obtain ⟨index, occurs⟩ := List.mem_iff_getElem?.mp member + have within : index < Service.budget := Nat.lt_of_lt_of_le + (List.getElem?_eq_some_iff.mp occurs).1 + (Resources.run_steps_le_fuel (Layout.program model) Service.budget s) + have before := (run_transition_at occurs).1 + have after := Resources.run_transition_after occurs + have prefixCanonical (fuel : Nat) (bound : fuel ≤ Service.budget) : + Retained.Canonical xs (run (Layout.program model) fuel s).final := by + rw [program_host] + exact ServiceSafety.actual_prefix_canonical xs (continuation model) left right fuel s + canonical entered bound + exact ⟨before ▸ prefixCanonical index (by omega), after ▸ prefixCanonical (index + 1) (by omega)⟩ + +theorem admission_transition_canonical (model : InputModel) (xs : List Int) + (left right : Nat) (s : State) (canonical : Retained.Canonical xs s) + (hl : left < 2 ^ wordWidth xs.length) (hr : right < 2 ^ wordWidth xs.length) : + ∀ t ∈ (requestProtocol Layout.serviceEntry left right s).transitions, + Retained.Canonical xs t.before ∧ Retained.Canonical xs t.after := by + apply (Resources.runBoundary_preserves (Retained.Canonical xs) + [.left left, .right right, .entry Layout.serviceEntry, .activate] s canonical ?_).2 + intro b member t ht + apply ht.boundary (len := (Layout.program model).length) (entry := Layout.serviceEntry.val) + simp only [List.mem_cons, List.not_mem_nil, or_false] at member + rcases member with rfl | rfl | rfl | rfl + · exact ⟨by decide, hl⟩ + · exact ⟨by decide, hr⟩ + · exact ⟨rfl, entry_inside model, Nat.lt_trans (entry_inside model) (program_fits model xs.length)⟩ + · trivial + +/-- Every event belongs to the actual charged admission or actual service run. -/ +theorem query_action_safe (model : InputModel) (xs : List Int) + (left right answer : Nat) (s : State) (canonical : Retained.Canonical xs s) + (halted : s.core.status = .halted answer) + (hl : left < 2 ^ wordWidth xs.length) (hr : right < 2 ^ wordWidth xs.length) : + ∀ t ∈ (queryRun model left right s).transitions, + t.ActionSafe (wordWidth xs.length) (Layout.program model).length 8273 + Layout.serviceEntry.val := by + have width := Nat.lt_trans (entry_inside model) (program_fits model xs.length) + have admission := requestProtocol_safe Layout.serviceEntry left right s hl hr + (entry_inside model) width (by decide : 301 < 8273) canonical.2.2 canonical.closed canonical.2.1 + have hc := canonical.requestProtocol Layout.serviceEntry left right (Layout.program model).length + hl hr (entry_inside model) width + have he := entered_after_admission left right answer s halted + have service := ServiceSafety.actual_prefix_safe xs (continuation model) left right Service.budget + (requestProtocol Layout.serviceEntry left right s).final hc he (Nat.le_refl _) + rw [← program_host model] at service + intro t member + change t ∈ (requestProtocol Layout.serviceEntry left right s).transitions ++ + (serviceRun model (requestProtocol Layout.serviceEntry left right s).final).transitions at member + rcases List.mem_append.mp member with member | member + · exact (admission.2.2.2 t member).1 + · exact instruction_action_safe (service t member) + +/-- Full state invariants cover both sides of every recorded query event. -/ +theorem query_transition_canonical (model : InputModel) (xs : List Int) + (left right answer : Nat) (s : State) (canonical : Retained.Canonical xs s) + (halted : s.core.status = .halted answer) + (hl : left < 2 ^ wordWidth xs.length) (hr : right < 2 ^ wordWidth xs.length) : + ∀ t ∈ (queryRun model left right s).transitions, + Retained.Canonical xs t.before ∧ Retained.Canonical xs t.after := by + have width := Nat.lt_trans (entry_inside model) (program_fits model xs.length) + have hc := canonical.requestProtocol Layout.serviceEntry left right (Layout.program model).length + hl hr (entry_inside model) width + have he := entered_after_admission left right answer s halted + intro t member + change t ∈ (requestProtocol Layout.serviceEntry left right s).transitions ++ + (serviceRun model (requestProtocol Layout.serviceEntry left right s).final).transitions at member + rcases List.mem_append.mp member with member | member + · exact admission_transition_canonical model xs left right s canonical hl hr t member + · exact service_transition_canonical model xs left right _ hc he t member + +theorem query_transition_fits (model : InputModel) (xs : List Int) + (left right answer : Nat) (s : State) (canonical : Retained.Canonical xs s) + (halted : s.core.status = .halted answer) + (hl : left < 2 ^ wordWidth xs.length) (hr : right < 2 ^ wordWidth xs.length) : + ∀ t ∈ (queryRun model left right s).transitions, + t.before.Fits (wordWidth xs.length) ∧ t.after.Fits (wordWidth xs.length) := by + intro t member + have states := query_transition_canonical model xs left right answer s canonical halted hl hr t member + exact ⟨states.1.2.2, states.2.2.2⟩ + +def ResourceFrame (s t : State) : Prop := + t.core.memory = s.core.memory ∧ t.core.extent = s.core.extent ∧ + t.core.keys = s.core.keys ∧ t.core.keyRegs = s.core.keyRegs ∧ + t.keyExtent = s.keyExtent ∧ t.keyRegExtent = s.keyRegExtent ∧ + ∀ r, 8273 ≤ r → t.core.regs r = s.core.regs r + +theorem canonical_frame {xs : List Int} {s t : State} + (hs : Retained.Canonical xs s) (ht : Retained.Canonical xs t) : ResourceFrame s t := by + rcases hs.1 with ⟨sm, se, sk, skr, ske, skre⟩ + rcases ht.1 with ⟨tm, te, tk, tkr, tke, tkre⟩ + exact ⟨tm.trans sm.symm, te.trans se.symm, tk.trans sk.symm, tkr.trans skr.symm, + tke.trans ske.symm, tkre.trans skre.symm, fun r hr => (ht.2.1 r hr).trans (hs.2.1 r hr).symm⟩ + +theorem query_resources (model : InputModel) (xs : List Int) + (left right answer : Nat) (s : State) (canonical : Retained.Canonical xs s) + (halted : s.core.status = .halted answer) + (hl : left < 2 ^ wordWidth xs.length) (hr : right < 2 ^ wordWidth xs.length) : + ResourceFrame s (queryRun model left right s).final ∧ + ∀ t ∈ (queryRun model left right s).transitions, + ResourceFrame s t.before ∧ ResourceFrame s t.after := by + refine ⟨canonical_frame canonical (query_correct model xs left right answer s canonical halted hl hr).1, ?_⟩ + intro t member + have states := query_transition_canonical model xs left right answer s canonical halted hl hr t member + exact ⟨canonical_frame canonical states.1, canonical_frame canonical states.2⟩ + +/-- The header read precedes every compact-query read, including on rejection. -/ +theorem query_reads (model : InputModel) (xs : List Int) + (left right answer : Nat) (s : State) (canonical : Retained.Canonical xs s) + (halted : s.core.status = .halted answer) + (hl : left < 2 ^ wordWidth xs.length) (hr : right < 2 ^ wordWidth xs.length) : + (queryRun model left right s).reads = (0, some xs.length) :: + (compactQueryRun (buildMemory xs) xs.length left right).reads.map (fun r => (r.address, r.reply)) := by + have width := Nat.lt_trans (entry_inside model) (program_fits model xs.length) + have hc := canonical.requestProtocol Layout.serviceEntry left right (Layout.program model).length + hl hr (entry_inside model) width + have he := entered_after_admission left right answer s halted + change ((requestProtocol Layout.serviceEntry left right s).transitions ++ + (serviceRun model (requestProtocol Layout.serviceEntry left right s).final).transitions).filterMap _ = _ + rw [List.filterMap_append] + change (runBoundary _ s).reads ++ (serviceRun model _).reads = _ + rw [Resources.runBoundary_reads, List.nil_append, service_reads model xs left right _ hc he] + +theorem query_ordered_reads (model : InputModel) (xs : List Int) + (left right answer : Nat) (s : State) (canonical : Retained.Canonical xs s) + (halted : s.core.status = .halted answer) + (hl : left < 2 ^ wordWidth xs.length) (hr : right < 2 ^ wordWidth xs.length) : + (queryRun model left right s).reads = (0, some xs.length) :: + (if ValidRange xs left right then + (List.range 174).map (fun i => (i, (PackedWordRAM.metadata (SuccinctClassic.cartesianShape xs))[i]?)) ++ + (PackedWordRAM.logicalTraceReads (SuccinctClassic.cartesianShape xs) (buildMemory xs) + (SuccinctClassic.queryTraceResult xs left right).trace).map (fun r => (r.address, r.reply)) + else []) := by + rw [query_reads model xs left right answer s canonical halted hl hr, + (compactQueryRun_original_observations (buildMemory xs) xs.length left right).2, + PackedWordRAM.queryRun_reference_reads] + split <;> simp [List.map_append, List.map_map] + +theorem query_reads_successful (model : InputModel) (xs : List Int) + (left right answer : Nat) (s : State) (canonical : Retained.Canonical xs s) + (halted : s.core.status = .halted answer) + (hl : left < 2 ^ wordWidth xs.length) (hr : right < 2 ^ wordWidth xs.length) + (address : Nat) (reply : Option Nat) + (member : (address, reply) ∈ (queryRun model left right s).reads) : + ∃ value, reply = some value := by + rw [query_reads model xs left right answer s canonical halted hl hr] at member + rcases List.mem_cons.mp member with first | rest + · have eq := congrArg Prod.snd first + exact ⟨xs.length, eq⟩ + · obtain ⟨receipt, member, eq⟩ := List.mem_map.mp rest + rw [(compactQueryRun_original_observations (buildMemory xs) xs.length left right).2] at member + obtain ⟨value, valueEq⟩ := PackedWordRAM.queryRun_reads_reply xs left right receipt member + exact ⟨value, (congrArg Prod.snd eq).symm.trans valueEq⟩ + +/-- An observed read has its actual service position after four boundary events. -/ +theorem query_read_occurrence (model : InputModel) (xs : List Int) + (left right answer : Nat) (s : State) (canonical : Retained.Canonical xs s) + (halted : s.core.status = .halted answer) + (hl : left < 2 ^ wordWidth xs.length) (hr : right < 2 ^ wordWidth xs.length) + (index : Nat) (t : Transition) (address : Nat) (reply : Option Nat) + (occurs : (queryRun model left right s).transitions[index]? = some t) + (read : t.read? = some (address, reply)) : + 4 ≤ index ∧ + (serviceRun model (requestProtocol Layout.serviceEntry left right s).final).transitions[index - 4]? = some t ∧ + t.before = (run (Layout.program model) (index - 4) + (requestProtocol Layout.serviceEntry left right s).final).final ∧ + step (Layout.program model) t.before = some t ∧ + address < 2 ^ wordWidth xs.length ∧ reply = (buildMemory xs)[address]? ∧ + ∃ value, reply = some value ∧ value < 2 ^ wordWidth xs.length := by + have admissionLength := (requestProtocol_exact Layout.serviceEntry left right answer s halted).2.1 + change (requestProtocol Layout.serviceEntry left right s).transitions.length = 4 at admissionLength + have original := occurs + change ((requestProtocol Layout.serviceEntry left right s).transitions ++ + (serviceRun model (requestProtocol Layout.serviceEntry left right s).final).transitions)[index]? = some t at occurs + have afterAdmission : (requestProtocol Layout.serviceEntry left right s).transitions.length ≤ index := by + by_cases small : (requestProtocol Layout.serviceEntry left right s).transitions.length ≤ index + · exact small + exfalso + have early : index < (requestProtocol Layout.serviceEntry left right s).transitions.length := by omega + rw [List.getElem?_append_left early] at occurs + have impossible : (address, reply) ∈ (requestProtocol Layout.serviceEntry left right s).reads := + List.mem_filterMap.mpr ⟨t, List.mem_iff_getElem?.mpr ⟨index, occurs⟩, read⟩ + rw [requestProtocol, Resources.runBoundary_reads] at impossible + cases impossible + rw [List.getElem?_append_right afterAdmission, admissionLength] at occurs + have actual := run_transition_at occurs + have width := Nat.lt_trans (entry_inside model) (program_fits model xs.length) + have hc := canonical.requestProtocol Layout.serviceEntry left right (Layout.program model).length + hl hr (entry_inside model) width + have he := entered_after_admission left right answer s halted + have hostedOccurs : (run (QuerySafetyBridge.host Service.program (continuation model)) + Service.budget (requestProtocol Layout.serviceEntry left right s).final).transitions[index - 4]? = some t := by + rwa [← program_host model] + have backing := ServiceSafety.actual_read_width xs (continuation model) left right _ hc he + (index - 4) t address reply hostedOccurs read + obtain ⟨value, valueEq⟩ := query_reads_successful model xs left right answer s canonical halted hl hr + address reply (List.mem_filterMap.mpr ⟨t, List.mem_iff_getElem?.mpr ⟨index, original⟩, read⟩) + exact ⟨by omega, occurs, actual.1, actual.2, backing.1, backing.2.1, + value, valueEq, backing.2.2 value valueEq⟩ + +theorem query_valid (model : InputModel) (xs : List Int) + (left right answer : Nat) (s : State) (canonical : Retained.Canonical xs s) + (halted : s.core.status = .halted answer) + (hl : left < 2 ^ wordWidth xs.length) (hr : right < 2 ^ wordWidth xs.length) + (valid : ValidRange xs left right) : + (queryRun model left right s).final.core.status = .halted (scanWindow xs left (right - left) + 1) ∧ + LeftmostArgMin xs left right (scanWindow xs left (right - left)) := by + have result := (query_correct model xs left right answer s canonical halted hl hr).2.1 + have packet := Option.some.inj ((compactQueryRun_result xs left right).symm.trans + (compactQueryRun_scanWindow xs left right valid)) + rw [packet] at result + exact ⟨result, compactQueryNat_leftmost xs left right _ + (by rw [compactQueryNat_exact, if_pos valid])⟩ + +theorem query_invalid (model : InputModel) (xs : List Int) + (left right answer : Nat) (s : State) (canonical : Retained.Canonical xs s) + (halted : s.core.status = .halted answer) + (hl : left < 2 ^ wordWidth xs.length) (hr : right < 2 ^ wordWidth xs.length) + (invalid : ¬ ValidRange xs left right) : + (queryRun model left right s).final.core.status = .halted 0 ∧ + (queryRun model left right s).reads = [(0, some xs.length)] := by + have result := (query_correct model xs left right answer s canonical halted hl hr).2.1 + have guard := compactQueryRun_invalid (buildMemory xs) xs.length left right invalid + have packet := Option.some.inj ((compactQueryRun_result xs left right).symm.trans guard.1) + rw [packet] at result + refine ⟨result, ?_⟩ + rw [query_reads model xs left right answer s canonical halted hl hr, guard.2] + rfl + +theorem query_leftmost (model : InputModel) (xs : List Int) + (left right answer index : Nat) (s : State) (canonical : Retained.Canonical xs s) + (halted : s.core.status = .halted answer) + (hl : left < 2 ^ wordWidth xs.length) (hr : right < 2 ^ wordWidth xs.length) + (observed : (queryRun model left right s).final.core.status = .halted (index + 1)) : + LeftmostArgMin xs left right index := by + by_cases valid : ValidRange xs left right + · have result := query_valid model xs left right answer s canonical halted hl hr valid + have eq := PackedConstruction.Status.halted.inj (observed.symm.trans result.1) + have index_eq : index = scanWindow xs left (right - left) := by omega + exact index_eq ▸ result.2 + · have result := (query_invalid model xs left right answer s canonical halted hl hr valid).1 + have impossible := PackedConstruction.Status.halted.inj (observed.symm.trans result) + omega + +/-- This bounds every construction prefix, hence also the completed full trace. +It remains true after the first service because no instruction grows either bank. -/ +theorem construction_key_peak (model : InputModel) (xs : List Int) + (left right fuel : Nat) : + (run (Layout.program model) fuel (initialState model xs left right Layout.builderBase)).final.keyExtent ≤ + (if model = .comparison then xs.length else 0) ∧ + (run (Layout.program model) fuel (initialState model xs left right Layout.builderBase)).final.keyRegExtent ≤ + (if model = .comparison then 2 else 0) := + (Resources.run_key_extents (Layout.program model) fuel + (initialState model xs left right Layout.builderBase)).1 + +theorem construction_transition_key_peak (model : InputModel) (xs : List Int) + (left right fuel : Nat) : + ∀ t ∈ (run (Layout.program model) fuel (initialState model xs left right Layout.builderBase)).transitions, + (t.before.keyExtent ≤ (if model = .comparison then xs.length else 0) ∧ + t.before.keyRegExtent ≤ (if model = .comparison then 2 else 0)) ∧ + (t.after.keyExtent ≤ (if model = .comparison then xs.length else 0) ∧ + t.after.keyRegExtent ≤ (if model = .comparison then 2 else 0)) := + (Resources.run_key_extents (Layout.program model) fuel + (initialState model xs left right Layout.builderBase)).2 + +theorem construction_numeric_closed (model : InputModel) (xs : List Int) + (left right fuel : Nat) : + PackedConstruction.CleanTail + (run (Layout.program model) fuel (initialState model xs left right Layout.builderBase)).final.core ∧ + ∀ t ∈ (run (Layout.program model) fuel (initialState model xs left right Layout.builderBase)).transitions, + PackedConstruction.CleanTail t.before.core ∧ PackedConstruction.CleanTail t.after.core := + Resources.run_numeric_closed (Layout.program model) fuel + (initialState model xs left right Layout.builderBase) + (initial_clean model xs left right Layout.builderBase).1 + +end RMQ.SuccinctFinal.PackedLifecycle.Reusable diff --git a/RMQ/Core/WordRAM/Lifecycle/Safety.lean b/RMQ/Core/WordRAM/Lifecycle/Safety.lean new file mode 100644 index 00000000..38b82010 --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/Safety.lean @@ -0,0 +1,129 @@ +import RMQ.Core.WordRAM.Lifecycle.Calculus + +/-! # Width and scalar retirement laws + +Key values remain in the comparison model. Numeric words, program control and +owned extents use the same declared width throughout each execution segment. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle + +theorem execute_safe_fits {W len : Nat} {s : State} {i : Instruction} + (hf : s.Fits W) (hs : i.Safe W len s) (hpc : s.core.pc < len) + (hlen : len < 2 ^ W) : (execute i s).Fits W := by + obtain ⟨hc, hk, hkr⟩ := hf + cases i with + | old p => exact ⟨PackedConstruction.Prim.safe_fits hc hs hpc hlen, hk, hkr⟩ + | releaseCell => + have hp : 0 < s.core.extent := hs.2 + obtain ⟨hr, _, he, hm, hh⟩ := hc + simp only [execute, Nat.ne_of_gt hp, ↓reduceIte, State.Fits, + PackedConstruction.State.Fits, PackedConstruction.State.next] + refine ⟨⟨hr, by omega, by omega, ?_, hh⟩, hk, hkr⟩ + intro a v hv + by_cases ha : a = s.core.extent - 1 + · simp [PackedConstruction.put, ha] at hv + · exact hm a v (by simpa [PackedConstruction.put, ha] using hv) + | releaseKey => + have hp : 0 < s.keyExtent := hs.2 + obtain ⟨hr, _, he, hm, hh⟩ := hc + simp only [execute, Nat.ne_of_gt hp, ↓reduceIte, State.Fits, + PackedConstruction.State.Fits, PackedConstruction.State.next] + exact ⟨⟨hr, by omega, he, hm, hh⟩, by omega, hkr⟩ + | releaseKeyRegister => + have hp : 0 < s.keyRegExtent := hs.2 + obtain ⟨hr, _, he, hm, hh⟩ := hc + simp only [execute, Nat.ne_of_gt hp, ↓reduceIte, State.Fits, + PackedConstruction.State.Fits, PackedConstruction.State.next] + exact ⟨⟨hr, by omega, he, hm, hh⟩, hk, by omega⟩ + +def Transition.Safe (W len : Nat) (t : Transition) : Prop := + ∃ i, t.action = .instruction i ∧ i.Safe W len t.before + +theorem step_safe_fits {program : List Instruction} {s : State} {t : Transition} {W : Nat} + (hstep : step program s = some t) (hf : s.Fits W) + (hlen : program.length < 2 ^ W) (hs : t.Safe W program.length) : t.after.Fits W := by + obtain ⟨hb, _, i, hfetch, hi, ha⟩ := step_spec hstep + obtain ⟨j, hj, hjSafe⟩ := hs + have heq : j = i := Action.instruction.inj (hj.symm.trans hi) + subst j + rw [hb] at hjSafe + rw [ha] + exact execute_safe_fits hf hjSafe (List.getElem?_eq_some_iff.mp hfetch).1 hlen + +theorem run_fits {program : List Instruction} {fuel : Nat} {s : State} {W : Nat} + (hf : s.Fits W) (hlen : program.length < 2 ^ W) + (hs : ∀ t ∈ (run program fuel s).transitions, t.Safe W program.length) : + (run program fuel s).final.Fits W ∧ + ∀ t ∈ (run program fuel s).transitions, t.before.Fits W ∧ t.after.Fits W := by + induction fuel generalizing s with + | zero => simp [run]; exact hf + | succ fuel ih => + cases h : step program s with + | none => simpa [run, h] using hf + | some t => + have ht := step_safe_fits h hf hlen (hs t (by simp [run, h])) + have hrest := ih ht (fun u hu => hs u (by simp [run, h, hu])) + refine ⟨by simpa [run, h] using hrest.1, ?_⟩ + intro u hu + simp only [run, h, List.mem_cons] at hu + rcases hu with rfl | hu + · exact ⟨(step_spec h).1 ▸ hf, ht⟩ + · exact hrest.2 u hu + +theorem releaseCell_closed (s : State) (h : s.Closed) : (execute .releaseCell s).Closed := by + obtain ⟨hm, hk, hkr⟩ := h + by_cases hz : s.core.extent = 0 + · simpa [execute, hz, State.Closed, PackedConstruction.CleanTail] using + (show s.Closed from ⟨hm, hk, hkr⟩) + · simp only [execute, hz, ↓reduceIte, State.Closed, PackedConstruction.CleanTail, + PackedConstruction.State.next] + refine ⟨?_, hk, hkr⟩ + intro a ha + by_cases he : a = s.core.extent - 1 + · simp [PackedConstruction.put, he] + · simp [PackedConstruction.put, he, hm a (by omega)] + +theorem releaseKey_closed (s : State) (h : s.Closed) : (execute .releaseKey s).Closed := by + obtain ⟨hm, hk, hkr⟩ := h + by_cases hz : s.keyExtent = 0 + · simpa [execute, hz, State.Closed, PackedConstruction.CleanTail] using + (show s.Closed from ⟨hm, hk, hkr⟩) + · simp only [execute, hz, ↓reduceIte, State.Closed, PackedConstruction.CleanTail, + PackedConstruction.State.next] + refine ⟨hm, ?_, hkr⟩ + intro a ha + by_cases he : a = s.keyExtent - 1 + · simp [PackedConstruction.put, he] + · simp [PackedConstruction.put, he, hk a (by omega)] + +theorem releaseKeyRegister_closed (s : State) (h : s.Closed) : + (execute .releaseKeyRegister s).Closed := by + obtain ⟨hm, hk, hkr⟩ := h + by_cases hz : s.keyRegExtent = 0 + · simpa [execute, hz, State.Closed, PackedConstruction.CleanTail] using + (show s.Closed from ⟨hm, hk, hkr⟩) + · simp only [execute, hz, ↓reduceIte, State.Closed, PackedConstruction.CleanTail, + PackedConstruction.State.next] + refine ⟨hm, hk, ?_⟩ + intro r hr + by_cases he : r = s.keyRegExtent - 1 + · simp [PackedConstruction.put, he] + · simp [PackedConstruction.put, he, hkr r (by omega)] + +theorem empty_keys_of_closed (s : State) (h : s.Closed) + (hk : s.keyExtent = 0) (hkr : s.keyRegExtent = 0) : + s.core.keys = (fun _ => none) ∧ s.core.keyRegs = (fun _ => 0) := by + constructor + · funext a; exact h.2.1 a (by omega) + · funext r; exact h.2.2 r (by omega) + +theorem requestProtocol_preserves_allocation (entry : PackedConstruction.Operand) + (left right answer : Nat) (s : State) (hs : s.core.status = .halted answer) : + let final := (requestProtocol entry left right s).final + final.core.memory = s.core.memory ∧ final.core.extent = s.core.extent ∧ + final.core.keys = s.core.keys ∧ final.core.keyRegs = s.core.keyRegs ∧ + final.keyExtent = s.keyExtent ∧ final.keyRegExtent = s.keyRegExtent := by + simp [(requestProtocol_exact entry left right answer s hs).1] + +end RMQ.SuccinctFinal.PackedLifecycle diff --git a/RMQ/Core/WordRAM/Lifecycle/Service.lean b/RMQ/Core/WordRAM/Lifecycle/Service.lean new file mode 100644 index 00000000..2591a4f4 --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/Service.lean @@ -0,0 +1,169 @@ +import RMQ.Core.WordRAM.Lifecycle.QueryBridge +import RMQ.Core.WordRAM.Lifecycle.QueryEntry +import RMQ.Core.WordRAM.Lifecycle.Calculus + +/-! # One fixed reusable query-service prefix + +The request slots are copied only after a charged load of n from the retained +allocation. Full finite-bank clearing and the jump then use the checked entry +adapter. This prefix can be followed by the construction and retirement code. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle.Service + +open PackedWordRAM.Optimization + +set_option maxRecDepth 30000 + +attribute [local irreducible] compactQueryProgram QueryEntry.setupCode + +abbrev QueryState := PackedWordRAM.State +abbrev QueryProgram := PackedWordRAM.Program +abbrev QueryMemory := PackedWordRAM.Memory + +def prepare : QueryProgram := [.constant 2 0, .load 2 2, .move 0 300, .move 1 301] +def program : QueryProgram := compactQueryProgram ++ (prepare ++ QueryEntry.setupCode) +def entry : Nat := 212964 +def budget : Nat := 4 + QueryEntry.setupCost + compactQueryBudget + +attribute [local irreducible] program entry budget + +theorem entry_eq : entry = 212964 := by rw [entry] + +theorem entry_length : entry = compactQueryProgram.length := by + rw [entry] + exact compactQueryProgram_length_eq.symm +theorem prepare_length : prepare.length = 4 := rfl +theorem budget_eq : budget = 160253 := by + rw [budget, QueryEntry.setupCost_eq, compactQueryBudget_eq] + +theorem program_length : program.length = 221239 := by + rw [program, List.length_append, compactQueryProgram_length_eq, + List.length_append, prepare_length, QueryEntry.setupCode_length, QueryEntry.setupCost_eq] + +def Inputs (left right : Nat) (s : QueryState) : Prop := + s.status = .running ∧ s.pc = entry ∧ s.regs 300 = left ∧ s.regs 301 = right ∧ + ∀ r, 8273 ≤ r → s.regs r = 0 + +def preparedAt (base n : Nat) (s : QueryState) : QueryState := + { regs := ((s.regs.write 2 n).write 0 (s.regs 300)).write 1 (s.regs 301) + pc := base + 4 + status := .running } + +abbrev prepared (n : Nat) (s : QueryState) : QueryState := preparedAt entry n s + +theorem middle_host (pre fragment suffix : QueryProgram) : + PackedWordRAM.Structured.HostedAt (pre ++ (fragment ++ suffix)) pre.length fragment := by + intro i hi + rw [List.getElem?_append_right (by omega), Nat.add_sub_cancel_left, + List.getElem?_append_left hi] + +theorem tail_host (pre middle suffix : QueryProgram) : + PackedWordRAM.Structured.HostedAt (pre ++ (middle ++ suffix)) + (pre.length + middle.length) suffix := by + intro i hi + rw [Nat.add_assoc, List.getElem?_append_right (by omega), Nat.add_sub_cancel_left, + List.getElem?_append_right (by omega), Nat.add_sub_cancel_left] + +theorem prepare_fetch (i : Nat) (hi : i < 4) : + program[entry + i]? = prepare[i]? := by + rw [program, entry_length] + exact middle_host compactQueryProgram prepare QueryEntry.setupCode i + (by simpa only [prepare_length] using hi) + +theorem preparation_tail_host (pre suffix : QueryProgram) : + PackedWordRAM.Structured.HostedAt (pre ++ (prepare ++ suffix)) (pre.length + 4) suffix := by + have h := tail_host pre prepare suffix + rw [prepare_length] at h + exact h + +theorem setup_host : PackedWordRAM.Structured.HostedAt program (entry + 4) + QueryEntry.setupCode := by + rw [program, entry_length] + exact preparation_tail_host compactQueryProgram QueryEntry.setupCode + +theorem prepare_exec_at (memory : QueryMemory) (p : QueryProgram) (base n : Nat) (s : QueryState) + (header : memory[0]? = some n) (hr : s.status = .running) (hpc : s.pc = base) + (host : ∀ i, i < 4 → p[base+i]? = prepare[i]?) : + (PackedWordRAM.run memory p 4 s).final = preparedAt base n s ∧ + (PackedWordRAM.run memory p 4 s).steps = 4 ∧ + (PackedWordRAM.run memory p 4 s).reads = [⟨0, some n⟩] := by + have h0 := host 0 (by decide) + have h1 := host 1 (by decide) + have h2 := host 2 (by decide) + have h3 := host 3 (by decide) + simp only [prepare, List.getElem?_cons_zero, List.getElem?_cons_succ, Nat.add_zero] at h0 h1 h2 h3 + simp [PackedWordRAM.run, PackedWordRAM.step, PackedWordRAM.execute, hpc, hr, + h0, h1, h2, h3, header, PackedWordRAM.State.writeNext, + PackedWordRAM.Registers.write, Nat.add_assoc, preparedAt, + PackedWordRAM.Run.steps, PackedWordRAM.Run.reads] + funext r + by_cases h : r = 2 <;> simp [PackedWordRAM.Registers.write, h] + +theorem prepare_exec (memory : QueryMemory) (n left right : Nat) (s : QueryState) + (header : memory[0]? = some n) (inputs : Inputs left right s) : + (PackedWordRAM.run memory program 4 s).final = prepared n s ∧ + (PackedWordRAM.run memory program 4 s).steps = 4 ∧ + (PackedWordRAM.run memory program 4 s).reads = [⟨0, some n⟩] := + prepare_exec_at memory program entry n s header inputs.1 inputs.2.1 prepare_fetch + +theorem prepared_inputs (n left right : Nat) (s : QueryState) (inputs : Inputs left right s) : + QueryEntry.SetupInputs n left right (prepared n s) := by + obtain ⟨_, _, hl, hr, ht⟩ := inputs + refine ⟨rfl, ?_, ?_, ?_, ?_⟩ + · simp [prepared, preparedAt, PackedWordRAM.Registers.write, hl] + · simp [prepared, preparedAt, PackedWordRAM.Registers.write, hr] + · simp [prepared, preparedAt, PackedWordRAM.Registers.write] + · intro r hout + have hh : 8273 ≤ r := by rw [compactQueryRegisterCount_eq] at hout; exact hout + simp [prepared, preparedAt, PackedWordRAM.Registers.write, show r ≠ 0 by omega, + show r ≠ 1 by omega, show r ≠ 2 by omega, ht r hh] + +theorem completed (memory : QueryMemory) (n left right : Nat) (s : QueryState) + (header : memory[0]? = some n) (inputs : Inputs left right s) : + ∃ setupTransitions, + PackedWordRAM.run memory program budget s = + ⟨(compactQueryRun memory n left right).final, + (PackedWordRAM.run memory program 4 s).transitions ++ setupTransitions ++ + (compactQueryRun memory n left right).transitions⟩ ∧ + setupTransitions.length = QueryEntry.setupCost ∧ + setupTransitions.filterMap (·.receipt) = [] := by + have hp := prepare_exec memory n left right s header inputs + obtain ⟨ts, _, hlen, hreads, hrun⟩ := QueryEntry.chargedEntry_compactQuery + memory (prepare ++ QueryEntry.setupCode) n left right (prepared n s) + (prepared_inputs n left right s inputs) (by simpa only [prepared, preparedAt, program] using setup_host) + rw [← program] at hrun + refine ⟨ts, ?_, hlen, hreads⟩ + rw [budget, Nat.add_assoc, PackedWordRAM.run_add] + dsimp only + rw [hp.1] + rw [hrun] + simp [List.append_assoc] + +theorem observations (memory : QueryMemory) (n left right : Nat) (s : QueryState) + (header : memory[0]? = some n) (inputs : Inputs left right s) : + let actual := PackedWordRAM.run memory program budget s + let query := compactQueryRun memory n left right + actual.final = query.final ∧ actual.result = query.result ∧ + actual.reads = ⟨0, some n⟩ :: query.reads ∧ + actual.steps = 4 + QueryEntry.setupCost + query.steps ∧ + actual.steps ≤ 160253 ∧ actual.final.status ≠ .running := by + obtain ⟨ts, he, hlen, hreads⟩ := completed memory n left right s header inputs + have hp := prepare_exec memory n left right s header inputs + have hbound := compactQueryRun_steps_le memory n left right + have hstop := compactQueryRun_stopped memory n left right + have hplen : (PackedWordRAM.run memory program 4 s).transitions.length = 4 := hp.2.1 + have hpreads : (PackedWordRAM.run memory program 4 s).transitions.filterMap (·.receipt) = + [⟨0, some n⟩] := hp.2.2 + dsimp only + rw [he] + simp only [PackedWordRAM.Run.result, PackedWordRAM.Run.reads, PackedWordRAM.Run.steps, + List.filterMap_append, List.length_append, hlen, hreads, List.append_nil, + hplen, hpreads, List.cons_append, List.nil_append, true_and] + refine ⟨?_, hstop⟩ + rw [QueryEntry.setupCost_eq] + rw [compactQueryBudget_eq] at hbound + change (compactQueryRun memory n left right).transitions.length ≤ 151978 at hbound + omega + +end RMQ.SuccinctFinal.PackedLifecycle.Service diff --git a/RMQ/Core/WordRAM/Lifecycle/ServiceSafety.lean b/RMQ/Core/WordRAM/Lifecycle/ServiceSafety.lean new file mode 100644 index 00000000..891afe0e --- /dev/null +++ b/RMQ/Core/WordRAM/Lifecycle/ServiceSafety.lean @@ -0,0 +1,362 @@ +import RMQ.Core.WordRAM.Lifecycle.Retained +import RMQ.Core.WordRAM.Lifecycle.Service + +/-! # Safety of the actual charged query service + +Preparation, finite-bank clearing, and the compact query run all on one program +and one represented state. Their safety is then transported to the lifecycle +prefix followed by an arbitrary continuation. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle.ServiceSafety + +open PackedWordRAM PackedWordRAM.Structured PackedWordRAM.Optimization +open PackedConstruction.Conservative + +abbrev QueryAction := PackedWordRAM.Structured.Action +set_option maxRecDepth 30000 + +attribute [local irreducible] compactQueryProgram QueryEntry.setupCode +attribute [local irreducible] Service.program Service.entry Service.budget + +theorem canonical_header (xs : List Int) : (buildMemory xs)[0]? = some xs.length := by + unfold buildMemory shapeMemory repackWords + rw [List.getElem?_append_left (by rw [metadata_length]; decide)] + unfold metadata + rw [List.getElem?_append_left (by rw [List.length_append, scalarMetadata_length]; omega)] + rw [List.getElem?_append_left (by rw [scalarMetadata_length]; decide)] + change some (SuccinctClassic.cartesianShape xs).size = some xs.length + rw [PackedCellProbe.packedReviewerCartesianShape_size] + +private theorem action_next (memory : PackedWordRAM.Memory) (op : QueryAction) (s : PackedWordRAM.State) + (running : (PackedWordRAM.execute memory op.instruction s).1.status = .running) : + (PackedWordRAM.execute memory op.instruction s).1.pc = s.pc + 1 := by + cases op <;> simp [PackedWordRAM.Structured.Action.instruction, PackedWordRAM.execute, PackedWordRAM.State.writeNext] at * + split <;> simp_all + +private theorem actions_safe (memory : PackedWordRAM.Memory) (program : PackedWordRAM.Program) + (W : Nat) (ops : List QueryAction) (s : PackedWordRAM.State) + (running : s.status = .running) (fit : s.Fits W) + (host : HostedAt program s.pc (ops.map PackedWordRAM.Structured.Action.instruction)) + (fields : ∀ op ∈ ops, op.instruction.Fits W) + (localSafe : ∀ op ∈ ops, ∀ t : PackedWordRAM.State, t.Fits W → + op.LocalSafe memory W (PackedWordRAM.Structured.Data.ofState t)) + (bound : s.pc + ops.length < 2 ^ W) : + TraceSafe W (PackedWordRAM.run memory program ops.length s).transitions := by + induction ops generalizing s with + | nil => intro t member; cases member + | cons op ops ih => + let after := (PackedWordRAM.execute memory op.instruction s).1 + let first : PackedWordRAM.Transition := + ⟨s, op.instruction, after, (PackedWordRAM.execute memory op.instruction s).2⟩ + have fetched := host.head + have stepEq : PackedWordRAM.step memory program s = some first := by + simp [PackedWordRAM.step, running, fetched, first, after] + have hs := PackedWordRAM.Structured.Action.execute_safe memory W op s fit (fields op (by simp)) + (localSafe op (by simp) s fit) (by simp only [List.length_cons] at bound; omega) + have tail : TraceSafe W (PackedWordRAM.run memory program ops.length after).transitions := by + by_cases hr : after.status = .running + · have hp : after.pc = s.pc + 1 := action_next memory op s hr + apply ih after hr hs.2 + · rw [hp]; exact QueryEntry.hosted_cons_tail host + · exact fun a ha => fields a (List.mem_cons_of_mem _ ha) + · exact fun a ha => localSafe a (List.mem_cons_of_mem _ ha) + · rw [hp]; simp only [List.length_cons] at bound; omega + · have noStep : PackedWordRAM.step memory program after = none := by + simp [PackedWordRAM.step] + rw [PackedWordRAM.run_of_step_none memory program after ops.length noStep] + intro t member; cases member + intro t member + simp only [List.length_cons, PackedWordRAM.run, stepEq, List.mem_cons] at member + rcases member with rfl | member + · exact hs + · exact tail t member + +theorem prepare_fields (W : Nat) (cap : 301 < 2 ^ W) : + ∀ i ∈ Service.prepare, i.Fits W := by + intro i member + simp only [Service.prepare, List.mem_cons, List.not_mem_nil, or_false] at member + rcases member with rfl | rfl | rfl | rfl <;> + simp only [PackedWordRAM.Instruction.Fits, PackedWordRAM.Instruction.encoding, + PackedWordRAM.Instruction.operands, List.mem_append, List.mem_cons, + List.not_mem_nil, or_false] <;> intro value h <;> + rcases h with rfl | rfl | rfl <;> omega + +theorem program_fields (n : Nat) : ∀ i ∈ Service.program, i.Fits (wordWidth n) := by + intro i member + rw [Service.program] at member + rcases List.mem_append.mp member with compact | rest + · exact compactQueryProgram_fits n i compact + · rcases List.mem_append.mp rest with preparation | setup + · exact prepare_fields _ (by have := query_small_fields_fit n; omega) i preparation + · exact QueryEntry.setupCode_fields n i setup + +theorem program_fields32 : ∀ i ∈ Service.program, OperandsFit32 i := by + intro i member + apply operandsFit32_of_fits + rw [Service.program] at member + rcases List.mem_append.mp member with compact | rest + · exact QueryBridge.compact_fields32 i compact + · rcases List.mem_append.mp rest with preparation | setup + · exact prepare_fields 32 (by decide) i preparation + · rw [QueryEntry.setupCode] at setup + rcases List.mem_append.mp setup with clearing | jumping + · exact QueryEntry.clearCode_fields 32 3 QueryEntry.clearCount (by decide) + (by rw [QueryEntry.clearCount_eq]; decide) i clearing + · have hi := List.mem_singleton.mp jumping + subst i + simp [PackedWordRAM.Instruction.Fits, PackedWordRAM.Instruction.encoding, + PackedWordRAM.Instruction.operands] + +theorem prepare_safe (xs : List Int) (left right : Nat) (s : PackedWordRAM.State) + (inputs : Service.Inputs left right s) (fit : s.Fits (wordWidth xs.length)) : + TraceSafe (wordWidth xs.length) + (PackedWordRAM.run (buildMemory xs) Service.program 4 s).transitions := by + let ops : List QueryAction := [.constant 2 0, .load 2 2, .move 0 300, .move 1 301] + have code : ops.map PackedWordRAM.Structured.Action.instruction = Service.prepare := rfl + have len : ops.length = 4 := rfl + rw [← len] + apply actions_safe (buildMemory xs) Service.program _ ops s inputs.1 fit + · rw [code, inputs.2.1] + intro i hi + exact Service.prepare_fetch i (by simpa only [Service.prepare_length] using hi) + · intro op member + apply prepare_fields _ (by have := query_small_fields_fit xs.length; omega) + rw [← code] + exact List.mem_map.mpr ⟨op, member, rfl⟩ + · intro op member t hfit + simp only [ops, List.mem_cons, List.not_mem_nil, or_false] at member + rcases member with rfl | rfl | rfl | rfl + · exact Nat.two_pow_pos _ + · intro value reply + exact buildMemory_words_fit xs value (List.mem_of_getElem? reply) + · exact hfit.2.1 300 + · exact hfit.2.1 301 + · rw [len, inputs.2.1, Service.entry_eq] + have := query_small_fields_fit xs.length + omega + +private theorem compose_safety (memory : PackedWordRAM.Memory) (program : PackedWordRAM.Program) + (W a b : Nat) (s middle : PackedWordRAM.State) (fit : s.Fits W) + (first : TraceSafe W (PackedWordRAM.run memory program a s).transitions) + (finish : (PackedWordRAM.run memory program a s).final = middle) + (second : RankExecutionSafety memory W program b middle) : + RankExecutionSafety memory W program (a + b) s := by + have splitRun := PackedWordRAM.run_add memory program a b s + dsimp only at splitRun + rw [finish] at splitRun + have all : TraceSafe W (PackedWordRAM.run memory program (a + b) s).transitions := by + rw [splitRun] + apply compact_traceSafe_append first + intro t member + obtain ⟨index, occurrence⟩ := List.mem_iff_getElem?.mp member + exact second.2.2.1 index t occurrence + refine ⟨second.1, ?_, ?_, ?_, ?_⟩ + · rw [splitRun]; exact second.2.1 + · intro index t occurrence; exact all t (List.mem_of_getElem? occurrence) + · exact run_prefix_fits _ _ _ _ s fit all + · intro index t receipt occurrence read + have hs := all t (List.mem_of_getElem? occurrence) + exact run_read_fits occurrence read hs.1 hs.2 + +theorem execution_safe (xs : List Int) (left right : Nat) (s : PackedWordRAM.State) + (inputs : Service.Inputs left right s) (fit : s.Fits (wordWidth xs.length)) + (hl : left < 2 ^ wordWidth xs.length) (hr : right < 2 ^ wordWidth xs.length) : + RankExecutionSafety (buildMemory xs) (wordWidth xs.length) Service.program Service.budget s := by + have prep := prepare_safe xs left right s inputs fit + have hp := Service.prepare_exec (buildMemory xs) xs.length left right s (canonical_header xs) inputs + have preparedFit : (Service.prepared xs.length s).Fits (wordWidth xs.length) := by + rw [← hp.1] + exact run_prefix_fits _ _ _ 4 s fit prep 4 (Nat.le_refl _) + have setupRaw := QueryEntry.chargedEntry_execution_safe xs + (Service.prepare ++ QueryEntry.setupCode) left right (Service.prepared xs.length s) + (Service.prepared_inputs _ _ _ _ inputs) + (by simpa only [Service.prepared, Service.preparedAt, Service.program] using Service.setup_host) + preparedFit (by + change Service.entry + 4 + QueryEntry.clearCount < 2 ^ wordWidth xs.length + rw [Service.entry_eq, QueryEntry.clearCount_eq] + have := query_small_fields_fit xs.length + omega) (by simpa only [Service.program] using program_fields xs.length) hl hr + have setup : RankExecutionSafety (buildMemory xs) (wordWidth xs.length) Service.program + (QueryEntry.setupCost + compactQueryBudget) (Service.prepared xs.length s) := by + simpa only [Service.program] using setupRaw + simpa only [Service.budget, Nat.add_assoc] using + compose_safety (buildMemory xs) Service.program (wordWidth xs.length) 4 + (QueryEntry.setupCost + compactQueryBudget) s (Service.prepared xs.length s) + fit prep hp.1 setup + +private theorem clear_writes (first count bank : Nat) (bound : first + count ≤ bank) : + ∀ i ∈ QueryEntry.clearCode first count, i.WritesOnly (fun r => r < bank) := by + induction count generalizing first with + | zero => simp [QueryEntry.clearCode] + | succ count ih => + intro i member + simp only [QueryEntry.clearCode, List.mem_cons] at member + rcases member with rfl | member + · change first < bank; omega + · exact ih (first + 1) (by omega) i member + +theorem program_writes : + ∀ i ∈ Service.program, i.WritesOnly (fun r => r < 8273) := by + intro i member + rw [Service.program] at member + rcases List.mem_append.mp member with compact | rest + · have h := compactAt_writesOnly compactQuerySource compactQueryFresh 0 0 + compactQuerySource_registersBelow + have hb : compactQueryFresh + 2 * (0 + compactDepth compactQuerySource) = 8273 := by + simpa only [Nat.zero_add, compactQueryRegisterCount] using compactQueryRegisterCount_eq + rw [hb] at h + apply h i + simpa only [compactQueryProgram] using compact + · rcases List.mem_append.mp rest with preparation | setup + · simp only [Service.prepare, List.mem_cons, List.not_mem_nil, or_false] at preparation + rcases preparation with rfl | rfl | rfl | rfl <;> simp [PackedWordRAM.Instruction.WritesOnly] + · rw [QueryEntry.setupCode] at setup + rcases List.mem_append.mp setup with clearing | jumping + · exact clear_writes 3 QueryEntry.clearCount 8273 + (by rw [QueryEntry.clearCount_eq]; decide) i clearing + · have hi := List.mem_singleton.mp jumping; subst i; trivial + +theorem program_control (tail : List PackedLifecycle.Instruction) : + ∀ i ∈ Service.program, QuerySafetyBridge.ControlBound + (QuerySafetyBridge.host Service.program tail).length i := by + intro i member + rw [Service.program] at member + rcases List.mem_append.mp member with compact | rest + · apply QuerySafetyBridge.compact_controlBound _ _ i compact + simp only [QuerySafetyBridge.host, List.length_append, List.length_map, + Service.program_length, compactQueryProgram_length_eq] + omega + · rcases List.mem_append.mp rest with preparation | setup + · simp only [Service.prepare, List.mem_cons, List.not_mem_nil, or_false] at preparation + rcases preparation with rfl | rfl | rfl | rfl <;> trivial + · apply QuerySafetyBridge.setupCode_controlBound _ _ i setup + simp only [QuerySafetyBridge.host, List.length_append, List.length_map, + Service.program_length] + omega + +theorem successful_reads (xs : List Int) (left right : Nat) (s : PackedWordRAM.State) + (inputs : Service.Inputs left right s) : + ∀ receipt ∈ (PackedWordRAM.run (buildMemory xs) Service.program Service.budget s).reads, + ∃ value, receipt.reply = some value := by + have obs := Service.observations (buildMemory xs) xs.length left right s + (canonical_header xs) inputs + rw [obs.2.2.1, (compactQueryRun_original_observations (buildMemory xs) xs.length left right).2] + intro receipt member + rcases List.mem_cons.mp member with rfl | old + · exact ⟨xs.length, rfl⟩ + · exact queryRun_reads_reply xs left right receipt old + +def Entered (left right : Nat) (s : PackedLifecycle.State) : Prop := + s.core.status = .running ∧ s.core.pc = Service.entry ∧ + s.core.regs 300 = left ∧ s.core.regs 301 = right + +theorem entered_inputs (xs : List Int) (left right : Nat) (s : PackedLifecycle.State) + (canonical : Retained.Canonical xs s) (entered : Entered left right s) : + Service.Inputs left right (Retained.projectQueryState s) := by + refine ⟨?_, entered.2.1, entered.2.2.1, entered.2.2.2, canonical.2.1⟩ + simp only [Retained.projectQueryState, entered.1, Retained.projectStatus] + +theorem entered_execution_safe (xs : List Int) (left right : Nat) (s : PackedLifecycle.State) + (canonical : Retained.Canonical xs s) (entered : Entered left right s) : + RankExecutionSafety (buildMemory xs) (wordWidth xs.length) Service.program Service.budget + (Retained.projectQueryState s) := by + apply execution_safe xs left right _ (entered_inputs xs left right s canonical entered) + (Retained.project_fits canonical.2.2) + · rw [← entered.2.2.1]; exact canonical.2.2.1.1 300 + · rw [← entered.2.2.2]; exact canonical.2.2.1.1 301 + +theorem stopped (xs : List Int) (left right : Nat) (s : PackedWordRAM.State) + (inputs : Service.Inputs left right s) : + (PackedWordRAM.run (buildMemory xs) Service.program Service.budget s).final.status ≠ .running := + (Service.observations (buildMemory xs) xs.length left right s (canonical_header xs) inputs).2.2.2.2.2 + +/-- The actual retained state, without replacing its registers or status, is +the input to the mixed lifecycle program. -/ +theorem actual_prefix (xs : List Int) (tail : List PackedLifecycle.Instruction) + (left right fuel : Nat) (s : PackedLifecycle.State) + (canonical : Retained.Canonical xs s) (entered : Entered left right s) + (within : fuel ≤ Service.budget) : + PackedLifecycle.run (QuerySafetyBridge.host Service.program tail) fuel s = + ⟨QuerySafetyBridge.embedded (buildMemory xs) + (PackedWordRAM.run (buildMemory xs) Service.program fuel (Retained.projectQueryState s)).final, + (PackedWordRAM.run (buildMemory xs) Service.program fuel (Retained.projectQueryState s)).transitions.map + (QuerySafetyBridge.liftTransition (buildMemory xs))⟩ := by + calc + _ = PackedLifecycle.run (QuerySafetyBridge.host Service.program tail) fuel + (QuerySafetyBridge.embedded (buildMemory xs) (Retained.projectQueryState s)) := + congrArg _ canonical.1.roundtrip + _ = _ := QuerySafetyBridge.prefix_run _ _ tail program_fields32 fuel Service.budget _ within + (stopped xs left right _ (entered_inputs xs left right s canonical entered)) + +theorem actual_prefix_canonical (xs : List Int) (tail : List PackedLifecycle.Instruction) + (left right fuel : Nat) (s : PackedLifecycle.State) + (canonical : Retained.Canonical xs s) (entered : Entered left right s) + (within : fuel ≤ Service.budget) : + Retained.Canonical xs + (PackedLifecycle.run (QuerySafetyBridge.host Service.program tail) fuel s).final := by + rw [actual_prefix xs tail left right fuel s canonical entered within] + refine ⟨⟨rfl, rfl, rfl, rfl, rfl, rfl⟩, ?_, ?_⟩ + · intro r hr + change (PackedWordRAM.run (buildMemory xs) Service.program fuel + (Retained.projectQueryState s)).final.regs r = 0 + rw [PackedWordRAM.run_frame _ _ _ _ _ program_writes r (by omega)] + exact canonical.2.1 r hr + · exact QuerySafetyBridge.embedded_fits _ _ _ + ((entered_execution_safe xs left right s canonical entered).2.2.2.1 fuel within) + (buildMemory_length_fit xs) (buildMemory_words_fit xs) + +theorem actual_prefix_safe (xs : List Int) (tail : List PackedLifecycle.Instruction) + (left right fuel : Nat) (s : PackedLifecycle.State) + (canonical : Retained.Canonical xs s) (entered : Entered left right s) + (within : fuel ≤ Service.budget) : + ∀ t ∈ (PackedLifecycle.run (QuerySafetyBridge.host Service.program tail) fuel s).transitions, + t.Safe (wordWidth xs.length) (QuerySafetyBridge.host Service.program tail).length := by + have source := entered_inputs xs left right s canonical entered + have safe := QuerySafetyBridge.prefix_safe (buildMemory xs) Service.program tail program_fields32 + fuel Service.budget (wordWidth xs.length) (Retained.projectQueryState s) within + (stopped xs left right _ source) (entered_execution_safe xs left right s canonical entered) + (program_control tail) (successful_reads xs left right _ source) (buildMemory_words_fit xs) + rwa [← canonical.1.roundtrip] at safe + +theorem actual_prefix_reads (xs : List Int) (tail : List PackedLifecycle.Instruction) + (left right fuel : Nat) (s : PackedLifecycle.State) + (canonical : Retained.Canonical xs s) (entered : Entered left right s) + (within : fuel ≤ Service.budget) : + (PackedLifecycle.run (QuerySafetyBridge.host Service.program tail) fuel s).reads = + (PackedWordRAM.run (buildMemory xs) Service.program fuel (Retained.projectQueryState s)).reads.map + (fun r => (r.address, r.reply)) := by + have h := QuerySafetyBridge.prefix_reads (buildMemory xs) Service.program tail program_fields32 + fuel Service.budget (Retained.projectQueryState s) within + (stopped xs left right _ (entered_inputs xs left right s canonical entered)) + rwa [← canonical.1.roundtrip] at h + +theorem actual_read_width (xs : List Int) (tail : List PackedLifecycle.Instruction) + (left right : Nat) (s : PackedLifecycle.State) + (canonical : Retained.Canonical xs s) (entered : Entered left right s) + (index : Nat) (t : PackedLifecycle.Transition) (address : Nat) (reply : Option Nat) + (occurs : (PackedLifecycle.run (QuerySafetyBridge.host Service.program tail) + Service.budget s).transitions[index]? = some t) + (read : t.read? = some (address, reply)) : + address < 2 ^ wordWidth xs.length ∧ reply = (buildMemory xs)[address]? ∧ + (∀ value, reply = some value → value < 2 ^ wordWidth xs.length) := by + apply QuerySafetyBridge.run_read_width (buildMemory xs) Service.program tail program_fields32 + Service.budget (wordWidth xs.length) (Retained.projectQueryState s) + (stopped xs left right _ (entered_inputs xs left right s canonical entered)) + (entered_execution_safe xs left right s canonical entered) index t address reply _ read + rwa [← canonical.1.roundtrip] + +theorem actual_transition_fits (xs : List Int) (tail : List PackedLifecycle.Instruction) + (left right : Nat) (s : PackedLifecycle.State) + (canonical : Retained.Canonical xs s) (entered : Entered left right s) : + ∀ t ∈ (PackedLifecycle.run (QuerySafetyBridge.host Service.program tail) + Service.budget s).transitions, + t.before.Fits (wordWidth xs.length) ∧ t.after.Fits (wordWidth xs.length) := by + have h := QuerySafetyBridge.run_transition_fits (buildMemory xs) Service.program tail program_fields32 + Service.budget (wordWidth xs.length) (Retained.projectQueryState s) + (stopped xs left right _ (entered_inputs xs left right s canonical entered)) + (entered_execution_safe xs left right s canonical entered) + (buildMemory_length_fit xs) (buildMemory_words_fit xs) + rwa [← canonical.1.roundtrip] at h + +end RMQ.SuccinctFinal.PackedLifecycle.ServiceSafety diff --git a/RMQ/Core/WordRAM/Native/Lifecycle.lean b/RMQ/Core/WordRAM/Native/Lifecycle.lean new file mode 100644 index 00000000..5eccad34 --- /dev/null +++ b/RMQ/Core/WordRAM/Native/Lifecycle.lean @@ -0,0 +1,6 @@ +import RMQ.Core.WordRAM.Native.Lifecycle.Entry +import RMQ.Core.WordRAM.Native.Lifecycle.Contract + +/-! The native lifecycle candidate exports and their source contract. +The C/runtime ownership boundary is validated separately from these Lean facts. +-/ diff --git a/RMQ/Core/WordRAM/Native/Lifecycle/Admission.lean b/RMQ/Core/WordRAM/Native/Lifecycle/Admission.lean new file mode 100644 index 00000000..b8ec310d --- /dev/null +++ b/RMQ/Core/WordRAM/Native/Lifecycle/Admission.lean @@ -0,0 +1,226 @@ +import RMQ.Core.WordRAM.Native.Lifecycle.Codec +import RMQ.Core.WordRAM.Lifecycle.Input + +/-! # Checked lifecycle input and request admission + +The word model checks the existing signed biased input domain. The comparison +model accepts arbitrary finite Lean integers. Endpoint checks impose only the +modeled word representation: empty, reversed and out-of-bounds represented +intervals are executed by the lifecycle guard. Count and wire-size ceilings +are explicitly native limits and do not restrict the all-size export theorem. +-/ + +namespace RMQ.SuccinctFinal.PackedNative.Lifecycle + +open PackedLifecycle (InputModel InputDomain) +open PackedWordRAM (wordWidth) + +def nativeCountLimit : Nat := 4096 +def nativeMagnitudeBudget : Nat := 16777216 + +/-- The actual lifecycle profile has no unused high endpoint bits. Malformed +padding is a generic codec case, not a reachable native-profile case. -/ +theorem word_profile_byte_aligned (count : Nat) : wordWidth count % 8 = 0 := by + unfold wordWidth + omega + +theorem nativeCount_toUSize_exact (count : Nat) (bounded : count ≤ nativeCountLimit) : + (USize.ofNat count).toNat = count := by + apply USize.toNat_ofNat_of_lt_32 + change count ≤ 4096 at bounded + omega + +/-- The foreign boundary validates its byte flag before converting to Bool. -/ +def modelOfComparison (comparison : Bool) : InputModel := + if comparison then .comparison else .word + +@[simp] theorem modelOfComparison_false : modelOfComparison false = .word := rfl +@[simp] theorem modelOfComparison_true : modelOfComparison true = .comparison := rfl + +def inputDomainCheck (model : InputModel) (xs : List Int) : Bool := + match model with + | .word => decide (0 < wordWidth xs.length ∧ xs.length < 2 ^ wordWidth xs.length ∧ + ∀ x ∈ xs, 0 < wordWidth xs.length ∧ + -((2 ^ (wordWidth xs.length - 1) : Nat) : Int) ≤ x ∧ + x < ((2 ^ (wordWidth xs.length - 1) : Nat) : Int)) + | .comparison => true + +theorem inputDomainCheck_iff (model : InputModel) (xs : List Int) : + inputDomainCheck model xs = true ↔ InputDomain model xs := by + cases model <;> simp [inputDomainCheck, InputDomain, + PackedConstruction.InputFits, PackedConstruction.SignedFits] + +def QueryRepresented (width : Nat) (left right : ByteArray) : Prop := + LimbWord.Canonical width left.data ∧ LimbWord.Canonical width right.data + +instance (width : Nat) (left right : ByteArray) : Decidable (QueryRepresented width left right) := + inferInstanceAs (Decidable (_ ∧ _)) + +/-- This check is pure and requires no operational owner to be taken. -/ +def queryAdmission (width : Nat) (left right : ByteArray) : Bool := + decide (QueryRepresented width left right) + +theorem queryAdmission_iff (width : Nat) (left right : ByteArray) : + queryAdmission width left right = true ↔ QueryRepresented width left right := by + simp [queryAdmission] + +theorem queryAdmission_success (width : Nat) (left right : ByteArray) + (accepted : queryAdmission width left right = true) : + left.size = LimbWord.limbCount width ∧ right.size = LimbWord.limbCount width ∧ + decodeMagnitude left < 2 ^ width ∧ decodeMagnitude right < 2 ^ width := by + have h := (queryAdmission_iff width left right).1 accepted + exact ⟨h.1.1, h.2.1, h.1.2, h.2.2⟩ + +theorem queryAdmission_encoded (width left right : Nat) + (hl : left < 2 ^ width) (hr : right < 2 ^ width) : + queryAdmission width (encodeEndpoint width left) (encodeEndpoint width right) = true := + (queryAdmission_iff _ _ _).2 + ⟨(encodeEndpoint_canonical _ _ hl).1, (encodeEndpoint_canonical _ _ hr).1⟩ + +def BuildAdmitted (model : InputModel) (xs : List Int) (suppliedCount : Nat) + (left right : ByteArray) : Prop := + suppliedCount = xs.length ∧ xs.length ≤ nativeCountLimit ∧ + InputDomain model xs ∧ QueryRepresented (wordWidth xs.length) left right + +def buildAdmission (model : InputModel) (xs : List Int) (suppliedCount : Nat) + (left right : ByteArray) : Bool := + decide (suppliedCount = xs.length ∧ xs.length ≤ nativeCountLimit) && + inputDomainCheck model xs && queryAdmission (wordWidth xs.length) left right + +theorem buildAdmission_iff (model : InputModel) (xs : List Int) (suppliedCount : Nat) + (left right : ByteArray) : + buildAdmission model xs suppliedCount left right = true ↔ + BuildAdmitted model xs suppliedCount left right := by + simp [buildAdmission, BuildAdmitted, inputDomainCheck_iff, queryAdmission_iff, and_assoc] + +/-- Successful admission exposes the exact domain and endpoint arguments used +by the first lifecycle invocation, together with the actual supplied count. -/ +theorem buildAdmission_success (model : InputModel) (xs : List Int) (suppliedCount : Nat) + (left right : ByteArray) + (accepted : buildAdmission model xs suppliedCount left right = true) : + suppliedCount = xs.length ∧ xs.length ≤ nativeCountLimit ∧ InputDomain model xs ∧ + left.size = LimbWord.limbCount (wordWidth xs.length) ∧ + right.size = LimbWord.limbCount (wordWidth xs.length) ∧ + decodeMagnitude left < 2 ^ wordWidth xs.length ∧ + decodeMagnitude right < 2 ^ wordWidth xs.length := by + obtain ⟨count, bounded, domain, represented⟩ := (buildAdmission_iff _ _ _ _ _).1 accepted + exact ⟨count, bounded, domain, represented.1.1, represented.2.1, + represented.1.2, represented.2.2⟩ + +theorem buildAdmission_word_bias (xs : List Int) (suppliedCount : Nat) + (left right : ByteArray) + (accepted : buildAdmission .word xs suppliedCount left right = true) : + ∀ x ∈ xs, (PackedConstruction.encodeInt (wordWidth xs.length) x : Int) = + x + ((2 ^ (wordWidth xs.length - 1) : Nat) : Int) := by + intro x member + have domain := (buildAdmission_success _ _ _ _ _ accepted).2.2.1 + exact PackedConstruction.encodeInt_asInt (domain.2.2 x member) + +theorem buildAdmission_word_rejects (xs : List Int) (suppliedCount : Nat) + (left right : ByteArray) + (outside : ¬ PackedConstruction.InputFits (wordWidth xs.length) xs) : + buildAdmission .word xs suppliedCount left right = false := by + cases result : buildAdmission .word xs suppliedCount left right with + | false => rfl + | true => exact False.elim (outside (buildAdmission_success _ _ _ _ _ result).2.2.1) + +/-- The foreign parser supplies exactly this sign/magnitude sequence. It does +not retain the sequence after constructing the decoded input list. -/ +structure SignedBytes where + negative : Bool + magnitude : ByteArray + +def decodeInputs (inputs : List SignedBytes) : List Int := + inputs.map fun input => decodeSigned input.negative input.magnitude + +def NativeInputFormat (inputs : List SignedBytes) : Prop := + inputs.length ≤ nativeCountLimit ∧ + (∀ input ∈ inputs, SignedFormat input.negative input.magnitude) ∧ + (inputs.map fun input => input.magnitude.size).sum ≤ nativeMagnitudeBudget + +instance (inputs : List SignedBytes) : Decidable (NativeInputFormat inputs) := + inferInstanceAs (Decidable (_ ∧ _)) + +def nativeInputFormat (inputs : List SignedBytes) : Bool := decide (NativeInputFormat inputs) + +theorem nativeInputFormat_iff (inputs : List SignedBytes) : + nativeInputFormat inputs = true ↔ NativeInputFormat inputs := by + simp [nativeInputFormat] + +def encodedBuildAdmission (model : InputModel) (inputs : List SignedBytes) + (left right : ByteArray) : Bool := + nativeInputFormat inputs && buildAdmission model (decodeInputs inputs) inputs.length left right + +@[simp] theorem decodeInputs_length (inputs : List SignedBytes) : + (decodeInputs inputs).length = inputs.length := by simp [decodeInputs] + +theorem decodeInputs_getElem? (inputs : List SignedBytes) (i : Nat) : + (decodeInputs inputs)[i]? = + (inputs[i]?).map (fun input => decodeSigned input.negative input.magnitude) := by + simp [decodeInputs] + +theorem decodeInputs_encoded (count : Nat) (xs : List Int) + (fits : ∀ x ∈ xs, x.natAbs < 256 ^ count) : + decodeInputs (xs.map (fun value => + (⟨signedNegative value, encodeSigned count value⟩ : SignedBytes))) = xs := by + induction xs with + | nil => rfl + | cons x xs ih => + change decodeSigned (signedNegative x) (encodeSigned count x) :: + decodeInputs (xs.map (fun value => + (⟨signedNegative value, encodeSigned count value⟩ : SignedBytes))) = x :: xs + rw [decodeSigned_encodeSigned count x (fits x (by simp))] + rw [ih (fun value member => fits value (by simp [member]))] + +/-- Full successful wire admission exposes per-element format, the total-byte +ceiling, exact count, input model, and both represented endpoint bounds. -/ +theorem encodedBuildAdmission_success (model : InputModel) (inputs : List SignedBytes) + (left right : ByteArray) + (accepted : encodedBuildAdmission model inputs left right = true) : + inputs.length ≤ nativeCountLimit ∧ + (∀ input ∈ inputs, SignedFormat input.negative input.magnitude) ∧ + (inputs.map fun input => input.magnitude.size).sum ≤ nativeMagnitudeBudget ∧ + (decodeInputs inputs).length = inputs.length ∧ + InputDomain model (decodeInputs inputs) ∧ + QueryRepresented (wordWidth inputs.length) left right := by + have parts : nativeInputFormat inputs = true ∧ + buildAdmission model (decodeInputs inputs) inputs.length left right = true := by + simpa only [encodedBuildAdmission, Bool.and_eq_true] using accepted + have format := (nativeInputFormat_iff _).1 parts.1 + have admitted := (buildAdmission_iff _ _ _ _ _).1 parts.2 + exact ⟨format.1, format.2.1, format.2.2, decodeInputs_length _, admitted.2.2.1, + by simpa only [decodeInputs_length] using admitted.2.2.2⟩ + +theorem encodedBuildAdmission_iff (model : InputModel) (inputs : List SignedBytes) + (left right : ByteArray) : + encodedBuildAdmission model inputs left right = true ↔ + NativeInputFormat inputs ∧ InputDomain model (decodeInputs inputs) ∧ + QueryRepresented (wordWidth inputs.length) left right := by + constructor + · intro accepted + have h := encodedBuildAdmission_success _ _ _ _ accepted + exact ⟨⟨h.1, h.2.1, h.2.2.1⟩, h.2.2.2.2.1, h.2.2.2.2.2⟩ + · rintro ⟨format, domain, query⟩ + have admitted : BuildAdmitted model (decodeInputs inputs) inputs.length left right := + ⟨(decodeInputs_length inputs).symm, by simpa using format.1, domain, + by simpa only [decodeInputs_length] using query⟩ + simp only [encodedBuildAdmission, Bool.and_eq_true] + exact ⟨(nativeInputFormat_iff _).2 format, (buildAdmission_iff _ _ _ _ _).2 admitted⟩ + +/-- The C parser's format checks and this Lean admission check compose at the +same decoded list. No output equality or trusted duplicate count is assumed. -/ +theorem represented_input_bridge (inputs : List SignedBytes) (model : InputModel) + (left right : ByteArray) (format : NativeInputFormat inputs) + (domain : inputDomainCheck model (decodeInputs inputs) = true) + (query : queryAdmission (wordWidth inputs.length) left right = true) : + buildAdmission model (decodeInputs inputs) inputs.length left right = true ∧ + InputDomain model (decodeInputs inputs) ∧ + decodeMagnitude left < 2 ^ wordWidth inputs.length ∧ + decodeMagnitude right < 2 ^ wordWidth inputs.length := by + have hd := (inputDomainCheck_iff _ _).1 domain + have hq := (queryAdmission_iff _ _ _).1 query + refine ⟨(buildAdmission_iff _ _ _ _ _).2 ?_, hd, hq.1.2, hq.2.2⟩ + exact ⟨(decodeInputs_length inputs).symm, by simpa using format.1, hd, + by simpa only [decodeInputs_length] using hq⟩ + +end RMQ.SuccinctFinal.PackedNative.Lifecycle diff --git a/RMQ/Core/WordRAM/Native/Lifecycle/AdmissionContract.lean b/RMQ/Core/WordRAM/Native/Lifecycle/AdmissionContract.lean new file mode 100644 index 00000000..39e55e32 --- /dev/null +++ b/RMQ/Core/WordRAM/Native/Lifecycle/AdmissionContract.lean @@ -0,0 +1,174 @@ +import RMQ.Core.WordRAM.Native.Lifecycle.Admission + +/-! # Independent expected-type admission consumer + +These clients state their expected clauses directly. In particular, the wire +limits, actual count and endpoint bounds are not inferred from the current +producer declaration. Mutation replay first compiles the producer, then this +client; native parser correctness remains a separate foreign-code obligation. +-/ + +namespace RMQ.SuccinctFinal.PackedNative.Lifecycle.AdmissionContract + +open PackedLifecycle (InputModel) +open PackedWordRAM (wordWidth) + +theorem model_selection : + modelOfComparison false = InputModel.word ∧ + modelOfComparison true = InputModel.comparison := + ⟨modelOfComparison_false, modelOfComparison_true⟩ + +theorem signed_roundtrip (count : Nat) (value : Int) + (fits : value.natAbs < 256 ^ count) : + decodeSigned (signedNegative value) (encodeSigned count value) = value := + decodeSigned_encodeSigned count value fits + +theorem finite_integer_representation (value : Int) : + ∃ count, 0 < count ∧ + decodeSigned (signedNegative value) (encodeSigned count value) = value := + signed_representation_exists value + +theorem natural_serialization (value : Nat) : + 0 < (encodeNatural value).size ∧ + (encodeNatural value).size = value.log2 / 8 + 1 ∧ + decodeMagnitude (encodeNatural value) = value := + encodeNatural_exact value + +theorem signed_format (count : Nat) (value : Int) + (positive : 0 < count) (bounded : count ≤ 4096) + (fits : value.natAbs < 256 ^ count) : + 0 < (encodeSigned count value).size ∧ + (encodeSigned count value).size ≤ 4096 ∧ + (signedNegative value = true → + decodeMagnitude (encodeSigned count value) ≠ 0) := + encoded_signed_format count value positive bounded fits + +theorem signed_format_check (negative : Bool) (bytes : ByteArray) : + signedFormat negative bytes = true ↔ + 0 < bytes.size ∧ bytes.size ≤ 4096 ∧ + (negative = true → decodeMagnitude bytes ≠ 0) := + signedFormat_iff negative bytes + +theorem decoded_signed_fields (negative : Bool) (bytes : ByteArray) + (positive : 0 < bytes.size) (bounded : bytes.size ≤ 4096) + (nonzero : negative = true → decodeMagnitude bytes ≠ 0) : + (decodeSigned negative bytes).natAbs = decodeMagnitude bytes ∧ + signedNegative (decodeSigned negative bytes) = negative := + ⟨decodeSigned_magnitude negative bytes, + decodeSigned_sign negative bytes ⟨positive, bounded, nonzero⟩⟩ + +theorem count_conversion (count : Nat) (bounded : count ≤ 4096) : + (USize.ofNat count).toNat = count := nativeCount_toUSize_exact count bounded + +theorem actual_profile_alignment (count : Nat) : wordWidth count % 8 = 0 := + word_profile_byte_aligned count + +theorem signed_sequence (count : Nat) (xs : List Int) + (fits : ∀ value ∈ xs, value.natAbs < 256 ^ count) : + decodeInputs (xs.map (fun value => + (⟨signedNegative value, encodeSigned count value⟩ : SignedBytes))) = xs := + decodeInputs_encoded count xs fits + +theorem actual_count (inputs : List SignedBytes) : + (decodeInputs inputs).length = inputs.length := decodeInputs_length inputs + +theorem actual_input_at (inputs : List SignedBytes) (i : Nat) : + (decodeInputs inputs)[i]? = + (inputs[i]?).map (fun input => decodeSigned input.negative input.magnitude) := + decodeInputs_getElem? inputs i + +theorem endpoint_projection (width : Nat) (left right : ByteArray) + (accepted : queryAdmission width left right = true) : + left.size = LimbWord.limbCount width ∧ right.size = LimbWord.limbCount width ∧ + decodeMagnitude left < 2 ^ width ∧ decodeMagnitude right < 2 ^ width := + queryAdmission_success width left right accepted + +theorem endpoint_admission_check (width : Nat) (left right : ByteArray) : + queryAdmission width left right = true ↔ + (left.data.size = LimbWord.limbCount width ∧ LimbWord.decode left.data < 2 ^ width) ∧ + (right.data.size = LimbWord.limbCount width ∧ LimbWord.decode right.data < 2 ^ width) := + queryAdmission_iff width left right + +theorem endpoint_roundtrip_projection (width : Nat) (bytes : ByteArray) + (length : bytes.data.size = LimbWord.limbCount width) + (bound : LimbWord.decode bytes.data < 2 ^ width) : + (encodeEndpoint width (decodeMagnitude bytes)).data = bytes.data := + endpoint_roundtrip width bytes ⟨length, bound⟩ + +/-- Invalid represented ranges still pass admission. The lifecycle itself +must establish the ordinary None packet; admission does not synthesize it. -/ +theorem represented_invalid_range (width n left right : Nat) + (hl : left < 2 ^ width) (hr : right < 2 ^ width) + (_invalid : ¬ (left < right ∧ right ≤ n)) : + queryAdmission width (encodeEndpoint width left) (encodeEndpoint width right) = true ∧ + decodeMagnitude (encodeEndpoint width left) = left ∧ + decodeMagnitude (encodeEndpoint width right) = right := + ⟨queryAdmission_encoded width left right hl hr, + (encodeEndpoint_canonical width left hl).2, + (encodeEndpoint_canonical width right hr).2⟩ + +theorem word_admission (xs : List Int) (count : Nat) (left right : ByteArray) + (accepted : buildAdmission .word xs count left right = true) : + count = xs.length ∧ xs.length ≤ 4096 ∧ + PackedConstruction.InputFits (wordWidth xs.length) xs ∧ + left.size = LimbWord.limbCount (wordWidth xs.length) ∧ + right.size = LimbWord.limbCount (wordWidth xs.length) ∧ + decodeMagnitude left < 2 ^ wordWidth xs.length ∧ + decodeMagnitude right < 2 ^ wordWidth xs.length := + buildAdmission_success .word xs count left right accepted + +theorem word_bias (xs : List Int) (count : Nat) (left right : ByteArray) + (accepted : buildAdmission .word xs count left right = true) : + ∀ value ∈ xs, (PackedConstruction.encodeInt (wordWidth xs.length) value : Int) = + value + ((2 ^ (wordWidth xs.length - 1) : Nat) : Int) := + buildAdmission_word_bias xs count left right accepted + +theorem word_domain_failure (xs : List Int) (count : Nat) (left right : ByteArray) + (outside : ¬ PackedConstruction.InputFits (wordWidth xs.length) xs) : + buildAdmission .word xs count left right = false := + buildAdmission_word_rejects xs count left right outside + +theorem comparison_domain (xs : List Int) : inputDomainCheck .comparison xs = true := + (inputDomainCheck_iff .comparison xs).2 True.intro + +theorem build_admission_check (model : InputModel) (xs : List Int) (count : Nat) + (left right : ByteArray) : + buildAdmission model xs count left right = true ↔ + count = xs.length ∧ xs.length ≤ 4096 ∧ PackedLifecycle.InputDomain model xs ∧ + (left.data.size = LimbWord.limbCount (wordWidth xs.length) ∧ + LimbWord.decode left.data < 2 ^ wordWidth xs.length) ∧ + (right.data.size = LimbWord.limbCount (wordWidth xs.length) ∧ + LimbWord.decode right.data < 2 ^ wordWidth xs.length) := + buildAdmission_iff model xs count left right + +theorem full_wire_admission (model : InputModel) (inputs : List SignedBytes) + (left right : ByteArray) + (accepted : encodedBuildAdmission model inputs left right = true) : + inputs.length ≤ 4096 ∧ + (∀ input ∈ inputs, 0 < input.magnitude.size ∧ input.magnitude.size ≤ 4096 ∧ + (input.negative = true → decodeMagnitude input.magnitude ≠ 0)) ∧ + (inputs.map fun input => input.magnitude.size).sum ≤ 16777216 ∧ + (decodeInputs inputs).length = inputs.length ∧ + PackedLifecycle.InputDomain model (decodeInputs inputs) ∧ + (left.data.size = LimbWord.limbCount (wordWidth inputs.length) ∧ + LimbWord.decode left.data < 2 ^ wordWidth inputs.length) ∧ + (right.data.size = LimbWord.limbCount (wordWidth inputs.length) ∧ + LimbWord.decode right.data < 2 ^ wordWidth inputs.length) := + encodedBuildAdmission_success model inputs left right accepted + +theorem full_wire_converse (model : InputModel) (inputs : List SignedBytes) + (left right : ByteArray) + (count : inputs.length ≤ 4096) + (keys : ∀ input ∈ inputs, 0 < input.magnitude.size ∧ input.magnitude.size ≤ 4096 ∧ + (input.negative = true → decodeMagnitude input.magnitude ≠ 0)) + (total : (inputs.map fun input => input.magnitude.size).sum ≤ 16777216) + (domain : PackedLifecycle.InputDomain model (decodeInputs inputs)) + (leftLength : left.data.size = LimbWord.limbCount (wordWidth inputs.length)) + (leftBound : LimbWord.decode left.data < 2 ^ wordWidth inputs.length) + (rightLength : right.data.size = LimbWord.limbCount (wordWidth inputs.length)) + (rightBound : LimbWord.decode right.data < 2 ^ wordWidth inputs.length) : + encodedBuildAdmission model inputs left right = true := + (encodedBuildAdmission_iff model inputs left right).2 + ⟨⟨count, keys, total⟩, domain, ⟨leftLength, leftBound⟩, ⟨rightLength, rightBound⟩⟩ + +end RMQ.SuccinctFinal.PackedNative.Lifecycle.AdmissionContract diff --git a/RMQ/Core/WordRAM/Native/Lifecycle/BoundaryProofs.lean b/RMQ/Core/WordRAM/Native/Lifecycle/BoundaryProofs.lean new file mode 100644 index 00000000..c61bd032 --- /dev/null +++ b/RMQ/Core/WordRAM/Native/Lifecycle/BoundaryProofs.lean @@ -0,0 +1,174 @@ +import RMQ.Core.WordRAM.Native.Lifecycle.Entry +import RMQ.Core.WordRAM.Native.Lifecycle.Contract + +/-! # Exact metadata, admission, and packet boundary + +The native entry points use the same produced owner and arbitrary-precision +packet as the source lifecycle. Byte canonicality and exact decoding are +derived here; neither the returned answer nor its fit is an admission premise. +The byte and owner operations still rely on the generated-code/FFI boundary. +-/ + +namespace RMQ.SuccinctFinal.PackedNative.Lifecycle + +open PackedLifecycle +open PackedWordRAM (wordWidth optionNatPacket) + +theorem nativeInitial_runFirst_admitted (comparison : Bool) (xs : List Int) (count : Nat) + (left right : ByteArray) (accepted : nativeAdmit comparison xs count left right = true) : + nativeRunFirst comparison count (nativeInitial comparison xs left right) = + nativeBuildFirst comparison xs left right := by + have count_eq := ((nativeAdmit_source comparison xs count left right).1 accepted).1 + rw [count_eq] + exact nativeInitial_runFirst comparison xs left right + +theorem nativeInitial_runFirstObserved_admitted (comparison : Bool) (xs : List Int) (count : Nat) + (left right : ByteArray) (accepted : nativeAdmit comparison xs count left right = true) : + nativeRunFirstObserved comparison count (nativeInitial comparison xs left right) = + nativeBuildFirstObserved comparison xs left right := by + have count_eq := ((nativeAdmit_source comparison xs count left right).1 accepted).1 + rw [count_eq] + exact nativeInitial_runFirstObserved comparison xs left right + +theorem nativeMetadata_ready {xs : List Int} {owner : Owner} + (ready : Ownership.Ready xs owner) : + nativeMetadata owner 0 = some xs.length ∧ + nativeMetadata owner 7 = some owner.memory.size := + ready_metadata ready + +theorem producedCount_ready {xs : List Int} {owner : Owner} + (ready : Ownership.Ready xs owner) : producedCount owner = xs.length := by + simp only [producedCount, (nativeMetadata_ready ready).1, Option.getD_some] + +theorem buildFirst_metadata (model : InputModel) (xs : List Int) (left right : Nat) + (domain : InputDomain model xs) (hl : left < 2 ^ wordWidth xs.length) + (hr : right < 2 ^ wordWidth xs.length) : + producedCount (buildFirst model xs left right) = xs.length ∧ + nativeMetadata (buildFirst model xs left right) 0 = some xs.length ∧ + nativeMetadata (buildFirst model xs left right) 7 = + some (buildFirst model xs left right).memory.size := by + have ready : Ownership.Ready xs (buildFirst model xs left right) := by + rw [buildFirst_eq] + exact Ownership.ready model xs left right domain hl hr + exact ⟨producedCount_ready ready, nativeMetadata_ready ready⟩ + +theorem nativeQueryAdmit_iff (xs : List Int) (owner : Owner) (left right : ByteArray) + (ready : Ownership.Ready xs owner) : + nativeQueryAdmit owner left right = true ↔ + LimbWord.Canonical (wordWidth xs.length) left.data ∧ + LimbWord.Canonical (wordWidth xs.length) right.data := by + rw [nativeQueryAdmit, producedCount_ready ready] + exact queryAdmission_iff _ _ _ + +/-- The packet is bounded independently of a returned owner: the valid branch +is an index plus one at most the input length, and the invalid branch is zero. -/ +theorem answer_packet_fits (xs : List Int) (left right : Nat) : + optionNatPacket (SuccinctClassic.queryTraceResult xs left right).value < + 2 ^ wordWidth xs.length := by + have capacity := PackedWordRAM.size_lt_wordCapacity xs.length + rw [PackedWordRAM.queryTraceResult_value_reference] + by_cases valid : ValidRange xs left right + · simp only [if_pos valid, optionNatPacket, Option.map_some, Option.getD_some] + have bounds := Cartesian.scanWindow_bounds xs left (right - left) + (Nat.sub_pos_of_lt valid.1) + have hleft := valid.1 + have hright := valid.2 + omega + · simp only [if_neg valid, optionNatPacket, Option.map_none, Option.getD_none] + omega + +theorem nativePacket_exact (xs : List Int) (owner : Owner) (packet : Nat) + (ready : Ownership.Ready xs owner) (halted : owner.status = .halted packet) + (fits : packet < 2 ^ wordWidth xs.length) : + nativePacket owner = encodeEndpoint (wordWidth xs.length) packet ∧ + LimbWord.Canonical (wordWidth xs.length) (nativePacket owner).data ∧ + decodeMagnitude (nativePacket owner) = packet := by + have encoded : nativePacket owner = encodeEndpoint (wordWidth xs.length) packet := by + simp only [nativePacket, halted, producedCount_ready ready] + rw [encoded] + exact ⟨rfl, encodeEndpoint_canonical _ _ fits⟩ + +/-- The packet refinement retains the all-size source domain. Native admission +ceilings are introduced only in the admitted ABI theorem below. -/ +theorem buildFirst_packet (model : InputModel) (xs : List Int) (left right : Nat) + (domain : InputDomain model xs) (hl : left < 2 ^ wordWidth xs.length) + (hr : right < 2 ^ wordWidth xs.length) : + nativePacket (buildFirst model xs left right) = encodeEndpoint (wordWidth xs.length) + (optionNatPacket (SuccinctClassic.queryTraceResult xs left right).value) ∧ + LimbWord.Canonical (wordWidth xs.length) (nativePacket (buildFirst model xs left right)).data ∧ + decodeMagnitude (nativePacket (buildFirst model xs left right)) = + optionNatPacket (SuccinctClassic.queryTraceResult xs left right).value := by + rw [buildFirst_eq] + exact nativePacket_exact xs _ _ (Ownership.ready model xs left right domain hl hr) + (Ownership.halted model xs left right domain hl hr) (answer_packet_fits xs left right) + +theorem query_packet (model : InputModel) (xs : List Int) (owner : Owner) + (left right answer : Nat) (ready : Ownership.Ready xs owner) + (halted : owner.status = .halted answer) + (hl : left < 2 ^ wordWidth xs.length) (hr : right < 2 ^ wordWidth xs.length) : + nativePacket (query model left right owner) = encodeEndpoint (wordWidth xs.length) + (optionNatPacket (SuccinctClassic.queryTraceResult xs left right).value) ∧ + LimbWord.Canonical (wordWidth xs.length) (nativePacket (query model left right owner)).data ∧ + decodeMagnitude (nativePacket (query model left right owner)) = + optionNatPacket (SuccinctClassic.queryTraceResult xs left right).value := by + rw [query_eq] + have reuse := ready.query model left right answer halted hl hr + exact nativePacket_exact xs _ _ reuse.1 reuse.2.1 (answer_packet_fits xs left right) + +theorem nativeBuildFirst_correct (comparison : Bool) (xs : List Int) (count : Nat) + (left right : ByteArray) (accepted : nativeAdmit comparison xs count left right = true) : + nativeBuildFirst comparison xs left right = Ownership.owner (modelOfComparison comparison) xs + (decodeMagnitude left) (decodeMagnitude right) ∧ + Ownership.Ready xs (nativeBuildFirst comparison xs left right) ∧ + (nativeBuildFirst comparison xs left right).status = .halted + (optionNatPacket (SuccinctClassic.queryTraceResult xs + (decodeMagnitude left) (decodeMagnitude right)).value) := by + obtain ⟨_, _, domain, represented⟩ := (nativeAdmit_source _ _ _ _ _).1 accepted + have source : nativeBuildFirst comparison xs left right = + Ownership.owner (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right) := + buildFirst_eq _ _ _ _ + rw [source] + exact ⟨rfl, Ownership.ready _ _ _ _ domain represented.1.2 represented.2.2, + Ownership.halted _ _ _ _ domain represented.1.2 represented.2.2⟩ + +theorem nativeBuildFirst_packet (comparison : Bool) (xs : List Int) (count : Nat) + (left right : ByteArray) (accepted : nativeAdmit comparison xs count left right = true) : + nativePacket (nativeBuildFirst comparison xs left right) = encodeEndpoint (wordWidth xs.length) + (optionNatPacket (SuccinctClassic.queryTraceResult xs + (decodeMagnitude left) (decodeMagnitude right)).value) ∧ + LimbWord.Canonical (wordWidth xs.length) + (nativePacket (nativeBuildFirst comparison xs left right)).data ∧ + decodeMagnitude (nativePacket (nativeBuildFirst comparison xs left right)) = + optionNatPacket (SuccinctClassic.queryTraceResult xs + (decodeMagnitude left) (decodeMagnitude right)).value := by + have correct := nativeBuildFirst_correct comparison xs count left right accepted + exact nativePacket_exact xs _ _ correct.2.1 correct.2.2 (answer_packet_fits xs _ _) + +theorem nativeQuery_correct (comparison : Bool) (xs : List Int) (owner : Owner) + (left right : ByteArray) (answer : Nat) (ready : Ownership.Ready xs owner) + (halted : owner.status = .halted answer) (accepted : nativeQueryAdmit owner left right = true) : + Ownership.Ready xs (nativeQuery comparison left right owner) ∧ + (nativeQuery comparison left right owner).status = .halted + (optionNatPacket (SuccinctClassic.queryTraceResult xs + (decodeMagnitude left) (decodeMagnitude right)).value) ∧ + (nativeQuery comparison left right owner).memory = owner.memory := by + have represented := (nativeQueryAdmit_iff xs owner left right ready).1 accepted + have reuse := ready.query (modelOfComparison comparison) (decodeMagnitude left) + (decodeMagnitude right) answer halted represented.1.2 represented.2.2 + simp only [nativeQuery, query_eq] + exact ⟨reuse.1, reuse.2.1, reuse.2.2.1⟩ + +theorem nativeQuery_packet (comparison : Bool) (xs : List Int) (owner : Owner) + (left right : ByteArray) (answer : Nat) (ready : Ownership.Ready xs owner) + (halted : owner.status = .halted answer) (accepted : nativeQueryAdmit owner left right = true) : + nativePacket (nativeQuery comparison left right owner) = encodeEndpoint (wordWidth xs.length) + (optionNatPacket (SuccinctClassic.queryTraceResult xs + (decodeMagnitude left) (decodeMagnitude right)).value) ∧ + LimbWord.Canonical (wordWidth xs.length) (nativePacket (nativeQuery comparison left right owner)).data ∧ + decodeMagnitude (nativePacket (nativeQuery comparison left right owner)) = + optionNatPacket (SuccinctClassic.queryTraceResult xs + (decodeMagnitude left) (decodeMagnitude right)).value := by + have correct := nativeQuery_correct comparison xs owner left right answer ready halted accepted + exact nativePacket_exact xs _ _ correct.1 correct.2.1 (answer_packet_fits xs _ _) + +end RMQ.SuccinctFinal.PackedNative.Lifecycle diff --git a/RMQ/Core/WordRAM/Native/Lifecycle/Codec.lean b/RMQ/Core/WordRAM/Native/Lifecycle/Codec.lean new file mode 100644 index 00000000..8681132a --- /dev/null +++ b/RMQ/Core/WordRAM/Native/Lifecycle/Codec.lean @@ -0,0 +1,155 @@ +import RMQ.Core.WordRAM.Native.Limbs + +/-! # Lifecycle signed magnitude and endpoint codecs + +Magnitude bytes are little endian. Leading zero bytes at the high end are +allowed; the native input format requires at least one byte and forbids a +negative sign on zero. Arithmetic in this module is arbitrary precision. +The size ceilings in `SignedFormat` describe host admission, not the model's +word domain. Foreign pointer validity and the 0/1 sign flag are C obligations. +-/ + +namespace RMQ.SuccinctFinal.PackedNative.Lifecycle + +def maxMagnitudeBytes : Nat := 4096 + +def decodeMagnitude (bytes : ByteArray) : Nat := LimbWord.decode bytes.data + +def decodeSigned (negative : Bool) (bytes : ByteArray) : Int := + if negative then -(decodeMagnitude bytes : Int) else (decodeMagnitude bytes : Int) + +def encodeMagnitude (count value : Nat) : ByteArray := + ⟨(LimbWord.encodeList count value).toArray⟩ + +def signedNegative (value : Int) : Bool := decide (value < 0) + +def encodeSigned (count : Nat) (value : Int) : ByteArray := + encodeMagnitude count value.natAbs + +/-- A host input may have high zero padding, but has a unique sign for zero. -/ +def SignedFormat (negative : Bool) (bytes : ByteArray) : Prop := + 0 < bytes.size ∧ bytes.size ≤ maxMagnitudeBytes ∧ + (negative = true → decodeMagnitude bytes ≠ 0) + +instance (negative : Bool) (bytes : ByteArray) : Decidable (SignedFormat negative bytes) := + inferInstanceAs (Decidable (_ ∧ _)) + +def signedFormat (negative : Bool) (bytes : ByteArray) : Bool := + decide (SignedFormat negative bytes) + +theorem signedFormat_iff (negative : Bool) (bytes : ByteArray) : + signedFormat negative bytes = true ↔ SignedFormat negative bytes := by + simp [signedFormat] + +theorem decodeSigned_magnitude (negative : Bool) (bytes : ByteArray) : + (decodeSigned negative bytes).natAbs = decodeMagnitude bytes := by + cases negative <;> simp [decodeSigned] + +theorem decodeSigned_sign (negative : Bool) (bytes : ByteArray) + (format : SignedFormat negative bytes) : + signedNegative (decodeSigned negative bytes) = negative := by + cases negative with + | false => simp [signedNegative, decodeSigned] + | true => + have positive : 0 < decodeMagnitude bytes := by + have nonzero := format.2.2 rfl + omega + simp [signedNegative, decodeSigned, positive] + +@[simp] theorem encodeMagnitude_size (count value : Nat) : + (encodeMagnitude count value).size = count := by + simp [encodeMagnitude, ByteArray.size] + +theorem decodeMagnitude_encodeMagnitude (count value : Nat) + (fits : value < 256 ^ count) : + decodeMagnitude (encodeMagnitude count value) = value := by + simpa [decodeMagnitude, encodeMagnitude, LimbWord.decode] using + LimbWord.decodeList_encodeList count value fits + +/-- Diagnostic naturals have an independent, nonempty magnitude buffer. -/ +def encodeNatural (value : Nat) : ByteArray := + encodeMagnitude (value.log2 / 8 + 1) value + +theorem encodeNatural_exact (value : Nat) : + 0 < (encodeNatural value).size ∧ + (encodeNatural value).size = value.log2 / 8 + 1 ∧ + decodeMagnitude (encodeNatural value) = value := by + refine ⟨by simp [encodeNatural], by simp [encodeNatural], ?_⟩ + apply decodeMagnitude_encodeMagnitude + rw [LimbWord.byte_capacity] + exact Nat.lt_of_lt_of_le Nat.lt_log2_self + (Nat.pow_le_pow_right (by decide : 0 < 2) (by omega)) + +theorem decodeSigned_encodeSigned (count : Nat) (value : Int) + (fits : value.natAbs < 256 ^ count) : + decodeSigned (signedNegative value) (encodeSigned count value) = value := by + unfold decodeSigned encodeSigned + rw [decodeMagnitude_encodeMagnitude count value.natAbs fits] + cases value with + | ofNat n => + change (if decide ((n : Int) < 0) then -(n : Int) else (n : Int)) = (n : Int) + have nonnegative : ¬ ((n : Int) < 0) := by omega + simp [nonnegative] + | negSucc n => + change (if decide (Int.negSucc n < 0) then -((n + 1 : Nat) : Int) + else ((n + 1 : Nat) : Int)) = Int.negSucc n + simp only [Int.negSucc_lt_zero, decide_true, ↓reduceIte] <;> rfl + +theorem encoded_signed_format (count : Nat) (value : Int) + (positive : 0 < count) (bounded : count ≤ maxMagnitudeBytes) + (fits : value.natAbs < 256 ^ count) : + SignedFormat (signedNegative value) (encodeSigned count value) := by + refine ⟨by simpa [encodeSigned] using positive, + by simpa [encodeSigned] using bounded, ?_⟩ + intro negative + rw [encodeSigned, decodeMagnitude_encodeMagnitude count value.natAbs fits] + have hneg : value < 0 := by simpa [signedNegative] using negative + cases value with + | ofNat n => omega + | negSucc n => simp + +/-- Every finite integer has an exact sign/magnitude representation. The +chosen count here is an existence witness, not an allocation policy. -/ +theorem signed_representation_exists (value : Int) : + ∃ count, 0 < count ∧ + decodeSigned (signedNegative value) (encodeSigned count value) = value := by + refine ⟨value.natAbs + 1, by omega, decodeSigned_encodeSigned _ _ ?_⟩ + have hlarge : value.natAbs < 2 ^ (value.natAbs + 1) := by + have := Nat.lt_two_pow_self (n := value.natAbs + 1) + omega + exact Nat.lt_of_lt_of_le hlarge + (Nat.pow_le_pow_left (by decide : 2 ≤ 256) (value.natAbs + 1)) + +theorem decodeSigned_nonnegative_zero (bytes : ByteArray) + (zero : decodeMagnitude bytes = 0) : decodeSigned false bytes = 0 := by + simp [decodeSigned, zero] + +theorem signedFormat_rejects_negative_zero (bytes : ByteArray) + (zero : decodeMagnitude bytes = 0) : signedFormat true bytes = false := by + simp [signedFormat, SignedFormat, zero] + +/-- Endpoint encoding is fixed width and separate from signed key encoding. -/ +def encodeEndpoint (width value : Nat) : ByteArray := ⟨LimbWord.encode width value⟩ + +theorem encodeEndpoint_canonical (width value : Nat) (fits : value < 2 ^ width) : + LimbWord.Canonical width (encodeEndpoint width value).data ∧ + decodeMagnitude (encodeEndpoint width value) = value := + ⟨LimbWord.canonical_encode width value fits, LimbWord.decode_encode width value fits⟩ + +theorem endpoint_roundtrip (width : Nat) (bytes : ByteArray) + (canonical : LimbWord.Canonical width bytes.data) : + (encodeEndpoint width (decodeMagnitude bytes)).data = bytes.data := + LimbWord.encode_decode width bytes.data canonical.1 + +/-- Kernel controls for permitted padding, canonical zero sign, and a negative +input beyond 128 bits. These are codec facts, not native execution evidence. -/ +theorem signed_codec_boundaries : + decodeSigned true ⟨#[5, 0]⟩ = -5 ∧ + signedFormat true ⟨#[5, 0]⟩ = true ∧ + signedFormat false ⟨#[0, 0]⟩ = true ∧ + signedFormat true ⟨#[0, 0]⟩ = false ∧ + decodeSigned true ⟨#[7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4]⟩ = + -((2 ^ 130 + 7 : Nat) : Int) := by + decide + +end RMQ.SuccinctFinal.PackedNative.Lifecycle diff --git a/RMQ/Core/WordRAM/Native/Lifecycle/Contract.lean b/RMQ/Core/WordRAM/Native/Lifecycle/Contract.lean new file mode 100644 index 00000000..23d8cdd9 --- /dev/null +++ b/RMQ/Core/WordRAM/Native/Lifecycle/Contract.lean @@ -0,0 +1,132 @@ +import RMQ.Core.WordRAM.Native.Lifecycle.Repack + +/-! # One export contract for the produced lifecycle owner + +Every construction projection below concerns `buildFirst`, without assuming a +final-memory or answer equality. The domain is the original all-size lifecycle +domain and represented endpoints, including represented invalid RMQ ranges. +Host admission and foreign ownership/capacity are deliberately not hypotheses +or conclusions of this kernel contract. +-/ + +namespace RMQ.SuccinctFinal.PackedNative.Lifecycle + +open PackedLifecycle +open PackedWordRAM (buildMemory wordWidth) +open PackedWordRAM.Optimization (compactQueryRun) + +set_option maxRecDepth 30000 + +theorem ready_metadata {xs : List Int} {owner : Owner} (ready : Ownership.Ready xs owner) : + owner.memory.getD 0 none = some xs.length ∧ + owner.memory.getD 7 none = some owner.memory.size := by + have contents : (fun a => owner.memory.getD a none) = fun a => (buildMemory xs)[a]? := + ready.2.1.1 + refine ⟨(congrFun contents 0).trans (Builder.metadata_zero xs), ?_⟩ + rw [congrFun contents 7, Builder.metadata_seven, ready.memory_size] + +structure QueryContract (model : InputModel) (xs : List Int) (left right : Nat) + (owner : Owner) : Prop where + source : query model left right owner = Executable.queryOwner model left right owner + projection : (query model left right owner).toState = + (Reusable.queryRun model left right owner.toState).final + ready : Ownership.Ready xs (query model left right owner) + halted : (query model left right owner).status = .halted + (PackedWordRAM.optionNatPacket (SuccinctClassic.queryTraceResult xs left right).value) + memory : (query model left right owner).memory = owner.memory + observations : (Executable.queryArray model left right owner).toRun = + Reusable.queryRun model left right owner.toState + boundary : (requestProtocol Layout.serviceEntry left right owner.toState).steps = 4 ∧ + (requestProtocol Layout.serviceEntry left right owner.toState).categories = + [.requestAdmission, .requestAdmission, .controlEntry, .controlEntry] + steps : (Reusable.queryRun model left right owner.toState).steps = 4 + 4 + QueryEntry.setupCost + + (compactQueryRun (buildMemory xs) xs.length left right).steps + budget : (Reusable.queryRun model left right owner.toState).steps ≤ 160257 + capacity : Ownership.capacity model (query model left right owner) * wordWidth xs.length ≤ + 2 * xs.length + retainedRho xs.length + +theorem query_contract (model : InputModel) (xs : List Int) (left right answer : Nat) + (owner : Owner) (ready : Ownership.Ready xs owner) (halted : owner.status = .halted answer) + (hl : left < 2 ^ wordWidth xs.length) (hr : right < 2 ^ wordWidth xs.length) : + QueryContract model xs left right owner := by + have reuse := ready.query model left right answer halted hl hr + have refinement := Executable.query_owner_refinement model xs left right answer owner + ready.1 ready.2 halted hl hr + have correct := Reusable.query_correct model xs left right answer owner.toState ready.2 halted hl hr + exact { + source := query_eq model left right owner + projection := by rw [query_eq]; exact refinement.1 + ready := by rw [query_eq]; exact reuse.1 + halted := by rw [query_eq]; exact reuse.2.1 + memory := by rw [query_eq]; exact reuse.2.2.1 + observations := reuse.2.2.2.1 + boundary := (requestProtocol_exact Layout.serviceEntry left right answer owner.toState halted).2 + steps := correct.2.2.2.2.1 + budget := reuse.2.2.2.2 + capacity := by rw [query_eq]; exact reuse.1.capacity_bound model } + +structure ExportContract (model : InputModel) (xs : List Int) (left right : Nat) : Prop where + program : cachedProgram model = (Layout.program model).toArray + owner : buildFirst model xs left right = Ownership.owner model xs left right + projection : (buildFirst model xs left right).toState = + (Continuous.continuousRun model xs left right).final + ready : Ownership.Ready xs (buildFirst model xs left right) + halted : (buildFirst model xs left right).status = .halted + (PackedWordRAM.optionNatPacket (SuccinctClassic.queryTraceResult xs left right).value) + memory : (∀ a, (buildFirst model xs left right).memory.getD a none = (buildMemory xs)[a]?) ∧ + (buildFirst model xs left right).memory.size = (buildMemory xs).length + emptyKeys : (buildFirst model xs left right).keys = #[] ∧ + (buildFirst model xs left right).keyRegs = #[] + bank : (buildFirst model xs left right).regs.size = 8273 + capacity : Ownership.capacity model (buildFirst model xs left right) * wordWidth xs.length ≤ + 2 * xs.length + retainedRho xs.length + metadata : (buildFirst model xs left right).memory.getD 0 none = some xs.length ∧ + (buildFirst model xs left right).memory.getD 7 none = + some (buildFirst model xs left right).memory.size + observations : (Ownership.observations model xs left right).toRun = + Continuous.continuousRun model xs left right + continuation : ∀ (es : Owner) (newLeft newRight answer : Nat), Ownership.Ready xs es → + es.status = .halted answer → newLeft < 2 ^ wordWidth xs.length → + newRight < 2 ^ wordWidth xs.length → QueryContract model xs newLeft newRight es + repacking : ∀ (source target : Owner) (newLeft newRight : Nat), Repacked source target → + target = source ∧ target.toState = source.toState ∧ target.status = source.status ∧ + (Ownership.Ready xs target ↔ Ownership.Ready xs source) ∧ + Ownership.capacity model target = Ownership.capacity model source ∧ + query model newLeft newRight target = query model newLeft newRight source + +theorem export_contract (model : InputModel) (xs : List Int) (left right : Nat) + (domain : InputDomain model xs) (hl : left < 2 ^ wordWidth xs.length) + (hr : right < 2 ^ wordWidth xs.length) : ExportContract model xs left right := by + have ready : Ownership.Ready xs (buildFirst model xs left right) := by + rw [buildFirst_eq] + exact Ownership.ready model xs left right domain hl hr + have refinement := Ownership.refinement model xs left right domain hl hr + exact { + program := cachedProgram_eq model + owner := buildFirst_eq model xs left right + projection := by rw [buildFirst_eq]; exact refinement.1 + ready := ready + halted := by rw [buildFirst_eq]; exact Ownership.halted model xs left right domain hl hr + memory := ⟨fun a => congrFun ready.2.1.1 a, ready.memory_size⟩ + emptyKeys := ready.empty_keys + bank := ready.1 + capacity := ready.capacity_bound model + metadata := ready_metadata ready + observations := refinement.2.2 + continuation := fun es newLeft newRight answer hrdy hhalt hleft hright => + query_contract model xs newLeft newRight answer es hrdy hhalt hleft hright + repacking := fun source target newLeft newRight copy => + repack_transport xs model newLeft newRight source target copy } + +theorem word_export_contract (xs : List Int) (left right : Nat) + (domain : PackedConstruction.InputFits (wordWidth xs.length) xs) + (hl : left < 2 ^ wordWidth xs.length) (hr : right < 2 ^ wordWidth xs.length) : + ExportContract .word xs left right := + export_contract .word xs left right domain hl hr + +theorem comparison_export_contract (xs : List Int) (left right : Nat) + (hl : left < 2 ^ wordWidth xs.length) (hr : right < 2 ^ wordWidth xs.length) : + ExportContract .comparison xs left right := + export_contract .comparison xs left right trivial hl hr + +end RMQ.SuccinctFinal.PackedNative.Lifecycle diff --git a/RMQ/Core/WordRAM/Native/Lifecycle/Entry.lean b/RMQ/Core/WordRAM/Native/Lifecycle/Entry.lean new file mode 100644 index 00000000..3cb62996 --- /dev/null +++ b/RMQ/Core/WordRAM/Native/Lifecycle/Entry.lean @@ -0,0 +1,187 @@ +import RMQ.Core.WordRAM.Native.Lifecycle.Admission +import RMQ.Core.WordRAM.Native.Lifecycle.Run +import RMQ.Core.WordRAM.Native.Lifecycle.Observations + +/-! # Computational exports for the consuming lifecycle ABI + +These declarations expose the existing lifecycle evaluator. Foreign pointer +validity, reference ownership, native array capacity and compiler correctness +are outside the kernel propositions. Admission is a separate operation before +the foreign caller transfers an operational owner. +-/ + +namespace RMQ.SuccinctFinal.PackedNative.Lifecycle + +open PackedLifecycle (Owner InputModel) +open PackedWordRAM (wordWidth) + +@[export rmq_lifecycle_decode_signed] +def nativeDecodeSigned (negative : Bool) (magnitude : ByteArray) : Int := + decodeSigned negative magnitude + +@[export rmq_lifecycle_signed_format] +def nativeSignedFormat (negative : Bool) (magnitude : ByteArray) : Bool := + signedFormat negative magnitude + +@[export rmq_lifecycle_profile] +def nativeProfile (count : Nat) : Nat := wordWidth count + +@[export rmq_lifecycle_admit] +def nativeAdmit (comparison : Bool) (xs : List Int) (count : Nat) + (left right : ByteArray) : Bool := + buildAdmission (modelOfComparison comparison) xs count left right + +@[export rmq_lifecycle_build_first] +def nativeBuildFirst (comparison : Bool) (xs : List Int) (left right : ByteArray) : Owner := + buildFirst (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right) + +/-- Split at the actual initial owner so the native boundary can inspect and +measure construction roots before consuming them. No reference payload enters +this interface. The count is the successfully admitted decoded list length. -/ +@[export rmq_lifecycle_initial] +def nativeInitial (comparison : Bool) (xs : List Int) (left right : ByteArray) : Owner := + PackedLifecycle.Executable.initialOwner (modelOfComparison comparison) xs + (decodeMagnitude left) (decodeMagnitude right) + +@[export rmq_lifecycle_run_first] +def nativeRunFirst (comparison : Bool) (count : Nat) (owner : Owner) : Owner := + runThin (cachedProgram (modelOfComparison comparison)) + (PackedLifecycle.Continuous.lifecycleBudget count) owner + +/-- A bounded-call surface for testing status classification. Canonical admitted +production calls use the proved full budget; this general runner changes no +primitive and makes no claim that injected fault states are valid inputs. -/ +@[export rmq_lifecycle_run_fuel] +def nativeRunFuel (comparison : Bool) (fuel : Nat) (owner : Owner) : Owner := + runThin (cachedProgram (modelOfComparison comparison)) fuel owner + +theorem nativeRunFuel_source (comparison : Bool) (fuel : Nat) (owner : Owner) : + nativeRunFuel comparison fuel owner = + PackedLifecycle.runOwner + (PackedLifecycle.Layout.program (modelOfComparison comparison)).toArray fuel owner := by + unfold nativeRunFuel + rw [runThin_eq_runOwner, cachedProgram_eq] + +theorem nativeInitial_runFirst (comparison : Bool) (xs : List Int) (left right : ByteArray) : + nativeRunFirst comparison xs.length (nativeInitial comparison xs left right) = + nativeBuildFirst comparison xs left right := rfl + +/-- Metadata is read from the actual produced memory, not caller duplicates. -/ +@[export rmq_lifecycle_metadata] +def nativeMetadata (owner : Owner) (address : Nat) : Option Nat := + owner.memory.getD address none + +def producedCount (owner : Owner) : Nat := + (nativeMetadata owner 0).getD 0 + +@[export rmq_lifecycle_query_admit] +def nativeQueryAdmit (owner : Owner) (left right : ByteArray) : Bool := + queryAdmission (wordWidth (producedCount owner)) left right + +@[export rmq_lifecycle_query] +def nativeQuery (comparison : Bool) (left right : ByteArray) (owner : Owner) : Owner := + query (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner + +/-- The answer packet stays a Nat until fixed-width byte encoding. -/ +@[export rmq_lifecycle_packet] +def nativePacket (owner : Owner) : ByteArray := + match owner.status with + | .halted packet => encodeEndpoint (wordWidth (producedCount owner)) packet + | _ => ByteArray.empty + +@[export rmq_lifecycle_status] +def nativeStatus (owner : Owner) : UInt8 := + match owner.status with + | .running => 0 + | .halted _ => 1 + | .fault => 2 + +@[export rmq_lifecycle_build_first_observed] +def nativeBuildFirstObserved (comparison : Bool) (xs : List Int) + (left right : ByteArray) : Owner × Observations.Stats := + Observations.buildFirst (modelOfComparison comparison) xs + (decodeMagnitude left) (decodeMagnitude right) + +@[export rmq_lifecycle_run_first_observed] +def nativeRunFirstObserved (comparison : Bool) (count : Nat) + (owner : Owner) : Owner × Observations.Stats := + Observations.run (cachedProgram (modelOfComparison comparison)) + (PackedLifecycle.Continuous.lifecycleBudget count) owner + +theorem nativeInitial_runFirstObserved (comparison : Bool) (xs : List Int) + (left right : ByteArray) : + nativeRunFirstObserved comparison xs.length (nativeInitial comparison xs left right) = + nativeBuildFirstObserved comparison xs left right := rfl + +@[export rmq_lifecycle_query_observed] +def nativeQueryObserved (comparison : Bool) (left right : ByteArray) + (owner : Owner) : Owner × Observations.Stats := + Observations.query (modelOfComparison comparison) (decodeMagnitude left) + (decodeMagnitude right) owner + +/-- The ABI rejects category IDs outside 0..15 before calling this projection. -/ +def observationCategories : Array PackedLifecycle.Category := + #[.old .read, .old .register, .old .arithmetic, .old .comparison, .old .branch, + .old .control, .old .write, .old .allocation, .old .keyRead, + .old .oracleComparison, .numericRelease, .keyRelease, .keyRegisterRelease, + .requestAdmission, .controlEntry] + +@[export rmq_lifecycle_observation_counter] +def nativeObservationCounter (stats : Observations.Stats) (category : UInt8) : Nat := + if category = 15 then stats.steps + else stats.counts.get (observationCategories[category.toNat]?.getD (.old .read)) + +@[export rmq_lifecycle_observation_reads] +def nativeObservationReads (stats : Observations.Stats) : Array (Nat × Option Nat) := + stats.reads.toArray + +def observationRouteMarks : Array Observations.RouteMark := + #[.compactQuery, .servicePrepare, .serviceSetup, .builder, .descriptor, + .finalizer, .retirement, .sameBlockDecision, .crossBlockDecision, + .interiorNonemptyDecision, .interiorEmptyDecision, .interiorReadMarker, + .crossingSecondLoad] + +@[export rmq_lifecycle_observation_route] +def nativeObservationRoute (stats : Observations.Stats) (mark : UInt8) : Nat := + stats.routes.get (observationRouteMarks[mark.toNat]?.getD .compactQuery) + +@[export rmq_lifecycle_signature_count] +def nativeSignatureCount (comparison : Bool) (mark : UInt8) : Nat := + Observations.programSignatureCount (modelOfComparison comparison) + (observationRouteMarks[mark.toNat]?.getD .compactQuery) + +@[export rmq_lifecycle_encode_natural] +def nativeEncodeNatural (value : Nat) : ByteArray := encodeNatural value + +/-- Borrowing/sharing this fixed code at the foreign boundary is separate from +the exclusive operational owner; it has no input-specific data. -/ +@[export rmq_lifecycle_program] +def nativeProgram (comparison : Bool) : Array PackedLifecycle.Instruction := + cachedProgram (modelOfComparison comparison) + +theorem nativeBuildFirstObserved_owner (comparison : Bool) (xs : List Int) + (left right : ByteArray) : + (nativeBuildFirstObserved comparison xs left right).1 = + nativeBuildFirst comparison xs left right := + Observations.buildFirst_owner _ _ _ _ + +theorem nativeQueryObserved_owner (comparison : Bool) (left right : ByteArray) + (owner : Owner) : (nativeQueryObserved comparison left right owner).1 = + nativeQuery comparison left right owner := + Observations.query_owner _ _ _ _ + +theorem nativeBuildFirst_source (comparison : Bool) (xs : List Int) (left right : ByteArray) : + nativeBuildFirst comparison xs left right = + buildFirst (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right) := rfl + +theorem nativeQuery_source (comparison : Bool) (left right : ByteArray) (owner : Owner) : + nativeQuery comparison left right owner = + query (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner := rfl + +theorem nativeAdmit_source (comparison : Bool) (xs : List Int) (count : Nat) + (left right : ByteArray) : + nativeAdmit comparison xs count left right = true ↔ + BuildAdmitted (modelOfComparison comparison) xs count left right := + buildAdmission_iff _ _ _ _ _ + +end RMQ.SuccinctFinal.PackedNative.Lifecycle diff --git a/RMQ/Core/WordRAM/Native/Lifecycle/Observations.lean b/RMQ/Core/WordRAM/Native/Lifecycle/Observations.lean new file mode 100644 index 00000000..85c734bc --- /dev/null +++ b/RMQ/Core/WordRAM/Native/Lifecycle/Observations.lean @@ -0,0 +1,665 @@ +import RMQ.Core.WordRAM.Native.Lifecycle.Run + +/-! # Separately owned lifecycle diagnostics + +The observation accumulator contains fifteen category counters, thirteen route +counters, a step count, and ordered numeric read/reply pairs. It contains no owner, transition, +input, or state-valued closure. The executable evaluator records prestate scalars +before calling the unchanged `executeArray`, and is unconditionally equal to the +`stepArray` evaluator. Histories appear only in the statements and proofs of its +fold theorem. These are model observations, not native allocator measurements. +-/ + +namespace RMQ.SuccinctFinal.PackedNative.Lifecycle + +open PackedLifecycle + +namespace Observations + +/-- One scalar for each constructor of the existing finite category universe. -/ +structure Counts where + read : Nat := 0 + register : Nat := 0 + arithmetic : Nat := 0 + comparison : Nat := 0 + branch : Nat := 0 + control : Nat := 0 + write : Nat := 0 + allocation : Nat := 0 + keyRead : Nat := 0 + oracleComparison : Nat := 0 + numericRelease : Nat := 0 + keyRelease : Nat := 0 + keyRegisterRelease : Nat := 0 + requestAdmission : Nat := 0 + controlEntry : Nat := 0 +deriving Repr, DecidableEq + +def Counts.get (n : Counts) : Category → Nat + | .old .read => n.read + | .old .register => n.register + | .old .arithmetic => n.arithmetic + | .old .comparison => n.comparison + | .old .branch => n.branch + | .old .control => n.control + | .old .write => n.write + | .old .allocation => n.allocation + | .old .keyRead => n.keyRead + | .old .oracleComparison => n.oracleComparison + | .numericRelease => n.numericRelease + | .keyRelease => n.keyRelease + | .keyRegisterRelease => n.keyRegisterRelease + | .requestAdmission => n.requestAdmission + | .controlEntry => n.controlEntry + +def Counts.bump (n : Counts) : Category → Counts + | .old .read => { n with read := n.read + 1 } + | .old .register => { n with register := n.register + 1 } + | .old .arithmetic => { n with arithmetic := n.arithmetic + 1 } + | .old .comparison => { n with comparison := n.comparison + 1 } + | .old .branch => { n with branch := n.branch + 1 } + | .old .control => { n with control := n.control + 1 } + | .old .write => { n with write := n.write + 1 } + | .old .allocation => { n with allocation := n.allocation + 1 } + | .old .keyRead => { n with keyRead := n.keyRead + 1 } + | .old .oracleComparison => { n with oracleComparison := n.oracleComparison + 1 } + | .numericRelease => { n with numericRelease := n.numericRelease + 1 } + | .keyRelease => { n with keyRelease := n.keyRelease + 1 } + | .keyRegisterRelease => { n with keyRegisterRelease := n.keyRegisterRelease + 1 } + | .requestAdmission => { n with requestAdmission := n.requestAdmission + 1 } + | .controlEntry => { n with controlEntry := n.controlEntry + 1 } + +theorem Counts.get_bump (n : Counts) (a c : Category) : + (n.bump a).get c = n.get c + if a = c then 1 else 0 := by + cases a <;> cases c + all_goals first + | rename_i a c; cases a <;> cases c <;> simp [Counts.bump, Counts.get] + | rename_i a; cases a <;> simp [Counts.bump, Counts.get] + | simp [Counts.bump, Counts.get] + +theorem Counts.get_zero (c : Category) : ({} : Counts).get c = 0 := by + cases c + · rename_i c; cases c <;> rfl + all_goals rfl + +/-- Phase visits and source-discriminator occurrences. A decision counter says +the corresponding comparison was executed on its recorded input values. The +separate interior-reader and crossing-load counters record actual instructions, +not a predicted route. Native labels must also check the fixed program's +signature inventory and successful completion. -/ +inductive RouteMark where + | compactQuery | servicePrepare | serviceSetup | builder | descriptor | finalizer | retirement + | sameBlockDecision | crossBlockDecision | interiorNonemptyDecision | interiorEmptyDecision + | interiorReadMarker | crossingSecondLoad +deriving Repr, DecidableEq + +def signature : RouteMark → Instruction → Bool + | .sameBlockDecision, i | .crossBlockDecision, i => + i == .old (.comparison .eq 1215 1203 1204) + | .interiorNonemptyDecision, i | .interiorEmptyDecision, i => + i == .old (.comparison .lt 1215 896 1204) + | .interiorReadMarker, i => i == .old (.constant 8192 20) + | .crossingSecondLoad, i => i == .old (.load 8266 8261) + | _, _ => false + +/-- Numeric ranges are the fixed `Layout`/`Service` boundaries. The retirement +range is comparison-specific; the word program's final service jump at 223370 +is explicitly excluded. -/ +def routeMarked (mark : RouteMark) (t : ArrayTransition) : Bool := + match t.action with + | .boundary _ => false + | .instruction i => + let pc := t.before.pc + match mark with + | .compactQuery => decide (pc < 212964) + | .servicePrepare => decide (212964 ≤ pc ∧ pc < 212968) + | .serviceSetup => decide (212968 ≤ pc ∧ pc < 221239) + | .builder => decide (221239 ≤ pc ∧ pc < 223345) + | .descriptor => decide (223345 ≤ pc ∧ pc < 223356) + | .finalizer => decide (223356 ≤ pc ∧ pc < 223370) + | .retirement => decide (223370 ≤ pc ∧ pc < 223378) && + !(i == .old (.jump Layout.serviceEntry)) + | .sameBlockDecision => decide (pc < 212964) && signature mark i && + (t.before.regs.getD 1203 0 == t.before.regs.getD 1204 0) + | .crossBlockDecision => decide (pc < 212964) && signature mark i && + !(t.before.regs.getD 1203 0 == t.before.regs.getD 1204 0) + | .interiorNonemptyDecision => decide (pc < 212964) && signature mark i && + decide (t.before.regs.getD 896 0 < t.before.regs.getD 1204 0) + | .interiorEmptyDecision => decide (pc < 212964) && signature mark i && + !decide (t.before.regs.getD 896 0 < t.before.regs.getD 1204 0) + | .interiorReadMarker | .crossingSecondLoad => + decide (pc < 212964) && signature mark i + +theorem sameBlockDecision_iff (t : ArrayTransition) : + routeMarked .sameBlockDecision t = true ↔ + t.before.pc < 212964 ∧ + t.action = .instruction (.old (.comparison .eq 1215 1203 1204)) ∧ + t.before.regs.getD 1203 0 = t.before.regs.getD 1204 0 := by + cases h : t.action <;> simp [routeMarked, signature, h, and_assoc] + +theorem crossBlockDecision_iff (t : ArrayTransition) : + routeMarked .crossBlockDecision t = true ↔ + t.before.pc < 212964 ∧ + t.action = .instruction (.old (.comparison .eq 1215 1203 1204)) ∧ + t.before.regs.getD 1203 0 ≠ t.before.regs.getD 1204 0 := by + cases h : t.action <;> simp [routeMarked, signature, h, and_assoc] + +theorem interiorNonemptyDecision_iff (t : ArrayTransition) : + routeMarked .interiorNonemptyDecision t = true ↔ + t.before.pc < 212964 ∧ + t.action = .instruction (.old (.comparison .lt 1215 896 1204)) ∧ + t.before.regs.getD 896 0 < t.before.regs.getD 1204 0 := by + cases h : t.action <;> simp [routeMarked, signature, h, and_assoc] + +theorem interiorEmptyDecision_iff (t : ArrayTransition) : + routeMarked .interiorEmptyDecision t = true ↔ + t.before.pc < 212964 ∧ + t.action = .instruction (.old (.comparison .lt 1215 896 1204)) ∧ + ¬ t.before.regs.getD 896 0 < t.before.regs.getD 1204 0 := by + cases h : t.action <;> simp [routeMarked, signature, h, and_assoc] + +theorem interiorReadMarker_iff (t : ArrayTransition) : + routeMarked .interiorReadMarker t = true ↔ + t.before.pc < 212964 ∧ t.action = .instruction (.old (.constant 8192 20)) := by + cases h : t.action <;> simp [routeMarked, signature, h] + +theorem crossingSecondLoad_iff (t : ArrayTransition) : + routeMarked .crossingSecondLoad t = true ↔ + t.before.pc < 212964 ∧ t.action = .instruction (.old (.load 8266 8261)) := by + cases h : t.action <;> simp [routeMarked, signature, h] + +/-- This checks the actual fixed code before any native client interprets a +decision signature. Phases are PC ranges and deliberately have no signature. -/ +def programSignatureCount (model : InputModel) (mark : RouteMark) : Nat := + ((cachedProgram model).toList.take 212964).countP (signature mark) + +theorem programSignatureCount_source (model : InputModel) (mark : RouteMark) : + programSignatureCount model mark = + ((Layout.program model).take 212964).countP (signature mark) := by + simp [programSignatureCount, cachedProgram_eq] + +structure RouteCounts where + compactQuery : Nat := 0 + servicePrepare : Nat := 0 + serviceSetup : Nat := 0 + builder : Nat := 0 + descriptor : Nat := 0 + finalizer : Nat := 0 + retirement : Nat := 0 + sameBlockDecision : Nat := 0 + crossBlockDecision : Nat := 0 + interiorNonemptyDecision : Nat := 0 + interiorEmptyDecision : Nat := 0 + interiorReadMarker : Nat := 0 + crossingSecondLoad : Nat := 0 +deriving Repr, DecidableEq + +def RouteCounts.get (r : RouteCounts) : RouteMark → Nat + | .compactQuery => r.compactQuery + | .servicePrepare => r.servicePrepare + | .serviceSetup => r.serviceSetup + | .builder => r.builder + | .descriptor => r.descriptor + | .finalizer => r.finalizer + | .retirement => r.retirement + | .sameBlockDecision => r.sameBlockDecision + | .crossBlockDecision => r.crossBlockDecision + | .interiorNonemptyDecision => r.interiorNonemptyDecision + | .interiorEmptyDecision => r.interiorEmptyDecision + | .interiorReadMarker => r.interiorReadMarker + | .crossingSecondLoad => r.crossingSecondLoad + +def RouteCounts.record (r : RouteCounts) (t : ArrayTransition) : RouteCounts := + { compactQuery := r.compactQuery + if routeMarked .compactQuery t then 1 else 0 + servicePrepare := r.servicePrepare + if routeMarked .servicePrepare t then 1 else 0 + serviceSetup := r.serviceSetup + if routeMarked .serviceSetup t then 1 else 0 + builder := r.builder + if routeMarked .builder t then 1 else 0 + descriptor := r.descriptor + if routeMarked .descriptor t then 1 else 0 + finalizer := r.finalizer + if routeMarked .finalizer t then 1 else 0 + retirement := r.retirement + if routeMarked .retirement t then 1 else 0 + sameBlockDecision := r.sameBlockDecision + if routeMarked .sameBlockDecision t then 1 else 0 + crossBlockDecision := r.crossBlockDecision + if routeMarked .crossBlockDecision t then 1 else 0 + interiorNonemptyDecision := r.interiorNonemptyDecision + if routeMarked .interiorNonemptyDecision t then 1 else 0 + interiorEmptyDecision := r.interiorEmptyDecision + if routeMarked .interiorEmptyDecision t then 1 else 0 + interiorReadMarker := r.interiorReadMarker + if routeMarked .interiorReadMarker t then 1 else 0 + crossingSecondLoad := r.crossingSecondLoad + if routeMarked .crossingSecondLoad t then 1 else 0 } + +theorem RouteCounts.get_record (r : RouteCounts) (t : ArrayTransition) (mark : RouteMark) : + (r.record t).get mark = r.get mark + if routeMarked mark t then 1 else 0 := by + cases mark <;> rfl + +theorem RouteCounts.get_zero (mark : RouteMark) : ({} : RouteCounts).get mark = 0 := by + cases mark <;> rfl + +structure Stats where + steps : Nat := 0 + counts : Counts := {} + readsRev : List (Nat × Option Nat) := [] + routes : RouteCounts := {} +deriving Repr, DecidableEq + +def Stats.reads (s : Stats) : List (Nat × Option Nat) := s.readsRev.reverse + +def Stats.record (s : Stats) (t : ArrayTransition) : Stats := + { steps := s.steps + 1 + counts := s.counts.bump t.action.category + readsRev := match t.read? with | none => s.readsRev | some r => r :: s.readsRev + routes := s.routes.record t } + +/-- Finish every scalar observation before executing the instruction. The +temporary transition is local to this non-inlined call; neither owner field +can escape in the returned `Stats`. Its after field is never inspected. -/ +@[noinline] def Stats.recordBefore (s : Stats) (action : Action) (before : Owner) : Stats := + s.record ⟨before, action, before⟩ + +theorem Stats.record_eq_recordBefore (s : Stats) (t : ArrayTransition) : + s.record t = s.recordBefore t.action t.before := by + cases t + rfl + +def Stats.fold (s : Stats) (ts : List ArrayTransition) : Stats := + ts.foldl Stats.record s + +theorem Stats.fold_append (s : Stats) (a b : List ArrayTransition) : + s.fold (a ++ b) = (s.fold a).fold b := by + simp [Stats.fold, List.foldl_append] + +theorem Stats.fold_steps (s : Stats) (ts : List ArrayTransition) : + (s.fold ts).steps = s.steps + ts.length := by + induction ts generalizing s with + | nil => simp [Stats.fold] + | cons t ts ih => + change ((s.record t).fold ts).steps = _ + rw [ih] + simp [Stats.record, Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] + +theorem Stats.fold_count (s : Stats) (ts : List ArrayTransition) (c : Category) : + (s.fold ts).counts.get c = s.counts.get c + (ts.map (·.action.category)).count c := by + induction ts generalizing s with + | nil => simp [Stats.fold] + | cons t ts ih => + change ((s.record t).fold ts).counts.get c = _ + rw [ih] + simp only [Stats.record, Counts.get_bump, List.map_cons, List.count_cons] + by_cases h : t.action.category = c + · simp [h, Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] + · simp [h, Ne.symm h] + +theorem Stats.fold_readsRev (s : Stats) (ts : List ArrayTransition) : + (s.fold ts).readsRev = (ts.filterMap ArrayTransition.read?).reverse ++ s.readsRev := by + induction ts generalizing s with + | nil => simp [Stats.fold] + | cons t ts ih => + change ((s.record t).fold ts).readsRev = _ + rw [ih] + cases h : t.read? <;> simp [Stats.record, h, List.reverse_cons, List.append_assoc] + +theorem Stats.fold_reads (s : Stats) (ts : List ArrayTransition) : + (s.fold ts).reads = s.reads ++ ts.filterMap ArrayTransition.read? := by + simp [Stats.reads, Stats.fold_readsRev, List.reverse_append] + +theorem Stats.empty_fold_reads (ts : List ArrayTransition) : + (({} : Stats).fold ts).reads = ts.filterMap ArrayTransition.read? := + (Stats.fold_reads {} ts).trans (by rfl) + +theorem Stats.fold_route (s : Stats) (ts : List ArrayTransition) (mark : RouteMark) : + (s.fold ts).routes.get mark = s.routes.get mark + ts.countP (routeMarked mark) := by + induction ts generalizing s with + | nil => simp [Stats.fold] + | cons t ts ih => + change ((s.record t).fold ts).routes.get mark = _ + rw [ih] + simp [Stats.record, RouteCounts.get_record, List.countP_cons, + Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] + +/-- Tail recursion retains scalar diagnostics, never a transition history. -/ +def runAcc (program : Array Instruction) : Nat → Owner → Stats → Owner × Stats + | 0, owner, stats => (owner, stats) + | fuel + 1, owner, stats => + match stepArray program owner with + | none => (owner, stats) + | some t => runAcc program fuel t.after (stats.record t) + +theorem runAcc_exact (program : Array Instruction) (fuel : Nat) (owner : Owner) (stats : Stats) : + runAcc program fuel owner stats = + (runOwner program fuel owner, stats.fold (runArray program fuel owner).transitions) := by + induction fuel generalizing owner stats with + | zero => rfl + | succ fuel ih => + cases h : stepArray program owner with + | none => simp [runAcc, runOwner, runArray, h, Stats.fold] + | some t => simpa [runAcc, runOwner, runArray, h, Stats.fold] using ih t.after (stats.record t) + +/-- The reference transition's prestate is consumed by scalar observation +before the same primitive mutates the owner. No transition crosses that call. -/ +def runAccThin (program : Array Instruction) : Nat → Owner → Stats → Owner × Stats + | 0, owner, stats => (owner, stats) + | fuel + 1, owner, stats => + if owner.status = .running then + match program[owner.pc]? with + | none => (owner, stats) + | some i => + let nextStats := stats.recordBefore (.instruction i) owner + let nextOwner := executeArray i owner + runAccThin program fuel nextOwner nextStats + else (owner, stats) + +/-- Exact accumulator equality for all programs, fuels, owners, and initial +diagnostics, including stopped owners, missing fetches, and failed operations. -/ +theorem runAccThin_eq_runAcc (program : Array Instruction) (fuel : Nat) + (owner : Owner) (stats : Stats) : + runAccThin program fuel owner stats = runAcc program fuel owner stats := by + induction fuel generalizing owner stats with + | zero => rfl + | succ fuel ih => + by_cases hs : owner.status = .running + · cases hf : program[owner.pc]? with + | none => simp [runAccThin, runAcc, stepArray, hs, hf] + | some i => + simp [runAccThin, runAcc, stepArray, hs, hf, ih, Stats.record_eq_recordBefore] + · simp [runAccThin, runAcc, stepArray, hs] + +def run (program : Array Instruction) (fuel : Nat) (owner : Owner) : Owner × Stats := + runAccThin program fuel owner {} + +theorem run_owner (program : Array Instruction) (fuel : Nat) (owner : Owner) : + (run program fuel owner).1 = runOwner program fuel owner := by + simp [run, runAccThin_eq_runAcc, runAcc_exact] + +theorem run_steps (program : Array Instruction) (fuel : Nat) (owner : Owner) : + (run program fuel owner).2.steps = (runArray program fuel owner).steps := by + simp [run, runAccThin_eq_runAcc, runAcc_exact, Stats.fold_steps, ArrayRun.steps] + +theorem run_count (program : Array Instruction) (fuel : Nat) (owner : Owner) (c : Category) : + (run program fuel owner).2.counts.get c = (runArray program fuel owner).categoryCount c := by + simp [run, runAccThin_eq_runAcc, runAcc_exact, Stats.fold_count, Counts.get_zero, + ArrayRun.categoryCount, ArrayRun.categories] + +theorem run_reads (program : Array Instruction) (fuel : Nat) (owner : Owner) : + (run program fuel owner).2.reads = (runArray program fuel owner).reads := by + rw [run, runAccThin_eq_runAcc, runAcc_exact, Stats.fold_reads] + rfl + +theorem run_route (program : Array Instruction) (fuel : Nat) (owner : Owner) (mark : RouteMark) : + (run program fuel owner).2.routes.get mark = + (runArray program fuel owner).transitions.countP (routeMarked mark) := by + simp [run, runAccThin_eq_runAcc, runAcc_exact, Stats.fold_route, RouteCounts.get_zero] + +/-- Indexed source occurrences preserve multiplicity and their actual prestates. +Together with `run_reads`, this identifies every stored pair's producing run; +equal pairs at distinct positions remain distinct occurrences. -/ +theorem source_occurrence {program : Array Instruction} {fuel : Nat} {owner : Owner} + {index : Nat} {t : ArrayTransition} + (h : (runArray program fuel owner).transitions[index]? = some t) : + t.before = runOwner program index owner ∧ stepArray program t.before = some t := by + induction fuel generalizing owner index with + | zero => simp [runArray] at h + | succ fuel ih => + cases hs : stepArray program owner with + | none => simp [runArray, hs] at h + | some first => + cases index with + | zero => + simp only [runArray, hs, List.getElem?_cons_zero, Option.some.injEq] at h + subst t + have hb := (stepArray_spec hs).1 + exact ⟨hb, by simpa [hb] using hs⟩ + | succ index => + simp only [runArray, hs, List.getElem?_cons_succ] at h + obtain ⟨hb, ht⟩ := ih h + exact ⟨by simpa [runOwner, hs] using hb, ht⟩ + +/-- The concrete output splits at each producing transition occurrence. This +retains order and multiplicity even when earlier or later pairs are equal. -/ +theorem read_occurrence_output {program : Array Instruction} {fuel : Nat} {owner : Owner} + {index : Nat} {t : ArrayTransition} {reply : Nat × Option Nat} + (occurs : (runArray program fuel owner).transitions[index]? = some t) + (read : t.read? = some reply) : + (run program fuel owner).2.reads = + ((runArray program fuel owner).transitions.take index).filterMap ArrayTransition.read? ++ + reply :: ((runArray program fuel owner).transitions.drop (index + 1)).filterMap + ArrayTransition.read? ∧ + t.before = runOwner program index owner ∧ stepArray program t.before = some t := by + refine ⟨?_, source_occurrence occurs⟩ + have split : (runArray program fuel owner).transitions = + (runArray program fuel owner).transitions.take index ++ + t :: (runArray program fuel owner).transitions.drop (index + 1) := by + have h := List.take_append_drop (index + 1) (runArray program fuel owner).transitions + rw [List.take_succ, occurs] at h + simpa [List.append_assoc] using h.symm + rw [run_reads] + change (runArray program fuel owner).transitions.filterMap ArrayTransition.read? = _ + simpa [read] using congrArg (List.filterMap ArrayTransition.read?) split + +def boundaryAcc : List Boundary → Owner → Stats → Owner × Stats + | [], owner, stats => (owner, stats) + | b :: bs, owner, stats => + match boundaryStepArray b owner with + | none => (owner, stats) + | some t => boundaryAcc bs t.after (stats.record t) + +theorem boundaryAcc_exact (bs : List Boundary) (owner : Owner) (stats : Stats) : + boundaryAcc bs owner stats = + (runBoundaryOwner bs owner, stats.fold (runBoundaryArray bs owner).transitions) := by + induction bs generalizing owner stats with + | nil => rfl + | cons b bs ih => + cases h : boundaryStepArray b owner with + | none => simp [boundaryAcc, runBoundaryOwner, runBoundaryArray, h, Stats.fold] + | some t => + simpa [boundaryAcc, runBoundaryOwner, runBoundaryArray, h, Stats.fold] using + ih t.after (stats.record t) + +/-- Observe each admitted boundary action before its unchanged state update. -/ +def boundaryAccThin : List Boundary → Owner → Stats → Owner × Stats + | [], owner, stats => (owner, stats) + | b :: bs, owner, stats => + match owner.status with + | .halted _ => + let nextStats := stats.recordBefore (.boundary b) owner + let nextOwner := executeBoundaryArray b owner + boundaryAccThin bs nextOwner nextStats + | _ => (owner, stats) + +theorem boundaryAccThin_eq_boundaryAcc (bs : List Boundary) (owner : Owner) (stats : Stats) : + boundaryAccThin bs owner stats = boundaryAcc bs owner stats := by + induction bs generalizing owner stats with + | nil => rfl + | cons b bs ih => + cases hs : owner.status <;> + simp [boundaryAccThin, boundaryAcc, boundaryStepArray, hs, ih, + Stats.record_eq_recordBefore] + +/-- These four events are observed exactly once on a halted owner's re-entry. +They do not read the payload; subsequent service instructions do. -/ +theorem boundary_four (entry : PackedConstruction.Operand) (left right answer : Nat) + (owner : Owner) (stats : Stats) (halted : owner.status = .halted answer) : + let result := boundaryAcc [.left left, .right right, .entry entry, .activate] owner stats + result.2.steps = stats.steps + 4 ∧ + result.2.counts.get .requestAdmission = stats.counts.get .requestAdmission + 2 ∧ + result.2.counts.get .controlEntry = stats.counts.get .controlEntry + 2 ∧ + result.2.reads = stats.reads := by + simp [boundaryAcc, boundaryStepArray, executeBoundaryArray, halted, Stats.record, + ArrayTransition.read?, Action.category, Counts.bump, Counts.get, Nat.add_assoc, Stats.reads] + +/-- The real first request starts directly at the supplied constructor owner. -/ +def buildFirst (model : InputModel) (xs : List Int) (left right : Nat) : Owner × Stats := + run (cachedProgram model) (Continuous.lifecycleBudget xs.length) + (Executable.initialOwner model xs left right) + +theorem buildFirst_owner (model : InputModel) (xs : List Int) (left right : Nat) : + (buildFirst model xs left right).1 = Lifecycle.buildFirst model xs left right := by + simpa only [buildFirst, Lifecycle.buildFirst, runThin_eq_runOwner] using + run_owner (cachedProgram model) (Continuous.lifecycleBudget xs.length) + (Executable.initialOwner model xs left right) + +theorem buildFirst_stats (model : InputModel) (xs : List Int) (left right : Nat) : + (buildFirst model xs left right).2 = + ({} : Stats).fold (Ownership.observations model xs left right).transitions := by + simp [buildFirst, run, runAccThin_eq_runAcc, runAcc_exact, cachedProgram_eq, + Ownership.observations] + +theorem buildFirst_steps (model : InputModel) (xs : List Int) (left right : Nat) : + (buildFirst model xs left right).2.steps = + (Ownership.observations model xs left right).steps := by + simp [buildFirst_stats, Stats.fold_steps, ArrayRun.steps] + +theorem buildFirst_count (model : InputModel) (xs : List Int) (left right : Nat) (c : Category) : + (buildFirst model xs left right).2.counts.get c = + (Ownership.observations model xs left right).categoryCount c := by + simp [buildFirst_stats, Stats.fold_count, Counts.get_zero, + ArrayRun.categoryCount, ArrayRun.categories] + +theorem buildFirst_reads (model : InputModel) (xs : List Int) (left right : Nat) : + (buildFirst model xs left right).2.reads = + (Ownership.observations model xs left right).reads := + (congrArg Stats.reads (buildFirst_stats model xs left right)).trans + (Stats.empty_fold_reads (Ownership.observations model xs left right).transitions) + +theorem buildFirst_route (model : InputModel) (xs : List Int) (left right : Nat) (mark : RouteMark) : + (buildFirst model xs left right).2.routes.get mark = + (Ownership.observations model xs left right).transitions.countP (routeMarked mark) := by + simp [buildFirst_stats, Stats.fold_route, RouteCounts.get_zero] + +/-- Every advertised fold projection is transported to the same abstract run, +not inferred merely from the final-owner equality. -/ +theorem fold_toRun (stats : Stats) (actual : ArrayRun) : + (stats.fold actual.transitions).steps = stats.steps + actual.toRun.steps ∧ + (∀ c, (stats.fold actual.transitions).counts.get c = + stats.counts.get c + actual.toRun.categoryCount c) ∧ + (stats.fold actual.transitions).reads = stats.reads ++ actual.toRun.reads := by + obtain ⟨steps, categories, reads, _⟩ := actual.observations_toRun + refine ⟨?_, ?_, ?_⟩ + · rw [Stats.fold_steps, steps]; rfl + · intro c + rw [Stats.fold_count] + simp only [PackedLifecycle.Run.categoryCount, categories, ArrayRun.categories] + · rw [Stats.fold_reads, reads]; rfl + +/-- Transport through generic objects first, so kernel conversion never needs +to expand a fixed program or its input-dependent complete lifecycle run. -/ +theorem observations_of_fold {stats : Stats} {actual : ArrayRun} {modelRun : PackedLifecycle.Run} + (folded : stats = ({} : Stats).fold actual.transitions) (refined : actual.toRun = modelRun) : + stats.steps = modelRun.steps ∧ + (∀ c, stats.counts.get c = modelRun.categoryCount c) ∧ stats.reads = modelRun.reads := by + subst stats + have projections := fold_toRun ({} : Stats) actual + rw [refined] at projections + simpa only [Counts.get_zero, Stats.reads, List.reverse_nil, + List.nil_append, Nat.zero_add] using projections + +theorem buildFirst_model_observations (model : InputModel) (xs : List Int) (left right : Nat) + (domain : InputDomain model xs) + (hl : left < 2 ^ PackedWordRAM.wordWidth xs.length) + (hr : right < 2 ^ PackedWordRAM.wordWidth xs.length) : + (buildFirst model xs left right).2.steps = + (Continuous.continuousRun model xs left right).steps ∧ + (∀ c, (buildFirst model xs left right).2.counts.get c = + (Continuous.continuousRun model xs left right).categoryCount c) ∧ + (buildFirst model xs left right).2.reads = + (Continuous.continuousRun model xs left right).reads := + observations_of_fold (buildFirst_stats model xs left right) + (Ownership.refinement model xs left right domain hl hr).2.2 + +/-- Later requests perform the original four events before service execution. -/ +def queryAcc (model : InputModel) (left right : Nat) (owner : Owner) (stats : Stats) : Owner × Stats := + let admission := boundaryAccThin [.left left, .right right, .entry Layout.serviceEntry, .activate] + owner stats + runAccThin (cachedProgram model) Service.budget admission.1 admission.2 + +theorem queryAcc_exact (model : InputModel) (left right : Nat) (owner : Owner) (stats : Stats) : + queryAcc model left right owner stats = + (Lifecycle.query model left right owner, + stats.fold (Executable.queryArray model left right owner).transitions) := by + simp only [queryAcc, boundaryAccThin_eq_boundaryAcc, boundaryAcc_exact, + runAccThin_eq_runAcc, runAcc_exact, Lifecycle.query, runThin_eq_runOwner, + requestProtocolThin_eq_requestProtocolOwner, + Executable.queryArray, requestProtocolArray, requestProtocolOwner, + runBoundaryOwner_projection, cachedProgram_eq, Stats.fold_append] + +def query (model : InputModel) (left right : Nat) (owner : Owner) : Owner × Stats := + queryAcc model left right owner {} + +theorem query_owner (model : InputModel) (left right : Nat) (owner : Owner) : + (query model left right owner).1 = Lifecycle.query model left right owner := by + simp [query, queryAcc_exact] + +theorem query_steps (model : InputModel) (left right : Nat) (owner : Owner) : + (query model left right owner).2.steps = (Executable.queryArray model left right owner).steps := by + simp [query, queryAcc_exact, Stats.fold_steps, ArrayRun.steps] + +theorem query_count (model : InputModel) (left right : Nat) (owner : Owner) (c : Category) : + (query model left right owner).2.counts.get c = + (Executable.queryArray model left right owner).categoryCount c := by + simp [query, queryAcc_exact, Stats.fold_count, Counts.get_zero, + ArrayRun.categoryCount, ArrayRun.categories] + +theorem query_reads (model : InputModel) (left right : Nat) (owner : Owner) : + (query model left right owner).2.reads = (Executable.queryArray model left right owner).reads := by + rw [query, queryAcc_exact, Stats.fold_reads] + rfl + +theorem query_route (model : InputModel) (left right : Nat) (owner : Owner) (mark : RouteMark) : + (query model left right owner).2.routes.get mark = + (Executable.queryArray model left right owner).transitions.countP (routeMarked mark) := by + simp [query, queryAcc_exact, Stats.fold_route, RouteCounts.get_zero] + +theorem query_model_observations (model : InputModel) (xs : List Int) (left right answer : Nat) + (owner : Owner) (ready : Ownership.Ready xs owner) (halted : owner.status = .halted answer) + (hl : left < 2 ^ PackedWordRAM.wordWidth xs.length) + (hr : right < 2 ^ PackedWordRAM.wordWidth xs.length) : + (query model left right owner).2.steps = + (Reusable.queryRun model left right owner.toState).steps ∧ + (∀ c, (query model left right owner).2.counts.get c = + (Reusable.queryRun model left right owner.toState).categoryCount c) ∧ + (query model left right owner).2.reads = + (Reusable.queryRun model left right owner.toState).reads := + observations_of_fold (congrArg Prod.snd (queryAcc_exact model left right owner {})) + (Executable.query_array_refinement model xs left right answer owner + ready.1 ready.2 halted hl hr).1 + +/-- An explicit accumulated session includes the complete first segment and +later segment in order. No claim identifies this whole history with query-only +evidence. The returned production owner is still the same continuation owner. -/ +theorem first_then_query (model : InputModel) (xs : List Int) (left right nextLeft nextRight : Nat) : + let first := buildFirst model xs left right + queryAcc model nextLeft nextRight first.1 first.2 = + (Lifecycle.query model nextLeft nextRight (Lifecycle.buildFirst model xs left right), + ({} : Stats).fold ((Ownership.observations model xs left right).transitions ++ + (Executable.queryArray model nextLeft nextRight + (Lifecycle.buildFirst model xs left right)).transitions)) := by + dsimp only + rw [queryAcc_exact, buildFirst_owner, buildFirst_stats, Stats.fold_append] + +/-! Small kernel controls for observation branches. These arbitrary test +programs do not claim to be reachable canonical lifecycle runs. Their owners +are theorem-local, so no test input or trace is initialized by a native import. -/ + +example : + let owner : Owner := ⟨#[0, 0], #[some 9], #[], #[], 0, .running⟩ + let actual := run #[.old (.load 1 0), .old (.load 1 0), .old (.halt 1)] 4 owner + actual.1.status = .halted 9 ∧ actual.2.steps = 3 ∧ + actual.2.counts.read = 2 ∧ actual.2.reads = [(0, some 9), (0, some 9)] := by + decide + +example : + let owner : Owner := ⟨#[0, 0], #[], #[], #[], 0, .running⟩ + let actual := run #[.old (.load 1 0)] 4 owner + actual.1.status = .fault ∧ actual.2.steps = 1 ∧ + actual.2.counts.read = 1 ∧ actual.2.reads = [(0, none)] := by + decide + +example : + let owner : Owner := ⟨#[], #[], #[], #[], 0, .running⟩ + let actual := run #[] 4 owner + actual.1.status = .running ∧ actual.2.steps = 0 ∧ actual.2.reads = [] := by + decide + +example : + let owner : Owner := ⟨#[], #[], #[], #[], 0, .halted 7⟩ + let actual := run #[.releaseCell] 4 owner + actual.1.status = .halted 7 ∧ actual.2.steps = 0 ∧ actual.2.reads = [] := by + decide + +end Observations +end RMQ.SuccinctFinal.PackedNative.Lifecycle diff --git a/RMQ/Core/WordRAM/Native/Lifecycle/Repack.lean b/RMQ/Core/WordRAM/Native/Lifecycle/Repack.lean new file mode 100644 index 00000000..a03c0693 --- /dev/null +++ b/RMQ/Core/WordRAM/Native/Lifecycle/Repack.lean @@ -0,0 +1,65 @@ +import RMQ.Core.WordRAM.Native.Lifecycle.Run + +/-! # Value transport across native array replacement + +A successful native copy must preserve the initialized size and each entry of +all four arrays, together with both control scalars. This interface entails +equality of Lean owner values. It asserts neither pointer equality nor native +capacity, exclusive ownership, allocation success, or correctness of C copying. +Those obligations belong to the foreign boundary and its measured controls. +-/ + +namespace RMQ.SuccinctFinal.PackedNative.Lifecycle + +open PackedLifecycle + +structure ArrayCopy {α : Type} (source target : Array α) : Prop where + size : target.size = source.size + entry : ∀ (i : Nat) (ht : i < target.size) (hs : i < source.size), target[i] = source[i] + +theorem ArrayCopy.eq {α : Type} {source target : Array α} + (copy : ArrayCopy source target) : target = source := by + apply Array.ext copy.size + exact copy.entry + +theorem ArrayCopy.refl {α : Type} (array : Array α) : ArrayCopy array array := + ⟨rfl, fun _ _ _ => rfl⟩ + +structure Repacked (source target : Owner) : Prop where + regs : ArrayCopy source.regs target.regs + memory : ArrayCopy source.memory target.memory + keys : ArrayCopy source.keys target.keys + keyRegs : ArrayCopy source.keyRegs target.keyRegs + pc : target.pc = source.pc + status : target.status = source.status + +theorem Repacked.eq {source target : Owner} (copy : Repacked source target) : + target = source := by + rcases source with ⟨sr, sm, sk, skr, sp, ss⟩ + rcases target with ⟨tr, tm, tk, tkr, tp, ts⟩ + obtain ⟨hr, hm, hk, hkr, hp, hs⟩ := copy + have er := hr.eq + have em := hm.eq + have ek := hk.eq + have ekr := hkr.eq + cases er + cases em + cases ek + cases ekr + cases hp + cases hs + rfl + +theorem Repacked.refl (owner : Owner) : Repacked owner owner := + ⟨ArrayCopy.refl _, ArrayCopy.refl _, ArrayCopy.refl _, ArrayCopy.refl _, rfl, rfl⟩ + +theorem repack_transport (xs : List Int) (model : InputModel) (left right : Nat) + (source target : Owner) (copy : Repacked source target) : + target = source ∧ target.toState = source.toState ∧ target.status = source.status ∧ + (Ownership.Ready xs target ↔ Ownership.Ready xs source) ∧ + Ownership.capacity model target = Ownership.capacity model source ∧ + query model left right target = query model left right source := by + rw [copy.eq] + exact ⟨rfl, rfl, rfl, Iff.rfl, rfl, rfl⟩ + +end RMQ.SuccinctFinal.PackedNative.Lifecycle diff --git a/RMQ/Core/WordRAM/Native/Lifecycle/Run.lean b/RMQ/Core/WordRAM/Native/Lifecycle/Run.lean new file mode 100644 index 00000000..ddfd5c22 --- /dev/null +++ b/RMQ/Core/WordRAM/Native/Lifecycle/Run.lean @@ -0,0 +1,56 @@ +import RMQ.Core.WordRAM.Lifecycle.Ownership +import RMQ.Core.WordRAM.Native.Lifecycle.ThinRun + +/-! # Fixed-code production lifecycle adapter + +The two closed arrays contain the existing lifecycle programs. The first call +executes construction, retirement, and the caller's first query continuously; +later calls execute the existing charged request protocol and service. These +equalities cover every owner, including stopped, faulted, and exhausted runs. +Native sharing and initialization of the closed arrays are separate runtime +properties; their source values are fixed here. +-/ + +namespace RMQ.SuccinctFinal.PackedNative.Lifecycle + +open PackedLifecycle + +@[noinline] def materializeProgram (model : InputModel) : Array Instruction := + (Layout.program model).toArray + +def wordProgram : Array Instruction := materializeProgram .word + +def comparisonProgram : Array Instruction := materializeProgram .comparison + +def cachedProgram : InputModel → Array Instruction + | .word => wordProgram + | .comparison => comparisonProgram + +theorem cachedProgram_eq (model : InputModel) : + cachedProgram model = (Layout.program model).toArray := by + cases model <;> rfl + +def buildFirst (model : InputModel) (xs : List Int) (left right : Nat) : Owner := + runThin (cachedProgram model) (Continuous.lifecycleBudget xs.length) + (Executable.initialOwner model xs left right) + +def query (model : InputModel) (left right : Nat) (owner : Owner) : Owner := + runThin (cachedProgram model) Service.budget + (requestProtocolThin Layout.serviceEntry left right owner) + +theorem cached_run (model : InputModel) (fuel : Nat) (owner : Owner) : + runOwner (cachedProgram model) fuel owner = + runOwner (Layout.program model).toArray fuel owner := by + rw [cachedProgram_eq] + +theorem buildFirst_eq (model : InputModel) (xs : List Int) (left right : Nat) : + buildFirst model xs left right = Ownership.owner model xs left right := by + unfold buildFirst Ownership.owner + rw [runThin_eq_runOwner, cachedProgram_eq] + +theorem query_eq (model : InputModel) (left right : Nat) (owner : Owner) : + query model left right owner = Executable.queryOwner model left right owner := by + unfold query Executable.queryOwner + rw [runThin_eq_runOwner, requestProtocolThin_eq_requestProtocolOwner, cachedProgram_eq] + +end RMQ.SuccinctFinal.PackedNative.Lifecycle diff --git a/RMQ/Core/WordRAM/Native/Lifecycle/ThinRun.lean b/RMQ/Core/WordRAM/Native/Lifecycle/ThinRun.lean new file mode 100644 index 00000000..f82d12a4 --- /dev/null +++ b/RMQ/Core/WordRAM/Native/Lifecycle/ThinRun.lean @@ -0,0 +1,58 @@ +import RMQ.Core.WordRAM.Lifecycle.ArrayRun + +/-! # Owner-consuming lifecycle loops + +These loops erase the temporary transition records, whose retained pre-states +can otherwise share arrays with the owner being executed. They call exactly +the existing primitive evaluators. The refinements quantify over every program, +fuel, boundary sequence, and owner, including fault and missing-fetch cases. +Native allocation behavior remains a separately measured property. +-/ + +namespace RMQ.SuccinctFinal.PackedNative.Lifecycle + +open PackedLifecycle + +def runThin (program : Array Instruction) : Nat → Owner → Owner + | 0, owner => owner + | fuel + 1, owner => + if owner.status = .running then + match program[owner.pc]? with + | none => owner + | some instruction => runThin program fuel (executeArray instruction owner) + else owner + +theorem runThin_eq_runOwner (program : Array Instruction) (fuel : Nat) (owner : Owner) : + runThin program fuel owner = runOwner program fuel owner := by + induction fuel generalizing owner with + | zero => rfl + | succ fuel ih => + by_cases hs : owner.status = .running + · cases hf : program[owner.pc]? <;> simp [runThin, runOwner, stepArray, hs, hf, ih] + · simp [runThin, runOwner, stepArray, hs] + +def runBoundaryThin : List Boundary → Owner → Owner + | [], owner => owner + | boundary :: rest, owner => + match owner.status with + | .halted _ => runBoundaryThin rest (executeBoundaryArray boundary owner) + | _ => owner + +theorem runBoundaryThin_eq_runBoundaryOwner (boundaries : List Boundary) (owner : Owner) : + runBoundaryThin boundaries owner = runBoundaryOwner boundaries owner := by + induction boundaries generalizing owner with + | nil => rfl + | cons boundary rest ih => + cases hs : owner.status <;> + simp [runBoundaryThin, runBoundaryOwner, boundaryStepArray, hs, ih] + +def requestProtocolThin (entry : PackedConstruction.Operand) (left right : Nat) + (owner : Owner) : Owner := + runBoundaryThin [.left left, .right right, .entry entry, .activate] owner + +theorem requestProtocolThin_eq_requestProtocolOwner + (entry : PackedConstruction.Operand) (left right : Nat) (owner : Owner) : + requestProtocolThin entry left right owner = requestProtocolOwner entry left right owner := + runBoundaryThin_eq_runBoundaryOwner _ _ + +end RMQ.SuccinctFinal.PackedNative.Lifecycle diff --git a/RMQ/Headlines.lean b/RMQ/Headlines.lean index b6072633..4ca195a3 100644 --- a/RMQ/Headlines.lean +++ b/RMQ/Headlines.lean @@ -1,5 +1,6 @@ import RMQ.Headlines.RMQ import RMQ.Headlines.RMQCompatibility +import RMQ.Headlines.Lifecycle import RMQ.Core.BPNavigationPublic import RMQ.Core.BPNavigationRAM import RMQ.Core.RankSelectPublic @@ -14,6 +15,10 @@ re-exports it, explicitly adds `RMQ.Headlines.RMQCompatibility` for historical RMQ profiles, and adds standalone rank/select and BP-navigation spoke aliases. Compatibility declarations are unmistakably named `Compatibility` or `Legacy` and are not in the `RMQPaper` import closure. + +The lifecycle candidate headline is also available through this broad barrel. +Its separate campaign acceptance and publication requirements remain in force; +the narrow `RMQPaper` import surface is unchanged. -/ namespace RMQ.Headlines diff --git a/RMQ/Headlines/Lifecycle.lean b/RMQ/Headlines/Lifecycle.lean new file mode 100644 index 00000000..0ad61bd2 --- /dev/null +++ b/RMQ/Headlines/Lifecycle.lean @@ -0,0 +1,17 @@ +import RMQ.Core.WordRAM.Lifecycle.Capstone + +/-! Additive candidate import for the continuous lifecycle model. Publication +integration and independent coordinator acceptance are separate campaign steps. -/ + +namespace RMQ.Headlines + +open SuccinctFinal SuccinctFinal.PackedLifecycle + +theorem succinctRMQContinuousLifecycle (model : InputModel) (xs : List Int) (left right : Nat) + (domain : InputDomain model xs) + (hl : left < 2 ^ PackedWordRAM.wordWidth xs.length) + (hr : right < 2 ^ PackedWordRAM.wordWidth xs.length) : + ContinuousConstructionQuery model xs left right := + continuousConstructionQuery_holds model xs left right domain hl hr + +end RMQ.Headlines diff --git a/RMQ/Validation/LifecycleContract.lean b/RMQ/Validation/LifecycleContract.lean new file mode 100644 index 00000000..cb87275b --- /dev/null +++ b/RMQ/Validation/LifecycleContract.lean @@ -0,0 +1,204 @@ +import RMQ.Core.WordRAM.Lifecycle.Capstone + +/-! # Frozen LIFE-1 client propositions + +The expected propositions below are independent source text. In particular they +do not abbreviate the producer's seven property aliases, `Retained.Canonical`, +`Ownership.Ready`, or `Continuous.PrefixProfile`. Each consumer projects the +actual public theorem. Shadow-source replay weakens that theorem's fields while +leaving this file unchanged. Lower machine predicates retain their usual meaning. +-/ + +namespace RMQ.SuccinctFinal.PackedLifecycle.ContractChecks + +open PackedWordRAM (wordWidth buildMemory) +open PackedWordRAM.Optimization (compactQueryRun) +open Continuous (continuousRun constructionBudget) +set_option maxRecDepth 30000 + +def ExpectedCanonical (xs : List Int) (s : State) : Prop := + (s.core.memory = (fun a => (buildMemory xs)[a]?) ∧ + s.core.extent = (buildMemory xs).length ∧ + s.core.keys = (fun _ => none) ∧ s.core.keyRegs = (fun _ => 0) ∧ + s.keyExtent = 0 ∧ s.keyRegExtent = 0) ∧ + (∀ r, 8273 ≤ r → s.core.regs r = 0) ∧ s.Fits (wordWidth xs.length) + +def ExpectedReady (xs : List Int) (es : Owner) : Prop := + es.regs.size = 8273 ∧ ExpectedCanonical xs es.toState + +def ExpectedPrefix (model : InputModel) (xs : List Int) (s : State) : Prop := + s.Fits (wordWidth xs.length) ∧ PackedConstruction.CleanTail s.core ∧ + (∀ r, 8273 ≤ r → s.core.regs r = 0) ∧ s.core.extent ≤ 5000000 * (xs.length + 1) ∧ + s.keyExtent ≤ (if model = .comparison then xs.length else 0) ∧ + s.keyRegExtent ≤ (if model = .comparison then 2 else 0) + +variable (model : InputModel) (xs : List Int) (left right : Nat) + (domain : InputDomain model xs) (hl : left < 2 ^ wordWidth xs.length) + (hr : right < 2 ^ wordWidth xs.length) + +include domain hl hr + +theorem publicContract : ContinuousConstructionQuery model xs left right := + continuousConstructionQuery_holds model xs left right domain hl hr + +theorem checkC01_construction : + ∃ abstract producer body, + Construction.BuildStage model xs left right abstract producer body ∧ + (Finalization.fullTrace model xs left right producer body).length ≤ constructionBudget xs.length ∧ + ExpectedCanonical xs (Finalization.finalState model xs left right producer) ∧ + ((Finalization.finalState model xs left right producer).core.status = .running ∧ + (Finalization.finalState model xs left right producer).core.pc = Service.entry ∧ + (Finalization.finalState model xs left right producer).core.regs 300 = left ∧ + (Finalization.finalState model xs left right producer).core.regs 301 = right) ∧ + continuousRun model xs left right = + ⟨(Reusable.serviceRun model (Finalization.finalState model xs left right producer)).final, + Finalization.fullTrace model xs left right producer body ++ + (Reusable.serviceRun model (Finalization.finalState model xs left right producer)).transitions⟩ ∧ + ∃ entryTransitions : List Transition, + entryTransitions.length = 4 + 8271 ∧ + (continuousRun model xs left right).transitions = + Finalization.fullTrace model xs left right producer body ++ entryTransitions ++ + (compactQueryRun (buildMemory xs) xs.length left right).transitions.map + (QuerySafetyBridge.liftTransition (buildMemory xs)) ∧ + (continuousRun model xs left right).steps = + (Finalization.fullTrace model xs left right producer body).length + 4 + 8271 + + (compactQueryRun (buildMemory xs) xs.length left right).steps := + (publicContract model xs left right domain hl hr).construction + +theorem checkC02_retained : + ExpectedCanonical xs (continuousRun model xs left right).final ∧ + (continuousRun model xs left right).final.core.status = .halted + (PackedWordRAM.optionNatPacket (SuccinctClassic.queryTraceResult xs left right).value) ∧ + (continuousRun model xs left right).steps ≤ constructionBudget xs.length + 160253 := + (publicContract model xs left right domain hl hr).retained + +theorem checkC03_safety : + (∀ fuel, fuel ≤ (continuousRun model xs left right).steps → + ExpectedPrefix model xs + (run (Layout.program model) fuel (initialState model xs left right Layout.builderBase)).final) ∧ + ∀ t ∈ (continuousRun model xs left right).transitions, + t.Safe (wordWidth xs.length) (Layout.program model).length := + (publicContract model xs left right domain hl hr).safety + +theorem checkC04_physical : + (Physical.physicalReads model (continuousRun model xs left right).transitions).map + Physical.Read.logicalReceipt = (continuousRun model xs left right).reads ∧ + (∀ fuel, fuel ≤ (continuousRun model xs left right).steps → + let s := (run (Layout.program model) fuel (initialState model xs left right Layout.builderBase)).final + Physical.extent model s < 2 ^ wordWidth xs.length ∧ + ∀ p value, Physical.lookup model s p = some value → value < 2 ^ wordWidth xs.length) ∧ + (∀ index t address reply, (continuousRun model xs left right).transitions[index]? = some t → + t.read? = some (address, reply) → + t.before = (run (Layout.program model) index (initialState model xs left right Layout.builderBase)).final ∧ + (Physical.imageTrace model (continuousRun model xs left right).transitions)[index]? = + some ⟨Physical.view model t.before, t.action, Physical.view model t.after⟩ ∧ + ∃ physical value, Physical.checkedAddress model t.before address = some physical ∧ + reply = some value ∧ Physical.lookup model t.before physical = some value ∧ + physical < 2 ^ wordWidth xs.length ∧ address < 2 ^ wordWidth xs.length ∧ + value < 2 ^ wordWidth xs.length) ∧ + ∀ (index : Nat) (t : Transition), (continuousRun model xs left right).transitions[index]? = some t → + ∃ instruction : Instruction, t.action = .instruction instruction ∧ + (Layout.program model)[t.before.core.pc]? = some instruction ∧ + ∀ field word, instruction.encoding[field]? = some word → + Physical.codeOffset (Layout.program model) t.before.core.pc + field < Physical.codeLength model ∧ + Physical.lookup model t.before + (Physical.codeAddress model + (Physical.codeOffset (Layout.program model) t.before.core.pc + field)) = some word := + (publicContract model xs left right domain hl hr).physical + +theorem checkC05_executable : + let es := Ownership.owner model xs left right + es.toState = (continuousRun model xs left right).final ∧ + (Ownership.observations model xs left right).toRun = continuousRun model xs left right ∧ + ExpectedReady xs es ∧ es.keys = #[] ∧ es.keyRegs = #[] ∧ + (es.memory.size + (encodedProgram model).length + es.regs.size + 8) * wordWidth xs.length ≤ + 2 * xs.length + retainedRho xs.length := + (publicContract model xs left right domain hl hr).executable + +theorem checkC06_reusable : + ∀ (es : Owner) (newLeft newRight answer : Nat), ExpectedReady xs es → es.status = .halted answer → + newLeft < 2 ^ wordWidth xs.length → newRight < 2 ^ wordWidth xs.length → + ExpectedReady xs (Executable.queryOwner model newLeft newRight es) ∧ + (Executable.queryOwner model newLeft newRight es).status = .halted + (PackedWordRAM.optionNatPacket (SuccinctClassic.queryTraceResult xs newLeft newRight).value) ∧ + (Executable.queryOwner model newLeft newRight es).memory = es.memory ∧ + (Executable.queryArray model newLeft newRight es).toRun = Reusable.queryRun model newLeft newRight es.toState ∧ + (Reusable.queryRun model newLeft newRight es.toState).steps ≤ 160257 ∧ + (Reusable.queryRun model newLeft newRight es.toState).reads = (0, some xs.length) :: + (compactQueryRun (buildMemory xs) xs.length newLeft newRight).reads.map (fun r => (r.address, r.reply)) ∧ + (∀ t ∈ (Reusable.queryRun model newLeft newRight es.toState).transitions, + t.ActionSafe (wordWidth xs.length) (Layout.program model).length 8273 Layout.serviceEntry.val ∧ + ExpectedCanonical xs t.before ∧ ExpectedCanonical xs t.after) ∧ + ((Executable.queryOwner model newLeft newRight es).memory.size + (encodedProgram model).length + + (Executable.queryOwner model newLeft newRight es).regs.size + 8) * wordWidth xs.length ≤ + 2 * xs.length + retainedRho xs.length := + (publicContract model xs left right domain hl hr).reusable + +theorem checkC07_uniform : + SuccinctSpace.LittleOLinear retainedRho ∧ + (Nat.log2 (xs.length + 2) + 1 ≤ wordWidth xs.length ∧ + wordWidth xs.length ≤ 192 * (Nat.log2 (xs.length + 2) + 1)) ∧ + ∀ word ∈ encodedProgram model, word < 2 ^ wordWidth xs.length := + (publicContract model xs left right domain hl hr).uniform + +omit domain in +/-- Both public input forms must return the actual seven-field interface. -/ +theorem checkC08_word (input : PackedConstruction.InputFits (wordWidth xs.length) xs) : + ContinuousConstructionQuery .word xs left right := + wordInputContinuousConstructionQuery xs left right input hl hr + +omit domain in +theorem checkC09_comparison : ContinuousConstructionQuery .comparison xs left right := + comparisonInputContinuousConstructionQuery xs left right hl hr + +omit domain hl hr in +/-- Compile-time pins on the shared constants used by the frozen client. -/ +theorem checkC10_constants : numericBank = 8273 ∧ controlWords = 8 ∧ codeWordBudget = 1116895 ∧ + QueryEntry.setupCost = 8271 ∧ Reusable.queryBudget = 160257 ∧ Service.budget = 160253 ∧ + (∀ n, constructionBudget n = 1100000000 * (n + 1)) := by + exact ⟨rfl, rfl, rfl, rfl, rfl, rfl, fun _ => rfl⟩ + +omit domain hl hr in +theorem checkC11_valid (contract : ContinuousConstructionQuery model xs left right) + (valid : ValidRange xs left right) : + (continuousRun model xs left right).final.core.status = .halted (scanWindow xs left (right - left) + 1) ∧ + LeftmostArgMin xs left right (scanWindow xs left (right - left)) := + contract.valid valid + +omit domain hl hr in +theorem checkC12_invalid (contract : ContinuousConstructionQuery model xs left right) + (invalid : ¬ ValidRange xs left right) : + (continuousRun model xs left right).final.core.status = .halted 0 := + contract.invalid invalid + +omit domain hl hr in +theorem checkC13_store (fuel : Nat) (s t : State) + (initial : + (s.core.regs = t.core.regs ∧ s.core.extent = t.core.extent ∧ + s.core.keyRegs = t.core.keyRegs ∧ s.core.pc = t.core.pc ∧ s.core.status = t.core.status) ∧ + s.keyExtent = t.keyExtent ∧ s.keyRegExtent = t.keyRegExtent) + (reads : DynamicReadsAgree (Layout.program model) fuel s t) : + (run (Layout.program model) fuel s).Agree (run (Layout.program model) fuel t) ∧ + (run (Layout.program model) fuel s).final.core.status = (run (Layout.program model) fuel t).final.core.status ∧ + (run (Layout.program model) fuel s).reads = (run (Layout.program model) fuel t).reads ∧ + ∀ category, (run (Layout.program model) fuel s).categoryCount category = + (run (Layout.program model) fuel t).categoryCount category := + lifecycle_store_determinism model fuel s t initial reads + +omit domain hl hr in +/-- The supplied-store premise includes both actual fetches and the numeric +extent guard. Its key channel is separately the existing Int lookup. -/ +theorem checkC14_store_guard (program : List Instruction) (fuel : Nat) (s t : State) : + DynamicReadsAgree program (fuel + 1) s t = + (match step program s, step program t with + | some a, some b => + (∀ i, a.action = .instruction i → + (∀ dst address, i = .old (.load dst address) → + s.core.regs address < s.core.extent → + t.core.memory (s.core.regs address) = s.core.memory (s.core.regs address)) ∧ + (∀ dst address, i = .old (.loadKey dst address) → + t.core.keys (s.core.regs address) = s.core.keys (s.core.regs address))) ∧ + DynamicReadsAgree program fuel a.after b.after + | _, _ => True) := rfl + +end RMQ.SuccinctFinal.PackedLifecycle.ContractChecks diff --git a/RMQ/Validation/LifecycleNativeContract.lean b/RMQ/Validation/LifecycleNativeContract.lean new file mode 100644 index 00000000..d6c52fb8 --- /dev/null +++ b/RMQ/Validation/LifecycleNativeContract.lean @@ -0,0 +1,696 @@ +import RMQ.Core.WordRAM.Native.Lifecycle.Contract +import RMQ.Core.WordRAM.Native.Lifecycle.BoundaryProofs + +/-! # Independent expected propositions for the native lifecycle exports + +Each check projects a mandatory public field at fixed objects. Ready and +capacity are expanded in independently written expected types, so the checks +do not merely accept a mutable producer record type. Producer-compiling +weakening/deletion/sibling controls must retain this consumer unchanged. +-/ + +namespace RMQ.SuccinctFinal.PackedNative.Lifecycle.ContractChecks + +open PackedLifecycle +open PackedWordRAM (buildMemory wordWidth) +open PackedWordRAM.Optimization (compactQueryRun) + +set_option maxRecDepth 30000 + +def ExpectedCanonical (xs : List Int) (s : State) : Prop := + (s.core.memory = (fun a => (buildMemory xs)[a]?) ∧ + s.core.extent = (buildMemory xs).length ∧ + s.core.keys = (fun _ => none) ∧ s.core.keyRegs = (fun _ => 0) ∧ + s.keyExtent = 0 ∧ s.keyRegExtent = 0) ∧ + (∀ r, 8273 ≤ r → s.core.regs r = 0) ∧ s.Fits (wordWidth xs.length) + +def ExpectedReady (xs : List Int) (es : Owner) : Prop := + es.regs.size = 8273 ∧ ExpectedCanonical xs es.toState + +variable (model : InputModel) (xs : List Int) (left right : Nat) + (domain : InputDomain model xs) (hl : left < 2 ^ wordWidth xs.length) + (hr : right < 2 ^ wordWidth xs.length) + +include domain hl hr + +theorem checkE01_program : cachedProgram model = (Layout.program model).toArray := + by with_reducible exact (export_contract model xs left right domain hl hr).program + +theorem checkE02_owner : buildFirst model xs left right = Ownership.owner model xs left right := + by with_reducible exact (export_contract model xs left right domain hl hr).owner + +theorem checkE03_projection : (buildFirst model xs left right).toState = + (Continuous.continuousRun model xs left right).final := + (export_contract model xs left right domain hl hr).projection + +theorem checkE04_ready : ExpectedReady xs (buildFirst model xs left right) := + (export_contract model xs left right domain hl hr).ready + +theorem checkE05_halted : (buildFirst model xs left right).status = .halted + (PackedWordRAM.optionNatPacket (SuccinctClassic.queryTraceResult xs left right).value) := + (export_contract model xs left right domain hl hr).halted + +theorem checkE06_memory : + (∀ a, (buildFirst model xs left right).memory.getD a none = (buildMemory xs)[a]?) ∧ + (buildFirst model xs left right).memory.size = (buildMemory xs).length := + (export_contract model xs left right domain hl hr).memory + +theorem checkE07_emptyKeys : (buildFirst model xs left right).keys = #[] ∧ + (buildFirst model xs left right).keyRegs = #[] := + (export_contract model xs left right domain hl hr).emptyKeys + +theorem checkE08_bank : (buildFirst model xs left right).regs.size = 8273 := + (export_contract model xs left right domain hl hr).bank + +theorem checkE09_capacity : + ((buildFirst model xs left right).memory.size + (encodedProgram model).length + + (buildFirst model xs left right).regs.size + 8) * wordWidth xs.length ≤ + 2 * xs.length + retainedRho xs.length := + (export_contract model xs left right domain hl hr).capacity + +theorem checkE10_metadata : (buildFirst model xs left right).memory.getD 0 none = some xs.length ∧ + (buildFirst model xs left right).memory.getD 7 none = + some (buildFirst model xs left right).memory.size := + (export_contract model xs left right domain hl hr).metadata + +theorem checkE11_observations : (Ownership.observations model xs left right).toRun = + Continuous.continuousRun model xs left right := + (export_contract model xs left right domain hl hr).observations + +theorem checkE12_repacking (source target : Owner) (newLeft newRight : Nat) + (copy : Repacked source target) : + target = source ∧ target.toState = source.toState ∧ target.status = source.status ∧ + (ExpectedReady xs target ↔ ExpectedReady xs source) ∧ + (target.memory.size + (encodedProgram model).length + target.regs.size + 8) = + (source.memory.size + (encodedProgram model).length + source.regs.size + 8) ∧ + query model newLeft newRight target = query model newLeft newRight source := + (export_contract model xs left right domain hl hr).repacking source target newLeft newRight copy + +variable (es : Owner) (newLeft newRight answer : Nat) (ready : ExpectedReady xs es) + (halted : es.status = .halted answer) (hnewLeft : newLeft < 2 ^ wordWidth xs.length) + (hnewRight : newRight < 2 ^ wordWidth xs.length) + +include ready halted hnewLeft hnewRight + +theorem checkQ01_source : query model newLeft newRight es = Executable.queryOwner model newLeft newRight es := + ((export_contract model xs left right domain hl hr).continuation es newLeft newRight answer + ready halted hnewLeft hnewRight).source + +theorem checkQ02_projection : (query model newLeft newRight es).toState = + (Reusable.queryRun model newLeft newRight es.toState).final := + ((export_contract model xs left right domain hl hr).continuation es newLeft newRight answer + ready halted hnewLeft hnewRight).projection + +theorem checkQ03_ready : ExpectedReady xs (query model newLeft newRight es) := + ((export_contract model xs left right domain hl hr).continuation es newLeft newRight answer + ready halted hnewLeft hnewRight).ready + +theorem checkQ04_halted : (query model newLeft newRight es).status = .halted + (PackedWordRAM.optionNatPacket (SuccinctClassic.queryTraceResult xs newLeft newRight).value) := + ((export_contract model xs left right domain hl hr).continuation es newLeft newRight answer + ready halted hnewLeft hnewRight).halted + +theorem checkQ05_memory : (query model newLeft newRight es).memory = es.memory := + ((export_contract model xs left right domain hl hr).continuation es newLeft newRight answer + ready halted hnewLeft hnewRight).memory + +theorem checkQ06_observations : (Executable.queryArray model newLeft newRight es).toRun = + Reusable.queryRun model newLeft newRight es.toState := + ((export_contract model xs left right domain hl hr).continuation es newLeft newRight answer + ready halted hnewLeft hnewRight).observations + +theorem checkQ07_boundary : (requestProtocol Layout.serviceEntry newLeft newRight es.toState).steps = 4 ∧ + (requestProtocol Layout.serviceEntry newLeft newRight es.toState).categories = + [.requestAdmission, .requestAdmission, .controlEntry, .controlEntry] := + ((export_contract model xs left right domain hl hr).continuation es newLeft newRight answer + ready halted hnewLeft hnewRight).boundary + +theorem checkQ08_steps : (Reusable.queryRun model newLeft newRight es.toState).steps = + 4 + 4 + 8271 + (compactQueryRun (buildMemory xs) xs.length newLeft newRight).steps := + ((export_contract model xs left right domain hl hr).continuation es newLeft newRight answer + ready halted hnewLeft hnewRight).steps + +theorem checkQ09_budget : (Reusable.queryRun model newLeft newRight es.toState).steps ≤ 160257 := + ((export_contract model xs left right domain hl hr).continuation es newLeft newRight answer + ready halted hnewLeft hnewRight).budget + +theorem checkQ10_capacity : + ((query model newLeft newRight es).memory.size + (encodedProgram model).length + + (query model newLeft newRight es).regs.size + 8) * wordWidth xs.length ≤ + 2 * xs.length + retainedRho xs.length := by + have projection := + ((export_contract model xs left right domain hl hr).continuation es newLeft newRight answer + ready halted hnewLeft hnewRight).capacity + change Ownership.capacity model (query model newLeft newRight es) * wordWidth xs.length ≤ + 2 * xs.length + retainedRho xs.length + with_reducible exact projection + +omit ready halted hnewLeft hnewRight in +theorem checkE13_invalid (invalid : ¬ ValidRange xs left right) : + (buildFirst model xs left right).status = .halted 0 ∧ + ExpectedReady xs (buildFirst model xs left right) := by + refine ⟨?_, (export_contract model xs left right domain hl hr).ready⟩ + rw [(export_contract model xs left right domain hl hr).halted, + SuccinctClassic.queryTraceResult_invalid xs left right invalid] + rfl + +theorem checkQ11_invalid (invalid : ¬ ValidRange xs newLeft newRight) : + (query model newLeft newRight es).status = .halted 0 ∧ + ExpectedReady xs (query model newLeft newRight es) := by + have contract := (export_contract model xs left right domain hl hr).continuation es + newLeft newRight answer ready halted hnewLeft hnewRight + refine ⟨?_, contract.ready⟩ + rw [contract.halted, SuccinctClassic.queryTraceResult_invalid xs newLeft newRight invalid] + rfl + +omit domain hl hr ready halted hnewLeft hnewRight in +theorem checkU01_cached_run (fuel : Nat) (owner : Owner) : + runOwner (cachedProgram model) fuel owner = + runOwner (Layout.program model).toArray fuel owner := + cached_run model fuel owner + +omit domain hl hr ready halted hnewLeft hnewRight in +theorem checkU02_word (input : PackedConstruction.InputFits (wordWidth xs.length) xs) + (hleft : left < 2 ^ wordWidth xs.length) (hright : right < 2 ^ wordWidth xs.length) : + (buildFirst .word xs left right).status = .halted + (PackedWordRAM.optionNatPacket (SuccinctClassic.queryTraceResult xs left right).value) := + (word_export_contract xs left right input hleft hright).halted + +omit domain hl hr ready halted hnewLeft hnewRight in +theorem checkU03_comparison + (hleft : left < 2 ^ wordWidth xs.length) (hright : right < 2 ^ wordWidth xs.length) : + (buildFirst .comparison xs left right).status = .halted + (PackedWordRAM.optionNatPacket (SuccinctClassic.queryTraceResult xs left right).value) := + (comparison_export_contract xs left right hleft hright).halted + +end RMQ.SuccinctFinal.PackedNative.Lifecycle.ContractChecks + +namespace RMQ.SuccinctFinal.PackedNative.Lifecycle.ContractChecks + +open PackedLifecycle +open PackedWordRAM (wordWidth optionNatPacket) + +theorem checkT01_arbitraryRun (program : Array Instruction) (fuel : Nat) (owner : Owner) : + runThin program fuel owner = runOwner program fuel owner := + runThin_eq_runOwner program fuel owner + +theorem checkT02_arbitraryBoundary (boundaries : List Boundary) (owner : Owner) : + runBoundaryThin boundaries owner = runBoundaryOwner boundaries owner := + runBoundaryThin_eq_runBoundaryOwner boundaries owner + +theorem checkT03_arbitraryRequest (entry : PackedConstruction.Operand) + (left right : Nat) (owner : Owner) : + requestProtocolThin entry left right owner = requestProtocolOwner entry left right owner := + requestProtocolThin_eq_requestProtocolOwner entry left right owner + +theorem checkT04_arbitraryObservedRun (program : Array Instruction) (fuel : Nat) + (owner : Owner) (stats : Observations.Stats) : + Observations.runAccThin program fuel owner stats = + Observations.runAcc program fuel owner stats := + Observations.runAccThin_eq_runAcc program fuel owner stats + +theorem checkT05_arbitraryObservedBoundary (boundaries : List Boundary) (owner : Owner) + (stats : Observations.Stats) : + Observations.boundaryAccThin boundaries owner stats = + Observations.boundaryAcc boundaries owner stats := + Observations.boundaryAccThin_eq_boundaryAcc boundaries owner stats + +theorem checkT06_arbitraryNativeFuel (comparison : Bool) (fuel : Nat) (owner : Owner) : + nativeRunFuel comparison fuel owner = + runOwner (Layout.program (modelOfComparison comparison)).toArray fuel owner := + nativeRunFuel_source comparison fuel owner + +theorem checkT07_arbitraryObservation (stats : Observations.Stats) (transition : ArrayTransition) : + stats.record transition = stats.recordBefore transition.action transition.before := + Observations.Stats.record_eq_recordBefore stats transition + +theorem expectedByteCanonical (width : Nat) (bytes : ByteArray) : + LimbWord.Canonical width bytes.data ↔ + bytes.size = LimbWord.limbCount width ∧ decodeMagnitude bytes < 2 ^ width := Iff.rfl + +theorem checkB01_metadata (xs : List Int) (owner : Owner) (ready : ExpectedReady xs owner) : + nativeMetadata owner 0 = some xs.length ∧ nativeMetadata owner 7 = some owner.memory.size := + nativeMetadata_ready ready + +theorem checkB02_count (model : InputModel) (xs : List Int) (left right : Nat) + (domain : InputDomain model xs) (hl : left < 2 ^ wordWidth xs.length) + (hr : right < 2 ^ wordWidth xs.length) : + producedCount (buildFirst model xs left right) = xs.length ∧ + nativeMetadata (buildFirst model xs left right) 0 = some xs.length ∧ + nativeMetadata (buildFirst model xs left right) 7 = + some (buildFirst model xs left right).memory.size := + buildFirst_metadata model xs left right domain hl hr + +theorem checkB03_queryAdmission (xs : List Int) (owner : Owner) (left right : ByteArray) + (ready : ExpectedReady xs owner) : + nativeQueryAdmit owner left right = true ↔ + (left.size = LimbWord.limbCount (wordWidth xs.length) ∧ + decodeMagnitude left < 2 ^ wordWidth xs.length) ∧ + (right.size = LimbWord.limbCount (wordWidth xs.length) ∧ + decodeMagnitude right < 2 ^ wordWidth xs.length) := + nativeQueryAdmit_iff xs owner left right ready + +theorem checkB04_first (comparison : Bool) (xs : List Int) (count : Nat) + (left right : ByteArray) (accepted : nativeAdmit comparison xs count left right = true) : + nativeBuildFirst comparison xs left right = Ownership.owner (modelOfComparison comparison) xs + (decodeMagnitude left) (decodeMagnitude right) ∧ + ExpectedReady xs (nativeBuildFirst comparison xs left right) ∧ + (nativeBuildFirst comparison xs left right).status = .halted + (optionNatPacket (SuccinctClassic.queryTraceResult xs + (decodeMagnitude left) (decodeMagnitude right)).value) := + nativeBuildFirst_correct comparison xs count left right accepted + +theorem checkB05_firstPacket (comparison : Bool) (xs : List Int) (count : Nat) + (left right : ByteArray) (accepted : nativeAdmit comparison xs count left right = true) : + nativePacket (nativeBuildFirst comparison xs left right) = encodeEndpoint (wordWidth xs.length) + (optionNatPacket (SuccinctClassic.queryTraceResult xs + (decodeMagnitude left) (decodeMagnitude right)).value) ∧ + ((nativePacket (nativeBuildFirst comparison xs left right)).size = + LimbWord.limbCount (wordWidth xs.length) ∧ + decodeMagnitude (nativePacket (nativeBuildFirst comparison xs left right)) < 2 ^ wordWidth xs.length) ∧ + decodeMagnitude (nativePacket (nativeBuildFirst comparison xs left right)) = + optionNatPacket (SuccinctClassic.queryTraceResult xs + (decodeMagnitude left) (decodeMagnitude right)).value := + let h := nativeBuildFirst_packet comparison xs count left right accepted + ⟨h.1, (expectedByteCanonical _ _).1 h.2.1, h.2.2⟩ + +theorem checkB06_query (comparison : Bool) (xs : List Int) (owner : Owner) + (left right : ByteArray) (answer : Nat) (ready : ExpectedReady xs owner) + (halted : owner.status = .halted answer) (accepted : nativeQueryAdmit owner left right = true) : + ExpectedReady xs (nativeQuery comparison left right owner) ∧ + (nativeQuery comparison left right owner).status = .halted + (optionNatPacket (SuccinctClassic.queryTraceResult xs + (decodeMagnitude left) (decodeMagnitude right)).value) ∧ + (nativeQuery comparison left right owner).memory = owner.memory := + nativeQuery_correct comparison xs owner left right answer ready halted accepted + +theorem checkB07_queryPacket (comparison : Bool) (xs : List Int) (owner : Owner) + (left right : ByteArray) (answer : Nat) (ready : ExpectedReady xs owner) + (halted : owner.status = .halted answer) (accepted : nativeQueryAdmit owner left right = true) : + nativePacket (nativeQuery comparison left right owner) = encodeEndpoint (wordWidth xs.length) + (optionNatPacket (SuccinctClassic.queryTraceResult xs + (decodeMagnitude left) (decodeMagnitude right)).value) ∧ + ((nativePacket (nativeQuery comparison left right owner)).size = + LimbWord.limbCount (wordWidth xs.length) ∧ + decodeMagnitude (nativePacket (nativeQuery comparison left right owner)) < 2 ^ wordWidth xs.length) ∧ + decodeMagnitude (nativePacket (nativeQuery comparison left right owner)) = + optionNatPacket (SuccinctClassic.queryTraceResult xs + (decodeMagnitude left) (decodeMagnitude right)).value := + let h := nativeQuery_packet comparison xs owner left right answer ready halted accepted + ⟨h.1, (expectedByteCanonical _ _).1 h.2.1, h.2.2⟩ + +theorem checkB08_packetFits (xs : List Int) (left right : Nat) : + optionNatPacket (SuccinctClassic.queryTraceResult xs left right).value < 2 ^ wordWidth xs.length := + answer_packet_fits xs left right + +theorem checkB09_allSizeFirstPacket (model : InputModel) (xs : List Int) (left right : Nat) + (domain : InputDomain model xs) (hl : left < 2 ^ wordWidth xs.length) + (hr : right < 2 ^ wordWidth xs.length) : + nativePacket (buildFirst model xs left right) = encodeEndpoint (wordWidth xs.length) + (optionNatPacket (SuccinctClassic.queryTraceResult xs left right).value) ∧ + ((nativePacket (buildFirst model xs left right)).size = LimbWord.limbCount (wordWidth xs.length) ∧ + decodeMagnitude (nativePacket (buildFirst model xs left right)) < 2 ^ wordWidth xs.length) ∧ + decodeMagnitude (nativePacket (buildFirst model xs left right)) = + optionNatPacket (SuccinctClassic.queryTraceResult xs left right).value := + let h := buildFirst_packet model xs left right domain hl hr + ⟨h.1, (expectedByteCanonical _ _).1 h.2.1, h.2.2⟩ + +theorem checkB10_allSizeQueryPacket (model : InputModel) (xs : List Int) (owner : Owner) + (left right answer : Nat) (ready : ExpectedReady xs owner) (halted : owner.status = .halted answer) + (hl : left < 2 ^ wordWidth xs.length) (hr : right < 2 ^ wordWidth xs.length) : + nativePacket (query model left right owner) = encodeEndpoint (wordWidth xs.length) + (optionNatPacket (SuccinctClassic.queryTraceResult xs left right).value) ∧ + ((nativePacket (query model left right owner)).size = LimbWord.limbCount (wordWidth xs.length) ∧ + decodeMagnitude (nativePacket (query model left right owner)) < 2 ^ wordWidth xs.length) ∧ + decodeMagnitude (nativePacket (query model left right owner)) = + optionNatPacket (SuccinctClassic.queryTraceResult xs left right).value := + let h := query_packet model xs owner left right answer ready halted hl hr + ⟨h.1, (expectedByteCanonical _ _).1 h.2.1, h.2.2⟩ + +theorem checkB11_initial (comparison : Bool) (xs : List Int) (left right : ByteArray) : + nativeInitial comparison xs left right = Executable.initialOwner (modelOfComparison comparison) xs + (decodeMagnitude left) (decodeMagnitude right) := rfl + +theorem checkB12_firstComposition (comparison : Bool) (xs : List Int) (left right : ByteArray) : + nativeRunFirst comparison xs.length (nativeInitial comparison xs left right) = + nativeBuildFirst comparison xs left right := + nativeInitial_runFirst comparison xs left right + +theorem checkB13_observedComposition (comparison : Bool) (xs : List Int) (left right : ByteArray) : + nativeRunFirstObserved comparison xs.length (nativeInitial comparison xs left right) = + nativeBuildFirstObserved comparison xs left right := + nativeInitial_runFirstObserved comparison xs left right + +theorem checkB14_observedFirstOwner (comparison : Bool) (xs : List Int) (left right : ByteArray) : + (nativeRunFirstObserved comparison xs.length (nativeInitial comparison xs left right)).1 = + nativeBuildFirst comparison xs left right := by + rw [nativeInitial_runFirstObserved] + exact nativeBuildFirstObserved_owner comparison xs left right + +theorem checkB15_observedQueryOwner (comparison : Bool) (left right : ByteArray) (owner : Owner) : + (nativeQueryObserved comparison left right owner).1 = nativeQuery comparison left right owner := + nativeQueryObserved_owner comparison left right owner + +theorem checkB16_observedArbitraryOwner (comparison : Bool) (count : Nat) (owner : Owner) : + (nativeRunFirstObserved comparison count owner).1 = nativeRunFirst comparison count owner := by + unfold nativeRunFirstObserved nativeRunFirst + rw [runThin_eq_runOwner] + exact Observations.run_owner _ _ _ + +theorem checkB17_admittedComposition (comparison : Bool) (xs : List Int) (count : Nat) + (left right : ByteArray) (accepted : nativeAdmit comparison xs count left right = true) : + nativeRunFirst comparison count (nativeInitial comparison xs left right) = + nativeBuildFirst comparison xs left right := + nativeInitial_runFirst_admitted comparison xs count left right accepted + +theorem checkB18_admittedObservedComposition (comparison : Bool) (xs : List Int) (count : Nat) + (left right : ByteArray) (accepted : nativeAdmit comparison xs count left right = true) : + nativeRunFirstObserved comparison count (nativeInitial comparison xs left right) = + nativeBuildFirstObserved comparison xs left right := + nativeInitial_runFirstObserved_admitted comparison xs count left right accepted + +end RMQ.SuccinctFinal.PackedNative.Lifecycle.ContractChecks + +namespace RMQ.SuccinctFinal.PackedNative.Lifecycle.ContractChecks + +open PackedLifecycle +open PackedWordRAM (wordWidth) + +set_option maxRecDepth 30000 + +/-! These checks pin the exported scalar IDs as well as the underlying counts. +First-run observations contain construction and the first request; query +observations contain only the four re-entry events and the service suffix. -/ + +section FirstObservations + +theorem expectedStepCounter (stats : Observations.Stats) : + nativeObservationCounter stats 15 = stats.steps := rfl + +variable (comparison : Bool) (xs : List Int) (left right : ByteArray) + (domain : InputDomain (modelOfComparison comparison) xs) + (hl : decodeMagnitude left < 2 ^ wordWidth xs.length) + (hr : decodeMagnitude right < 2 ^ wordWidth xs.length) + +include domain hl hr + +theorem checkO01_firstSteps : + nativeObservationCounter (nativeBuildFirstObserved comparison xs left right).2 15 = (Continuous.continuousRun (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).steps := by + rw [expectedStepCounter] + exact (Observations.buildFirst_model_observations (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right) domain hl hr).1 + +theorem checkO02_firstCategories : + nativeObservationCounter (nativeBuildFirstObserved comparison xs left right).2 0 = + (Continuous.continuousRun (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).categoryCount (.old .read) ∧ + nativeObservationCounter (nativeBuildFirstObserved comparison xs left right).2 1 = + (Continuous.continuousRun (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).categoryCount (.old .register) ∧ + nativeObservationCounter (nativeBuildFirstObserved comparison xs left right).2 2 = + (Continuous.continuousRun (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).categoryCount (.old .arithmetic) ∧ + nativeObservationCounter (nativeBuildFirstObserved comparison xs left right).2 3 = + (Continuous.continuousRun (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).categoryCount (.old .comparison) ∧ + nativeObservationCounter (nativeBuildFirstObserved comparison xs left right).2 4 = + (Continuous.continuousRun (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).categoryCount (.old .branch) ∧ + nativeObservationCounter (nativeBuildFirstObserved comparison xs left right).2 5 = + (Continuous.continuousRun (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).categoryCount (.old .control) ∧ + nativeObservationCounter (nativeBuildFirstObserved comparison xs left right).2 6 = + (Continuous.continuousRun (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).categoryCount (.old .write) ∧ + nativeObservationCounter (nativeBuildFirstObserved comparison xs left right).2 7 = + (Continuous.continuousRun (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).categoryCount (.old .allocation) ∧ + nativeObservationCounter (nativeBuildFirstObserved comparison xs left right).2 8 = + (Continuous.continuousRun (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).categoryCount (.old .keyRead) ∧ + nativeObservationCounter (nativeBuildFirstObserved comparison xs left right).2 9 = + (Continuous.continuousRun (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).categoryCount (.old .oracleComparison) ∧ + nativeObservationCounter (nativeBuildFirstObserved comparison xs left right).2 10 = + (Continuous.continuousRun (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).categoryCount (.numericRelease) ∧ + nativeObservationCounter (nativeBuildFirstObserved comparison xs left right).2 11 = + (Continuous.continuousRun (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).categoryCount (.keyRelease) ∧ + nativeObservationCounter (nativeBuildFirstObserved comparison xs left right).2 12 = + (Continuous.continuousRun (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).categoryCount (.keyRegisterRelease) ∧ + nativeObservationCounter (nativeBuildFirstObserved comparison xs left right).2 13 = + (Continuous.continuousRun (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).categoryCount (.requestAdmission) ∧ + nativeObservationCounter (nativeBuildFirstObserved comparison xs left right).2 14 = + (Continuous.continuousRun (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).categoryCount (.controlEntry) := by + have h := (Observations.buildFirst_model_observations (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right) domain hl hr).2.1 + exact ⟨h (.old .read), + h (.old .register), + h (.old .arithmetic), + h (.old .comparison), + h (.old .branch), + h (.old .control), + h (.old .write), + h (.old .allocation), + h (.old .keyRead), + h (.old .oracleComparison), + h (.numericRelease), + h (.keyRelease), + h (.keyRegisterRelease), + h (.requestAdmission), + h (.controlEntry)⟩ + +theorem checkO03_firstOrderedReads : + nativeObservationReads (nativeBuildFirstObserved comparison xs left right).2 = (Continuous.continuousRun (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).reads.toArray := + congrArg List.toArray + (Observations.buildFirst_model_observations (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right) domain hl hr).2.2 + +omit domain hl hr in +theorem checkO04_firstRoutes : + nativeObservationRoute (nativeBuildFirstObserved comparison xs left right).2 0 = + (Ownership.observations (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).transitions.countP + (Observations.routeMarked .compactQuery) ∧ + nativeObservationRoute (nativeBuildFirstObserved comparison xs left right).2 1 = + (Ownership.observations (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).transitions.countP + (Observations.routeMarked .servicePrepare) ∧ + nativeObservationRoute (nativeBuildFirstObserved comparison xs left right).2 2 = + (Ownership.observations (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).transitions.countP + (Observations.routeMarked .serviceSetup) ∧ + nativeObservationRoute (nativeBuildFirstObserved comparison xs left right).2 3 = + (Ownership.observations (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).transitions.countP + (Observations.routeMarked .builder) ∧ + nativeObservationRoute (nativeBuildFirstObserved comparison xs left right).2 4 = + (Ownership.observations (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).transitions.countP + (Observations.routeMarked .descriptor) ∧ + nativeObservationRoute (nativeBuildFirstObserved comparison xs left right).2 5 = + (Ownership.observations (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).transitions.countP + (Observations.routeMarked .finalizer) ∧ + nativeObservationRoute (nativeBuildFirstObserved comparison xs left right).2 6 = + (Ownership.observations (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).transitions.countP + (Observations.routeMarked .retirement) ∧ + nativeObservationRoute (nativeBuildFirstObserved comparison xs left right).2 7 = + (Ownership.observations (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).transitions.countP + (Observations.routeMarked .sameBlockDecision) ∧ + nativeObservationRoute (nativeBuildFirstObserved comparison xs left right).2 8 = + (Ownership.observations (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).transitions.countP + (Observations.routeMarked .crossBlockDecision) ∧ + nativeObservationRoute (nativeBuildFirstObserved comparison xs left right).2 9 = + (Ownership.observations (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).transitions.countP + (Observations.routeMarked .interiorNonemptyDecision) ∧ + nativeObservationRoute (nativeBuildFirstObserved comparison xs left right).2 10 = + (Ownership.observations (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).transitions.countP + (Observations.routeMarked .interiorEmptyDecision) ∧ + nativeObservationRoute (nativeBuildFirstObserved comparison xs left right).2 11 = + (Ownership.observations (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).transitions.countP + (Observations.routeMarked .interiorReadMarker) ∧ + nativeObservationRoute (nativeBuildFirstObserved comparison xs left right).2 12 = + (Ownership.observations (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right)).transitions.countP + (Observations.routeMarked .crossingSecondLoad) := + ⟨Observations.buildFirst_route (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right) .compactQuery, + Observations.buildFirst_route (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right) .servicePrepare, + Observations.buildFirst_route (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right) .serviceSetup, + Observations.buildFirst_route (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right) .builder, + Observations.buildFirst_route (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right) .descriptor, + Observations.buildFirst_route (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right) .finalizer, + Observations.buildFirst_route (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right) .retirement, + Observations.buildFirst_route (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right) .sameBlockDecision, + Observations.buildFirst_route (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right) .crossBlockDecision, + Observations.buildFirst_route (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right) .interiorNonemptyDecision, + Observations.buildFirst_route (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right) .interiorEmptyDecision, + Observations.buildFirst_route (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right) .interiorReadMarker, + Observations.buildFirst_route (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right) .crossingSecondLoad⟩ + +end FirstObservations + +section QueryObservations + +variable (comparison : Bool) (xs : List Int) (left right : ByteArray) + (owner : Owner) (answer : Nat) (ready : ExpectedReady xs owner) + (halted : owner.status = .halted answer) + (hl : decodeMagnitude left < 2 ^ wordWidth xs.length) + (hr : decodeMagnitude right < 2 ^ wordWidth xs.length) + +include ready halted hl hr + +theorem checkO05_querySteps : + nativeObservationCounter (nativeQueryObserved comparison left right owner).2 15 = (Reusable.queryRun (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner.toState).steps := + (Observations.query_model_observations (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right) + answer owner ready halted hl hr).1 + +theorem checkO06_queryCategories : + nativeObservationCounter (nativeQueryObserved comparison left right owner).2 0 = + (Reusable.queryRun (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner.toState).categoryCount (.old .read) ∧ + nativeObservationCounter (nativeQueryObserved comparison left right owner).2 1 = + (Reusable.queryRun (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner.toState).categoryCount (.old .register) ∧ + nativeObservationCounter (nativeQueryObserved comparison left right owner).2 2 = + (Reusable.queryRun (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner.toState).categoryCount (.old .arithmetic) ∧ + nativeObservationCounter (nativeQueryObserved comparison left right owner).2 3 = + (Reusable.queryRun (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner.toState).categoryCount (.old .comparison) ∧ + nativeObservationCounter (nativeQueryObserved comparison left right owner).2 4 = + (Reusable.queryRun (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner.toState).categoryCount (.old .branch) ∧ + nativeObservationCounter (nativeQueryObserved comparison left right owner).2 5 = + (Reusable.queryRun (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner.toState).categoryCount (.old .control) ∧ + nativeObservationCounter (nativeQueryObserved comparison left right owner).2 6 = + (Reusable.queryRun (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner.toState).categoryCount (.old .write) ∧ + nativeObservationCounter (nativeQueryObserved comparison left right owner).2 7 = + (Reusable.queryRun (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner.toState).categoryCount (.old .allocation) ∧ + nativeObservationCounter (nativeQueryObserved comparison left right owner).2 8 = + (Reusable.queryRun (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner.toState).categoryCount (.old .keyRead) ∧ + nativeObservationCounter (nativeQueryObserved comparison left right owner).2 9 = + (Reusable.queryRun (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner.toState).categoryCount (.old .oracleComparison) ∧ + nativeObservationCounter (nativeQueryObserved comparison left right owner).2 10 = + (Reusable.queryRun (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner.toState).categoryCount (.numericRelease) ∧ + nativeObservationCounter (nativeQueryObserved comparison left right owner).2 11 = + (Reusable.queryRun (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner.toState).categoryCount (.keyRelease) ∧ + nativeObservationCounter (nativeQueryObserved comparison left right owner).2 12 = + (Reusable.queryRun (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner.toState).categoryCount (.keyRegisterRelease) ∧ + nativeObservationCounter (nativeQueryObserved comparison left right owner).2 13 = + (Reusable.queryRun (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner.toState).categoryCount (.requestAdmission) ∧ + nativeObservationCounter (nativeQueryObserved comparison left right owner).2 14 = + (Reusable.queryRun (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner.toState).categoryCount (.controlEntry) := by + have h := (Observations.query_model_observations (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right) + answer owner ready halted hl hr).2.1 + exact ⟨h (.old .read), + h (.old .register), + h (.old .arithmetic), + h (.old .comparison), + h (.old .branch), + h (.old .control), + h (.old .write), + h (.old .allocation), + h (.old .keyRead), + h (.old .oracleComparison), + h (.numericRelease), + h (.keyRelease), + h (.keyRegisterRelease), + h (.requestAdmission), + h (.controlEntry)⟩ + +theorem checkO07_queryOrderedReads : + nativeObservationReads (nativeQueryObserved comparison left right owner).2 = (Reusable.queryRun (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner.toState).reads.toArray := + congrArg List.toArray + (Observations.query_model_observations (modelOfComparison comparison) xs (decodeMagnitude left) (decodeMagnitude right) + answer owner ready halted hl hr).2.2 + +omit ready halted hl hr in +theorem checkO08_queryRoutes : + nativeObservationRoute (nativeQueryObserved comparison left right owner).2 0 = + (Executable.queryArray (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner).transitions.countP + (Observations.routeMarked .compactQuery) ∧ + nativeObservationRoute (nativeQueryObserved comparison left right owner).2 1 = + (Executable.queryArray (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner).transitions.countP + (Observations.routeMarked .servicePrepare) ∧ + nativeObservationRoute (nativeQueryObserved comparison left right owner).2 2 = + (Executable.queryArray (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner).transitions.countP + (Observations.routeMarked .serviceSetup) ∧ + nativeObservationRoute (nativeQueryObserved comparison left right owner).2 3 = + (Executable.queryArray (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner).transitions.countP + (Observations.routeMarked .builder) ∧ + nativeObservationRoute (nativeQueryObserved comparison left right owner).2 4 = + (Executable.queryArray (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner).transitions.countP + (Observations.routeMarked .descriptor) ∧ + nativeObservationRoute (nativeQueryObserved comparison left right owner).2 5 = + (Executable.queryArray (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner).transitions.countP + (Observations.routeMarked .finalizer) ∧ + nativeObservationRoute (nativeQueryObserved comparison left right owner).2 6 = + (Executable.queryArray (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner).transitions.countP + (Observations.routeMarked .retirement) ∧ + nativeObservationRoute (nativeQueryObserved comparison left right owner).2 7 = + (Executable.queryArray (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner).transitions.countP + (Observations.routeMarked .sameBlockDecision) ∧ + nativeObservationRoute (nativeQueryObserved comparison left right owner).2 8 = + (Executable.queryArray (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner).transitions.countP + (Observations.routeMarked .crossBlockDecision) ∧ + nativeObservationRoute (nativeQueryObserved comparison left right owner).2 9 = + (Executable.queryArray (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner).transitions.countP + (Observations.routeMarked .interiorNonemptyDecision) ∧ + nativeObservationRoute (nativeQueryObserved comparison left right owner).2 10 = + (Executable.queryArray (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner).transitions.countP + (Observations.routeMarked .interiorEmptyDecision) ∧ + nativeObservationRoute (nativeQueryObserved comparison left right owner).2 11 = + (Executable.queryArray (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner).transitions.countP + (Observations.routeMarked .interiorReadMarker) ∧ + nativeObservationRoute (nativeQueryObserved comparison left right owner).2 12 = + (Executable.queryArray (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner).transitions.countP + (Observations.routeMarked .crossingSecondLoad) := + ⟨Observations.query_route (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner .compactQuery, + Observations.query_route (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner .servicePrepare, + Observations.query_route (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner .serviceSetup, + Observations.query_route (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner .builder, + Observations.query_route (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner .descriptor, + Observations.query_route (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner .finalizer, + Observations.query_route (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner .retirement, + Observations.query_route (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner .sameBlockDecision, + Observations.query_route (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner .crossBlockDecision, + Observations.query_route (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner .interiorNonemptyDecision, + Observations.query_route (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner .interiorEmptyDecision, + Observations.query_route (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner .interiorReadMarker, + Observations.query_route (modelOfComparison comparison) (decodeMagnitude left) (decodeMagnitude right) owner .crossingSecondLoad⟩ + +end QueryObservations + +/-- Each equal-valued read remains tied to its own transition position and +producing prestate in the actual array execution. -/ +theorem checkO09_readPosition {program : Array Instruction} {fuel : Nat} {owner : Owner} + {index : Nat} {t : ArrayTransition} {reply : Nat × Option Nat} + (occurs : (runArray program fuel owner).transitions[index]? = some t) + (read : t.read? = some reply) : + (Observations.run program fuel owner).2.reads = + ((runArray program fuel owner).transitions.take index).filterMap ArrayTransition.read? ++ + reply :: ((runArray program fuel owner).transitions.drop (index + 1)).filterMap + ArrayTransition.read? ∧ + t.before = runOwner program index owner ∧ stepArray program t.before = some t := + Observations.read_occurrence_output occurs read + +/-- This position includes the four boundary events. Its producing prestate is +the actual service prestate, not a restarted run or a deduplicated read value. -/ +theorem checkO10_queryReadPosition (model : InputModel) (xs : List Int) + (left right answer : Nat) (owner : Owner) (ready : ExpectedReady xs owner) + (halted : owner.status = .halted answer) + (hl : left < 2 ^ wordWidth xs.length) (hr : right < 2 ^ wordWidth xs.length) + (index : Nat) (t : ArrayTransition) (address : Nat) (reply : Option Nat) + (occurs : (Executable.queryArray model left right owner).transitions[index]? = some t) + (read : t.read? = some (address, reply)) : + 4 ≤ index ∧ + (Reusable.serviceRun model + (requestProtocol Layout.serviceEntry left right owner.toState).final).transitions[index - 4]? = + some t.toTransition ∧ + t.before.toState = (run (Layout.program model) (index - 4) + (requestProtocol Layout.serviceEntry left right owner.toState).final).final ∧ + step (Layout.program model) t.before.toState = some t.toTransition ∧ + address < 2 ^ wordWidth xs.length ∧ reply = (PackedWordRAM.buildMemory xs)[address]? ∧ + ∃ value, reply = some value ∧ value < 2 ^ wordWidth xs.length := by + have refinement := (Executable.query_array_refinement model xs left right answer owner + ready.1 ready.2 halted hl hr).1 + have mapped : (Reusable.queryRun model left right owner.toState).transitions[index]? = + some t.toTransition := by + rw [← refinement] + change ((Executable.queryArray model left right owner).transitions.map + ArrayTransition.toTransition)[index]? = some t.toTransition + simp only [List.getElem?_map, occurs, Option.map_some] + have abstractRead : t.toTransition.read? = some (address, reply) := by + rw [ArrayTransition.read_toTransition] + exact read + exact Reusable.query_read_occurrence model xs left right answer owner.toState ready.2 + halted hl hr index t.toTransition address reply mapped abstractRead + +/-- Accumulation is explicitly concatenated first history plus query suffix. -/ +theorem checkO11_session (model : InputModel) (xs : List Int) + (left right nextLeft nextRight : Nat) : + let first := Observations.buildFirst model xs left right + Observations.queryAcc model nextLeft nextRight first.1 first.2 = + (query model nextLeft nextRight (buildFirst model xs left right), + ({} : Observations.Stats).fold + ((Ownership.observations model xs left right).transitions ++ + (Executable.queryArray model nextLeft nextRight + (buildFirst model xs left right)).transitions)) := + Observations.first_then_query model xs left right nextLeft nextRight + +end RMQ.SuccinctFinal.PackedNative.Lifecycle.ContractChecks diff --git a/RMQ/Validation/PackedLifecycle.lean b/RMQ/Validation/PackedLifecycle.lean new file mode 100644 index 00000000..69d6ade9 --- /dev/null +++ b/RMQ/Validation/PackedLifecycle.lean @@ -0,0 +1,287 @@ +import RMQ.Core.WordRAM.Lifecycle.Executable +import RMQ.Core.WordRAM.Lifecycle.Controls + +/-! Finite lifecycle validation. The production owner is run directly. A second, +bounded, history-free fold counts transitions produced by the same scalar step; +its final-owner projection is proved below. Answers come from an independent +strict-comparison scan. No canonical output is materialized as an implementation. +-/ +namespace RMQ.Validation.PackedLifecycle +open RMQ.SuccinctFinal RMQ.SuccinctFinal.PackedLifecycle + +def categories : Array Category := #[ + .old .read, .old .register, .old .arithmetic, .old .comparison, + .old .branch, .old .control, .old .write, .old .allocation, + .old .keyRead, .old .oracleComparison, .numericRelease, .keyRelease, + .keyRegisterRelease, .requestAdmission, .controlEntry] + +def categoryIndex : Category → Nat + | .old .read => 0 | .old .register => 1 | .old .arithmetic => 2 + | .old .comparison => 3 | .old .branch => 4 | .old .control => 5 + | .old .write => 6 | .old .allocation => 7 | .old .keyRead => 8 + | .old .oracleComparison => 9 | .numericRelease => 10 | .keyRelease => 11 + | .keyRegisterRelease => 12 | .requestAdmission => 13 | .controlEntry => 14 + +theorem category_index_exact (c : Category) : categories[categoryIndex c]? = some c := by + cases c with + | old c => cases c <;> rfl + | numericRelease | keyRelease | keyRegisterRelease | requestAdmission | controlEntry => rfl + +structure Counters where + steps : Nat := 0 + counts : Array Nat := Array.replicate 15 0 + peak : Nat := 0 + source : Option (Nat × Nat) := none + scalarSizes : Bool := true + +def Counters.add (c : Counters) (t : ArrayTransition) : Counters := + let i := categoryIndex t.action.category + let sizes := match t.action with + | .instruction .releaseCell => t.before.memory.size == t.after.memory.size + 1 + | .instruction .releaseKey => t.before.keys.size == t.after.keys.size + 1 + | .instruction .releaseKeyRegister => t.before.keyRegs.size == t.after.keyRegs.size + 1 + | .instruction (.old (.reserve _)) => t.after.memory.size == t.before.memory.size + 1 + | _ => true + { steps := c.steps + 1 + counts := c.counts.setIfInBounds i (c.counts.getD i 0 + 1) + peak := max c.peak (max t.before.memory.size t.after.memory.size) + source := if t.before.pc == Layout.finalizerBase then + some (t.before.regs.getD 0 0, t.before.regs.getD 2 0) else c.source + scalarSizes := c.scalarSizes && sizes && t.before.regs.size == t.after.regs.size } + +/-- Validation-only counters retain no states, input, key bank or trace. -/ +def counted (program : Array Instruction) : Nat → Owner → Counters → Owner × Counters + | 0, owner, c => (owner, c) + | fuel + 1, owner, c => match stepArray program owner with + | none => (owner, c) + | some t => counted program fuel t.after (c.add t) + +theorem counted_owner (program : Array Instruction) (fuel : Nat) (owner : Owner) (c : Counters) : + (counted program fuel owner c).1 = runOwner program fuel owner := by + induction fuel generalizing owner c with + | zero => rfl + | succ fuel ih => cases h : stepArray program owner <;> simp [counted, runOwner, h, ih] + +def sameOwner (a b : Owner) : Bool := + a.regs == b.regs && a.memory == b.memory && a.keys == b.keys && + a.keyRegs == b.keyRegs && a.pc == b.pc && a.status == b.status + +/-- Invalid endpoints yield zero. Only strict improvements replace the current +index, so ties keep the first index. This does not call any packed query oracle. -/ +def reference (xs : Array Int) (left right : Nat) : Nat := + if left < right && right ≤ xs.size then + let best := (List.range (right-left)).foldl (fun best offset => + let i := left + offset + if xs.getD i 0 < xs.getD best 0 then i else best) left + best + 1 + else 0 + +structure Fixture where + id : String + model : InputModel + xs : List Int + queries : List (Nat × Nat) + dirty : Bool := false + +def geometryInput (n : Nat) : List Int := + (List.range n).map (fun i => (Int.ofNat ((i*17 + i/3) % 11)) - 5) + +def wideGeometryInput (n : Nat) : List Int := + (geometryInput n).map (fun x => x * (2^(PackedWordRAM.wordWidth n + 5) : Int) + 17) + +def registry : List Fixture := [ + ⟨"L01-W-EMPTY", .word, [], [(0,0)], false⟩, + ⟨"L02-C-EMPTY", .comparison, [], [(0,1)], false⟩, + ⟨"L03-W-SINGLE", .word, [-7], [(0,1)], false⟩, + ⟨"L04-C-SINGLE", .comparison, [-7], [(0,1)], false⟩, + ⟨"L05-W-REPEAT", .word, [2,2,2], [(0,3),(1,3)], false⟩, + ⟨"L06-C-REPEAT", .comparison, [2,2,2], [(0,3),(1,3)], false⟩, + ⟨"L07-W-TIE", .word, [4,-3,-3,8], [(0,4),(2,4)], false⟩, + ⟨"L08-C-TIE", .comparison, [4,-3,-3,8], [(0,4),(2,4)], false⟩, + ⟨"L09-W-INVALID", .word, [3,1], [(2,1),(0,3),(1,1),(0,2)], false⟩, + ⟨"L10-C-INVALID", .comparison, [3,1], [(2,1),(0,3),(1,1),(0,2)], false⟩, + ⟨"L11-W-DIRTY", .word, [4,-3,-3,8], [(0,4),(1,3)], true⟩, + ⟨"L12-C-DIRTY", .comparison, [4,-3,-3,8], [(0,4),(1,3)], true⟩, + ⟨"L13-W-N24", .word, geometryInput 24, [(0,24),(8,23),(12,24),(1,22)], false⟩, + ⟨"L14-C-N24", .comparison, wideGeometryInput 24, [(0,24),(8,23),(12,24),(1,22)], false⟩, + ⟨"L15-W-N83", .word, geometryInput 83, [(0,83),(27,82),(41,83),(1,81)], false⟩, + ⟨"L16-C-N83", .comparison, wideGeometryInput 83, [(0,83),(27,82),(41,83),(1,81)], false⟩] + +def requiredIds := ["L01-W-EMPTY", "L02-C-EMPTY", "L03-W-SINGLE", "L04-C-SINGLE", + "L05-W-REPEAT", "L06-C-REPEAT", "L07-W-TIE", "L08-C-TIE", "L09-W-INVALID", + "L10-C-INVALID", "L11-W-DIRTY", "L12-C-DIRTY", "L13-W-N24", "L14-C-N24", + "L15-W-N83", "L16-C-N83"] + +#guard registry.map (·.id) == requiredIds +#guard requiredIds.eraseDups.length == 16 +#guard reference #[] 0 0 == 0 +#guard reference #[4,-3,-3,8] 0 4 == 2 +#guard reference #[4,-3,-3,8] 2 4 == 3 +#guard reference #[4,-3,-3,8] 0 5 == 0 + +def require (ok : Bool) (surface : String) : IO Unit := + unless ok do throw (IO.userError surface) + +def modelName : InputModel → String | .word => "word" | .comparison => "comparison" + +def checkRetained (xs : List Int) (owner : Owner) : IO Unit := do + require (owner.regs.size == 8273) "numeric-bank" + require (owner.keys.isEmpty && owner.keyRegs.isEmpty) "literal-key-retirement" + require (owner.memory.getD 0 none == some xs.length) "retained-header" + require (owner.memory.getD 7 none == some owner.memory.size) "retained-extent" + require (owner.memory.all Option.isSome) "retained-initialization" + +def checkAnswer (xs : List Int) (left right : Nat) (owner : Owner) : IO Unit := + require (owner.status == .halted (reference xs.toArray left right)) "independent-answer" + +def checkCounts (c : Counters) : IO Unit := do + require (c.counts.size == 15 && c.counts.foldl (·+·) 0 == c.steps) "category-sum" + require c.scalarSizes "scalar-size-step" + +def entryMatches (n left right : Nat) (owner : Owner) : Bool := + owner.regs.size == 8273 && owner.pc == 0 && owner.status == .running && + (List.range 8273).all (fun r => owner.regs.getD r 0 == + (PackedWordRAM.initialState n left right).regs r) + +/-- Both executions start with the SAME real halted first-query owner. The sole +challenge replaces its witnessed dirty register's clear by a self move. The +rejected surface is the real compact-query entry ABI, not an invented answer. -/ +def dirtyControl (f : Fixture) (program : Array Instruction) (first : Owner) : IO Nat := do + let some r := (List.range (8273-400)).map (·+400) |>.find? + (fun r => first.regs.getD r 0 != 0) + | throw (IO.userError "dirty-witness-missing") + let admitted := requestProtocolOwner Layout.serviceEntry 1 3 first + let fuel := 4 + QueryEntry.setupCost + let positive := runOwner program fuel admitted + require (entryMatches f.xs.length 1 3 positive) "dirty-positive-full-entry" + require (Controls.entryRegisterClean positive r) "dirty-positive-register" + let patch := Service.entry + 4 + (r-3) + let operand : PackedConstruction.Operand := ⟨r % 2^32, Nat.mod_lt _ (by decide)⟩ + require (program[patch]? == some (.old (.constant operand 0))) "dirty-patch-identity" + let challenged := program.setIfInBounds patch (.old (.move operand operand)) + let negative := runOwner challenged fuel admitted + require (negative.pc == 0 && negative.status == .running) "dirty-negative-reaches-entry" + require (negative.memory == positive.memory && negative.regs.size == 8273) "dirty-same-owner-data" + require (!entryMatches f.xs.length 1 3 negative && !Controls.entryRegisterClean negative r) + "dirty-negative-entry-must-reject" + require (negative.regs.getD r 0 == first.regs.getD r 0) "dirty-witness-preserved" + return r + +def runFixture (f : Fixture) : IO Unit := do + let width := PackedWordRAM.wordWidth f.xs.length + let half : Int := Int.ofNat (2^(width-1)) + if f.model == .word then + require (width > 0 && f.xs.length < 2^width && + f.xs.all (fun x => -half ≤ x && x < half)) "represented-word-input-domain" + if f.id == "L14-C-N24" || f.id == "L16-C-N83" then + require (f.model == .comparison && f.xs.any (fun x => x < -half || half ≤ x)) + "comparison-key-outside-word-domain" + require (f.queries.all fun q => q.1 < 2^width && q.2 < 2^width) + "represented-query-endpoints" + let (left,right) := f.queries.head! + let program := (Layout.program f.model).toArray + let fuel := 1100000000 * (f.xs.length+1) + Service.budget + let initial := Executable.initialOwner f.model f.xs left right + let owner := runOwner program fuel initial + let observed := counted program fuel initial {} + require (sameOwner owner observed.1) "counted-production-owner" + checkCounts observed.2 + checkRetained f.xs owner + checkAnswer f.xs left right owner + let some (base, length) := observed.2.source + | throw (IO.userError "actual-finalizer-entry-missing") + require (base > 0 && length > 0 && owner.memory.size == length && + observed.2.counts.getD 10 0 == base) + "actual-copy-and-release" + require (initial.memory.size + observed.2.counts.getD 7 0 == owner.memory.size + base && + observed.2.counts.getD 0 0 > 0 && observed.2.counts.getD 6 0 > 0 && + observed.2.counts.getD 7 0 > 0) "actual-load-store-reserve-balance" + require (observed.2.counts.getD 11 0 == (if f.model == .comparison then f.xs.length else 0)) + "actual-key-release" + require (observed.2.counts.getD 12 0 == (if f.model == .comparison then 2 else 0)) + "actual-key-register-release" + require (observed.2.counts.getD 5 0 == 1 && observed.2.counts.getD 13 0 == 0 && + observed.2.counts.getD 14 0 == 0) "initial-single-halt-no-boundary" + require (observed.2.peak ≤ 5000000*(f.xs.length+1)) "construction-peak" + let dirty ← if f.dirty then dirtyControl f program owner else pure 0 + let mut retained := owner + let mut querySteps := 0 + for (l,r) in f.queries.drop 1 do + let admission := requestProtocolArray Layout.serviceEntry l r retained + require (admission.steps == 4 && admission.categoryCount .requestAdmission == 2 && + admission.categoryCount .controlEntry == 2) "charged-boundary-categories" + let next := Executable.queryOwner f.model l r retained + let countedQuery := counted program Service.budget admission.final {} + require (sameOwner next countedQuery.1) "query-production-owner" + checkCounts countedQuery.2 + require (next.memory == retained.memory) "query-same-allocation" + require (([6,7,8,9,10,11,12].all fun i => countedQuery.2.counts.getD i 0 == 0)) + "query-no-store-allocation-keys-release" + require (countedQuery.2.counts.getD 5 0 == 1 && countedQuery.2.steps + 4 ≤ 160257) + "query-cost-and-single-halt" + checkRetained f.xs next + checkAnswer f.xs l r next + querySteps := querySteps + countedQuery.2.steps + 4 + retained := next + IO.println s!"LIFE1-CASE|{f.id}|PASS|steps={observed.2.steps}|queries={f.queries.length}|querySteps={querySteps}|extent={owner.memory.size}|peak={observed.2.peak}|release={base}|dirty={dirty}" + +def select (args : List String) (env : Option String) : Except String (String × List Fixture) := do + if args.length > 1 then throw "duplicate-selector" + if !args.isEmpty && env.isSome then throw "duplicate-selector-channel" + let selector ← match args, env with + | [], none => pure none + | [arg], none => pure (some arg) + | [], some value => + if value.startsWith "id:" then pure (some (value.drop 3)) + else throw "selector-environment-prefix" + | _, _ => throw "duplicate-selector" + match selector with + | none => pure ("full", registry) + | some id => + if id.isEmpty then throw "empty-selector" + if id.trim != id || id.trim.isEmpty then throw "whitespace-selector" + match registry.find? (·.id == id) with + | none => throw "unknown-selector" + | some f => pure ("single", [f]) + +private def rejectedAs (args : List String) (env : Option String) (surface : String) : Bool := + match select args env with | .error error => error == surface | .ok _ => false + +#guard rejectedAs [""] none "empty-selector" +#guard rejectedAs [] (some "id:") "empty-selector" +#guard rejectedAs [" "] none "whitespace-selector" +#guard rejectedAs [" L01-W-EMPTY"] none "whitespace-selector" +#guard rejectedAs ["UNKNOWN"] none "unknown-selector" +#guard rejectedAs ["L01-W-EMPTY", "L01-W-EMPTY"] none "duplicate-selector" +#guard rejectedAs ["L01-W-EMPTY"] (some "id:L01-W-EMPTY") "duplicate-selector-channel" +#guard rejectedAs [] (some "L01-W-EMPTY") "selector-environment-prefix" +#guard match select ["L01-W-EMPTY"] none with + | .ok (mode, fixtures) => mode == "single" && fixtures.map (·.id) == ["L01-W-EMPTY"] + | .error _ => false + +def mainImpl (args : List String) : IO UInt32 := do + let env ← IO.getEnv "LIFE1_VALIDATE_SELECTOR" + if args == ["--registry"] && env.isNone then + for f in registry do IO.println s!"LIFE1-REGISTRY|{f.id}|{modelName f.model}|{if f.dirty then "dirty-entry" else "lifecycle"}|PASS" + return 0 + if args == ["--startup"] && env.isNone then + require (registry.map (·.id) == requiredIds && requiredIds.eraseDups.length == 16) "registry-shape" + let owner := Executable.initialOwner .comparison [] 0 0 + require (owner.regs.size == 8273 && owner.memory.size == 3 && owner.keyRegs.size == 2) + "startup-finite-owner" + IO.println "LIFE1-STARTUP|PASS|cases=16" + return 0 + let (mode, fixtures) ← match select args env with + | .error error => throw (IO.userError error) + | .ok selected => pure selected + for fixture in fixtures do runFixture fixture + IO.println s!"LIFE1-PASS|mode={mode}|cases={fixtures.length}" + return 0 + +end RMQ.Validation.PackedLifecycle + +def main (args : List String) : IO UInt32 := do + try RMQ.Validation.PackedLifecycle.mainImpl args + catch error => + IO.eprintln s!"LIFE1-FAIL|{error.toString}" + return (1 : UInt32) diff --git a/docs/DIGESTION_LOG.md b/docs/DIGESTION_LOG.md index fc35a416..840b1156 100644 --- a/docs/DIGESTION_LOG.md +++ b/docs/DIGESTION_LOG.md @@ -2067,3 +2067,82 @@ consumers are the coordinator's aggregate gate and a fresh blind audit. A skeptical reader should ask whether the linear bound is tight enough to matter in practice, how the temporary space compares to the output size, and whether a relocated in-place query execution can be proved as well. + +## 2026-09-20 — LIFE-1 continuous lifecycle candidate + +The builder's output now becomes the query's retained allocation through +execution. The fixed program enters the existing builder body at PC 221239, +copies its output register into the descriptor ABI, reads length and extent +from the produced cells, and saves the request before the arena is compacted. +Forward copy preserves overlapping source words; one scalar release per old +prefix cell removes the stale suffix. The comparison route then releases its +input-key cells and both key registers before jumping into query preparation. + +The first query and later requests use that same memory. Preparation reloads +the length from retained address zero, transfers the bounded request slots, +clears all scratch registers in the 8273-register bank, and jumps into the +accepted compact query. Later requests enter through four visible charged +events after a halted query. The theorem carries every real transition and +its producing state, including reads, stores, releases and code-word fetches. +An independent typed client checks the advertised conclusions; executable +validation uses finite arrays and independently scanned expected answers. + +The conceptual advance is that construction, resource retirement and reusable +queries now share one operational account. Retained bits include code, +registers and controls as well as the packed data; temporary numeric space +and arbitrary-integer comparison resources have separate bounds. The plain +word view at the retained boundary follows from initialization, so a proof +predicate is not an extra retained bitmap. + +Live assumptions are the stated unit-cost numeric primitives at the existing +logarithmic width, signed representability for word inputs, represented request +endpoints and the separately counted comparison channel for arbitrary Int +keys. Input materialization occurs before execution. Array sizes describe +logical ownership; native capacity and external aliases need the separately +commissioned native evidence. The next skeptical checks are whether the native +consuming adapter preserves this ownership boundary and whether independent +exact-commit review reconstructs the public same-object joins and mutations. +This entry records a candidate model result, not campaign acceptance. + +## Consuming the lifecycle owner in compiled clients + +The new native adapter carries the existing lifecycle owner across the language +boundary. It constructs once, executes the caller's first query continuously, +replaces all four backing arrays while preserving their entries, and accepts +later requests through the four charged events on that produced owner. The +export theorem derives its facts from the lifecycle capstone; final memory and +answer equality are conclusions, not foreign-caller assumptions. + +Every later successful publication also replaces those arrays and copies the +whole canonical memory. That physical copying is separate from the model's +query work and does not support a native constant-time query claim. + +A runtime obstacle made the distinction between mathematical equality and +physical behavior concrete. The original transition record retained the old +owner while the primitive updated its arrays. Historical bounded 100-step +probes measured 69 array copies before the consuming loop and one copy afterward; +those probes were not repeated for the refreshed native recipe. The consuming +loop has an unconditional proof of equality to the original runner for all +programs, owners and fuel. The optional observer computes scalar diagnostics +before primitive execution and has an unconditional equality for both owner and +statistics. Neither refinement changes instruction semantics or uses a reference +answer. Actual copy counts remain measurements of the pinned build. + +The main live assumptions are correct Lean/C/Rust compilation, the pinned +runtime layout and allocation behavior, and valid exclusive foreign handles on +the initializing thread. Safe Rust expresses unique mutation and runtime/result +lifetimes; finite native controls cannot quantify over arbitrary C misuse. +Logical owner equality proves preserved values and READY facts, while physical +capacity, retired roots and failure cleanup need separate compiled evidence. +The same distinction applies to fixed code globals, requested bytes and modeled +payload bits. + +All required export mutations now replay at their independent consumers, and +all transfer controls replay under the corrected complete source recipe. The +native fixtures, Rust misuse checks, axiom inventory and default build also pass. +The external delivery receipt binds the final report and committed source; the +details are in `docs/internal/extensions/lifecycle-native1/ACCEPTANCE_MATRIX.md`. +The next skeptical questions concern independent exact-commit reconstruction, +coordinator acceptance and how a future native specialization can reduce the +measured copying and initialization costs while preserving these same contracts. +This entry records a local candidate, not coordinator acceptance. diff --git a/docs/FAMILY_SUMMARY.md b/docs/FAMILY_SUMMARY.md index 711f75ed..ab58d929 100644 --- a/docs/FAMILY_SUMMARY.md +++ b/docs/FAMILY_SUMMARY.md @@ -3668,3 +3668,61 @@ emitted list; no relocated in-place query execution is claimed. The executable bounds. This is candidate status only: the aggregate gate, a fresh blind audit and coordinator acceptance are still required, and the paper and headline identities are unchanged. + +### LIFE-1 continuous lifecycle candidate (2026-09-20) + +`RMQ.SuccinctFinal.PackedLifecycle.continuousConstructionQuery_holds` in +`RMQ/Core/WordRAM/Lifecycle/Capstone.lean` joins the live builder body, +metadata/request transfer, forward overlapping copy, scalar retirement and +first query in one fixed program per input model. Its counted retained owner +contains the same canonical memory used by every query, fixed code, 8273 +numeric registers and eight control words. The complete numeric capacity is +at most `2*n + retainedRho n` bits with a checked `LittleOLinear retainedRho`. +Comparison input cells and key registers have zero owned extents and empty +executable containers at the retained boundary. + +Construction through query entry takes at most `1100000000*(n+1)` primitive +transitions and owns at most `5000000*(n+1)` numeric arena cells at every +prefix. The first service takes at most 160253 further transitions; each +subsequent request costs at most 160257, including four charged external +admission/control events and full finite-bank initialization. These are +uniform upper bounds, not tightness or elapsed-time claims. + +Word inputs require `InputFits (wordWidth n) xs`; the separately named +comparison theorem covers every `List Int` with explicit comparison resources. +Both cover represented valid and invalid half-open requests, with leftmost +ties. One query-independent logarithmic width bounds the actual states, +physical addresses and dormant encoded fields. The array runner refines the +same execution; its logical sizes do not prove native backing capacity or +external alias freedom. Input materialization precedes the modeled run. +The additive `RMQ/Headlines/Lifecycle.lean` import exposes this candidate. +The broad `RMQ.Headlines` barrel also exposes that existing headline so +documentary identifiers resolve through the repository import contract. +This private candidate addition leaves the narrow `RMQPaper` surface unchanged. +Native ownership review, aggregate certification, a fresh blind audit and +coordinator acceptance remain campaign requirements. + +### Candidate consuming native lifecycle adapter + +`RMQ.Core.WordRAM.Native.Lifecycle` connects the actual construction, retirement +and query owner to an additive C ABI and safe Rust facade. Its export contract +derives the halted answer, canonical produced memory, empty key banks, fixed +numeric bank and inherited retained-capacity bound from the lifecycle theorem. +The independent `RMQ.Validation.LifecycleNativeContract` consumer fixes those +propositions at the same objects. Admission codecs preserve arbitrary-width +signed values and represented endpoints; native resource ceilings remain +separate from the all-size Lean statements. + +The compiled route uses fixed cached program arrays and consuming loops proved +equal to the original runner for every program, fuel and owner. Optional +observations have an exact final-owner and counter/read-fold connection and +their own lifetime. Value-preserving repacking transports READY and later-query +facts across publication; it does not kernel-verify C reference counts, pointer +validity, physical capacity or allocation behavior. + +The local native candidate's checked source statements, exact replay campaigns +and finite compiled measurements are indexed in +`docs/internal/extensions/lifecycle-native1/ACCEPTANCE_MATRIX.md`; the worked +interface is in `GUIDE.md` beside it. Modeled retained bits, native requested +storage, shared code, diagnostics and elapsed time remain distinct. This adapter +does not establish a native heap asymptotic or a portable runtime-speed theorem. diff --git a/docs/digests/LIFECYCLE_PROOF_GUIDE.md b/docs/digests/LIFECYCLE_PROOF_GUIDE.md new file mode 100644 index 00000000..e343d1c9 --- /dev/null +++ b/docs/digests/LIFECYCLE_PROOF_GUIDE.md @@ -0,0 +1,128 @@ +# Lifecycle proof guide + +This guide follows the executed objects in `RMQ/Core/WordRAM/Lifecycle`. The +[proof inventory](../internal/extensions/lifecycle1/PROOF_INVENTORY.md) records +the precise guards, propositions and frozen acceptance-row dependencies. It is +an implementation guide, not an acceptance or final-verification record. + +## The objects to keep together + +For input `xs`, write `n = xs.length`, `W = PackedWordRAM.wordWidth n`, and +`cells = PackedWordRAM.buildMemory xs`. `InputModel.word` requires the existing +signed `InputFits W xs`; `InputModel.comparison` admits every `List Int` and +accounts for the Int key banks separately. Both routes require +`left < 2^W` and `right < 2^W`. Input materialization is the declared initial +boundary; construction and query instructions do not construct their expected +answers from `xs`. + +The program is `Layout.program model`. Its definition has no `xs`, `n`, shape, +or endpoint argument. The initial state is +`initialState model xs left right Layout.builderBase`. Its numeric memory owns +the input representation followed by two request words. Initial numeric extent +is `n+3` for word input and `3` for comparison input. Comparison input owns `n` +key cells and two key registers; word input owns neither bank. + +The actual physical numeric view places the fixed encoded code, 8273 numeric +registers, eight control words, and the current arena in consecutive disjoint +ranges. The arena evolves through stores, reservations and tail releases. An +uninitialized reserved cell remains `none` in this view. Int comparison values +are not silently recoded as bounded numeric words. + +## A worked route + +Consider `xs = [4,1,1,7]` with request `[0,3)`. The independent half-open, +leftmost specification selects index `1`, so the machine's successful packet is +`2`. This is an explanatory instance of the quantified contract, not a recorded +execution measurement. Keep `M = cells.length` symbolic and obtain `B` from the +execution rather than guessing either value. + +| Phase | Actual location and effect | Proof route | +| --- | --- | --- | +| Builder BODY | Starts running at PC `221239`; exits running at `223345`. It allocates the produced canonical cells at `[B,B+M)` and leaves `B` in register 3. | [Builder.HostedBody](../../RMQ/Core/WordRAM/Lifecycle/Builder.lean#L123), [Construction.build_stage](../../RMQ/Core/WordRAM/Lifecycle/Construction.lean#L267). | +| Descriptor | Eleven charged instructions start at `223345`. Occurrence 0 moves register 3 to register 0. Reads at occurrences 1 and 4 load `n` from `B` and `M` from `B+7`; occurrences 8 and 10 load the saved request into registers 300 and 301. | [Descriptor.transfer](../../RMQ/Core/WordRAM/Lifecycle/Descriptor.lean#L53), [read_occurrences](../../RMQ/Core/WordRAM/Lifecycle/Descriptor.lean#L271). | +| Numeric finalizer | Starts at `223356`. Copies forward from `[B,B+M)` to `[0,M)`, then executes exactly `B` single-cell releases. | [Finalizer.finalizer_memory](../../RMQ/Core/WordRAM/Lifecycle/Finalizer.lean#L534), [ordered_copy](../../RMQ/Core/WordRAM/Lifecycle/Finalizer.lean#L570), [ordered_release](../../RMQ/Core/WordRAM/Lifecycle/Finalizer.lean#L615). | +| Key retirement | At `223370`, comparison input executes `n` key releases followed by two key-register releases. Word input has an empty retirement fragment. | [Retirement.comparison_retired](../../RMQ/Core/WordRAM/Lifecycle/Retirement.lean#L394), [Finalization.retire_copied](../../RMQ/Core/WordRAM/Lifecycle/Finalization.lean#L154). | +| First query entry | A real jump enters PC `212964`. Four service instructions load the retained header and copy the request, then 8270 scalar clears and one jump establish the compact-query ABI at PC 0. | [Service.prepare](../../RMQ/Core/WordRAM/Lifecycle/Service.lean#L24), [QueryEntry.setup_exec](../../RMQ/Core/WordRAM/Lifecycle/QueryEntry.lean#L181). | +| Compact query | The accepted compact transition list is lifted on exactly `cells`. The final packet is obtained by those instructions. | [Continuous.query_suffix](../../RMQ/Core/WordRAM/Lifecycle/Continuous.lean#L161), [QuerySafetyBridge](../../RMQ/Core/WordRAM/Lifecycle/QuerySafetyBridge.lean). | + +The reservation provenance is stronger than a numerical equality: it supplies +an indexed actual `reserve 3` occurrence, its pre-state extent, and a register-3 +frame through the entire following builder suffix. The descriptor's source is +the operand `3` of its actual `move 0 3`, even if some other register happens to +contain the same number. + +[Provenance.continuous_production](../../RMQ/Core/WordRAM/Lifecycle/Provenance.lean#L201) +lifts these receipts into the actual continuous trace using one shared producer +witness. If the builder trace has length `T`, transfer is at `T`, descriptor +reads at `T+1`, `T+4`, `T+8`, `T+10`, copy load/store at +`T+11+4+7*i` and `T+11+5+7*i`, and release `k` at +`T+11+5+7*M+4*k`. Each occurrence includes its complete actual prefix pre-state +and step equation, so equal repeated events remain distinct occurrences. + +Forward order matters when source and destination overlap. At copy iteration +`i`, the load precedes the store and the copy invariant preserves every future +source cell. The whole-memory theorem includes absence at every address +`a >= M`; matching only the first `M` values would not establish retirement. + +## Composition and repeated queries + +`Construction.build_stage` derives a live producer and its complete state from +the input contract. `Finalization.full_execution` composes its actual ordered +trace with descriptor, copy, key retirement and jump. `Continuous.exact_run` +then identifies the fixed-fuel `continuousRun` with that trace followed by the +actual service trace. Extra fuel is justified only after the composed execution +is proved halted. No phase replaces the machine state by a separately prepared +equal-memory state. + +At the retained boundary, `Retained.Canonical xs s` means the whole numeric +memory is canonical lookup, extent is exactly `M`, both key functions are +default, both key extents are zero, registers at or above 8273 are zero, and the +state fits `W`. Registers below 8273 may be dirty. The service clears the full +finite query bank, so a second request such as `[2,4)` does not rely on the +builder's smaller 400-register frame. + +`Reusable.queryRun` first executes four explicit boundary events on a halted +state: write left, write right, set the fixed service PC, activate. It appends +the actual service transitions. The boundary contributes four charged events +and no numeric reads. Every service performs its header read, including invalid +requests. Consequently an invalid represented request has packet zero and read +list `[(0,some n)]`; the compact guarded suffix alone has an empty read list. +For valid requests, the additional header read precedes the compact metadata +and logical-read sequence, including repeated addresses. + +## What is counted + +| Quantity | Fixed theorem bound or exact expression | +| --- | --- | +| Finalizer transitions | `7*M + 4*B + 5`. | +| Comparison retirement transitions | `4*n + 5`; word retirement is zero. | +| Builder through final jump | At most `1100000000*(n+1)`, derived from a completed concatenated trace. | +| Service | `4 + 8271 + compactQueryRun.steps <= 160253`. | +| Reusable query including admission | `4 + 4 + 8271 + compactQueryRun.steps <= 160257`. | +| Peak numeric arena | At most `5000000*(n+1)` words at every actual prefix. | +| Separate comparison peak | At most `n` key cells and two key registers; both become zero before service. | +| Retained numeric capacity | `(M + encodedProgram.length + 8273 + 8)*W <= 2*n + retainedRho n`, with checked `LittleOLinear retainedRho`. | + +These are model transitions and logical ownership/capacity bounds. They do not +measure native runtime, native allocation capacity, or external aliases. +`Physical.wordView` is an observation of the counted state, not an uncharged +machine operation used to produce the answer. + +## Following the executable owner + +`Executable.initialOwner` materializes the finite input arrays and requests. +`runOwner` computes only the final owner. `runArray` additionally returns +validation observations; the observations are not owner fields. +`Executable.initial_owner_refinement` and `initial_array_refinement` prove +equality with the same abstract execution for every fuel, deriving all finite +destination bounds from the actual phases. `Ownership.refinement` specializes +them to the continuous budget. `Ownership.Ready.empty_keys` concludes literal +empty key arrays, and `Ownership.Ready.query` preserves the actual numeric array +while restoring readiness after another charged query. + +For maintenance, start with the smallest affected scalar theorem, then its +handoff and exact consumer. Keep occurrence indices when changing copy, release, +descriptor or read claims. Preserve all request guards across result, trace, +cost and capacity conjuncts. The [inventory](../internal/extensions/lifecycle1/PROOF_INVENTORY.md) +and [control predicates](../internal/extensions/lifecycle1/CONTROL_PREDICATES.md) +identify the concrete counterfactual each dependency must reject. diff --git a/docs/internal/DESIGN_DECISIONS.md b/docs/internal/DESIGN_DECISIONS.md index 9400037d..43882b2b 100644 --- a/docs/internal/DESIGN_DECISIONS.md +++ b/docs/internal/DESIGN_DECISIONS.md @@ -13213,3 +13213,213 @@ Decision: set package `moreLeanArgs = ["-s", "65536"]` in lakefile.toml. The pin Alternatives: increasing the OS stack again does not set Lean's explicit worker stack; rewriting the literal program proofs would change proof source before testing the compiler's resource setting. The worker-stack setting is a candidate repair until the required Linux checks pass; this entry does not claim those pending results. Consequences: reproducible resource configuration applies to local and hosted Lake builds. The existing OS stack setup remains needed for interpreter execution. Both required protected-main checks must pass on the final candidate before promotion; lifecycle work is excluded. + +## DD-20260920-LIFE-001: extend scalar execution with owned-bank retirement and charged request entry + +Context: the existing builder produces the packed allocation behind its input and temporary arena. Its standalone run halts, and the accepted compact query begins from a separately initialized immutable memory. A continuous lifecycle must instead execute the live builder body at its real program offset, transfer its produced output base and request through instructions, compact the produced cells, retire temporary banks, and enter the query on that same memory. The frozen LIFE-1 contract commissions this additive candidate; it does not authorize predecessor changes or claim campaign acceptance. + +Decision: `PackedLifecycle.State` contains the unchanged construction `State` plus explicit owned extents for comparison input cells and key registers. Old instruction evaluation delegates definitionally to `PackedConstruction.execPrim`. Three new instructions revoke exactly one numeric, key-input, or key-register tail cell, decrease the corresponding extent, and fault at zero extent. Extents supplement pointwise absence: the executable refinement must finish with empty containers, while native backing capacity remains a separately assigned obligation. Ordered transitions keep complete producing states and actions; the retained machine state has no observation history. + +Sequential query entry uses four separately charged external transitions from a halted state: write the current left request word, write the current right request word, set the entry PC, and activate running status. The old stopped-state rule stays intact. Registers 300 and 301 are the bounded admission slots within the accounted finite numeric bank; no future-request tape is retained. The entry program transfers the request and metadata-derived size to the query ABI, clears the complete finite query bank, then executes its jump to the compact prefix. The accepted query proves a zero tail from register 8273, so general re-entry uses that bank rather than assuming the builder-only zero tail from 400. + +Alternatives rejected: resuming a halted builder or query with an uncharged record update; replacing scalar retirement with a whole-array semantic clear; inferring empty storage from absent lookups; reusing the first-query 400-register frame after query scratch is dirtied; counting a separate canonical memory while executing another arena. The old builder/layout/query are reused through proved adapters, avoiding a new RMQ layout or a broad machine unification. + +Consequences and evidence: `Lifecycle/Machine.lean` and `Lifecycle/Calculus.lean` provide the conservative projection, ordered old-prefix simulation and exact four-event admission protocol. `Lifecycle/QueryBridge.lean` preserves every compact transition and attempted read/reply; `Lifecycle/QueryEntry.lean` derives the ABI through 8271 charged setup steps. `Continuous.lean`, `Ownership.lean` and `Capstone.lean` derive their entry premises, actual completed trace, finite-container projection and retained capacity from the represented input domain. Array logical size and model ticks imply neither native allocator capacity nor measured runtime complexity. + +The fixed layout places the compact query at zero, the four-instruction preparation at 212964, full-bank setup immediately after it, the builder body at 221239, the eleven-instruction descriptor at 223345, the fourteen-instruction finalizer at 223356, and optional eight-instruction key retirement at 223370. The final charged jump targets preparation. The word/comparison programs contain 223371/223379 instructions; their actual encoded words are bounded by 1116895. Exact numeric offsets avoid kernel normalization of the large query prefix, while checked length and hosted-fragment equalities justify every offset. The service bound is 4+8271+151978=160253; adding boundary events gives 160257. Construction/finalization work is bounded by 1100000000*(n+1), and every prefix arena extent by 5000000*(n+1). All constants are deliberately coarse and fixed outside certificates. + +`Physical.lean` gives disjoint consecutive code/register/control/arena regions in one evolving finite numeric view. `CodeFetch.lean` translates actual instruction PCs to encoded-word offsets. A failed extent guard retains the represented logical address, faults, and performs no physical fetch; an actual safe load derives its physical address bound from the same prefix extent bound. This avoids falsely claiming that adding a region offset to every arbitrary W-bit invalid address still fits W. Scalar store/reserve/release and boundary equations bind the view to actual state changes. Uninitialized arena cells use the existing optional-value semantics; canonical initialization proves a plain Nat word view at READY without charging a fictional bitmap. Arbitrary Int keys remain outside that numeric view, with their extents recorded in control words. + +The public interface has seven connected groups: actual construction/suffix, retained semantic result/work, state safety/resources, physical execution, finite owner/capacity, reusable owner protocol, and uniform width/rho/code bounds. It does not accept an answer or final-memory equality as an input. The independent client expands the shared data/ownership/profile predicates and pins their exact propositions and objects. Alternative designs rejected include a checklist-sized certificate with unused facts and a same-sized sibling payload substituted for the executed allocation. + +## DD-20260920-LIFE-NATIVE-P0-001: measured replacement ownership before a production consuming interface + +Context: LIFE-NATIVE-P0 is the native prerequisite for the commissioned continuous construction/finalization/query lifecycle. PRE's executable arrays and logical extents preserve inputs; existing native image handles retain immutable query images. Neither establishes retained allocation size or exclusive transfer. The pinned Lean 4.22 header exposes array capacity independently of size and decrements removed references in pop without reducing capacity. + +Decision: add an isolated C runtime probe inside the existing authorized native package. External test objects have destructor counters; snapshots copy only numeric projections from live registered roots and never retain Lean objects. Record logical size, actual capacity, requested outer-container bytes, actual element reference counts, finalizer counts, root aliasing and old-allocation reachability through registered roots. Exercise replacement allocated at capacity m, acquired references for the selected source interval, then consuming release. Controlled failure consumes and cleans every initialized destination and source reference. Preserve alias-aware observations separately from strict exclusive-transfer acceptance. No production ABI or Lean proof surface changes. + +Alternatives rejected: shrinking logical size and calling it reclamation; reading freed tails/objects to inspect capacity; interpreting destructor counts as allocator/RSS measurements; treating one dropped owner as exclusive consumption; reusing result-derived expected values; assuming allocation failure returns a recoverable Lean error; or freezing a BuilderOwner-to-QueryOwner ABI before LIFE-1's reviewed formal interface. A fresh destination avoids overwrite hazards but incurs a separately measured transient source-plus-destination peak. + +Consequences and evidence: lifecycle_storage_probe.c uses the actual pinned inline array operations and runtime RC paths; its operational capacity, alias, cleanup and value mutations call the same predicates as their strict positive controls. BOUNDARY.md maps all four ExecState arrays and ArrayRun observations to StorageImage's nested limb arrays and the existing C/Rust owners. The generic object-array experiment does not bound the full nested production image, arbitrary foreign aliases, allocator usable bytes or process RSS, and does not count C loops as atomic model instructions. Exact replay and identity receipts are recorded in docs/internal/extensions/lifecycle-native-p0/REPORT.md. The next production adapter must consume the reviewed formal output, discharge every old-root retirement obligation and account for its actual nested allocation representation. + +Measured-runtime refinement for DD-20260920-LIFE-NATIVE-P0-001: exact upstream object.cpp at installed Lean commit ba2cbbf09d4978f416e0ebd1fceeebc2c4138c05 confirms shared copy with expansion disabled preserves capacity, and array destruction visits initialized logical elements before capacity-sized allocator deallocation. Both independent shrink predicates therefore check capacity 32 for unique and shared cases. The source's allocator dispatch and fatal panic path are explicitly distinct from requested bytes and controlled-error cleanup. RUNTIME_SOURCE.json binds the reviewed source bytes; installed release binaries are separately pinned, with no reproducible-runtime-build claim. + + +## DD-LIFE-NATIVE1-01 - Consume the continuous owner through one native transfer boundary + +Date: 2026-09-23. Status: implementation decision; candidate evidence pending. + +The LIFE-NATIVE-1 local rung consumes reviewed formal parent +7d247703a7009aa0f5faa1a9a67abf5f2ce526b6 and native prerequisite parent +8a74ad3af84feaf0ccea7185813ce8b55c50d96a through private base +3dbdebedcc6ba6b2a864df0d46dcc09ccaaa7536. Its first operation is explicitly +build-and-first-query on the caller's endpoints. Publication waits for the +actual halted owner and native repacking. Subsequent requests consume the +produced owner through the existing four request/control events and finite +service setup. READY remains a status-independent mathematical predicate. + +The export adapter uses the existing runOwner, initialOwner and queryOwner +semantics, with fixed program arrays and equality proofs. It does not obtain +answers from Native.LimbMachine or from a reference query. The array-copy +interface relates contents and extents; native pointer identity and backing +capacity remain separate observations. Exact-capacity native replacement is +required for all four operational arrays before publication. Fixed code, +boxed values, logical capacity, requested outer bytes, modeled ticks and +runtime costs receive separate accounts. The safe Rust facade will retain a +unique opaque handle and use the existing sticky process runtime claim. + +Input admission uses signed little-endian magnitude bytes and the actual +lifecycle bias encoding for the word model; comparison input preserves Int. +Host format/resource ceilings are an executable profile, separate from the +all-size Lean theorems. Ordinary represented invalid ranges are not malformed +requests. Native validation precedes irrevocable owner transfer; post-take +failure releases initialized resources and leaves an explicit empty slot. +These decisions reject a hidden dummy query, a fresh canonical rebuild per +request, a borrowed extra owner root, or a logical-pop-only capacity argument. + +The generated initialization inventory exposed five proof-witness values in +protected imports. The user approved exactly five macro_inline annotations in +SparseLevelWidth.lean and ReviewerReachabilitySmall.lean (the exact patch and +authorization are under docs/internal/extensions/lifecycle-native1/). Their +names, types, bodies and propositions are unchanged. The pinned compiler's +shouldGenerateCode excludes macro_inline definitions, so the intended native +change is erasure of eager witness initialization. Fresh generated-code checks +are still required. A custom C-initializer pruning pass was considered and +rejected because it would add another trusted code transformation. No other +predecessor source modification follows from this exception. + +Evidence/consumer: CONTRACT_REQUIREMENTS.json, ACCEPTANCE_MATRIX.frozen.md, +STARTUP_AMENDMENT.md, STARTUP_AMENDMENT.patch and CONTRACT_AMENDMENT_01.json; +the new Native/Lifecycle export and exact-type consumer are the implementation +consumers. Final correctness, native measurements and all matrix closures +remain pending until recorded; this decision is not campaign acceptance. + +## DD-LIFE-NATIVE1-02 - Measure persistent code roots separately from published owners + +Date: 2026-09-23. Status: implementation decision; native evidence pending. + +Two cached program arrays do not describe the entire fixed Lean representation: +generated initialization also retains source-list spines and intermediate global +fragments. Counting only the arrays would understate fixed storage. The build +therefore appends a read-only root visitor to each unchanged emitted RMQ C unit +and an aggregator over the exact Entry import closure. Visitors read initialized +global object slots without adding references, forcing thunks, or modifying +initializers. The derivation receipt binds original bytes, appended bytes, +enumerated globals, objects, compiler identity, link map, and DLL. Parsing rejects +unsupported global declarations; function-local variables are excluded. + +One traversal deduplicates the two program-array graphs, and a separate traversal +deduplicates all visited RMQ globals. They overlap and their totals must not be +added. Runtime/standard-library global infrastructure lies outside this RMQ root +inventory. Per-input owners have their own traversal. Object identity and +requested array/object/digit storage are measurements of the pinned runtime; +they do not assert allocator usable size, process RSS, or a native succinct bound. +Boxed integers require a separate digit-allocation account because their object +header size excludes the digit block. The pinned non-GMP layout is checked using +actual positive and negative values above 128 bits before traversal is enabled. + +Rejected alternatives were counting only the cached arrays, assuming all boxed +numbers fit machine integers, and pruning generated initialization. They would +respectively omit live storage, lose admitted comparison values, or enlarge the +trusted semantic transformation. The visitor and layout checks instead add a +reviewable native measurement boundary while leaving the proved evaluator and +generated original bytes intact. Startup execution and finite controls must +still validate these implementation choices before they support acceptance rows. + +## DD-LIFE-NATIVE1-03 - Bind boxed-integer accounting to the loaded GMP runtime + +Date: 2026-09-23. Status: measured layout repair; full native campaign pending. + +The non-GMP assumption in DD-LIFE-NATIVE1-02 was an implementation hypothesis, +not a certified property of the installed runtime. The actual production startup +rejected it with initialization status 5. The pinned runtime's PE exports identify +the GMP branch, and an augmented diagnostic DLL using the exact existing compiled +objects and production shim confirmed positive and negative values of magnitude +2^130+7 have tag 250, a 24-byte outer object, allocated limb count 3, and signed +used count +3/-3. Both values serialized back to the exact independently chosen +17-byte magnitude. The diagnostic DLL had a separate output and supplement; +it did not replace the production artifact or bypass its failed layout check. + +The native measurement implementation will use the matching GMP header layout +and keep allocated limb storage separate from runtime-reported outer bytes. +Allocated capacity, rather than the number of used limbs, determines requested +limb storage. Startup must validate the signs, object size, known limb contents, +and exact codec roundtrip before graph traversal is enabled. These finite checks +and pinned runtime/source identities support an explicit representation assumption; +they are not a universal allocator theorem or a proof of C/runtime correctness. + +Rejected alternatives were disabling the layout verifier, continuing with the +non-GMP mirror, and inferring all requested bytes from serialized magnitude length. +They would respectively hide an unsupported runtime, read incorrect fields, or +omit allocated but unused limb capacity. A first standalone diagnostic executable +also linked a second Lean runtime and was excluded from layout evidence. The +successful supplement operates within the runtime used by the tested DLL. + +Evidence: `.lake/lifecycle-native1/runs/init-probe-20260923T091504228/RESULT.json` +records the successful bounded probe and 816 unchanged integrity pins. Subsequent +production startup and complete native execution remain required after the repair. + +## DD-LIFE-NATIVE1-04 - Erase temporary transition owners through an exact runner refinement + +Date: 2026-09-23. Status: measured motivation; refinement implementation underway. + +Frozen N1-02 permits an observation-erasing loop only after emitted-source +inspection and bounded actual execution justify it. The original compiled +`runOwner` increments the incoming owner before calling `stepArray`, and +`stepArray` retains that producing state across the unchanged `executeArray`. +Although no history remains in the returned owner, this temporary reference +prevents exclusive mutation during the current step. + +The bounded comparison-input probes used the actual initial owner for four +values, without a healthy full-build baseline. Fuel zero recorded no array copy. +Fuel 20 recorded 15 calls copying 124095 cells; fuel 100 recorded 69 calls copying +570837 cells. Each copied array had capacity 8273, and neither probe expanded an +array. Both returned explicit exhausted-fuel status, no published handles, +successful cleanup, and no counter overflow. These are counters at the compiled +generated-code copy sites, not a claim about every runtime-internal allocation. +Receipts are replay/20260923T093044941-37e95309 and +replay/20260923T093128262-4dc3924c under `.lake/lifecycle-native1`. + +The chosen adapter will preserve status/fetch/fuel behavior and delegate each +primitive to unchanged `executeArray`, with an unconditional equality theorem +to `runOwner` for every program, state, and fuel. The optional observed adapter +will compute scalar/read/category/route diagnostics from the actual producing +state before consuming it, with unconditional equality to the existing complete +Stats result. All export facts must consume these equalities; a helper theorem +without the production composition would not establish the boundary. + +Rejected alternatives were increasing full-fixture deadlines without inspecting +copy behavior, changing a primitive evaluator, and replacing execution with a +canonical memory or reference-answer computation. The first leaves measured +avoidable copying unexplained; the others violate the frozen consumer contract. +This change asserts neither native constant-time query nor a universal speedup. +Fresh generated-code lifetime inspection, rebuilt clients, and repeated bounded +copy probes are required before claiming any measured improvement. + + +## DD-LIFE-TOPOLOGY-01 - Expose the existing lifecycle headline through the broad barrel + +Date: 2026-09-28. Status: private certification repair, not campaign acceptance. + +The exact e13e6631 lifecycle candidate passed source and frozen-row review, but +the final repository gate failed documentary symbol resolution: the historical +LIFE-1 report names RMQ.Headlines.succinctRMQContinuousLifecycle while the broad +RMQ.Headlines barrel omits its existing module. Both positive topology regression +cases failed for that same reason. The production virtual-removal control passed +when only that citation was omitted; no historical source was actually edited. + +Import RMQ.Headlines.Lifecycle from the broad barrel. The declaration, its type, +all proofs and native implementations remain byte-identical. Source import review +finds no cycle; the broad closure grows from 297 to 413 local modules. RMQPaper's +262-module closure and the native Entry producer's 365-module closure do not +contain this barrel, so the repair does not broaden the paper theorem or change +native compilation provenance. The formal LifecycleContract closure likewise +excludes the barrel. The family summary retains the candidate status and limits. + +Rejected alternatives: rewriting the frozen historical report, adding a linter +exception, weakening documentary resolution, or changing the RMQPaper root. +Those would conceal the mismatch or alter the paper boundary. The existing +theorem already supplies the intended declaration; no new proof architecture is +needed. Build the actual headline target before testing its import, then require +the unchanged linter and all topology regressions. Aggregate and independent +blind audit remain acceptance prerequisites. There is no merge or push here. diff --git a/docs/internal/WORKFLOW_DESIGN_DECISIONS.md b/docs/internal/WORKFLOW_DESIGN_DECISIONS.md index ae21206c..a4668da4 100644 --- a/docs/internal/WORKFLOW_DESIGN_DECISIONS.md +++ b/docs/internal/WORKFLOW_DESIGN_DECISIONS.md @@ -14007,3 +14007,1457 @@ Decision: the regex literal is written with its two-character escapes again, the Alternatives rejected: leaving the CRLF blob and adding a `cr-at-eol` whitespace exemption (it would silence the check that caught a real defect, on a maintained script rather than on frozen evidence); `text` without `eol=lf` (correct in the repository but it changes Windows checkout bytes for no benefit); a repository-wide `* text=auto` (it would renormalize evidence deliberately pinned `-text` by four lanes). Consequences: no behaviour of the lint changes; the diff against the pre-integration blob is exactly the prefilter block. The committed-patch whitespace check is still absent from the local gate, so this class can reach CI again from a file the attribute does not cover; adding it to `scripts/gate.ps1` is proposed as a separate tooling change. + +## WDD-20260920-LIFE-001: freeze complete lifecycle rows and serialize proof evidence + +Context: LIFE-1 has 43 frozen acceptance rows and several independent proof leaves. Earlier lifecycle experiments exposed a parser that compared only the first line of wrapped requirement cells, and historical receipts confused checkout newline serialization with exact Git bytes. Heavy proof checks share a host with the independent native prerequisite, but each worktree must own its artifacts. + +Decision: the lifecycle task records its exact base, governance, branch, runtime skill inventory and isolated absolute worktree in `extensions/lifecycle1/START.json`. Before implementation, all eight columns of every row were frozen in strict UTF-8, with complete requirement cells matched to the exact launch prompt and an embedded source snapshot. `scripts/lifecycle_contract_integrity.ps1` checks the exact ordered 43-ID registry, full row/prefix bytes and complete source requirement text. Evidence is append-only below the frozen matrix marker. The initial Open dispositions remain historical baseline data; later evidence states each current disposition without altering those rows. + +Alternatives rejected: row counts alone, first-line comparison, rewriting requirements into summaries, normalizing later row bytes, or editing initial statuses in place. Parser boundary checks include duplicate/unknown/missing IDs, late-clause changes, malformed columns/encoding and explicitly empty paths. Their receipt is parser evidence, not proof closure of semantic rows. + +Execution policy: leaf checks use the shared host mutex `Local\RMQLifecycleImplementationHeavy20260920` and the existing owned-process-tree helper, preserving full stdout, stderr, exit and elapsed time before compact summaries. Warm baseline artifacts were copied into this worktree as separate files from a clean exact `7b227c4` source whose Lean/toolchain/Lake content matches `bf31f983`; `CACHE_PROVENANCE.json` records the identity. These are development artifacts, not independent cold-build evidence or a shared mutable cache. Final candidate checks remain the frozen verification plan, with the complete aggregate and fresh-blind acceptance assigned to the coordinator. + +Consequences: the final receipt must distinguish exact Git blobs from LF/CRLF working bytes, especially because local Git enables automatic CRLF conversion. Neither a parser pass nor a successful component compilation closes the lifecycle target. The optional external Claude source-review transfer was rejected by automatic approval review on authorization grounds; it was stopped, and local Astra/Lean work continued without a transfer workaround or quota change. + +## WDD-20260920-LIFE-002: independent client types, shadow dependency mutations and direct owner validation + +Context: a successful producer build can hide a weakened public conclusion if its clients simply adopt the producer's current type. The lifecycle also needs executable evidence for the new scalar owner, including a second query with dirty registers. Predecessor validators and copied diagnostic transcripts cannot establish either dependency. + +Decision: `LifecycleContract.lean` independently spells the seven public groups, expanding canonical data, finite-owner readiness, numeric prefix resources and the literal bank/setup constants. The separate `scripts/lifecycle_provenance_contract.lean` pins actual producing occurrences without importing a precompiled downstream module into a mutated capstone environment. Dedicated dependency cases modify copies of the real producer source, compile shadow artifacts in an isolated `.lake` tree, and elaborate the unchanged direct client against those artifacts. A producer error is not the expected client rejection. The exact ordered registry records each edit, expected verdict and diagnostic surface; positive controls retain the public propositions. Replays reject missing/unknown/duplicate/explicit-empty selectors, mixed diagnostics, output/deadline failures and restoration mismatches. Original sources and build artifacts remain distinct from the shadow tree. + +The compiled `rmq_lifecycle_validate` target invokes `Executable.initialOwner`, the new `runOwner`, and `queryOwner`; expected answers come from a separate strict-comparison half-open scan. Validation-only counters fold actual scalar transitions and have a proved final-owner projection, while the production owner contains no observations. Sixteen cases cover empty, singleton, ties, invalid/repeated requests and sizes 24 and 83 in both input models; comparison cases include keys larger than the numeric word domain. The dirty-bank control starts from an actual first-query owner, skips one witnessed nonzero scratch register's clear, and challenges the same compact-entry ABI projection proved by the positive entry theorem. It does not invent an answer-failure counterexample. + +Alternatives rejected: mutating source in the shared checkout, accepting any compiler failure, keeping an adapted alias as the expected public type, importing old downstream artifacts after mutating their dependency, reading success markers before checking all diagnostics, running only an old validator, or claiming a dirty-bank counterexample from an artificial starting state. Scalar controls are direct checked positive/negative fixtures where a mutation harness would add no evidence. + +Consequences: source, registry, client and command receipts must be frozen together before the final replay. The Windows runner uses the existing owned process-tree helper and the shared compiler mutex. Startup and one known exact case precede the complete native registry. The interrupted first native build is an uncertified scheduling checkpoint, with retained partial C artifacts; the incremental continuation is separately identified. The final report distinguishes these development events from the required final content checks and records platform coverage explicitly. The complete repository aggregate and fresh blind exact-candidate audit remain coordinator-owned. + +A read-only runner review found that text diagnostic grouping could accept an expected located type error followed by an unlocated compiler failure. The final classifier consumes Lean's JSON diagnostics and rejects every non-JSON output line, unexpected severity/count/class/surface, or stderr. Explicit controls retain the three rejected tails (`error:`, `uncaught exception:`, and `PANIC:`); the clean expected JSON error remains accepted. Exact assignment proofs in the independent client avoid cascading tactic diagnostics after the first deliberately weakened field. The client also pins both the service budget and the linear construction-budget function to literal expressions, so an alias cannot silently loosen the advertised bounds. + +## WDD-20260920-LIFE-003: separate the implementation identity from the closing evidence identity + +Context: LIFE-1 requires a durable complete report, exact source and receipt hashes, per-commit design checks, an exact-base committed-range check, and a clean delivered tree. A report cannot contain the Git hash of its own enclosing commit. The source implementation is committed as `299ec6527ca2fbcf73cfc34e9de75f4a1f34140c`; all final Lean, native and dependency checks consumed the source bytes identified by the manifest. + +Decision: use one subsequent evidence-only closing commit for the contract/evidence packet and final report. `SOURCE_MANIFEST.json` independently records raw workspace SHA-256/length and exact Git blob SHA-256/length/OID at the implementation commit. `FINAL_RECEIPTS.json` binds compact results and complete ignored local outputs by bytes and hashes. The final submission and local `delivery.json` bind the closing commit, report bytes, committed-range/per-commit checks and clean state. Byte-pinned contract files require an LF-preserving checkout; the checker must reject CRLF serialization rather than normalize frozen rows. No user Git configuration or repository attributes are changed. + +Alternatives rejected: inventing a self-referential report hash/commit, leaving the requested report uncommitted, treating working-tree whitespace checks as committed-range evidence, conflating raw checkout bytes with Git blobs, or rerunning unchanged expensive semantic suites solely because evidence prose changed. Evidence edits receive the appropriate claim/design/row/whitespace checks; unchanged implementation results retain their source bindings. + +Consequences: the delivered commit contains both the implementation and the complete local candidate packet. Each commit receives its own strict design check and the final range receives the exact-base check. The closing commit introduces no new machine or proof-design decision, so DD-20260920-LIFE-001 remains the design rationale. Coordinator aggregate certification, native consuming-boundary integration and fresh blind exact-candidate acceptance remain separately commissioned consumers. + +Final scheduling evidence: the first whole-repository claim scan exhausted its 180-second wrapper budget after 181.412 seconds, before a verdict. The owned job terminated its three process IDs, and all were verified absent. Read-only inspection identified the last emitted policy item as term 29 of 35; later multiline PCRE2 scans buffer their output. The retry raises only the owned deadline to 900 seconds, based on that measured lower bound and remaining-stage uncertainty. Scope, policy, matching logic and acceptance criteria are unchanged; the earlier receipt is retained as uncertified and the completed retry owns final coverage. + +The 900-second scan also supplied no verdict (900.910 seconds); its three owned IDs were verified absent. Static inspection found that the generated FINAL_RECEIPTS.json had one 1,691-line paragraph, while a late PCRE2 rule tries arbitrary nonempty-line prefixes before a trigger and applies its reporting-scope filter after matching. A temporary object-separated copy preserved deep JSON equality and every nonblank line, reduced the maximum paragraph to 44 lines, and passed the production scoped strict scan in 4.734 seconds. The final receipt therefore inserts only 270 LF bytes after object records. This is an owned metadata serialization change, with no policy/matcher/scope/claim change and no alteration of recorded hashes or frozen files. The isolated result supports the change but does not by itself establish the full-tree bottleneck or final coverage; the full scan must run again on the final serialized packet. Both prior attempts remain uncertified in delivery evidence. + +The formatted full scan likewise timed out at 901.547 seconds and its owned process IDs were verified absent. Further read-only diagnosis found baseline-identical native1 receipts with 40,000–66,000-line nonempty paragraphs. Exact production term-34 samples of 4,000/8,000/16,000 lines took 1.964/12.384/45.017 seconds, supporting roughly quadratic growth but not a guaranteed runtime bound. Weighted estimates place one representative whole receipt near 896 seconds and sequential no-trigger work near 5,724 seconds; parallel scheduling is uncertain. The unchanged full scan therefore receives a 7200-second owned deadline with margin. Replacing or weakening the scanner, excluding inherited files, or changing their pinned bytes was rejected. Samples are scheduling evidence, never final-scan coverage; the third timeout remains uncertified and all sample identities/outputs are bound by delivery.json. An attempted coordinator status message was separately rejected by automatic approval review on destination-authorization grounds; it was not sent, and explicit confirmation was requested while local work continued. + +## WDD-20260921-LIFE-R1-001: preserve selector absence and independent failure cleanup + +Context: the exact LIFE-1 executable and wrapper pass full validation on Windows +PowerShell 5.1, while bundled pwsh 7.6.5 preserves an empty environment value +that the old wrapper uses to mean omission. The unchanged native selector then +correctly rejects registry startup as duplicate channels. The old dependency +finally also skips safe disposable-shadow removal when original integrity fails. +Both failures were independently reproduced with source and executable pins. + +Decision: introduce a lifecycle-local, production-used process adapter whose +object selector distinguishes null absence from exact string presence. It +snapshots process key presence/value, removes or sets that key before calling +the unchanged owned helper without a selector override, and restores the caller +state in finally. Ordinary registry/startup/argument/full callers pass absence; +intentional id: values retain their characters. Add the adapter/helper to the +validator identity roster and persist its full available returned process result. +Do not alter the native selector or the Stage/Case command interface. + +The dependency finalizer independently guards original integrity and safe shadow +removal, retaining separate stage, integrity and cleanup errors. Any failure +keeps a nonzero exit and suppresses the production terminal success record. +The resolved descendant and exact shadow-basename guards stay byte-identical. +No changed original source is overwritten automatically. + +Alternatives rejected: empty string or null through the inherited helper's +string cast, allowing ambient selector inheritance on omission, weakening the +Lean selector, editing the global helper, treating integrity failure as success, +or removing an unchecked path. Exact source-derived finalizer children preserve +production function/block bytes and error/terminal paths; only owned scratch +pin/shadow fixtures are challenged. Real exclusive file locks and private mutex +observers distinguish cleanup failure, integrity failure and ordinary release. + +Evidence plan: the repair's 45-row matrix preserves all 43 original complete +rows and adds the exact two repair requirements. The frozen process-control +registry binds every ID to its production route and exact outcome; registry +mutations and focused selection are separate real command-boundary controls. +Both declared shells require full16 native validation and real selector/deadline +controls. Current pwsh additionally requires all26 original producer/client +cases through the changed dependency runner. Source/build/tool/old-receipt +identities remain separately pinned. Windows dependency finalizer verification +has exposed the existing Hash-Bytes API incompatibility with .NET Framework; +its out-of-scope implementation change is pending explicit authorization, not +silently substituted in the controls. + +Consequences: this repair changes launch and failure-cleanup evidence, with no +new Lean theorem, machine operation, native capacity or alias claim. The shared +heavy mutex still serializes expensive children; callers never acquire it around +a production wrapper that already owns it. Historical receipts retain their +original source hashes. The inherited helper supplies returned nonempty lines, +not original raw bytes, and may lose overflow/exception output. An empty captured +baseline proves no whole-tree integrity. Aggregate certification, native consumer +review, fresh-blind audit, coordinator acceptance and publication remain later +campaign phases. The exact repaired-source report and receipts will record final +outcomes before submission; this entry is the implementation/evidence choice. +### WDD-20260921-LIFE-R1-002: bind repair controls to actual runtime and exact positive fixtures + +Before freezing the repair source, independent review identified three ways a +control could report the intended rejection for an unintended reason: a registry +reserialization changed its newline as well as the selected edit, captured stderr +was trimmed, and a profile label did not prove the driver ran in that runtime. +The controls now run the original registry bytes as P before a one-byte Q, compare +all captured Console.Error text including its newline, and bind both the current +host and supplied child executable to exact runtime paths, hashes and versions. +Native and wrapper negatives likewise first run an accepted case in the same +ambient process environment. The bounded failure fixture compares exit 0 with +exit 7 through the same source and production environment adapter. + +The alternatives of accepting the first 67-control development PASS unchanged, +or accepting any exception as an intended rejection, would leave those evidence +boundaries untested. That earlier run is retained only as development evidence. +The corrected focused native, wrapper and registry-edit checks pass; independent +source review found no further actionable defect. The twelve registry controls +also reject wrong profile and wrong supplied-shell identity through the actual +driver before semantic work. Full final replays remain required after this freeze. + +The unchanged installed Lean 4.22.0 Lake binary completed both the default build +and the named lifecycle builds using verified copied cache artifacts. The elan +shim had attempted a network download and failed before build work; the direct +pinned installed binary avoids that unrelated shim lookup. No installation or +runtime mutation occurred, and the lifecycle executable retains its original +SHA256. Original contract serialization and the protected dependency Hash-Bytes +WinPS incompatibility still require the pending scope decisions. This entry does +not amend those requirements or imply acceptance. The repair changes launch and +cleanup evidence; theorem types, counted resources and native ownership remain +outside its modification scope. +### WDD-20260921-LIFE-R1-003: portable control bootstrap and JSON receipt cardinality + +The actual Windows PowerShell control run exposed two repair-harness portability +issues after the production full16 and full26 replays had passed. At parameter +binding, the optional RegistryPath default evaluated PSScriptRoot before that +shell supplied it. After an explicit registry path reached the real wrapper, +ConvertFrom-Json returned its array as one pipeline object, and an outer array +expression made the harness count one instead of the valid two startup records. +Neither failure was accepted as semantic evidence; the production startup PASS +and restored ambient selector were preserved for diagnosis. + +The driver now supplies its default registry path in the body only when the +parameter is absent. Explicit empty remains distinct. The receipt reader assigns +the parsed JSON value directly and keeps the exact two/three-process count check. +Using only explicit RegistryPath is contract-compatible, but fixing this small +convenience default is preferable while the receipt reader already requires a +new control freeze. Dropping the count check or accepting either count would +weaken the evidence and was rejected. The frozen case mappings and all production +scripts, Lean sources, consumers and strict diagnostics are unchanged. + +A bounded Windows W01 startup control with omitted RegistryPath passed after +both fixes, in 13.013 seconds. Independent source review found no actionable +defect. A new private control-source commit will be followed by fresh complete +current-PowerShell controls, both registry campaigns, and Windows controls up to +the separately known protected Hash-Bytes blocker. Existing successful production +full16/full26 and build receipts retain their exact consumed source identities; +repeating those unchanged semantic suites would add no coverage. This does not +waive the blocked Windows intact-pin/finalizer or original contract-byte gates. +### WDD-20260921-LIFE-R1-004: preserve a blocked repair with complete observed evidence + +The final control revision passed all 67 current-PowerShell controls and both +12-case registry campaigns. Windows passed its exact 32 selector/wrapper prefix +and the separate real descendant timeout. Its full profile still selects all +66 assigned IDs: D01's accepted P fails at the protected SHA256.HashData call, +and the source-bound intact-pin F01 positive separately fails at that same call. +These are unmet obligations, not accepted negative controls. The missing API +prevents the shared accepted baseline for the remaining Windows dependency and +finalizer pairs. The final report therefore remains BLOCKED for L1R1-CLEANUP, +L1-18, INV-MUTATION-REPRODUCIBILITY and the corresponding delivery rows. + +Both production full16 runs and the current-PowerShell full26 replay passed on +unchanged production bytes; the latter retains exactly 23 rejects/3 accepts, +original/private restoration and shadow removal. Default and named builds, +source and artifact identities, and historical exact type/axiom output remain +bound separately from finite runtime observations. The initial contract-byte +checker still rejects the checkout's inherited CRLF serialization. Restoring +those protected files or changing the protected hash implementation requires +the already requested scope decision, which has not arrived. Weakening either +checker, substituting a passing hash predicate, or calling a partial campaign +complete was rejected. The repair does not establish a theorem obstruction. + +Packaging quotes all 43 inherited proposition/object-chain cells and appends all +45 successor dispositions without changing any frozen row. Generated indexes +store identities and compact summaries; bulky child outputs and fixtures remain +in the owned .lake evidence directory. A read-only scope --check mode runs the +same full raw preservation predicate after committing without rewriting its +committed receipt. Postcommit delivery binds the enclosing commit, report hash, +source checks and clean state outside the report, avoiding a self-hash cycle. + +The conceptual change is limited to environment absence and independent safe +cleanup. Formal model counts, counted payload, executable owner and native +allocation obligations remain distinct. Final report/contract/workflow prose +receives the unchanged strict claim scanner; each commit and exact-base range +receives the unchanged strict design checker. No aggregate, acceptance, push, +merge or retirement is authorized or recorded by this blocked package. +### WDD-20260921-LIFE-R2-001: exact contract commissioning and portable byte hashing + +Context: the completed coordinator LIFE-1-R1 review measured two blockers at +0485a64920a273d0830b926ee46275085222819d. Original contract files had their +reviewed CRLF checkout representation while the unchanged checker pins Git LF +bytes. Windows PowerShell's .NET Framework cannot execute the dependency +runner's SHA256.HashData or Convert.ToHexString. The frozen R2 prompt explicitly +authorizes only three exact-blob setup writes and the Hash-Bytes body repair. + +Decision: capture all initial tracked raw and Git identities, reproduce the old +actual checker failure, verify each of the three files equals its reviewed raw +baseline and differs only by the recorded CRLF checkout transformation, then +materialize its exact base Git blob once. A four-root actual-checker control +requires the original CRLF negative, each partial materialization negative, +and the complete Git-byte positive. The live checker must then pass before a +new protected raw baseline is captured. This operation is never called by a +runtime finally and does not claim default CRLF checkout portability. + +Hash-Bytes keeps its byte-array signature and every caller. Its body now uses +SHA256.Create, ComputeHash, portable BitConverter hexadecimal conversion and +finally disposal. The raw file-hash path remains raw; only the existing explicit +registry caller normalizes its registry text. Raw prefix and suffix equality +outside this body is recorded, preserving the source's mixed newline history. +Eight fixed independent Python/hashlib vectors cover empty, binary, UTF-8, +one-byte and LF/CRLF differences. The exact old function passes on modern pwsh +and still fails at HashData on Windows; the repaired production span passes all +eight on both shells. Actual F01 controls then capture and check two real pins +on both shells, before the full negative campaigns. An empty baseline is never +credited as this positive. + +Alternatives rejected: normalizing equality, updating expected hashes, changing +attributes/configuration, hiding the Windows error, replacing the hash only in +a fixture, broad helper changes, or rewriting old manifests to fit new source. +Historical pins are resolved against their immutable producing source, followed +by separate checks of unchanged actual consumer inputs. The old wrapper's extra +dependency pin is incidental to validator execution; this does not permit +omitting a real validator, helper, executable, runtime or Lean dependency. + +Consequences: new R2 artifacts preserve all45 inherited complete row bytes and +add the exact two requirements. R1 reports and failed receipts remain immutable. +The unchanged 67/66 controls and affected current-pwsh full26 must be replayed +against the repaired hash with their original predicates and bounds. A required +warm default build reuses the verified unchanged cache; unchanged full16/type/ +axiom evidence is reused only after the new applicability check. Every private +commit receives strict design certification. No proof/model design changed, so +no DESIGN_DECISIONS edit is authorized or needed. Native ownership, full Windows +compiler replay, joint aggregate, fresh-blind audit and coordinator acceptance +are separate obligations or unclaimed platforms, exactly as the prompt assigns. + +### WDD-20260921-LIFE-R2-002: exact execution evidence and separate historical applicability + +Context: the unchanged R1 registry/handlers now complete all 67 current-pwsh and +66 Windows cases; both 12-case registry campaigns and the fresh current-pwsh +26-case dependency replay also pass. A count alone cannot establish that these +were the intended inputs, P/Q controls, diagnostic surfaces or source versions. + +Decision: freeze a separate read-only evidence reader that binds actual ordered +registry mappings, source/tool/runtime pins, owned process bounds, both wrapper +log roots, intact positives and exact negative verdicts. It reconstructs each +dependency producer edit and checked consumer, binds all 52 compiler invocations, +and checks diagnostic class, consumer path boundary and named theorem range. +The original predicates, selectors, bounds and handler files remain unchanged. +Independent review tightened six such bindings before this code freeze. The one +new HASH_CHANGE receipt originally emitted as CRLF has its exact raw hash pinned +separately from its immutable Git LF blob; no normalizing equality is credited. + +Historical reuse has its own exhaustive read-only applicability verifier. It +checks all actual artifacts and cache inputs, resolves old pins against exact +producing Git content and documented raw profiles, and separately checks current +consumer inputs. It preserves the original mixed lakefile bytes and all old +reports/receipts. Changed-runner full26 and blocked old Windows controls receive +fresh evidence; they are not excused by historical applicability. The actual old +full16 and type/axiom observations remain bounded historical evidence, not new +runs or a theorem about host allocation. The final report generator requires a +fresh successful 47-row/22-control receipt for its actual final inputs and an +exact commit-bound source freeze before asserting local completion. + +Alternatives rejected: editing historical manifests to fit current files, +discarding inconvenient old failures, treating a manifest as execution, checking +only counts, substituting loose diagnostics, or rerunning unaffected expensive +Lean work after reader-only changes. New compact indexes reference preserved +complete child outputs in owned .lake evidence. Consequences: every reused item +has an explicit applicability relation, every newly affected campaign has actual +current receipts, and final packaging remains a separately certified step. No +mathematical or model design changed, so DESIGN_DECISIONS remains unchanged. + +### WDD-20260921-LIFE-R2-003: complete local evidence package and external final certification + +Context: production/control freeze cb4739220c01e6554a25ff8333652c0501486fa8 +and evidence-code freeze d8a2d8bad2f1e7a8cd89e7905c1568fd98001dbe preserve +the assigned production boundary. Actual current-pwsh/Windows control campaigns +passed 67/66 cases in 495.745/296.723 seconds; registry profiles passed 12/12 in +41.579/37.634 seconds. Fresh current-pwsh full26 passed in 421.444 seconds, +including all 23 expected rejects and three accepts; its 52 compiler invocations +retained the original per-process bound and restored the complete baseline. +The required warm default build passed in 2.039 seconds. These observations do +not claim a full Windows compiler campaign or native allocation correspondence. + +Decision: package the complete 47-row appendix, preserving every frozen row and +quoting exact original proposition/object-chain and challenge paragraphs. Bind +the complete current receipts, historical applicability, source freeze and final +contract verification separately. Append this decision before the last history +generation so its current raw source identity is included. The final report +retains previous failures as failures and distinguishes raw bytes, returned helper +lines, immutable Git objects, actual executed inputs and historical applicability. + +Each private commit and the exact-base range receive strict unchanged design +checks. Final report-sensitive claim checking uses explicit package paths and +the unchanged policy after final prose exists. Hygiene/trust, whitespace, source, +scope and clean-state checks complete certification. Their actual receipts and +the enclosing commit/report identity are pinned outside the committed report in +owned .lake delivery evidence, avoiding a self-referential hash. Any final failed +check must be resolved before the candidate is handed back; this entry itself is +not a substitute for those receipts. + +Alternatives rejected: overwriting R1 closure history, reducing inherited rows +to theorem names, treating a green component as complete acceptance, inventing a +raw-stream guarantee, or running an unauthorized campaign aggregate. The report +may state only CANDIDATE_COMPLETE after all assigned local rows and the final +delivery condition hold. Native ownership, the consuming adapter, joint aggregate, +fresh-blind audit and coordinator acceptance retain their campaign order. No +push, integration, publication, branch retirement or transfer retry is performed. +This is an evidence/process packaging decision; no formal design log changes. + +## WDD-20260920-LIFE-NATIVE-P0-001: frozen native ownership registry and exact measured verdicts + +Context: the local native prerequisite needs executable evidence against three false ownership claims, and the commissioning review identified first-line-only matrix comparisons, mixed expected/unrelated diagnostics and source/newline hash confusion as recurring failures. The production design classifier already authorizes C sources under native/packed-rmq and treats scripts/internal contracts as workflow-sensitive; no classification allowance is changed. + +Decision: freeze twelve complete eight-column acceptance rows before implementation, with strict UTF-8 prompt requirements, baseline bytes and independent hash pins. Preserve the frozen rows and append evidence separately. A local evidence-directory gitattributes rule fixes LF transport so actual Git and working evidence bytes remain distinguishable and replayable under core.autocrlf. Commit an ordered registry and an owned replay runner that executes the C operations, checks observed projections against a fixed independent input specification, rejects unexpected or mixed diagnostics and tests focused, missing, empty, unknown and duplicate selectors at the command boundary. Negative mutations are explicit executable branches, with the same positive predicates and restoration after observation, rather than unreferenced patched Git objects. + +Alternatives rejected: interpreting arbitrary process failure as successful mutation rejection; accepting labels or a prewritten expected log instead of capacity/value/reference observations; deleting the full output after retaining only a summary; weakening old gate policies or silently installing a compiler/runtime; running predecessor fixtures as evidence for the new native path; and concurrent broad Lean builds. Compiler/probe processes have finite stage deadlines and owned-tree cleanup. Actual fatal allocation-handler termination is a separate measured process outcome, not recoverable cleanup evidence. + +Consequences and evidence: exact raw stdout/stderr, actual exits, source/compiler/header/runtime/binary identities and durations remain at explicit ignored local paths with hashes; compact result evidence and replayable fixtures are committed. The single unchanged Lean baseline build holds Local\RMQLifecycleImplementationHeavy20260920, with source-verified independently copied cache provenance if reused. The final report records strict design/claim, hygiene, frozen-row and clean-commit checks. Aggregate certification, fresh-blind audit, coordinator acceptance and any later published integration remain ordered downstream campaign responsibilities. + +Pre-commit review refinement for WDD-20260920-LIFE-NATIVE-P0-001: a phase-name-only checker could accept a mid-copy failure rerouted to the empty allocated buffer, or a post-consumption failure rerouted before release, because their phase sequences coincide. The probe now exposes the full frozen case tuple, and the replay must additionally check the actual failure pre-state: source ownership, initialized destination size/values and reference projections. Tuple metadata is provenance, not operational reach evidence. Source and measurement controls challenge these stage distinctions through the production verdict. The checked intermediate object, rather than a stage label, supplies the cleanup-stage claim. + +Toolchain refinement for WDD-20260920-LIFE-NATIVE-P0-001: the installed pinned leanc/clang distribution lacks general-purpose C headers. The measured build retains that compiler and Lean runtime, adds the already-installed matching Strawberry x64 MinGW standard-header tree, and copies only its exact mm_malloc.h into a run-local fallback directory. A whole GCC builtin-header fallback was rejected after its stdatomic.h conflicted with Clang. The successful command pins every included header from the compiler's requested include trace, an actual link map, the conservative installed archive/object roster and compiler/runtime binaries. It rejects unrecorded compiler search overrides. Failed startup/header attempts remain raw local evidence. A final output-length check after draining both streams covers fast-exit overflow; complete identity-output grammar and strict protocol shapes reject mixed diagnostics. These are owned runner repairs, not changes to production claim/design policies. + +## WDD-20260920-LIFE-NATIVE-P0-002: separate native source identity from final report certification + +Context: source commit bea5ce75f788c4035031ba81e69d8de36eda3f92 freezes the measured C probe, replay script, registry and result receipts. A report cannot contain its own future commit hash. The first post-report claim invocation also exposed a capture error: Write-Host bypassed the draft redirection, so that invocation was interrupted and is explicitly non-certifying. + +Decision: preserve the source commit and add a documentation-only packaging commit, following WDD-20260912-NATIVE1-013. Record the source hash in the report, its final byte length and SHA-256 in certification, and the exact packaging commit in the final handoff and local post-commit receipt. Capture complete raw streams and actual exits in an owned replacement invocation. The unchanged default-root strict claim scanner passed with 3,479 hits, zero strict failures, exit 0, in 2,211.841 seconds under a 3,600-second deadline. The earlier same-policy scan at d0b4cef took 1,265.16 seconds with the same three large native JSON blobs; those inherited records explain why a short default scan estimate was unsuitable. No scanner or policy changes are made. + +Alternatives rejected: asserting a future report commit hash inside that same commit; treating the interrupted invocation as a pass; truncating evidence to obtain a convenient log; rerunning the expensive default-root scan solely for final documentation edits; or reporting a focused scan as if it were a new whole-tree execution. Inspection of claim_drift_scan.ps1 lines 338-456 establishes that term decisions and attribution requirements are per file, with only failure aggregation at the end. Therefore the completed full scan composes with a final unchanged-policy scan of the entire lifecycle-native-p0 directory and both ledgers, provided every outside path and byte and the scanner environment remain unchanged. A snapshot and final check cover all 2,910 outside files; final focused checks include the completed report and certification. + +Consequences and evidence: CERTIFICATION.json indexes the completed full scan, native replay, baseline, source-byte and evidence-pin checks. The final package's per-commit and whole-range design checks, whitespace checks, claim coverage, exact Git/report bytes and clean status are recorded after committing, without creating another self-referential receipt commit. The first capture failure remains in claim-draft-interrupted.json; the corrected run retains all 4,118,433 stdout bytes and empty stderr. Native source is unchanged, so the completed replay and source-verified Lean build remain applicable. This is local CANDIDATE_COMPLETE evidence only; the coordinator still owns acceptance, campaign gates, independent final audit and integration. + +## WDD-20260921-LIFE-NATIVE-P0-R1-001: independent final integrity and measured compiler dependency closure + +Context: exact native source bea5ce75f788c4035031ba81e69d8de36eda3f92 and report base 0c873072e84be9e1d65edab1985bcff1d23abef1 passed the bounded ownership experiment, but coordinator source review found that earlier stage failures bypassed the success-only pin loop and that substantive compiler DLLs were absent. The existing coordinator skill's finally-integrity floor already applies; this repair creates no repository-wide policy. Independent normal-import inspection also found zlib1.dll beyond the three direct clang imports named in the repair prompt. + +Decision: register each captured pin immediately, independently of partially constructed identity records. The production finally checks every captured pin and the declared live tracked/index/nonignored-untracked baseline, records its own outcome, and forces a failed final verdict independently of the original stage error. It detects rather than overwrites unrelated data. Raw stage files enter the inventory before strict decoding; available compiler binary/map outputs enter it in a local finally whose capture errors cannot replace a propagating stage error. The tree inventory checks working bytes and semantic staged entries; ignored outputs enter separately through explicit artifact pins. Unsupported multiline Git path output fails closed under this Windows text-host boundary. + +The compiler/runtime receipt derives a recursive local normal-import closure from the actual pinned executable roots, records PE import names and delay-directory metadata, and pins discovered files before invoking tools. The current closure contains eleven local PE files, including libclang-cpp.dll, libLLVM-19.dll, libc++.dll and zlib1.dll. Unresolved non-system dependencies and unsupported delay imports prevent success. OS/API-set loading, dynamic LoadLibrary behavior, PowerShell/.NET and compiler correctness remain external assumptions. Link-map integrity is included explicitly. + +Alternatives rejected: giving an expected earlier error precedence over integrity failure; success-only checking; replacing the dependency inventory with a fixed three-DLL list; testing installed-file mutations; resetting unrelated live user data; and accepting broad error prefixes without actual exit/stream guards. Isolated committed controls preserve the production runner's complete setup/functions and catch/finally/verdict while substituting only its stage body. They run actual owned processes and real pin/tree checks. Each owned mutation is restored in its own finally, including ignored maps without depending on summary parsing. Dependency controls use actual measured PE inventory and copied-file/manifest fixtures. The historical source and result are bound through strict Git bytes, independently of Windows checkout newline filtering. + +Consequences and evidence: all twelve inherited complete rows remain unchanged; two repair rows and replayable controls are additive. Native C, Lean, ABI, reference semantics, registry, and the sixty-five original check identities remain preserved. Exact ordinary exits, malformed bytes, mixed diagnostics, timeout, partial initialization, source/index/untracked/map changes and artifact-capture errors are distinguished. Source and report packaging identities remain separate; the final full native replay holds the assigned host mutex and an owned deadline. Verified unchanged baseline sources and original claim coverage can be reused with a final unchanged-policy changed-root rescan. The concrete receipts and final outcomes are indexed in repair-r1/REPORT.md. No mathematical/model decision changed, so DESIGN_DECISIONS.md needs no append. The production consuming adapter, aggregate, fresh-blind campaign audit and coordinator acceptance remain downstream. + +## WDD-20260921-LIFE-NATIVE-P0-R1-002: certify established timeout reach and correct the mutex wrapper + +Context: the first source-frozen repair-control invocation reached the expected timeout but its three-second fixture budget expired before the native child PID was established under concurrent lightweight verification. The tightened control correctly rejected this as uncovered. A separate focused invocation stopped at a PowerShell parser error in the generated mutex wrapper (`catch` needed whitespace before its exception type); no native semantic process ran in that attempt. + +Decision: retain the live-child/cleanup assertion and raise only this new fixture's deadline to the existing eight-second sleeper margin, while its deliberate sleep remains 120 seconds. Correct the wrapper syntax without changing mutex identity, ownership, native predicates or the compiler/probe limits. Preserve both failed raw receipts, then rerun the affected controls and native wrapper on the corrected committed source. The original whole-source static checks remain historical evidence; final checks will include this commit independently. + +Alternatives rejected: accepting a timeout with no established native process; weakening exact exit/stream assertions; calling the parser failure a native result; changing production compiler/probe deadlines; or retrying unchanged. Consequences: the new timed control remains a measured termination test, the full native replay still requires the assigned host mutex and 1200-second owned deadline, and the final report separates these failed development/certification attempts from the final outcomes. This is a verification-process correction with no Lean/C/ABI/model change. + +## WDD-20260921-LIFE-NATIVE-P0-R1-003: package final local repair evidence separately from source + +Context: the corrected source closes the native prerequisite verifier through the unchanged operational registry plus independent integrity and compiler-dependency controls. A report cannot contain its own future commit/hash, and final committed policy checks must consume the complete report. + +Decision: preserve the implementation and certification correction commits; add the complete report, compact pinned results and append-only matrix dispositions in a documentation-only package. Exact source/runtime/control receipts retain the measured outcomes. Run final exact-base and each-parent strict design, working/range whitespace, hygiene, frozen-byte/scope/baseline identity and clean-tree checks after committing; preserve their raw logs and actual exits in local final certification without creating a recursive receipt commit. Re-establish the unchanged outside-file/checker context and run the unchanged strict claim scanner over lifecycle-native-p0 and both ledgers after report packaging. This composes with the verified prior full scan and is not described as a newly executed default-root scan. + +Alternatives rejected: rewriting historical candidate receipts or pending frozen cells; recording a future package hash as if already known; rerunning unchanged Lean compilation; hiding the diagnosed source-frozen wrapper/timeout failures; or presenting local controls as campaign acceptance. Consequences: the handoff gives exact source/correction/package commits and report bytes/hash; coordinator reconstruction, production consuming adapter, aggregate and fresh-blind campaign audit remain downstream. No representation or mathematical-model change needs a design-ledger entry. + +## WDD-20260921-LIFE-NATIVE-P0-R2-001: validate complete outer diagnostic streams at their actual callers + +Context: the exact 2307e3ad candidate's integrity-control harness accepted an unrelated derived-runner stderr line both after intact success and alongside the expected exit-seven diagnostic. Its native measurements, production finally verification and eleven-node compiler provenance remain supported. The certification wrapper likewise recorded child streams without checking their declared output grammar. The existing exact-diagnostics requirements already govern this omission; no policy expansion is needed. + +Decision: a focused shared stream validator checks the actual ordinary exit and complete strict UTF-8 raw streams, after transport/timeout/overflow checks, at both callers. Integrity expectations come from the declared case and independently checked inner operations, including runtime-specific decoder and exclusive-lock messages. Expected stage and integrity errors remain separate, ordered and exact; the expected-error route does not skip stdout or stderr validation. Each supported wrapper profile has a precise producer-derived contract. Claim records are independently enumerated from the protected policy and actual source matches, with exact whole-record content/multiplicity and terminal summary while allowing ripgrep file-order variation. Useful multiline claim output is retained. + +The integrity caller reuses the production byte-copy child. At the unchanged owned-process helper's cleanup boundary, a scope-local adapter copies only this invocation's exact stdout/stderr redirect files before forwarding deletion to the original cmdlet. This retains even blank-only launcher output that the helper's text arrays omit. The adapter does not change process launch, deadlines, ownership, termination or global commands; retention failure prevents acceptance. Fixture controls exercise real blank launcher streams as well as successful and expected-failure derived runners with extra stdout/stderr. + +Alternatives rejected: a blanket empty-stderr rule for expected failures; prefix-only exceptions or successful JSON as an output oracle; normalizing away unrelated whitespace; modifying the protected native/finally/PE/process implementations; broad claim-output wildcards; regenerating old reports or receipts; and making the later adapter prerequisite gate its own producer. Controls use immutable source-derived carriers and restore only owned fixture state. The old source and captured accepted failure remain immutable counterexamples. Exact row/prompt/byte checks and historical Git identities are distinct from current working-byte pins. + +Consequences and evidence: repair-r2 freezes all sixteen complete rows, preserves the original operational and R1 control rosters, and adds exact selector-aware stream registries plus real caller regressions. Shared heavy work remains serialized by Local\RMQLifecycleImplementationHeavy20260920 with evidence-based deadlines. The successor report corrects the R1 map wording: dependency_controls creates a synthetic text map fixture; actual generated-map capture/final hashing are separate observations. No Lean, C, ABI, allocation model, payload theorem or production design decision changes, so DESIGN_DECISIONS.md is preserved. Source freeze and final report packaging remain separate; final claims include the completed report. The consuming adapter, formal/native aggregate, fresh-blind audit and coordinator acceptance remain downstream. + +## WDD-20260921-LIFE-NATIVE-P0-R2-002: bind wrapper controls to both observed streams and their producing roster + +Context: the production predicate and all six legitimate profiles passed on source c3fcc2e0beb08d090382f56d16dbe9446639164a. Independent review then found two test-harness weaknesses: an expected stdout exception could precede an unrelated stderr check, and a claims holdout could use an independently named expectation without binding it to the producer receipt. + +Decision: establish both complete observed streams and all transport/ordinary-exit guards before crediting a real wrapper rejection. Add an explicit mixed-output holdout on the same captured object. Require the exact claims expectation path, bytes and hash saved by the producing wrapper. Publish the independent result collector with these checks, retaining all failed development attempts separately. Source-sensitive work was kept in ignored scratch until the live native/integrity snapshots completed. + +Alternatives rejected: treating any expected exception as adequate evidence; accepting a compatible but unbound claims roster; editing tracked source while live baseline snapshots run; and repeating the unchanged full native/integrity runs for test-only corrections. Those runs already measured the unchanged production validator and native sources. Final checks and claims do change with the new source and report content, so they are regenerated on each final clean freeze before the complete wrapper registry is evaluated. + +Consequences and evidence: the wrapper registry has 120 exact controls with recorded operational mappings, including the new two-stream holdout. The eleven real harness controls and original native, integrity and dependency evidence remain applicable by checked source identity. The final report distinguishes source-phase and post-package receipts; no aggregate or coordinator acceptance is inferred. This is an internal verification-process decision and changes no mathematical or native model. + +## WDD-20260921-LIFE-NATIVE-P0-R2-003: package complete diagnostic evidence without recursive report identities + +Context: core source c3fcc2e0beb08d090382f56d16dbe9446639164a passed all six genuine profiles and the eleven-case real harness registry. Corrected test/collector source 4d6f195b306bd1615aced8c7a7cd1db0d48a8d69 passed fresh checks/claims and all 120 wrapper controls in 93.550 seconds. The independent collector verified 1938 distinct pins over 2931 occurrences, including the successful 23/65/58 native run, all fifteen integrity and nineteen dependency controls, and the immutable old counterexample that still accepts both unrelated diagnostics. + +Decision: package the complete successor report, compact factual result index and appended matrix evidence in a documentation-only commit. Keep the complete raw streams, actual exits and full pin ledger at exact ignored local paths pinned by that index. After committing, rerun checks and claims against the complete report and exact package, then re-evaluate the full wrapper registry with those new producer receipts and run the independent collector. Record the final commit/report bytes/hash and those results in local FINAL_CERTIFICATION.json and the handoff; do not create a recursive report-hash commit. + +Alternatives rejected: recording a future package hash inside itself; calling source-only claims coverage final report coverage; treating a source-phase checks roster as current after another commit; committing large raw transcripts; or rerunning unchanged native/Lean producers solely for packaging. The unchanged-policy final subtree/both-ledger claim scan composes only after exact outside source, policy, scanner, ripgrep and configuration verification. + +Consequences and evidence: all sixteen frozen rows and historical reports remain byte-preserved. The successor explicitly corrects the old copied-map wording and retains platform, final-drain overflow, OS/dynamic-loading and consuming-adapter limits. The final package is clean and private; no push, integration, aggregate, fresh-blind campaign audit or coordinator acceptance is inferred. This is evidence packaging with no mathematical or native-model change. + +## WDD-20260921-LIFE-NATIVE-P0-R3-001: literal decoded streams and upfront nonempty profile selection + +Context: independent review of exact 9519b2c1af5e2cf59536b311db5e8dc81376a32f measured four actual captured children. Exact expected error passed, extra ASCII rejected, but trailing U+FEFF after an expected error and U+FEFF-only stderr incorrectly passed. Strict UTF-8 decoding preserved the characters; PowerShell's culture-sensitive case comparison treated some additions as ignorable. A separate direct invocation with explicitly empty Kinds returned without a child or profile manifest. Both defects violate existing local requirements; neither changes the native ownership experiment. + +Decision: change only the common text equality to String.Equals with StringComparison.Ordinal after the unchanged strict UTF-8 decoder. Preserve characters, newlines, BOMs and every existing transport/ordinary-exit guard. At the actual certify_profiles boundary, validate the whole explicitly bound profile array before any output creation or invocation, rejecting null, empty, whitespace, unknown and repeated values. Omission retains the six-profile default. Current checks dispatch and its stream roster advance together to exact base 9519b2c1 and the successor contract verifier. + +Alternatives rejected: stripping ignorable characters, normalizing bytes, using a stronger test-only equality, accepting an expected-error prefix, rejecting all stderr, validating selections inside the execution loop, or adding another wrapper hierarchy. A private fixture suite prescribes exact bytes before execution and consumes the actual comparator; malformed UTF-8 and normalization/newline holdouts distinguish decoding from equality. Direct selector controls include invalid trailing entries so no valid leading profile starts first. One real focused native invocation supplies nonvacuous positive selection evidence. + +Evidence reuse: the sixteen complete historical rows remain frozen including pending cells, and two additive rows bind this repair. The retained six-profile and fifteen-integrity captures keep original paths, producing roots, source identities and ordinary exits. Their historical checks roster is reconstructed at its own base and HEAD before the current common predicate is applied. Fresh current checks/claims and the focused invocation consume their complete current profile predicate. Retained named old counterexamples still demonstrate old acceptance on the same bytes; copied-capture and synthetic launcher components are labeled separately from actual emitted children. The unchanged native 23/65/58 and dependency/control/build records are reused only after exact protected-source, registry and raw-pin checks. The final-drain overflow limit remains disclosed. + +Consequences: this is a narrow local verifier repair, with replayable registry, source and report identities, full raw local artifacts and finally checks. Source freeze precedes execution and report packaging; final committed checks and completed-report claims are recorded without recursive self-hashes. No Lean, C, ABI, mathematical model or public theorem changes require DESIGN_DECISIONS.md. The consuming adapter, joint aggregate, fresh-blind audit and coordinator acceptance remain downstream. + + +## WDD-20260921-LIFE-NATIVE-P0-R3-002: bind final claims to scanned inputs and package literal evidence + +Context: source 6bcd1fc50020482ab441723a1964eec0232d223f passed all 37 controls, including actual focused native execution and the success/error integrity caller pair. The retained component pass verified 40 cases. A read-only evidence review found that a claims receipt in the same checkout plus a manifest HEAD would not by itself prove which report bytes were scanned. It also identified an exit-artifact check that must precede malformed UTF-8 rejection and a missing explicit join between pinned fixture drivers and captured commands. + +Decision: publish an explicit final evidence adapter that snapshots the clean producing HEAD and exact complete native-subtree/both-ledger scanned inputs before and after invoking the existing checks/claims certification boundary. The result collector binds that actual captured command, source pins, report bytes, final checks contract and resulting six-profile manifest. It checks the retained actual exit artifact even when strict decoding rejects, and verifies each source-control capture names its pinned driver and working directory. This adapter only produces evidence for the existing verification actions; it does not add a new production stream layer or change the named convenience-launcher scope. + +Alternatives rejected: trusting an edited manifest HEAD, treating a malformed decoder exception as enough without the ordinary-exit artifact, cloning historical validators, repeating unchanged native experiments for documentation packaging, or embedding a future commit/report hash inside the report. A compact committed index pins source evidence; the post-commit external FINAL_CERTIFICATION.json and handoff carry the final package/report identity. Complete raw streams remain at their original local paths. Historical source and historical captures retain their distinct exact-byte/Git-identity treatment. + +Execution evidence: the original 300-second combined tiny group timed out and is excluded. Owned captures were short but pre-capture gaps accumulated, consistent with uninstrumented shared-mutex waiting; after process-identity and cleanup inspection, ordered subsets of 9, 9 and 17 controls completed under the same bound. PID reuse was distinguished by creation time rather than killing an unrelated later process. The first retained convenience driver failed on its own path-format expectation; its original failure is preserved, its successful child is separately revalidated, and a distinct canonical-path driver is used for the final retained pass. These are recorded failures and evidence scheduling decisions, not relaxed verdicts. + +Consequences: append the full row dispositions without rewriting frozen cells, commit the complete successor report and evidence consumers, then run final checks/claims and the inexpensive retained component against that clean package. All production/control source pins tested at the source freeze must remain identical. No Lean/C/ABI or public theorem change occurred; no DESIGN_DECISIONS.md entry is needed. The native consuming adapter, complete joint aggregate, fresh-blind campaign audit and coordinator acceptance remain downstream. + + +## WDD-20260921-LIFE-NATIVE-P0-R3-003: preserve pinned claim-tool selection across process environments + +Context: the first final-profile invocation on package a7b8566a44f9ff6d3e9c294f822937eaa76c3754 failed the unchanged historical-claim composition guard because the elevated shell resolved a WinGet ripgrep path ahead of the pinned Codex ripgrep. The source-phase process had resolved the pinned path. The actual child/launcher exited 1/1 and the final before/after source checks remained intact; no final profile from that attempt is credited. + +Decision: preserve the failed raw records and append the failure to the report/index. Use a separate local convenience driver that checks the original claim-context SHA256 and existing pinned ripgrep SHA256, then prepends only that directory to PATH in its disposable process and descendants. Keep the unchanged contract and claim producer responsible for verifying the actual resolved path, binary bytes and configuration. Commit this complete evidence disclosure before the final check/claim rerun. + +Alternatives rejected: weakening the exact path guard, substituting the other installed binary, changing any installed tool or persistent environment, concealing the failed attempt, or repeating the identical environment. The failure did not invalidate native/Lean evidence or justify an expensive full campaign. A fresh output directory preserves both attempts and source identity. + +Consequences: no production verifier, formal model, native implementation or policy change; this is an explicit process-environment and evidence-packaging decision. Final certification is still required on the resulting clean package. Source controls remain attributed to 6bcd1fc50020482ab441723a1964eec0232d223f; downstream adapter, aggregate, audit and acceptance obligations remain unchanged. + + +## WDD-20260921-LIFE-NATIVE-P0-R3-004: make pinned process-local tool discovery unique + +Context: package 9a15563f4231e79bb143ddbd885f6171811f94d2 passed all ten source checks, including full contract, hygiene, committed whitespace, whole-range and each-parent strict design, and clean HEAD. The protected claim-expectation producer then rejected multiple resolved ripgrep applications. The prior PATH prepend selected the right first executable but retained duplicate or alternate executable directories; the historical producer requires exactly one discovery result. + +Decision: retain both the failed producer and enclosing final-invocation records. In a separate disposable convenience process, remove PATH directories containing rg.exe and duplicate entries, insert the existing hash-checked pinned ripgrep directory once, and require exactly one resolved application at the pinned path. Run the failing expectation producer alone before another final package run. Its actual bounded diagnostic passed at claim-expectation-042b2d5a1b6b4cb4a26681d312fa2cd3 with complete raw captures. Preserve this diagnostic as a component, not final report coverage. + +Alternatives rejected: relaxing the unchanged producer's one-executable condition, changing the production script or installed tools, accepting the earlier checks receipt as final after report edits, or rerunning the same PATH unchanged. All edits to PATH exist only in the disposable process and descendants; the full final invocation still verifies actual rg path, hash, policy/config and scanned inputs. + +Consequences: the report/index now disclose both failed final attempts and the successful narrow diagnosis. No production/control-source bytes or native operations changed. The final package must receive fresh checks and claims, followed by retained revalidation and complete collection; source controls and downstream campaign limits retain their original attribution. + + +## WDD-20260922-LIFE-NATIVE-JOIN-001: private reviewed producer base for the consuming adapter + +Context: formal R2 7d247703a7009aa0f5faa1a9a67abf5f2ce526b6 and native prerequisite R3 8a74ad3af84feaf0ccea7185813ce8b55c50d96a have completed coordinator source/evidence review. The consuming adapter requires both. Their common base is bf31f983205175481fcb659caa4dfb70ef43e361; source paths are disjoint and only append-only design ledgers overlap. + +Decision: form one private unpublished two-parent preparation base, preserving every non-ledger blob from its producing parent. Preserve the common ledger prefix once, then the complete formal additions and complete native additions verbatim. No code, model, public theorem or policy choice is made by this mechanical join. Exact parent/blob/raw-byte checks and canonical skill preflight are retained in the external coordination packet. New checkout materializes Git bytes with command-local autocrlf=false; old raw receipts still resolve to their original producers, not this checkout. + +Alternatives rejected: launching the adapter on an incomplete sibling, modifying retired worktrees, silently rebasing historical evidence, or calling a private preparation join acceptance. No old heavy evidence is relabeled as a joint run. The adapter still needs its own frozen scope/controls, source review, complete final aggregate and fresh-blind exact-candidate audit. Main integration, push and destructive retirement remain unauthorized. + + +## WDD-LIFE-NATIVE1-01 - Freeze requirements before compilation and retain literal child evidence + +Date: 2026-09-23. Status: implementation workflow; certification pending. + +LIFE-NATIVE-1 starts at the exact reviewed private join with a successful +project-skill preflight and a clean private branch. START.json records the +actual runtime catalog and startup result; BASE_IDENTITY.json records raw and +Git identities of all 3844 predecessor tracked paths. The 55 ordered acceptance +rows and complete verbatim source spans are frozen before production editing. +Markdown line-break rendering is distinct from exact source UTF-8 bytes, which +are retained and hashed in CONTRACT_REQUIREMENTS.json. Evidence/status evolve +separately. The explicitly approved five-annotation source exception is stored +as CONTRACT_AMENDMENT_01.json without rewriting the frozen requirements. + +New build/replay scripts reuse the protected owned-process and literal-stream +helpers. Every compiler/native child gets a positive evidence-based deadline, +complete retained stdout/stderr bytes, ordinary-exit status, and timeout/limit +flags. The helper's returned line arrays are not literal stream evidence: +strict UTF-8 decoding and ordinal checks operate on the raw captures. Build +logs have no prescribed semantic output language; exact replay diagnostics do. +Integrity and disposable cleanup are independent finalization obligations. +A new wrapper registry does not reinterpret the old profile-specific registries. + +Heavy work acquires Local\RMQLifecycleImplementationHeavy20260920. The first +cold-dependency attempt found the slot busy and launched no child; a later +attempt after the authorized source amendment acquired it. The cold worktree +has a 2400-second dependency-build deadline, explicitly distinct from the +62-120-second historical warm lifecycle validation clue. Silence alone does +not trigger a restart. Root owns compilation while disjoint proof leaves edit +new module files; no leaf runs a competing Lean/Lake process. + +The verification order is frozen contract/scope, narrow Lean/export consumer, +generated initialization, bounded native startup, one exact selector, frozen +full native registry, then final report-sensitive checks. One default lake +build is assigned here; the full campaign aggregate and blind audit belong to +the coordinator and are not duplicated. Compact indexes are committed; complete +raw captures remain at exact ignored .lake/lifecycle-native1 paths. A completed +report precedes its final scope/design/claim certification, with external +receipt pins avoiding recursive report self-hashes. + +Alternatives rejected: copying predecessor whole-checkout pins onto the new +join, treating a busy slot as a build result, silently relaxing literal stream +checks, and accepting a route probe as the production owner. The local worker +may report CANDIDATE_COMPLETE only when every applicable frozen row closes. +The new lifecycle_native_identity/build/replay scripts consume these decisions; +no protected generic helper, policy, gate or registry is changed. + +## WDD-LIFE-NATIVE1-02 - Share checked staging within the native control campaign + +Date: 2026-09-27. Status: implementation workflow; certification pending. + +The first actual healthy control established a measurable orchestration cost: +the native process took 2.1593481 seconds, while its nested replay wrapper took +47.295414 seconds. The outer campaign had already pinned the complete source, +tool and artifact inputs and checked them again in finally. Spawning a complete +inner replay for each of 48 cases would repeat that same full inventory around +every short native call. The historical measurement is retained at +`.lake/lifecycle-native1/native-controls/20260927T045419192-8422f68f/RESULT.json`. + +The native-control runner instead stages one hash-identical testing client, +testing DLL and pinned Lean runtime together, checks their PE dependency closure, +and runs each declared control through that same C entry point. It holds the +shared heavy-work mutex for the campaign. Each actual native child retains its +own positive deadline, owned process tree, complete raw stdout/stderr, ordinary +exit and exact expected OBSERVED line. Full source/tool/artifact integrity is +checked before the campaign and independently in finally; environment and mutex +cleanup are separate obligations. Staged-file identity is part of the evidence. + +The ordered 48 challenges, direct C acceptance predicates, report projection +and root-review-before-verdict protocol remain unchanged. This orchestration +edit changes the runner fingerprint, so prior captures are historical and new +discovery must bind the revised runner before expectations can be frozen. +Caller/registry controls run again on the changed script. Root still reviews +actual state/resource differences before assigning rejection, acceptance or an +explicitly nondistinguishing outcome. + +Alternatives rejected were repeatedly hashing the same inventory per control, +removing integrity checks, replacing the actual C client with a synthetic +component, and weakening stream or timeout verdicts to compensate for setup +cost. The narrow runner reuses the unchanged generic stream, owned-process and +PE helpers. No protected policy or predecessor producer is modified, and no +native source or Lean theorem changes for this scheduling decision. + + +## WDD-LIFE-NATIVE1-03 - Bind final certification to report bytes and actual checker output + +Date: 2026-09-27. Status: local worker certification design. + +Execution receipts bind the frozen producing sources, while final scope, design +and claim checks must consume the final report, evidence matrix and decision +ledgers. Rebuilding an unchanged native DLL after prose edits would not establish +that second property. Conversely, a pre-report claim scan cannot certify prose +written later. The local final_checks helper therefore invokes the unchanged +production scope/design/claim checkers on the complete changed/new path roster, +including process records and frozen JSON evidence, then checks HEAD, the roster +and every consumed byte again. Strict design receives the exact assigned base. +A later committed pass also requires clean Git state and committed-range +whitespace. Report-sensitive edits require only these narrow checks to repeat; +unchanged native semantic campaigns are not repeated for separate report edits. +Comments inside pinned native source files are a different recipe boundary: +even an operationally inert comment correction changes those raw source pins. +The strict final-source contract therefore refreshes affected native producers +and consumers, while retaining the earlier measurements as historical evidence. + +The full ordinary exit and strict UTF-8 stdout/stderr of every child are retained +before deciding its verdict. Output validation reconstructs the scope receipt +line, design count line and source-authenticated claim findings from the pinned +checker/policy inputs; unrelated diagnostics cannot be accepted as self-supplied +expectations. The unchanged production scanner remains the classification +consumer. The scope receipt and its input identities are included in the final +record. Temporary Git advice/exclude overrides are confined to a fresh child; +they append to inherited entries so the sandbox's Git ownership context remains +intact. No repository or user configuration is edited. + +A separate default_build helper owns the required single final default Lake +build under the shared heavy mutex. Its compiler version is retained as exact +raw bytes, including the observed LF, instead of relying on legacy returned-line +normalization. Failed build captures remain indexed before any assertion throws. +Default build progress and warnings are a variable output language, distinct from +fixed semantic-rejection diagnostics; the complete bytes, ordinary exit, +timeout/overflow and independent source/tool integrity remain recorded. Cleanup +and integrity run independently even after partial setup. + +Alternatives rejected were treating parsed PASS text as the exit status, +accepting captured diagnostics as their own expected language, dropping failed +captures from result indexes, changing the protected claim policy, and embedding +self-referential commit/report hashes in the report. The external delivery +receipt instead pins the final commit, report bytes, source applicability and +final certification receipts after the local candidate commit exists. Coordinator +aggregate, blind audit, acceptance, integration and publication remain separate. + +The output-language controls also freeze their complete ID, handler, mutation, +verdict and diagnostic mapping before setup. Checking only the ordered names +would let a retained name dispatch to another harmless case while losing its +intended challenge. Actual disposable mapping mutations test that rejection. +Git whitespace and clean-tree checks require empty stdout and stderr through +the existing ordinal raw-stream predicate; cultural equality to an empty string +would accept a NUL-only diagnostic. These are constraints on the added wrappers, +not changes to the protected production scanner, policy or Git implementation. + +The refresh also exposed a distinct source-binding defect: named-property +sorting with `-Unique` over ordered-dictionary pins collapsed the native control +recipe to its first row. Individual file checks still ran, but the resulting +cross-run fingerprint did not bind all inputs. The corrected local recipe uses +explicit path keys, rejects conflicting duplicates, sorts complete key strings +ordinally and retains the exact recipe rows and counts. Sensitivity controls +change non-first records and test ordering and duplicate behavior through the +same recipe function. Reassigning the old hash or changing the expected native +projections would conceal the defect; neither is an acceptable repair. Old +measurements remain historical oracle data, and current full replay follows a +fresh discovery and independently reviewed binding of that unchanged oracle. + + +## WDD-LIFE-NATIVE1-R1 - Certify setup lifetime, exact registry strings and native closure + +Date: 2026-09-27. Status: repair implementation; local certification pending. + +Trigger: independent c52c453a2f0f49c568886f502687e4d0667838e9 review established +three required certification failures. Missing replay source escaped selector +setup finalization; cultural case-sensitive comparison accepted altered frozen +registry strings; Codec-only native builds certified three source modules while +Entry compilation consumed 365. The full default roots cover 371. These findings +concern promised verification boundaries and do not demonstrate an incorrect RMQ +answer or a stale default-target DLL. + +Decision: begin the selector runner's protected lifetime before evidence/scratch +acquisition, initialize a failure report first, and accumulate pins individually. +On setup failure the independent integrity, disposal and final receipt attempts +retain the original error and explicitly incomplete pin set. A cleanup failure +cannot turn the setup failure into success or suppress other finalization duties. +The actual owning runner receives missing-input and changed-pin-plus-missing-input +controls, with isolated fault injection and complete ordinary-exit streams. + +Both external native registries now compare every fixed textual field with an +explicit string-type check and StringComparison.Ordinal. The frozen expectation +cross-map additionally checks each exact ID/field/verdict, and complete normalized +projections compare ordinally. Hash spelling normalization remains separately +identified where the inherited interface permits hexadecimal case variation. +Actual Plan and Validate callers exercise healthy, ordinary corruption, middle +omission/duplication, matching middle-ID changes, NUL/soft-hyphen/BOM/zero-width +space and non-string fields. Strict output decoding was already correct and is +not a substitute for registry validation. Original 48/10 case mappings and +measured meanings remain immutable. + +The native builder computes the actual Entry closure before acquiring output +resources and rejects every native phase whose selected Lean closure omits a +compiled module. Lean-only focused compilation stays supported. The existing +source/generated/tool/cache checks then certify a superset of the actual native +closure. This guard was chosen over silently expanding a focused request because +it keeps the requested compilation domain explicit and preserves the unchanged +default route. The regression is the actual closure/preflight/receipt predicate; +it does not manufacture a stale DLL or count a rejected unsupported combination +as a compiler failure. + +Alternatives rejected: copied-detector tests instead of caller controls, complete +pin-set prerequisites on a failure whose cause is pin acquisition, merely moving +one hash while leaving acquisition unprotected, cultural case-sensitive equality, +pass-total-only closure, and reusing a focused proof receipt for a larger native +consumer. The four production repairs leave Lean/C/Rust/C++ semantics, old frozen +rows, shared helpers, prior captures and public claims unchanged. + +Evidence refresh follows actual consumed inputs. A fresh focused Lean receipt and +native DLL/client chain, startup, fixtures, ABI/client cases and full native +controls are required because the build and control scripts are pinned inputs. +Unchanged formal export/axiom and Rust misuse evidence requires explicit original +source/tool/generated applicability. New native expectations preserve the complete +old measured projections/verdicts but need an externally approved new recipe +binding before Replay. Pending coordinator approval is never self-assigned. +R1 scope/final wrappers preserve the exact four-script exception, fourteen-file +new roster, all original bytes and this ledger prefix; final design checks use +both c52 and 3db, and strict claim checking covers the original-base cumulative +surface including the final report. Aggregate and blind audit remain subsequent +coordinator gates. + +Exact sources: original audit packet native1-review-20260927/{DISPOSITION.md, +FAILURE_FEEDBACK.md,R1_SCOPE_REVIEW.md,SELECTOR_SETUP_REPRO.json, +MAPPING_CALLER_REPRO.json,BUILD_CLOSURE_REPRO.json} beneath +C:/Users/poin/Documents/RMQ/lifecycle-implementation-20260920. Fresh reproduction +and control receipts are indexed by docs/internal/extensions/lifecycle-native1-r1/ +COMMANDS.md and its final report. The original candidate remains the named failed +fixture; no historical evidence is overwritten. Publication significance is +reliable certification of this bounded native consumer, with model steps/payload, +foreign runtime assumptions and measured native resources still separate. + +## WDD-LN1-R1-CHECKOUT-20260927 - Preserve audited raw bytes in the fresh worktree + +The managed 4935 checkout was Git-clean at c52 but 64 tracked files had CRLF +conversion relative to the immutable audited 44d6 producer. The unchanged frozen +contract and selector registry hashes correctly rejected them. This blocked the +actual H1 reproduction before its intended lifetime boundary. All 3930 tracked +files were compared; exactly 64 differed, solely in line endings. Eight origin +files have audited mixed endings, so extracting Git blobs or generic normalization +would not reproduce their recorded raw identity. + +Coordinator CHECKOUT_DISPOSITION.md, SHA256 +8c6d80c15ce32fbe0fd64f2bcae78be3678d0e6cd88ca2ba2b90c9f9c67dd13d, +authorized only the independently reviewed 64 exact source-to-target copies. +Initial bytes/inventory were retained, both hashes checked before each write, +and the full post-restore inventory matched all 3930 original files. The first +finalization receipt failed because Git status retained representation-related +modified flags despite empty content diffs. Coordinator INDEX_DISPOSITION.md, +SHA256 235a3225b43cf9c6a366baaeffedeba94a46aa6a6200a4a175a5b6382a1c28c9, +authorized the separately tested bounded `git update-index --info-only --` over +only those 64 paths. The successful live operation preserved every staged entry +and flag, both diffs remained empty, and only owned new R1 files remained in status. +The index was backed up; the original worktree, object database, configuration and +policies were not modified. Initial and restored identities stay separate in the +R1 BASE_IDENTITY, with failed attempts retained under ignored restoration evidence. + +The approval documents are under the campaign native1-repair-launch-20260927 +folder. Successful finalization is .lake/lifecycle-native1-r1/ +restoration-final-authorized/RESULT.json. This bounded materialization exception +does not promise arbitrary default checkouts reproduce byte-pinned evidence. +Future audit/integration checkouts must establish the same raw identity. A general +line-ending policy, hash relaxation or repository configuration change is outside +this repair. The choice preserves the original evidence domain and implementation +scope rather than retroactively declaring converted bytes to be original bytes. + + +## WDD-LIFE-TOPOLOGY-01 - Certify documentary imports before expensive aggregate replay + +Date: 2026-09-28. Status: private coordinator repair; final gates pending. + +The final e13e6631 aggregate ran all 20 advertised checkers in 16302 seconds and +failed only paper topology lint and its regression. The local lifecycle headline +was explicitly importable in its producer's build but was not exported by the +repository-wide headline barrel used to check every documentary citation. A +locally complete producer report therefore remained incompatible with the final +repository import contract. This is a reusable verification-order miss, not a +new lifecycle proof or native ownership finding. + +The root retained the failed raw output, normal exit, restored source/index and +released mutex; it then reproduced both failed positive cases through the +unchanged production linter, and a virtual citation-removal control passed. The +original exact e13 case is the negative fixture. Preserve that failure and every +historical report. Do not let a later repair relabel the failed aggregate green. + +The new private repair owns only the broad headline barrel, its family-summary +import description and append-only DD/WDD entries. The former R1 four-script and +fourteen-new-file scope is historical and is not silently widened. An explicit +source applicability bridge must show that all 55 frozen rows, original source, +native producer recipe and approved 48-case expectations survive this successor. +No expectation rebinding or native semantic replay is justified merely by a +barrel import outside the native producer's dependency closure. + +Run focused actual headline/default builds and unchanged documentary lint plus +the full 16-case regression on a clean private commit before one final aggregate +on the unchanged tree. Reuse an independent copied cache, never producer evidence +directories or concurrent owners. Fresh-blind full lifecycle audit follows the +successful aggregate; the repair and coordinator reviews are not that audit. +This scheduling rule and evidence bridge replace an expensive blind full retry; +checker policies, all cases and deadlines remain unchanged. Campaign evidence is +in lifecycle-implementation-20260920/native1-final-aggregate-20260928 and +native1-topology-repair-20260928. No main integration, publication or push. + + +## WDD-20260929-LIFE1-R3-01 - Freeze the failure-path integrity contract before touching harnesses + +Date: 2026-09-29. Status: LIFE-1-R3 worker decision; coordinator acceptance pending. + +Context. The fresh blind audit of lifecycle candidate eb8e4f25 found one P2 +workflow defect (F1): the formal control orchestrator +`lifecycle1/repair-r1/run_controls.ps1` compared its entry source pins with the +live tree only on the success path, and its `finally` wrote the entry pins into +`summary.json` as if they were verified. A coordinator sibling review widened the +same defect class to eight more committed harnesses in this lane. The repair +contract (LIFE1_R3_FINALLY_INTEGRITY.md, SHA-256 552fe34f...) fixes the property +per harness: on every exit path, cleanup runs, every entry pin and tree snapshot +is compared independently, the stage error, every integrity difference and every +cleanup error are recorded separately in an always-written durable result, and +the verdict fails when any is non-empty. + +Decision. Create `lifecycle1/repair-r3/ACCEPTANCE_MATRIX.md` as the first edit of +the branch. Inherited rows are referenced, not restated: each is identified by its +frozen source file, line and exact row SHA-256 at the base, so the matrix cannot +drift from the frozen matrices it cites. The nine R3/REPLAY requirement texts are +copied mechanically from the prompt bytes. Evidence, dispositions and the command +ledger are append-only below a marker. + +Alternatives rejected. Restating inherited rows by hand would create a second +copy that could silently diverge from the frozen blobs. Writing evidence into the +row cells would make the frozen rows mutable. + +Consequences. Every later commit on this branch must leave the rows above the +marker byte-identical; row closure is argued only in the appended evidence. +No theorem, Lean, native, frozen matrix or frozen registry changes. + +Evidence. Row identities are listed in the matrix; the generator asserted the +prompt SHA-256 and that no inherited row ID is missing or duplicated. + + +## WDD-20260929-LIFE1-R3-02 - Whole-harness failure-path controls in disposable copies + +Date: 2026-09-29. Status: LIFE-1-R3 worker decision; coordinator acceptance pending. + +Context. REQ-L1R3-CONTROLS requires committed P/C/Q/S/M controls per repaired +harness that run the whole harness file, not a copied detector, in a disposable +copy with only the minimal injected stage or test double, fixed before entry pins +are taken, and that first show the unchanged base harness fails them. + +Decision. Add `lifecycle1/repair-r3/failure_controls.ps1` with the exact ordered, +versioned `FAILURE_CONTROL_REGISTRY.json` (47 controls: P/C/Q/S/M for nine +harnesses, K1-X for an owned-process exception, HS-R for a dirty owned carrier). +For each control the runner materializes the harness's inputs under +`.lake/life1-r3/controls/...`, takes the harness bytes from an exact Git ref +(`base` = eb8e4f25, otherwise the candidate commit), git-initializes the copy so +tree snapshots stay inside it, places one test double, and launches the whole +harness through the unchanged `scripts/owned_process_tree.ps1` with a positive +deadline. The doubles are: a replacement handler child, a stage script, an +in-process dependency-replay double, a compiled validator executable, a fault +hook inside the production `Write-Json` used by the finalizer control, and +function wrappers appended to disposable copies of the stream-capture and +integrity helpers. Each injects one fault at most once, selected by environment: +change a pinned file, change it and fail, delete it and fail (so the harness's +own integrity step raises), or dirty an owned carrier and fail. +The runner evaluates mode-independent core predicates (completed owned launch, +exit class, durable result present, stage error and integrity difference recorded +as exact text groups in string values of that durable result) and, for the +candidate, the structural finalization contract (separate stageError, +integrityErrors and cleanupErrors fields, verdict, every pin verified for P). +Base mode compares observed outcomes with predictions written from source before +the run, and accepts a base rejection only when the same harness's P control +passed in that run. After every control the runner restores the disposable copy +from pristine bytes, verifies the exact manifest and a clean copy Git state, and +in its own finally re-checks its inputs and the real worktree Git state. +`selector_controls.ps1` launches the runner at its real parameter boundary for +omitted, valid, empty, empty-array, whitespace, malformed, unknown and duplicate +selectors and for registry copies with an omitted, duplicated or unknown middle +ID, a reordering, byte drift and an empty registry. A third ref value, `worktree`, reads the nine harness files from the working tree +for the development loop only; its receipts record that mode and are never cited +as candidate evidence. `heavy_run.ps1` wraps any +multi-minute command in the fixed global-then-lane mutex order and always writes +RESULT.json. + +Alternatives rejected. Copying only the finalization code into a detector would +not show that the real harness reaches it; editing harness bytes to inject faults +would test a different file; injecting faults from a concurrent process would be +nondeterministic; mutating tracked files would risk the real worktree. + +Consequences. The controls are component/failure-path tests of harness control +flow with real owned processes; they are not semantic or native campaigns. +Harnesses that take the lane mutex themselves are launched without the runner +holding it; for the others the runner holds the lane mutex around the launch. + +Evidence. Base and candidate receipts are committed under +`lifecycle1/repair-r3/receipts/` and indexed in the R3 acceptance matrix. + + +## WDD-20260929-LIFE1-R3-03 - Record base reproductions before repairing + +Date: 2026-09-29. Status: LIFE-1-R3 worker decision; coordinator acceptance pending. + +Context. REQ-L1R3-CONTROLS requires that the P/C/Q/S/M shapes first run against +the unchanged base harness so that each control is shown to discriminate. + +Decision. Run the committed runner in base mode on both declared shells and the +selector/registry controls before any harness byte changes, and commit their +complete receipts (run RESULT.json, heavy-wrapper RESULT.json and every +control's durable result, normalized to LF) under `repair-r3/receipts/`, with the +per-harness failed clauses appended to the R3 acceptance matrix. Predictions of +which shapes the base fails were fixed in the registry from source reading before +the run; a base rejection counts only when the same harness's P control passed. + +Alternatives rejected. Repairing first and reconstructing the base behaviour +from source alone would not show the controls discriminate; keeping receipts only +under ignored `.lake` would lose them to host cleanup. + +Consequences. 47/47 base predictions matched on pwsh 7.6.5 and Windows +PowerShell 5.1; the only already-satisfied shape is the finalizer control's +changed-pin success path. Development-loop runs that preceded these (a registry +component-byte recipe error and missing-file message wording) are not evidence +and are not committed. + + +## WDD-20260929-LIFE1-R3-04 - One finalization shape for the nine lifecycle harnesses + +Date: 2026-09-29. Status: LIFE-1-R3 worker decision; coordinator acceptance pending. + +Context. Each of the nine named harnesses had at least one exit path on which +entry pins were never compared with the live state, a cleanup or integrity throw +replaced the original error, or no durable result was written. The committed +base-mode control receipts reproduce every listed defect class (see the R3 +acceptance matrix evidence). + +Decision. Every repaired harness now follows the same local shape, written +inline in each file rather than through a new shared helper: +(1) pre-evidence argument, selector and frozen-registry validation stays exactly +where it was and still launches nothing and pins nothing; (2) once the harness's +own evidence location exists, all setup (helper dot-sourcing, entry pins, tree +snapshots, child generation) runs inside one `try`; (3) `catch` keeps the +original error record as the stage error; (4) `finally` runs each cleanup step +in its own guard, then compares every captured entry pin (and tree snapshot) +with the live state in its own guard, continuing past the first difference or +exception, and records a pin that was never captured as `not-captured` rather +than comparing it; (5) the durable result (summary/result/receipt/RESULTS/ +RESULT json) is always written with a `finalization` block +(`life1-r3-finalization-v1`: verdict, stageError, integrityErrors, +cleanupErrors, pinChecks with entry and final hashes and a status) and its own +write failure is reported on stderr without replacing the first error; (6) after +`finally`, extra integrity/cleanup errors go to stderr and the original stage +error record is rethrown unchanged, so every existing diagnostic surface that +frozen cases compare (selector rejections, validator stage errors, the +integrity-controls stream contract) is byte-identical when integrity holds. +Summaries now name entry pins as entry pins (`entrySourcePins`, +`entrySources`, `entryInvocation`); verified state lives only in `pinChecks`. +`run_check.ps1` keeps its transparent child exit code and adds exit 3 for an +integrity or cleanup failure. `lifecycle_validator.ps1` compares identity +before releasing its slot, reports every changed path and writes RESULT.json on +every exit after its log root exists. `integrity_controls.ps1` pins every live +source it reads or copies, checks each fixture restoration step's exit code and +keeps restoration errors separate from the case error. `harness_stream_controls.ps1` +pins the live sources it copies into carriers and status-checks every created +carrier and fixture in finally. `dependency_controls.ps1` re-checks every captured +installed-tool pin (including a partial inventory), its historical inputs and +the owned fixture in finally. + +Alternatives rejected. A shared dot-sourced finalization helper would add a new +pinned dependency to nine old harnesses and redesign the harness framework, +which the contract forbids. Throwing a combined message would change existing +failure surfaces that frozen selector cases compare exactly. + +Consequences. No case, expected verdict, diagnostic, frozen registry or pin +value of another artifact changes. The nine files' raw bytes now differ from the +historical per-branch inventories (lifecycle1 SOURCE_FREEZE/EVIDENCE_INDEX and +lifecycle-native1 BASE_IDENTITY); those records describe their historical bases +and remain unchanged, and their branch-bound scope checkers are not rerun on +this branch. + +Evidence. Candidate control receipts and the re-run campaigns are committed +under `lifecycle1/repair-r3/receipts/`. + + +## WDD-20260929-LIFE1-R3-05 - Candidate controls, and an incomplete run is not a failed or passed run + +Date: 2026-09-30. Status: LIFE-1-R3 worker decision; coordinator acceptance pending. + +Context. The repaired harness commit a2e40779 was run through the unchanged +runner on both shells. The first Windows PowerShell run was terminated by its +own wrapper deadline after a five-hour gap with no activity between two +consecutive control steps, consistent with host suspension. + +Decision. Commit the complete receipts of the passing runs and, separately, the +wrapper receipt of the terminated attempt labelled incomplete. Retry only after +confirming that no owned process survived, with a fresh output root and no change +to harness, runner or registry bytes; the material change is the host state, +evidenced by the directory timestamps. + +Alternatives rejected. Treating the timeout as a failed control would claim a +semantic result nobody observed; silently discarding it would hide a real event +in the verification history; raising deadlines would not address suspension. + +Consequences. Candidate evidence: 47/47 on pwsh 7.6.5 and 47/47 on Windows +PowerShell 5.1, with all structural finalization predicates, plus 15/15 selector +and registry controls. The runner cannot write its own result when it is killed +from outside; that limit is recorded, and the wrapper's result stands in for it. + + +## WDD-20260930-LIFE1-R3-06 - Materialize exact blob bytes of three LF-pinned inputs for the frozen campaign + +Date: 2026-09-30. Status: LIFE-1-R3 worker decision; coordinator acceptance pending. + +Context. The frozen 67-case control registry pins CONTROL_REGISTRY(.frozen).json +and finalizer_cases.json by the SHA-256 of their LF Git blobs, but pins +selector_cases.json and dependency_boundary_cases.json, and the finalizer control +pins scripts/owned_process_tree.ps1, by their CRLF checkout bytes. The historical +campaign worktree had exactly that mixed materialization. This checkout uses +core.autocrlf=true, so run_controls.ps1 correctly rejects the CRLF registry. +The fresh blind audit met the same boundary and restored only those JSON bytes in +its disposable tree. + +Decision. Before the campaign, `repair-r3/materialize_registries.py` writes the +exact Git blob bytes of only those three files into this checkout, after proving +each CRLF-normalized working text equals its blob and each blob has the frozen +hash, and proves `git status` is unchanged. It writes a JSON receipt. + +Alternatives rejected. Relaxing any pinned hash or normalizing inside the harness +would weaken a frozen check; changing repository line-ending configuration would +affect other worktrees; re-freezing the registry is forbidden. + +Consequences. Git content is unchanged; only the checkout representation of three +frozen inputs matches the one they were frozen in. A default CRLF checkout still +needs this step before replaying the frozen campaign. + + +## WDD-20260930-LIFE1-R3-07 - Prove materialization by content, not porcelain status + +Date: 2026-09-30. Status: LIFE-1-R3 worker decision; coordinator acceptance pending. + +Context. The first run of materialize_registries.py (c6d94ad0) wrote the three +exact blob byte strings, but `git status` then reported them modified at stat +level although `git diff` was empty and `git hash-object` equalled the index +blob; the script correctly refused and wrote no receipt. The files were restored +by `git checkout --` before any campaign ran. + +Decision. The receipt now proves identity by an empty `git diff --exit-code` over +the three paths and per-path equality of `git hash-object` with the index blob, +recording both porcelain states. A `--restore` mode re-checks-out the three paths +after the campaign and requires a clean status for them, so the branch ends with +a clean tree. + +Alternatives rejected. `git update-index` flag surgery would change index state +for a representation artifact; accepting a status change without the content +proof would not show the Git content is unchanged. + +Consequences. The campaign's frozen inputs are exact blob bytes during the run and +the checkout representation is restored afterwards. + + +## WDD-20260930-LIFE1-R3-08 - Repair a newline literal collapsed while generating the restore mode + +Date: 2026-09-30. Status: LIFE-1-R3 worker correction; coordinator acceptance pending. + +Context. Commit 4a2a56d5 generated the `--restore` branch of +materialize_registries.py through a shell here-document; two escaped newline +literals were collapsed into real line breaks, leaving a Python syntax error +(no carriage return was introduced). The script failed to compile before doing +anything. + +Decision. Replace the two literals with `chr(10)`, compile-check the file, scan +it for carriage returns, and only then run it. The exact committed bytes are the +ones that produced the campaign materialization receipt. + +Consequences. Commit 4a2a56d5 remains in history as a non-functional +intermediate; no evidence was produced by it. Generated source is compile-checked +before it is committed for the rest of this branch. + + +## WDD-20260930-LIFE1-R3-09 - Re-run the lane campaigns through the repaired harnesses + +Date: 2026-09-30. Status: LIFE-1-R3 worker decision; coordinator acceptance pending. + +Context. REQ-L1R3-CAMPAIGNS requires fresh evidence produced by the repaired +harnesses: the frozen control registry on both declared profiles through the +repaired repair-r2 run_check.ps1, the validator's standard modes, and the normal +full run of each repaired lifecycle-native-p0 harness. + +Decision. Run each campaign as one repaired run_check.ps1 spec (mutex false, +because each harness owns the lane mutex itself and a nested acquisition would +deadlock) under heavy_run.ps1 holding the global mutex, and commit complete +receipts plus a machine summary. The p0 integrity and dependency harnesses run +through their existing run_owned.ps1 wrapper, whose unchanged stream contract +also validates the repaired harness output. + +Alternatives rejected. Holding the lane mutex in the wrapper would block every +case of run_controls for two hours; running harnesses directly would skip the +repaired run_check finalization being certified. + +Consequences. 67/67 and 66/66 frozen cases, six validator runs, 15/15, 19/19 and +11/11 p0 controls passed with finalization verdict pass and every entry pin +verified. The p0 harnesses have no Windows PowerShell campaign; that is recorded +as not run. + + +## WDD-20260930-LIFE1-R3-10 - Close the R3 rung with a returned report and final dispositions + +Date: 2026-09-30. Status: LIFE-1-R3 worker decision; coordinator acceptance pending. + +Context. The contract names `repair-r3/REPORT.md` as the durable completion +artifact, but this worker's runtime refused to write a report file at that path +and instructs the worker to return the report as text; the coordinator's runtime +adaptation says to report the refusal verbatim and return the report with its +byte length and SHA-256 rather than work around the refusal. + +Decision. Append the final check results and worker row dispositions to the R3 +acceptance matrix, return the complete report text to the coordinator for +persistence, and state that the status is INCOMPLETE pending coordinator +certification, continuation audit, integration with main and CI. + +Alternatives rejected. Writing the report through a shell command would evade the +runtime's refusal; claiming candidate completion would overstate the remaining +coordinator-owned phases. + +Consequences. The branch tip carries every receipt and the matrix; the report +bytes are identified by the hash given in the handoff. + + +## WDD-20260930-LIFE1-R3-11 - Commit the coordinator-persisted R3 report + +Date: 2026-09-30. Status: coordinator decision; coordinator acceptance pending. + +Context. WDD-20260930-LIFE1-R3-10 records that the worker runtime refused the +report write and returned the report text with its byte length and SHA-256. The +coordinator recovered the text from the worker transcript and confirmed 11,450 +bytes and SHA-256 69eed604f6e4fd74b008c920b08f6cceeea0a5e9455bc4d34005239705c45810 +before writing it. + +Decision. Commit exactly those bytes at `repair-r3/REPORT.md`, the durable +completion artifact the contract names, without editing them. The worker's +status inside the report (INCOMPLETE pending coordinator certification) is left +as written; coordinator verification and the continuation audit are recorded +outside the report. + +Alternatives rejected. Leaving the report only in the coordinator directory would +leave the branch without its contracted artifact; editing it to reflect later +coordinator steps would make its bytes differ from the hash in the handoff. + +Consequences. The branch tip carries the report whose identity matches the +worker handoff; the delta scope is unchanged (repair-r3/** plus this append). + + +## WDD-20260930-LIFE1-R4-01 - Freeze the R4 contract before reproducing or repairing anything + +Date: 2026-09-30. Status: LIFE-1-R4 worker decision; coordinator acceptance pending. + +Context. The fresh blind delta audit of LIFE-1-R3 (LIFE-1-R3-A1) found one P2 +(both run_check.ps1 files record `finalization.verdict = "pass"` when the child +stage fails or times out) and seven P3 items. The R4 contract closes P2-1 and +P3-1, P3-2, P3-3, P3-5, P3-6 and P3-7, defers P3-4, and requires every R3 row to +be re-established on the R4 tip. It asks for the matrix before any other edit and +for a base reproduction of P2-1 before the repair. + +Decision. Create `repair-r4/ACCEPTANCE_MATRIX.md` as the first edit. The nine R4 +requirement texts are copied mechanically from the contract bytes (lines 37-45, +the text after the ID and its audit tag), and a self-check asserts each appears +byte-for-byte in the table. The thirteen inherited R3 rows are referenced by the +exact line, byte length and SHA-256 of their table line in +`repair-r3/ACCEPTANCE_MATRIX.md` at 695a7e72, the frozen commit the contract +names, rather than restated. The P2-1 reproduction is run after this commit, on +unchanged base harness bytes, by a committed probe, which reconciles "matrix +first" with "reproduce before repair". + +Alternatives rejected. Restating the inherited rows would create a second copy +that could drift from the frozen source. Running the probe before the matrix +would make an uncommitted experiment the reproduction evidence. + +Consequences. Every later commit appends evidence below the marker only; the +frozen block is an exact byte prefix and its row identities can be rechecked +from Git objects. + + +## WDD-20260930-LIFE1-R4-02 - Reproduce P2-1 on the unchanged base with a committed probe + +Date: 2026-09-30. Status: LIFE-1-R4 worker decision; coordinator acceptance pending. + +Context. The auditor reproduced P2-1 with a disposable probe under `.lake`; +the R4 contract asks for a committed-quality reproduction on the unchanged base +before the repair, and for reproductions of the other in-scope items where +feasible. + +Decision. Commit `repair-r4/base_probe.ps1`, a probe with an exact ordered case +list and no selector. Each case exports the exact harness blob of the named ref, +copies it with the unchanged owned-process helper into a git-initialized +disposable root, launches the whole harness file through the helper with a +positive deadline and reads its durable result. `-Expect defect` requires every +case to show the audited defect; `-Expect repaired` requires the repaired shape, +so the same committed probe is later rerun at the R4 tip. Cases: child exit 7 +with intact pins (K1, K2), a 30 s stage under a real 3 s owned deadline (K1, K2), +a durable-write failure in K2 (P3-1), and the validator without its pinned +executable (P3-3). A small `collect_receipts.py` copies evidence into +`repair-r4/receipts//`, stores CRLF-written text as LF, refuses a lone CR, +records source and committed hashes in INDEX.json and never overwrites a receipt. + +Evidence. At d27ffa34 (pwsh 7.6.5, 31 s): 6/6 cases show the defect. Both +run_check files write `verdict: "pass"` beside `childFailure` for exit 7 and for +the helper timeout (process exit 2, `result.TimedOut = true`); the K2 +durable-write failure exits 0 with only a stderr line; the validator without its +executable exits 1 with no RESULT.json. + +Alternatives rejected. Reusing the auditor's probe would not be committed +evidence; waiting for the extended control runner would place the reproduction +after the repair it motivates. P3-2 (coverage), P3-5 (labels), P3-6 (ordering) +and P3-7 (unowned git) are reproduced from source here and by base-mode R4 +controls or static controls at d27ffa34 once those exist, because each needs a +test double or AST check that belongs to the control runner. + +Consequences. The probe is replayable on any ref, and it is the before/after +witness for P2-1 independent of the control runner. + + +## WDD-20260930-LIFE1-R4-03 - One overall verdict, a failing durable write, and owned finalization git in the nine harnesses + +Date: 2026-09-30. Status: LIFE-1-R4 worker decision; coordinator acceptance pending. + +Context. After LIFE-1-R3 the nine lifecycle harnesses record stage, integrity +and cleanup errors separately, but the fresh blind delta audit found: both +run_check.ps1 files compute `finalization.verdict` without the child outcome +(P2-1); every durable-result write failure only prints to stderr and can leave +a PASS line or PASS.json (P3-1); the validator checks its pinned executable +before its evidence root (P3-3); integrity_controls and harness_stream_controls +publish entry pins under keys that at eb8e4f25 held post-run pins (P3-5); the +run_check files and run_controls' per-case slot release the lane mutex before +the integrity re-check (P3-6); and the finalization git calls added by R3 are +not owned (P3-7). + +Decision. +- run_check (r1, r2): `verdict` is the overall verdict and includes + `childFailure` (child exit != 0, timeout, output limit); a malformed or unowned + helper result (non-integer exit, unknown ownership, terminated IDs on a + completed run) is raised as a stage error. The exit mapping is unchanged + (child exit; 2 timeout/overflow; 3 integrity or cleanup; 1 harness + exception); a durable-write failure that would otherwise exit 0 exits 1. +- Every durable write failure (all nine harnesses) now marks the run failed: + nonzero exit, no PASS line, and the validator writes PASS.json only when + RESULT.json was written; the write error is still printed and the first error + is still rethrown first. +- The validator's pinned-executable check moves inside the evidence region, + after the identity capture, so a missing executable yields RESULT.json with + the unchanged diagnostic and every other captured pin re-verified. The other + pre-root checks (argument, selector and registry validation, including the + registry and runtime-profile reads that validate the arguments) stay before + the root: they launch and pin nothing, and REPLAY-EXACT-REGISTRY requires + them to reject before any execution. +- integrity_controls adds `entrySource`/`entryHelper` and harness_stream_controls + `entryRegistry`/`entrySource`/`entryValidator`; the old keys again carry the + post-run pin read in finalization (their eb8e4f25 meaning), or null. +- Both run_check finally blocks re-check every pin before releasing the mutex; + run_controls re-checks every captured pin in each case's finally before + releasing that case's slot and records the result in + `finalization.caseSlotChecks`. +- repair-r2 run_check reads HEAD (entry and final) and harness_stream_controls + reads carrier/fixture status through Invoke-RMQOwnedBoundedProcess with a + 60 s deadline; exit, streams, timeout and overflow are recorded + (`finalization.gitProcesses`, `finalization.ownedRootStatus`) and any failure + is an integrity error (a stage error at entry). + +Alternatives rejected. Renaming the IC/HS keys outright (as run_controls and +run_check did) would make the dormant lifecycle-native-p0 verifiers +(repair-r2/verify_results.py `integrity_results`/`verify_harness`, reused by +repair-r3/verify_contract.py) raise KeyError on current outputs; restoring the +old keys to their original post-run meaning satisfies "no top-level key presents +an entry value as verified" and keeps every reader on retained keys. Renaming +`verdict` to an integrity-only field would leave two meanings of one schema. +Owning only the final HEAD read would compare two differently produced strings. + +Consequences. Case semantics, expected verdicts and diagnostics are unchanged; +the frozen control registry and the lane's stream contracts see identical +stdout. Controls for each change follow in the extended control registry. + + +## WDD-20260930-LIFE1-R4-04 - Keep the missing-executable diagnostic ahead of helper loading + +Date: 2026-09-30. Status: LIFE-1-R4 worker correction; coordinator acceptance pending. + +Context. WDD-20260930-LIFE1-R4-03 moved the validator's pinned-executable check +inside the evidence region but left it after the two helper dot-sources. The +committed base probe (`-Expect repaired` at 5fbc1c99) caught the consequence: +in a root without the environment helper the run wrote RESULT.json, but its +stage error was the dot-source failure, not the missing-executable diagnostic +that at d27ffa34 preceded every other check. + +Decision. Order the validator's try block as: capture every identity pin (pure +hashing, no helper), write identity-before.json, check the executable with the +unchanged diagnostic, raise any other identity failure, then load the helpers. +The executable check keeps its base precedence over helper loading, and every +pin captured before any failure is re-verified in finally. + +Alternatives rejected. Adding the environment helper to the probe root would +hide the precedence change instead of removing it. Checking the executable +before the identity capture would leave the other identity pins uncaptured on +this path. + +Consequences. A missing dot-sourced helper is now reported as an identity +failure at entry (the file is itself an identity path) rather than a +dot-source error; both are stage errors naming the path, and no control or +frozen case depends on that wording. + + +## WDD-20260930-LIFE1-R4-05 - Version the failure-control runner and add discriminating R4 controls + +Date: 2026-09-30. Status: LIFE-1-R4 worker decision; coordinator acceptance pending. + +Context. The R4 contract requires controls that fail at d27ffa34 and pass at the +R4 tip for the run_check verdict (ordinary child failure, and a real +harness-level deadline), a durable-write failure, a cleanup/restoration +exception, the validator's missing executable, and a stronger setup-failure +predicate; it lets the R3 runner files change only through a versioned change +that keeps every R3 receipt byte-identical and the R3 v1 registry replayable. + +Decision. +- Registry versioning. `repair-r3/failure_controls.ps1` now accepts exactly two + pinned registries, selected by schema and version: the unchanged R3 v1 + registry (default; 47 controls; base eb8e4f25) and a new v2 registry at + `repair-r4/FAILURE_CONTROL_REGISTRY.json` (normalized SHA-256 + cf5ef090543773ef0a4fa473164e56633fabeef140301aad737bb2a7a3226dbc; 60 controls; + base d27ffa34), generated by the committed `repair-r4/make_registry.py`. The + 47 R3 control objects are copied from the exact d27ffa34 blob; their + `baseExpectation` is re-derived for the new base (accept, because the nine + harness blobs at d27ffa34 equal those of the R3 candidate runs) with the R3 + value kept as `r3BaseExpectation`, and the nine S controls gain + `expect.capturedPins`, derived from each harness's capture order. +- Thirteen R4 controls: K1-F/K2-F (child exit 7, pins intact, verdict must be + fail), K1-T/K2-T (60 s stage under a real 3 s owned deadline), K1-W/K2-W/LV-W + (durable path made a directory: nonzero exit, no durable file, no PASS.json or + PASS line), IC-U (an exclusive lock held until exit makes the fixture + restoration throw inside cleanup), LV-E (missing validator executable), IC-L + and HS-L (a labelled pin changes: entry value only under entry*), K2-G and + HS-G (a compiled git double on PATH hangs or fails during finalization). +- Predicates live in `repair-r4/predicates.ps1` (Test-R4PinCoverage, + Test-R4Labels, Test-R4Values), dot-sourced by the runner and exercised by + synthetic mutation cases. Pin coverage now requires every captured pin to be + re-verified, the captured count to equal entryPinCount and, for setup-failure + shapes, the registry count; it applies to v1 and v2 alike (a strengthening). +- The R3 doubles gain modes (sleep, block-durable, git-hang, git-fail, + lock-cleanup, and block-durable in the validator double); the R3 modes are + unchanged. `selector_controls.ps1 -RegistryVersion v2` replays the same + fifteen selector/registry cases against v2; v1 remains the default. +- `repair-r4/aux_controls.ps1` adds static ordering controls on exact blobs + (P3-6: every integrity recording precedes the first ReleaseMutex in each + releasing finally), heavy_run.ps1 write-failure controls, and the synthetic + predicate controls. heavy_run.ps1, failure_controls.ps1 and + selector_controls.ps1 fail when their own durable write fails. + +Alternatives rejected. A separate R4 runner would duplicate 550 lines and leave +the R3 runner's own durable-write defect; editing the v1 registry would break +its pinned identity and the R3 receipts' meaning. A behavioural ordering control +would have to contend for the live lane mutex (the runner itself holds it for +the run_check controls), so ordering is certified statically on Git blobs. + +Consequences. v1 stays replayable at this tip; v2 base mode runs at d27ffa34 +and candidate mode at the R4 tip. + + +## WDD-20260930-LIFE1-R4-06 - Record the control receipts and repair a synthetic-fixture defect in the auxiliary controls + +Date: 2026-09-30. Status: LIFE-1-R4 worker decision and correction; coordinator acceptance pending. + +Context. With the harnesses and runners fixed at d9411a7d, one sequential queue +under the global mutex ran: the v2 registry in base mode at d27ffa34 on pwsh 7 +and Windows PowerShell 5.1; the v2 registry in candidate mode at d9411a7d on +both shells; the unchanged R3 v1 registry at d9411a7d on pwsh (replayability); +the selector/registry controls for v1 and v2; the auxiliary controls at +d27ffa34 and d9411a7d; and the base probe with `-Expect repaired` at d9411a7d. +Everything passed except the auxiliary candidate run: PRED-PIN-GOOD was +rejected with "captured pin not re-verified: d status not-captured". + +Diagnosis. The fixture, not the predicate: the synthetic row builder typed the +entry hash as `[string]`, and PowerShell coerces `$null` to `''` for a string +parameter, so the uncaptured row looked captured. The rejection cases then +passed partly for that unintended reason. No real harness writes an empty entry +hash (all 47 R3 and all 60 R4 durable results use JSON null), and the runner's +evaluation of real results is unaffected. + +Decision. Keep the pinned predicate unchanged (the candidate control runs used +it), make the builder's entry/final parameters untyped, and require each +synthetic case to match both the expected verdict and the exact first violated +clause, so a rejection for an unintended reason fails. Both auxiliary runs are +kept as `*-attempt1*` receipts and rerun with the corrected script. Receipts +are collected with `collect_receipts.py` (LF, indexed, append-only). + +Evidence. Base v2: 60/60 predictions matched on each shell (the thirteen R4 +controls: eleven base rejections, IC-U accepted as predicted, K2-G hung until the +180 s control deadline). Candidate v2: 60/60 on each shell. v1 at the candidate: +47/47. Selector/registry: 15/15 for v1 and 15/15 for v2. Probe at d9411a7d: +6/6 in the repaired shape. Every control restored and verified its copy, and +the real worktree Git state was unchanged across each run. + +Consequences. The candidate harness and runner bytes stay those of d9411a7d; +only the auxiliary control script changes in this commit. + + +## WDD-20260930-LIFE1-R4-07 - Rerun the auxiliary controls with the corrected fixture + +Date: 2026-09-30. Status: LIFE-1-R4 worker decision; coordinator acceptance pending. + +Context. WDD-20260930-LIFE1-R4-06 corrected the auxiliary synthetic row builder +and made each synthetic case pin its first violated clause. + +Decision. Rerun the committed auxiliary controls under the global mutex: at +d27ffa34 with `-Expect base` and at 9a21a547 with `-Expect candidate`, and +record both as receipts next to the attempt-1 receipts. + +Evidence. Base: 17/17 as predicted (ORD-K1, ORD-K2 and ORD-RC find a mutex +released before any integrity recording, ORD-LV passes, HR-W exits 0 with its +success line although RESULT.json was not written, the predicate cases are not +applicable because repair-r4/predicates.ps1 does not exist at d27ffa34). +Candidate: 17/17 (every ordering holds, HR-W exits 1 without a success line, +every synthetic case matches its verdict and exact reason; the transcribed R3 +predicate accepts all four pin-coverage mutations the R4 predicate rejects). + +Consequences. The auxiliary evidence is produced by the committed corrected +script; the next step is the lane campaign queue. + + +## WDD-20260930-LIFE1-R4-08 - Re-run the lane campaigns through the R4 harnesses, now on both shells for the p0 harnesses + +Date: 2026-09-30. Status: LIFE-1-R4 worker decision; coordinator acceptance pending. + +Context. REQ-L1R4-CAMPAIGNS asks for the complete frozen control registry +(67 cases on pwsh, 66 on winps) through run_controls.ps1 invoked by repair-r2 +run_check.ps1, the validator's startup, single and full modes on both shells, +and the normal full run of each lifecycle-native-p0 harness on pwsh and, where +the harness supports it, on winps. + +Decision. Run one sequential queue at 2802b84d, whose nine harness blobs and +runner files equal d9411a7d: materialize the three LF-pinned frozen inputs with +the unchanged repair-r3/materialize_registries.py, run fourteen campaigns, each +as a repaired repair-r2 run_check.ps1 spec (`mutex: false`) under +repair-r3/heavy_run.ps1 holding only the global mutex, because every campaign +harness takes the lane mutex itself (run_controls per case, the validator, +run_owned for integrity and dependencies, harness_stream_controls), then +restore the checkout representation. The p0 harnesses run on Windows +PowerShell 5.1 as well, because the R3 and R4 control runs show all three run +under 5.1. + +Evidence. Every run_check finalization passed with 17/17 pins verified and a +global-mutex wait of at most 0.006 s. Frozen registry: 67/67 (pwsh, 273.4 s) and +66/66 (winps, 204.5 s) in frozen order, registry SHA-256 385c9bc9..., summary +12/12 pins, and every per-case slot re-check (67 and 66) verified before +release. Validator: startup 2, single 3, full 9 processes on each shell with +12/12 identity pins and PASS.json. p0: integrity 15 controls (273.5 s pwsh, +170.8 s winps), dependencies 19 (20.0 s, 14.0 s), harness-stream 11 (121.7 s, +94.4 s), each finalization pass; the stream check's retained keys hold, the +entry-labelled keys equal the post-run keys on these intact runs, and all twelve +owned carrier/fixture git status checks are verified. Materialization and +restore both proved the Git content unchanged; the tree was clean afterwards. + +Consequences. The R3 "uncovered" note for winps runs of the p0 harnesses is +closed for R4. The historical verifiers remain as deferred under P3-4. + + +## WDD-20260930-LIFE1-R4-09 - Record R4 row dispositions and hand the report back + +Date: 2026-09-30. Status: LIFE-1-R4 worker decision; coordinator acceptance pending. + +Context. Every R4 control, replay and campaign has run on the candidate harness +and runner bytes (d9411a7d, unchanged through this commit), and the +preservation, whitespace, design and hygiene checks pass for d27ffa34..8ec10ec2. +The claim-drift scanner reads `docs/`, so any report or matrix text changes its +input, and the contract requires the scans on the final tip. + +Decision. Append the evidence sections E-00..E-07 and the worker row +dispositions to the R4 matrix below the frozen marker, and make this commit the +final tip. The claim-drift `-Strict` and `-SelfTest` runs then execute on this +exact tip, and the worker report, which the contract names as +`repair-r4/REPORT.md`, carries their counts. The worker runtime refuses writes +into this worktree through its file tool; the contract forbids working around a +refusal for the report, so the report is returned verbatim with its byte length +and SHA-256 for coordinator persistence, as for R3 (WDD-20260930-LIFE1-R3-10). + +Alternatives rejected. Committing the report before the scans would leave the +scans on an earlier tree; scanning, then committing the counts, would scan a +tree that is not the final one. + +Consequences. The final tip carries every receipt and the matrix; the report, +with the final-tip scan counts, is identified by the hash in the handoff. + + +## WDD-20260930-LIFE1-R4-10 - Commit the coordinator-persisted R4 report + +Date: 2026-09-30. Status: coordinator decision; coordinator acceptance pending. + +Context. WDD-20260930-LIFE1-R4-09 records that the worker runtime refused the +report write and returned the report text with its byte length and SHA-256. The +coordinator recovered the text from the worker transcript and confirmed 14,179 +bytes and SHA-256 229aa70c45ada4187d631b90bd78a89ddcbb801dba99fae4d312c0f29a45a739 +before writing it. + +Decision. Commit exactly those bytes at `repair-r4/REPORT.md`, the durable +completion artifact the contract names, without editing them; follow the R3 +precedent WDD-20260930-LIFE1-R3-11. + +Alternatives rejected. Leaving the report outside the branch would leave the rung +without its contracted artifact; editing it would break the handoff hash. + +Consequences. The branch tip carries the report whose identity matches the +worker handoff; the delta scope is unchanged (repair-r4/** plus this append). diff --git a/docs/internal/extensions/lifecycle-native-p0/.gitattributes b/docs/internal/extensions/lifecycle-native-p0/.gitattributes new file mode 100644 index 00000000..32c5ed88 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/.gitattributes @@ -0,0 +1,2 @@ +# Freeze evidence and registry bytes consistently with the first UTF-8 receipt. +* text eol=lf diff --git a/docs/internal/extensions/lifecycle-native-p0/ACCEPTANCE_MATRIX.md b/docs/internal/extensions/lifecycle-native-p0/ACCEPTANCE_MATRIX.md new file mode 100644 index 00000000..9b07c65c --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/ACCEPTANCE_MATRIX.md @@ -0,0 +1,55 @@ +# LIFE-NATIVE-P0 frozen acceptance matrix + +Frozen before implementation from docs/internal/templates/PROOF_ACCEPTANCE_MATRIX.md. +All eight columns and full requirements are frozen as strict UTF-8 bytes in ACCEPTANCE_ROWS.txt; REQUIREMENTS.json preserves the prompt requirement cells. Evidence and final dispositions are appended below the table. No existing public theorem is changed. + +| ID | Exact frozen requirement | Scope | Evidence needed (exact proposition/check) | Named consumer and identity/composition chain | Anti-vacuity challenge attempted and outcome | Evidence obtained | Status / residual gap | +| --- | --- | --- | --- | --- | --- | --- | --- | +| `LN0-01` | Implement a reproducible probe of the pinned Lean 4.22 runtime array ownership operations, without altering the production RMQ ABI. Record logical size, retained capacity, requested container bytes and live element references as distinct quantities. Inspect actual runtime definitions and record compiler/runtime/header identity; do not infer capacity from Array.size. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-02` | Exercise unique and shared owners with destructor-counted elements. Demonstrate the actual effects of pop/shrink on surviving values, tail element references and retained backing capacity, without accessing freed objects. Distinguish release of one owner from reclamation when another alias remains live. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-03` | Exercise a consuming replacement-buffer route: copy surviving output values into a newly allocated bounded-capacity buffer, release the old owner, and measure which old allocations/elements remain reachable. Include success, empty output, overlap-relevant source positions, alias-retained and deterministically injected handoff/allocation-stage failure cleanup. Do not assume actual Lean allocator failure is recoverable; a fatal process outcome is reported separately. Treat observed allocator/requested capacity separately from a universal native heap theorem. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-04` | Commit an exact replay registry and positive/negative controls for logical shrink falsely labeled reclamation, retained alias falsely labeled exclusive consumption, and an omitted cleanup action. Validation executes the actual pinned runtime operations and the owned measurement/verdict path; predecessor RMQ replay is regression evidence only. The verdict must depend on observed value/ownership/capacity projections, not labels or a prewritten expected log; use the same positive predicate or a checked/explicit measured implication. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-05` | Use bounded owned compiler/probe processes, preserve full stdout/stderr and actual exits, reject unexpected or mixed diagnostics, validate focused/unknown/empty selector behavior, and exercise cleanup. A platform/toolchain inability is uncovered, not success. No credit purchase, package installation or persistent service is needed as an assumed prerequisite. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-06` | Deliver a source-grounded consuming-boundary recommendation mapping Construction.ExecState resources and Native.StorageImage/NativeImage ownership to later transfer obligations. Specify success/failure ownership, aliases, retained observations and capacity. Do not implement a speculative production BuilderOwner-to-QueryOwner ABI before the formal lifecycle interface is reviewed. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-SEMANTIC-NONVACUITY` | semantic coverage, liveness, ownership, and refinement predicates are derived from the operational construction they describe. A predicate defined to be `True`, an enumeration restated as membership, or a separately hand-written consumer label does not establish operational liveness by itself; | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-ORACLE-INDEPENDENCE` | executable fixtures and edge-case expected values come from an independent specification or a theorem already connected to it, never from the implementation result being tested; | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-CATEGORY-SEPARATION` | payload bits, proof fields, model ticks, machine state, Lean runtime, and measured performance remain distinct. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-MUTATION-REPRODUCIBILITY` | when acceptance relies on an exhaustive, production, or public-dependency mutation campaign, the candidate contains a versioned runner or fixtures that replay every claimed case, check the exact expected failure/acceptance surface, restore tracked state, and leave the tree clean. Report prose, copied terminal output, and dangling Git objects are not replayable evidence. A public theorem additionally has a checked exact-type consumer that fails when the advertised dependency is removed; `#print axioms` over the theorem's current type is not such a consumer. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `CHK-FINAL` | Run the final-required checks on the final submitted content, with exact identities, complete outcomes and declared platform limits. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `CHK-SCOPE` | Keep the assigned write scope, clean committed tree, exact base, full frozen row integrity and truthful local-versus-campaign status. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | + +## Verification coverage plan + +Development: pinned compiler startup (30 s), one exact probe (30 s), then registry/selector/diagnostic/cleanup controls. Full C compilation (120 s) and individual probes (30 s) have cold startup margin; replace with measured evidence if insufficient. These cover LN0-01 through LN0-05 and the four applicable invariants. No old RMQ fixture is used as an oracle. + +Final-required: full owned replay, matrix strict UTF-8/eight-column/ID/full-cell/row-byte checks, compiler/header/runtime/source/binary hashes, strict design check against exact base and each commit parent, strict claim scan after report, hygiene and diff checks, final report hash and clean committed scope. Run one baseline lake build under Local\RMQLifecycleImplementationHeavy20260920; cold deadline 7200 s (prior cold closures about 3600 s; warm exact baseline 30.677 s). Reuse only byte-identical source/toolchain artifacts as independent copies, recording provenance; never share a mutable cache. C tests may overlap read-only review. + +Conditional: full native predecessor replay only if existing native code changes (outside scope); aggregate gate and independent final audit belong to the later coordinator campaign. Formal machine invariants, arbitrary-Int word claims and public exact-type theorem mutation consumers do not apply to this C-only runtime experiment. LN0-04 supplies actual-runtime validation reach. All measured loops and releases are native work, not charged single-step formal instructions. + +Target: replayable ownership/capacity evidence feeding the future consuming adapter after formal interface review. Stop only on closed assigned rows, a precise external blocker/obstruction, or explicit redirection; no ABI change, kernel trust change, push, merge or campaign acceptance. + +## Source-freeze evidence (append-only) + +The final owned replay on C SHA-256 `5F32F4A91B21697F86B4F2FEA855CD050E59E330CE6C6FFDA28898353B66D7B1`, runner `077BF8D478141F8891AB6F9C2E332CBF8C8F75ACA32C722B29BD307924957B8E` and registry `6CD97F40E7C39D2212A8C8705D264D4832DCF2542815B72CD927906A01DC8B20` passed 23 registered semantic cases, 58 bounded stages and 65 checks in 161.682 s under the required host mutex. `RESULTS.json` records exact raw-output paths/hashes, per-case numeric projections, case/control verdicts, exits, durations, compiler/header/runtime/binary identities and the outer receipt. `BASELINE.json` records the one source-verified baseline build, exit 0. `RUNTIME_SOURCE.json` binds actual runtime C++ definitions to the installed compiler commit; installed headers and Basic.lean are included in the replay identities. + +LN0-01: the C inspector reads `lean_array_size`, `lean_array_capacity`, `lean_array_byte_size`, positive single-thread `m_rc` and destructor counters from live registered roots. The fixed x64 shape is pointer 8 bytes and array header 24 bytes. Requested bytes are 24+8*capacity; this excludes element/nested allocations and allocator/RSS behavior. The source and runtime are separately pinned; the production ABI is unchanged. + +LN0-02: unique/shared pop and repeated-pop shrink check independent prefix values and object IDs, actual reference multiplicities and destruction. Unique shrink to two preserves capacity 32 and 280 requested bytes. Shared shrink retains two capacity-32 arrays (560 requested bytes), six live objects and eight element references. Empty shared pop still retains two empty capacity-32 arrays; no tail slot or freed object is read. Every registered root is released after the observed handoff, and each allocated token's destructor count is exactly one. + +LN0-03: prefix, overlapping source-position, tail and empty replacement allocate capacity m, acquire references via `lean_array_uget`, fill initialized slots, then release the old owner. Four surviving output objects retain capacity 4 and 56 requested bytes with no old registered array root; an old array alias retains 336 total requested array bytes and ten element references. A separate discarded-element alias keeps that element alive after the old container becomes unreachable through registered roots. Controlled failures before allocation, after empty allocation, after two copied slots, before handoff and after source consumption publish no output and clean initialized ownership; alias-retained failure explicitly retains its allowed old alias. Fatal-handler exit 1 is separately recorded with cleanupClaim=false, not allocator-exhaustion recovery. + +LN0-04 and INV-SEMANTIC-NONVACUITY: all verdicts are derived from runtime observations; the PowerShell consumer independently reconstructs root/reference/destructor summaries and the C predicate. Strict transfer P requires selected values/IDs, bounded output capacity/bytes, unique new output, no source/old aliases and exact surviving reference/destructor projections. `negative-shrink` uses this same P and fails capacity; `negative-alias` uses the same P as `replace-overlap` and fails ownership; `negative-value` uses it and fails values. `negative-cleanup` uses the same cleanup P as `fail-handoff` and fails cleanup before restoration. Positive domains and parameters are respectively (n,b,m)=(6,0,2), (6,1,4), (6,1,4), and (6,1,4,alias=0). The alias-aware positive uses a separately named observational predicate, never the strict positive for the exclusivity mutation. Intermediate stage guards reject actual earlier-stage observations relabeled as mid-copy or post-consumption failure. + +LN0-05 and INV-MUTATION-REPRODUCIBILITY: registry and selector controls enter the actual command boundary; missing/duplicate/unknown/reordered/mapping/unknown-key registry fixtures and explicit-empty/whitespace/missing/duplicate/unknown/zero selectors reject, while omitted and focused selections pass. Full raw stdout/stderr and native/launcher exits are retained. Mixed diagnostics and false labels/summaries reject through the production validators. Output overflow rejects, and the timeout control observes root and descendant absence. Final source/tool/header/library/binary pins are rechecked; semantic mutations are committed operational branches and the probe restores their omitted cleanup after measuring rejection, without editing tracked files. No public theorem changes, so public expected-type theorem mutation requirements are inapplicable. + +LN0-06 and INV-CATEGORY-SEPARATION: `BOUNDARY.md` maps the four `Construction.ExecState` array owners, `ArrayRun` observations and existing `outputCells`/`inputRetained`/`arrayReflects` propositions to `Native.StorageImage`, nested limb arrays, `nativeCore`, loaded-reference refinement and C/Rust owners. It specifies consume-and-clean-up on controlled failure, separate alias obligations, retained/peak capacity and the reviewed formal interface prerequisite. Native loops/RC work, payload bits, formal model ticks, arbitrary-Int resources and measured process duration are distinct. This local result supplies evidence to the future adapter and does not close the formal/native lifecycle campaign. + +INV-ORACLE-INDEPENDENCE: input values [101,-7,303,303,505,-19] and exact source-position IDs are frozen independently in the registry and PowerShell checker. Expected output comes from the specified interval, never the tested output. Wrong-index and equal-value position identity are observable; no RMQ predecessor result is an oracle for native capacity. + +Verification so far: frozen UTF-8/all-eight-column/full-cell/ordered-ID checks pass; whole RMQ/lakefile hygiene and native-decision scans both exit 1 with no matches and empty stderr; no Lean/lakefile changes. Initial strict design classification passes with no policy change. CHK-FINAL and CHK-SCOPE receive final dispositions after report creation and committed-range/per-commit certification in REPORT.md; these are not inferred from source-freeze evidence. + +## Final local dispositions (append-only) + +All twelve assigned rows are CANDIDATE_COMPLETE in worker review. CHK-FINAL uses the completed 23-case/58-stage/65-check native replay, the one source-verified baseline build, the default-root strict claim scan (3,479 hits, zero strict failures, exit 0, 2,211.841 seconds), and final unchanged-policy coverage of the whole owned evidence directory plus both ledgers. The 2,910 outside files retain identical paths and bytes. Frozen contract, source/evidence pins, strict design, whitespace and report identity checks are indexed by CERTIFICATION.json and the post-commit receipt named in REPORT.md. The interrupted first claim invocation is not counted as a pass. + +CHK-SCOPE uses exact base bf31f983205175481fcb659caa4dfb70ef43e361, source commit bea5ce75f788c4035031ba81e69d8de36eda3f92 and a subsequent documentation-only packaging commit. The complete final change has 17 assigned paths; both ledgers preserve the base prefix, and the entire frozen eight-column table remains byte-identical. The exact packaging hash, clean committed status and report byte length/hash are supplied at handoff. No push, merge, production ABI change or campaign acceptance occurs. The substantive LN0 and invariant evidence above remains unchanged; final REPORT.md gives each row's disposition and the ownership digestion. Coordinator acceptance is still required. diff --git a/docs/internal/extensions/lifecycle-native-p0/ACCEPTANCE_ROWS.txt b/docs/internal/extensions/lifecycle-native-p0/ACCEPTANCE_ROWS.txt new file mode 100644 index 00000000..fe30a223 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/ACCEPTANCE_ROWS.txt @@ -0,0 +1,12 @@ +| `LN0-01` | Implement a reproducible probe of the pinned Lean 4.22 runtime array ownership operations, without altering the production RMQ ABI. Record logical size, retained capacity, requested container bytes and live element references as distinct quantities. Inspect actual runtime definitions and record compiler/runtime/header identity; do not infer capacity from Array.size. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-02` | Exercise unique and shared owners with destructor-counted elements. Demonstrate the actual effects of pop/shrink on surviving values, tail element references and retained backing capacity, without accessing freed objects. Distinguish release of one owner from reclamation when another alias remains live. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-03` | Exercise a consuming replacement-buffer route: copy surviving output values into a newly allocated bounded-capacity buffer, release the old owner, and measure which old allocations/elements remain reachable. Include success, empty output, overlap-relevant source positions, alias-retained and deterministically injected handoff/allocation-stage failure cleanup. Do not assume actual Lean allocator failure is recoverable; a fatal process outcome is reported separately. Treat observed allocator/requested capacity separately from a universal native heap theorem. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-04` | Commit an exact replay registry and positive/negative controls for logical shrink falsely labeled reclamation, retained alias falsely labeled exclusive consumption, and an omitted cleanup action. Validation executes the actual pinned runtime operations and the owned measurement/verdict path; predecessor RMQ replay is regression evidence only. The verdict must depend on observed value/ownership/capacity projections, not labels or a prewritten expected log; use the same positive predicate or a checked/explicit measured implication. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-05` | Use bounded owned compiler/probe processes, preserve full stdout/stderr and actual exits, reject unexpected or mixed diagnostics, validate focused/unknown/empty selector behavior, and exercise cleanup. A platform/toolchain inability is uncovered, not success. No credit purchase, package installation or persistent service is needed as an assumed prerequisite. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-06` | Deliver a source-grounded consuming-boundary recommendation mapping Construction.ExecState resources and Native.StorageImage/NativeImage ownership to later transfer obligations. Specify success/failure ownership, aliases, retained observations and capacity. Do not implement a speculative production BuilderOwner-to-QueryOwner ABI before the formal lifecycle interface is reviewed. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-SEMANTIC-NONVACUITY` | semantic coverage, liveness, ownership, and refinement predicates are derived from the operational construction they describe. A predicate defined to be `True`, an enumeration restated as membership, or a separately hand-written consumer label does not establish operational liveness by itself; | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-ORACLE-INDEPENDENCE` | executable fixtures and edge-case expected values come from an independent specification or a theorem already connected to it, never from the implementation result being tested; | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-CATEGORY-SEPARATION` | payload bits, proof fields, model ticks, machine state, Lean runtime, and measured performance remain distinct. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-MUTATION-REPRODUCIBILITY` | when acceptance relies on an exhaustive, production, or public-dependency mutation campaign, the candidate contains a versioned runner or fixtures that replay every claimed case, check the exact expected failure/acceptance surface, restore tracked state, and leave the tree clean. Report prose, copied terminal output, and dangling Git objects are not replayable evidence. A public theorem additionally has a checked exact-type consumer that fails when the advertised dependency is removed; `#print axioms` over the theorem's current type is not such a consumer. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `CHK-FINAL` | Run the final-required checks on the final submitted content, with exact identities, complete outcomes and declared platform limits. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `CHK-SCOPE` | Keep the assigned write scope, clean committed tree, exact base, full frozen row integrity and truthful local-versus-campaign status. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | diff --git a/docs/internal/extensions/lifecycle-native-p0/BASELINE.json b/docs/internal/extensions/lifecycle-native-p0/BASELINE.json new file mode 100644 index 00000000..9cbf9ada --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/BASELINE.json @@ -0,0 +1,128 @@ +{ + "role": "one required baseline regression; reused after final C/docs changes because all Lean/Lake/toolchain sources remain unchanged", + "outcome": { + "status": "PASS", + "base": "bf31f983205175481fcb659caa4dfb70ef43e361", + "repo": "C:/Users/poin/.codex/worktrees/af4b/RMQ", + "command": [ + "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\lake.exe", + "build" + ], + "environment": { + "LEAN_NUM_THREADS": "1", + "PATHPrefix": "C:/Users/poin/.elan/toolchains/leanprover--lean4---v4.22.0/bin" + }, + "deadlineSeconds": 7200, + "outputLimitBytes": 16777216, + "mutexName": "Local\\RMQLifecycleImplementationHeavy20260920", + "mutexWaitStartedUtc": "2026-09-20T23:45:28.7954012Z", + "cacheSource": "C:/Users/poin/Documents/RMQ/.claude/worktrees/wf1-whole-project-audit/.lake/cold", + "cacheHead": "7b227c49ef2ec044b702126cc41c9add847eed01", + "mutexAcquiredUtc": "2026-09-20T23:45:28.8349857Z", + "mutexAbandoned": false, + "cacheArtifactCount": 4208, + "compilerIdentities": [ + { + "path": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\lean.exe", + "bytes": 82432, + "sha256": "9B5AF669D8DC9B5826A1F5427584915EECA659E9BF34C7EE72667B93C0BFDCB0" + }, + { + "path": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\lake.exe", + "bytes": 85504, + "sha256": "AED396C5F1948B673416C8B509FA2CA31F3E2BB9596CC2D75485963F3E17BDD7" + } + ], + "toolchainText": "leanprover/lean4:v4.22.0\r\n\r\n", + "ownedHelperSha256": "6690AD4F9E3AEE9596E53E89D3D242E4BE59C0A04733BC50184AE35B292FF90E", + "startedUtc": "2026-09-20T23:47:23.97532Z", + "finishedUtc": "2026-09-20T23:47:27.560179Z", + "exitCode": 0, + "durationSeconds": 2.931, + "timedOut": false, + "outputLimitExceeded": false, + "ownership": "kill-on-close-job", + "terminatedIds": [], + "actualLakeExit": 0, + "logFiles": [ + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-baseline\\lake.stdout.log", + "bytes": 108128, + "sha256": "71EDA76B38D67DE94ACB8A0C29AD261CC78F51FE68C189E7F28C9E64482E75CB" + }, + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-baseline\\lake.stderr.log", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + } + ], + "sourceRechecked": true, + "mutexReleasedUtc": "2026-09-20T23:47:31.7432237Z" + }, + "sourceFileCount": 1125, + "diagnostics": { + "completeWarningBlocks": 188, + "exactWarningBlockMultisetEqual": true, + "stderrEmpty": true, + "orderingNote": "Lake replay task order/progress indices differ; complete warning blocks compare exactly after sorting. All nonblank non-progress non-completion lines belong to the compared blocks.", + "priorLog": "C:/Users/poin/Documents/RMQ/lifecycle-experiments-20260920/baseline-build.stdout.txt", + "priorSha256": "A0B3F115D496AC0A7A1C34BD61B233948AB07370B276BCE6467006358BBC5396" + }, + "files": [ + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-baseline\\build-receipt.json", + "bytes": 3071, + "sha256": "5FE8D12507A3C9A532A8F2A4AD13F664358A730951345AB14FBF95C3FA80DC9A" + }, + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-baseline\\source-provenance.json", + "bytes": 385496, + "sha256": "9B9DB21354DF51B6E0DDBA87EB3BFF18C9E3D163DC824C2B1A62385CED4EC88B" + }, + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-baseline\\cache-provenance.json", + "bytes": 1261753, + "sha256": "D42E99CC8B900909C164170F909234EF7AE0FADA1FAA1817D85890FF2E5F3682" + }, + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-baseline\\diagnostic-comparison.json", + "bytes": 1239, + "sha256": "1BFA1B4B1A98BA5BC21BEF7363C80888D12269663B9AC9727A878BC8F6162AC6" + }, + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-baseline\\lake.stdout.log", + "bytes": 108128, + "sha256": "71EDA76B38D67DE94ACB8A0C29AD261CC78F51FE68C189E7F28C9E64482E75CB" + }, + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-baseline\\lake.stderr.log", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-baseline\\lake-exit.json", + "bytes": 313, + "sha256": "9F11637C6927DF39380A5F7EC722A0BB1F15B8532E72EAC7F3BB4AA319B34E5A" + }, + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-baseline\\owned-process-result.json", + "bytes": 432, + "sha256": "F58657319ECF6762698CA9DE2BA63EDCEB231554AC0AB058160E313EF9A1A566" + }, + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-baseline\\run-baseline.ps1", + "bytes": 7934, + "sha256": "8C5539CE6D510E593A224BBF8EB5C016FE7DEDC5D345BFC6B72BA65E7D845399" + }, + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-baseline\\build-child.ps1", + "bytes": 1218, + "sha256": "63AC15DBFF6BB3EC339EB1496FA29E4BEABADD1EE6692F6925CC78A33312D3F9" + }, + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-baseline\\verify-diagnostics.ps1", + "bytes": 2220, + "sha256": "1EC8413D681B82885550A3355A54C445FBBF440E4E2B2A443D9539504F07924C" + } + ] +} diff --git a/docs/internal/extensions/lifecycle-native-p0/BOUNDARY.md b/docs/internal/extensions/lifecycle-native-p0/BOUNDARY.md new file mode 100644 index 00000000..f51cf6c0 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/BOUNDARY.md @@ -0,0 +1,105 @@ +# Source-grounded consuming-boundary recommendation + +This is the LIFE-NATIVE-P0 native prerequisite at base +`bf31f983205175481fcb659caa4dfb70ef43e361`. It determines ownership questions for +the later adapter after LIFE-1's formal lifecycle interface is source-reviewed. +It implements no production ABI and supplies no Lean heap theorem. + +## Pinned runtime definitions + +The installed `include/lean/lean.h:754-770` defines allocation requests and +separate size/capacity projections. Lines 815-817 acquire an element reference; +838-846 dispatch shared arrays to copying; 872-881 implement pop by obtaining an +exclusive array, reducing size and decrementing the removed element. The +installed `src/lean/Init/Data/Array/Basic.lean:446-458` defines shrink by repeated +pop. These are actual included definitions, not deductions from `Array.size`. + +The corresponding +[runtime object.cpp at the installed compiler commit](https://github.com/leanprover/lean4/blob/ba2cbbf09d4978f416e0ebd1fceeebc2c4138c05/src/runtime/object.cpp) +was retrieved separately because runtime C++ bodies are absent from the installed +source bundle. `RUNTIME_SOURCE.json` pins its exact URL, bytes and local path. +`lean_copy_expand_array` at 2525 preserves the original capacity when expansion +is false; its shared branch increments initialized elements and releases one old +array owner. `lean_array_push` at 2548 reuses an exclusive buffer while space +remains. `lean_del_core` at 332 decrements logical elements then dispatches +capacity-sized deallocation. Deallocation at 213 depends on the runtime build's +allocator configuration. The fatal handler at 90 delegates to internal panic, +which prints its diagnostic and exits (or aborts under the runtime panic policy). +The installed binaries are pinned release artifacts; this task does not claim to +rebuild or formally verify the runtime compiler/allocator implementation. + +## Resources and actual producer-to-consumer chains + +| Source and resource | Current proposition or operation | Later consuming obligation | +| --- | --- | --- | +| `RMQ/Core/WordRAM/Construction/ArrayRun.lean:20`, `ExecState` | Four arrays: `regs : Array Nat`, `memory : Array (Option Nat)`, `keys : Array (Option Int)`, `keyRegs : Array Int`; plus `pc : Nat`, `status : Status`. `abstract` uses `getD`; numeric extent is `memory.size`. | Inventory every root and nested boxed value. Transfer exact output cells and retire all other arrays, including the separate comparison-key banks. Logical zero/absence does not imply capacity reduction. | +| Same file:57, `ArrayRun` | `final`, `steps`, `categories`, `writes`, `reserves`, `result` are ordinary executable fields. `runArrayAux` collects lists; `finishRun` reverses them. | Release observation lists and obsolete run/state/result roots before the retained boundary, or account for all of their reachable storage. Observations are not erased merely because they describe execution. | +| Same file:414, `ExecState.ofWordInput`, `ofComparisonInput` | Word input stores header and encoded keys in numeric memory; comparison input stores the header numerically and arbitrary `Int` values in separate keys. Both have key registers. | Keep input models distinct. Caller input lists, boxed integers and external element aliases may remain live independently of the array owner. | +| `Construction/Proof/RunFacts.lean:49`, `BuilderRunFacts.outputCells` | For every `outBase` with the builder's final status `halted outBase`, `s0.extent <= outBase`, final extent equals `outBase + (buildMemory xs).length`, and for every `i < (buildMemory xs).length`, final memory at `outBase+i` equals `some ((buildMemory xs).getD i 0)`. `outputProvenance` additionally gives the occurrence and final write at each cell. | Use this exact interval/value producer or its reviewed LIFE-1 successor; copying an independently reconstructed sibling image would need a proved correspondence. | +| Same file:75, `inputRetained` | Every initial numeric cell is preserved and final `keys = s0.keys`; `arrayReflects` links all executable run projections and final abstraction under matching initial state and 400-element register banks. | Existing PRE preserves input. New consuming behavior must establish new retirement obligations; predecessor clean tails and extents cannot discharge them. | +| `RMQ/Core/WordRAM/Native/Binary.lean:17`, `StorageImage` | Fields `width`, `inputLength`, `registerCount`, `code`, `memory`; `Native/Machine.lean:16` defines `Memory = Array Word`, `Code = Array (Array Word)`; `Native/Limbs.lean:15` defines `Word = Array UInt8`. | Account for every nested container, metadata and conversion/parser temporary. Generic object-array tests establish outer-reference mechanics only. | +| `Native/Machine.lean:734`, `runThin_loaded_reference` | Under canonical memory/state, code equality to `encodeCode width program`, fitting instructions, bounded register writes and safety of the reference run, decoding the native final state and statistics equals `observeRun` on that same decoded memory. | Establish these exact premises on the transferred allocation and code. A capacity measurement is not this representation/refinement bridge. | +| `Native/Runtime.lean:25`, `nativeInitialState`, `nativeCore` | `nativeCore` runs supplied image code/memory with freshly encoded registers. `nativeCore_no_reads` states the `readsRev` projection is empty when reads are disabled. | Distinguish temporary endpoints/registers/text/receipts from retained image storage. Existing fresh query setup does not prove charged sequential lifecycle re-entry. | +| `native/packed-rmq/src/native.rs:65`, `LoadOwner`, `QueryOwner`, `NativeImage` | Rust drops call matching C frees. `NativeImage` owns `LoadOwner` and borrows the process-lifetime initializing-thread runtime; query text is copied before dropping `QueryOwner`. | Future success and failure must give explicit owners/borrowed lifetimes, same-thread destruction and exactly-once release obligations. This remains native implementation reasoning outside the kernel. | +| `native/packed-rmq/native_shim.c:52-89` and `include/packed_rmq.h:23` | Loaded image is borrowed from a load result; query increments the image before an owned Lean call, retaining the old load owner. C frees decrement the matching result. | Existing immutable reuse supplies no exclusive consuming transfer. Every outstanding handle and element alias must be covered by the later boundary contract. | + +`StorageImage.encoded_bit_accounting` (`Native/Binary.lean:535`) separates numeric +bits, encoded-byte rounding and framing; it explicitly excludes physical object +allocation. `Native/CanonicalImage.lean:9` selects the original `queryProgram`, +so this prerequisite does not imply an existing compact lifecycle native path. + +## Recommended ownership semantics + +For the measured route, consume-and-clean-up is explicit. On success, acquire one +reference per initialized destination occurrence before releasing its source. +Publish the bounded-capacity output only after all required ownership checks. +Release construction memory, numeric and key registers, separate keys, obsolete +results and observations; separately retain only reviewed query resources. + +On controlled failure before allocation, after allocation, during copying, before +handoff, or after old-owner release, release all initialized destination entries, +temporary references and the consumed source; publish no output. Returning the +original owner would be a different viable contract, but cannot be mixed with +this consuming experiment after destructive progress. A real Lean allocator +failure invokes a non-returning fatal path; deterministic injection tests cleanup +of recoverable stages, not recovery from actual out-of-memory termination. + +Array uniqueness and element uniqueness are different. An old array alias keeps +its backing allocation and all old element references alive after one owner is +released. An independently retained element can outlive the old container. +The native contract must either rule out such aliases at entry, or report their +retained storage separately and qualify its retained-memory bound accordingly. +The probe enumerates its own roots; it cannot certify absence of arbitrary +foreign aliases in a future program. + +The replacement uses `lean_alloc_array(0,m)` and fills at most `m` initialized +slots, acquiring each source with `lean_array_uget`. The observed requested bytes +are `sizeof(lean_array_object) + sizeof(void*) * capacity`. This is a container +allocation request, not allocator usable bytes, process RSS, nested element bytes, +numeric payload bits or a universal heap bound. While both source and destination +live, transient container storage includes both; it belongs in the construction +peak, not the final retained target. The C loops and releases are real measured +native work and are not claimed single charged word-RAM instructions. + +## Worked example and next review + +The independent fixture is `[101, -7, 303, 303, 505, -19]`, with distinct +destructor-counted objects even for the equal values. Select positions 1 through +4 into capacity four. Each acquired value gains a reference; releasing the sole +old array destroys positions 0 and 5 while positions 1 through 4 survive with one +reference each. If an old array alias remains, the old capacity and all six +objects remain reachable, and selected elements have two references. The same +output values therefore coexist with two different retained-memory outcomes. + +The source interval `[1,5)` overlaps the hypothetical in-place destination +`[0,4)`. A separate buffer avoids overwrite dependencies; prefix, overlap, tail +and empty selections check the actual position arithmetic. Snapshots retain only +integers and counts, never extra Lean references. Finalizer counts concern the +Lean external test objects; their static payload records require no allocation. + +The next consumer must source-review LIFE-1's full formal output/resource +interface, then establish that the compiled consuming adapter releases every +construction root and transfers the exact image used by its query refinement. +It must additionally bound nested native allocations and decide how alias freedom +is enforced. Those are explicit later campaign phases, not properties inferred +from the local probe or its candidate status. diff --git a/docs/internal/extensions/lifecycle-native-p0/CERTIFICATION.json b/docs/internal/extensions/lifecycle-native-p0/CERTIFICATION.json new file mode 100644 index 00000000..00a9d01c --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/CERTIFICATION.json @@ -0,0 +1,238 @@ +{ + "status": "CANDIDATE_COMPLETE", + "coordinatorAcceptanceRequired": true, + "sourceCommit": "bea5ce75f788c4035031ba81e69d8de36eda3f92", + "base": "bf31f983205175481fcb659caa4dfb70ef43e361", + "branch": "codex/life-native-p0-owned-finalization", + "report": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\docs\\internal\\extensions\\lifecycle-native-p0\\REPORT.md", + "bytes": 25211, + "sha256": "658652FEB62B1A5DCEEC2BCC030C3DF3A24B19B8D34933A8FA4561142C8CFD98" + }, + "platform": "Microsoft Windows NT 10.0.26200.0", + "powerShell": "7.6.5", + "native": { + "status": "PASS", + "cases": 23, + "stages": 58, + "checks": 65, + "actualRunnerExit": 0, + "seconds": 161.682, + "evidence": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\docs\\internal\\extensions\\lifecycle-native-p0\\RESULTS.json", + "bytes": 63804, + "sha256": "6440A963BE7A0E65222F86AFE3CFB89E4BEE1B6BDCD0226DC0D5CDA88D296FDD" + } + }, + "baseline": { + "status": "PASS", + "actualExit": 0, + "evidence": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\docs\\internal\\extensions\\lifecycle-native-p0\\BASELINE.json", + "bytes": 5699, + "sha256": "DA869E0C2AC50C3CC042C6C44ECCEF4E3DE9C59BF205AD8DBA888B9410C67238" + } + }, + "fullClaims": { + "command": "scripts/claim_drift_scan.ps1 -Strict", + "actualExit": 0, + "seconds": 2211.841, + "deadlineSeconds": 3600, + "hits": 3479, + "strictFailures": 0, + "reportDraftSha256": "43F14694FC97D7B1105170E3ED36A1F38F554749E04058D60B69F00E591E620C", + "receipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\checks\\claim-full-owned\\receipt.json", + "bytes": 1192, + "sha256": "308E9954716F0102E8783AC5CC2D280427E7E507A887B29812825C79627C448D" + }, + "rawFiles": [ + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\checks\\claim-full-owned\\stdout.log", + "bytes": 4118433, + "sha256": "C72C69D5C0127F99D0E7EF8FE82B71B3A610F1CEBA5E600ACE5B572E95CBB925" + }, + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\checks\\claim-full-owned\\stderr.log", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + } + ] + }, + "precommitChecks": [ + { + "name": "contract", + "expectedExit": 0, + "actualExit": 0, + "timedOut": false, + "outputLimitExceeded": false, + "durationSeconds": 2.241, + "deadlineSeconds": 180, + "lastStdout": "CONTRACT PASS: 12 exact ordered IDs, all eight columns, full prompt requirements, frozen UTF-8 row bytes" + }, + { + "name": "design-source", + "expectedExit": 0, + "actualExit": 0, + "timedOut": false, + "outputLimitExceeded": false, + "durationSeconds": 3.533, + "deadlineSeconds": 180, + "lastStdout": "DESIGN-CHECK: checked 15 changed files (1 code, 11 workflow, 3 neutral)" + }, + { + "name": "design-package", + "expectedExit": 0, + "actualExit": 0, + "timedOut": false, + "outputLimitExceeded": false, + "durationSeconds": 4.359, + "deadlineSeconds": 180, + "lastStdout": "DESIGN-CHECK: checked 3 changed files (0 code, 2 workflow, 1 neutral)" + }, + { + "name": "design-whole", + "expectedExit": 0, + "actualExit": 0, + "timedOut": false, + "outputLimitExceeded": false, + "durationSeconds": 3.289, + "deadlineSeconds": 180, + "lastStdout": "DESIGN-CHECK: checked 17 changed files (1 code, 13 workflow, 3 neutral)" + }, + { + "name": "working-whitespace", + "expectedExit": 0, + "actualExit": 0, + "timedOut": false, + "outputLimitExceeded": false, + "durationSeconds": 2.831, + "deadlineSeconds": 180, + "lastStdout": null + }, + { + "name": "staged-whitespace", + "expectedExit": 0, + "actualExit": 0, + "timedOut": false, + "outputLimitExceeded": false, + "durationSeconds": 2.565, + "deadlineSeconds": 180, + "lastStdout": null + }, + { + "name": "final-owned-claims", + "expectedExit": 0, + "actualExit": 0, + "timedOut": false, + "outputLimitExceeded": false, + "durationSeconds": 6.094, + "deadlineSeconds": 300, + "lastStdout": "CLAIM-DRIFT: scan complete (382 hits, 0 strict failures)" + }, + { + "name": "claim-context", + "expectedExit": 0, + "actualExit": 0, + "timedOut": false, + "outputLimitExceeded": false, + "durationSeconds": 5.222, + "deadlineSeconds": 180, + "lastStdout": "CLAIM CONTEXT PASS: 2910 outside-rescan files have identical paths and bytes; scanner, policy and ripgrep unchanged" + } + ], + "precommitReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\checks\\package-precommit\\receipt.json", + "bytes": 300419, + "sha256": "2905DCA6FA46ABC3259BD48B8F8B5483E8776BB3819004B3D742775BC14E849D" + }, + "precommitRawFiles": [], + "otherEvidence": [ + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\checks\\source-bytes.json", + "bytes": 2339, + "sha256": "B2575CEBBB93A495C87CB209B6D6F952B6EDFD3414D3324C9907CC7347713F56" + }, + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\checks\\evidence-pins.json", + "bytes": 58511, + "sha256": "179A0E923FB20D4FF1884EDDC16AFD8B14CC5C6D6FE43A853BF127242DCE76E8" + }, + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\checks\\default-claim-context.json", + "bytes": 646753, + "sha256": "93DE2690CB6509033FC93F3BDD7BA42CEF2E21F9A0AA9761DC04DF511EB0F8F4" + }, + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\checks\\hygiene.json", + "bytes": 243, + "sha256": "CAEF28A2A2660D09018E6CB329771A617AA579AC7D3BC49FF030C7638448E898" + }, + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\checks\\hygiene.stdout.txt", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\checks\\hygiene.stderr.txt", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\checks\\native-decision.stdout.txt", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\checks\\native-decision.stderr.txt", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\checks\\claim-draft-interrupted.json", + "bytes": 2064, + "sha256": "CB969E95FA505539BD57B2461E87D6EACEE9C6CE82BB34BD434A06A599894BC2" + }, + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\docs\\internal\\extensions\\lifecycle-native-p0\\RUNTIME_SOURCE.json", + "bytes": 1398, + "sha256": "F32AA70D04AA8FE2A14873DA0E6B22501781187544B5335918A7925221C7E9A6" + }, + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\lean-4.22-object.cpp", + "bytes": 88248, + "sha256": "44C1430D9C6DA2FE9FDE073D407F9FD58860D869D09B8C7EA0BC0E27D85916FB" + }, + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\checks\\final-package-checks.ps1", + "bytes": 2932, + "sha256": "C2D9529FBF0A8948E13AE19EDB1CEBE9EE946580E6CEE2DC3FC852E5A58116CB" + }, + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\checks\\verify-claim-context.ps1", + "bytes": 1734, + "sha256": "0510367F57A14D624817C05D488BB0840447E40B55E0395AAE41B3B9FF9D7CA8" + } + ], + "finalCoverage": { + "method": "Completed default-root PASS plus final changed-file PASS under the unchanged complete policy; not a second default-root execution.", + "finalRescan": [ + "docs/internal/extensions/lifecycle-native-p0", + "docs/internal/DESIGN_DECISIONS.md", + "docs/internal/WORKFLOW_DESIGN_DECISIONS.md" + ], + "unchangedOutsideFiles": 2910, + "postcommitReceipt": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\checks\\package-postcommit\\receipt.json", + "finalIdentityReceipt": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\checks\\final-identity.json", + "note": "The report/status and this certification record are finalized after the precommit checks. The final focused scan and exact committed-range checks cover their final bytes; their outcomes and the packaging SHA are issued at handoff without a self-referential receipt commit." + }, + "sourceAndScope": { + "assignedChangedPaths": 17, + "nativeSourceUnchangedAfterReplay": true, + "frozenRowsSha256": "F45113AE6BF3F769105A748B3D0A61EA99532A05A715410F11EF29E7E518EC29", + "requirementsSha256": "0983881A85F9A3B42ECD54C0BFB18170C3BE3E5A65602CDE66547042CA5421C9", + "published": false, + "productionAbiChanged": false + }, + "conditionalChecks": "No predecessor native implementation changed. Aggregate gate, fresh-blind campaign audit and acceptance remain coordinator responsibilities." +} diff --git a/docs/internal/extensions/lifecycle-native-p0/REGISTRY.json b/docs/internal/extensions/lifecycle-native-p0/REGISTRY.json new file mode 100644 index 00000000..79c348f3 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/REGISTRY.json @@ -0,0 +1,313 @@ +{ + "schema": 1, + "inputSpecification": [ + 101, + -7, + 303, + 303, + 505, + -19 + ], + "initialCapacity": 32, + "cases": [ + { + "id": "pop-unique", + "operation": 0, + "n": 6, + "start": 0, + "count": 5, + "alias": 0, + "elementAlias": 0, + "failStage": 0, + "mutation": 0, + "expectedExit": 0, + "failure": "none" + }, + { + "id": "shrink-unique", + "operation": 1, + "n": 6, + "start": 0, + "count": 2, + "alias": 0, + "elementAlias": 0, + "failStage": 0, + "mutation": 0, + "expectedExit": 0, + "failure": "none" + }, + { + "id": "pop-shared", + "operation": 0, + "n": 6, + "start": 0, + "count": 5, + "alias": 1, + "elementAlias": 0, + "failStage": 0, + "mutation": 0, + "expectedExit": 0, + "failure": "none" + }, + { + "id": "shrink-shared", + "operation": 1, + "n": 6, + "start": 0, + "count": 2, + "alias": 1, + "elementAlias": 0, + "failStage": 0, + "mutation": 0, + "expectedExit": 0, + "failure": "none" + }, + { + "id": "pop-empty-unique", + "operation": 0, + "n": 0, + "start": 0, + "count": 0, + "alias": 0, + "elementAlias": 0, + "failStage": 0, + "mutation": 0, + "expectedExit": 0, + "failure": "none" + }, + { + "id": "pop-empty-shared", + "operation": 0, + "n": 0, + "start": 0, + "count": 0, + "alias": 1, + "elementAlias": 0, + "failStage": 0, + "mutation": 0, + "expectedExit": 0, + "failure": "none" + }, + { + "id": "shrink-noop", + "operation": 1, + "n": 6, + "start": 0, + "count": 6, + "alias": 0, + "elementAlias": 0, + "failStage": 0, + "mutation": 0, + "expectedExit": 0, + "failure": "none" + }, + { + "id": "replace-prefix", + "operation": 2, + "n": 6, + "start": 0, + "count": 2, + "alias": 0, + "elementAlias": 0, + "failStage": 0, + "mutation": 0, + "expectedExit": 0, + "failure": "none" + }, + { + "id": "replace-overlap", + "operation": 2, + "n": 6, + "start": 1, + "count": 4, + "alias": 0, + "elementAlias": 0, + "failStage": 0, + "mutation": 0, + "expectedExit": 0, + "failure": "none" + }, + { + "id": "replace-tail", + "operation": 2, + "n": 6, + "start": 4, + "count": 2, + "alias": 0, + "elementAlias": 0, + "failStage": 0, + "mutation": 0, + "expectedExit": 0, + "failure": "none" + }, + { + "id": "replace-empty", + "operation": 2, + "n": 6, + "start": 0, + "count": 0, + "alias": 0, + "elementAlias": 0, + "failStage": 0, + "mutation": 0, + "expectedExit": 0, + "failure": "none" + }, + { + "id": "replace-alias", + "operation": 2, + "n": 6, + "start": 1, + "count": 4, + "alias": 1, + "elementAlias": 0, + "failStage": 0, + "mutation": 0, + "expectedExit": 0, + "failure": "none" + }, + { + "id": "replace-element-alias", + "operation": 2, + "n": 6, + "start": 4, + "count": 2, + "alias": 0, + "elementAlias": 1, + "failStage": 0, + "mutation": 0, + "expectedExit": 0, + "failure": "none" + }, + { + "id": "fail-alloc", + "operation": 3, + "n": 6, + "start": 1, + "count": 4, + "alias": 0, + "elementAlias": 0, + "failStage": 1, + "mutation": 0, + "expectedExit": 0, + "failure": "none" + }, + { + "id": "fail-after-alloc", + "operation": 3, + "n": 6, + "start": 1, + "count": 4, + "alias": 0, + "elementAlias": 0, + "failStage": 2, + "mutation": 0, + "expectedExit": 0, + "failure": "none" + }, + { + "id": "fail-mid-copy", + "operation": 3, + "n": 6, + "start": 1, + "count": 4, + "alias": 0, + "elementAlias": 0, + "failStage": 3, + "mutation": 0, + "expectedExit": 0, + "failure": "none" + }, + { + "id": "fail-handoff", + "operation": 3, + "n": 6, + "start": 1, + "count": 4, + "alias": 0, + "elementAlias": 0, + "failStage": 4, + "mutation": 0, + "expectedExit": 0, + "failure": "none" + }, + { + "id": "fail-after-consume", + "operation": 3, + "n": 6, + "start": 1, + "count": 4, + "alias": 0, + "elementAlias": 0, + "failStage": 5, + "mutation": 0, + "expectedExit": 0, + "failure": "none" + }, + { + "id": "fail-alias", + "operation": 3, + "n": 6, + "start": 1, + "count": 4, + "alias": 1, + "elementAlias": 0, + "failStage": 3, + "mutation": 0, + "expectedExit": 0, + "failure": "none" + }, + { + "id": "negative-shrink", + "operation": 2, + "n": 6, + "start": 0, + "count": 2, + "alias": 0, + "elementAlias": 0, + "failStage": 0, + "mutation": 1, + "expectedExit": 3, + "failure": "capacity" + }, + { + "id": "negative-alias", + "operation": 2, + "n": 6, + "start": 1, + "count": 4, + "alias": 1, + "elementAlias": 0, + "failStage": 0, + "mutation": 2, + "expectedExit": 3, + "failure": "ownership" + }, + { + "id": "negative-cleanup", + "operation": 3, + "n": 6, + "start": 1, + "count": 4, + "alias": 0, + "elementAlias": 0, + "failStage": 4, + "mutation": 3, + "expectedExit": 3, + "failure": "cleanup" + }, + { + "id": "negative-value", + "operation": 2, + "n": 6, + "start": 1, + "count": 4, + "alias": 0, + "elementAlias": 0, + "failStage": 0, + "mutation": 4, + "expectedExit": 3, + "failure": "values" + } + ] +} \ No newline at end of file diff --git a/docs/internal/extensions/lifecycle-native-p0/REPORT.md b/docs/internal/extensions/lifecycle-native-p0/REPORT.md new file mode 100644 index 00000000..1d81ea29 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/REPORT.md @@ -0,0 +1,356 @@ +Status: CANDIDATE_COMPLETE +I found no assigned or inherited acceptance criterion unmet; coordinator acceptance is still required. + +# LIFE-NATIVE-P0 — native finalization ownership and capacity + +## Identity and submitted scope + +Handle: LIFE-NATIVE-P0. Task: `01a0c12b-88c6-7ef2-bd68-bf63cd80b872`. +Requested task title: `(LIFE-NATIVE-P0) Validate native finalization ownership and capacity`. +Worktree: `C:/Users/poin/.codex/worktrees/af4b/RMQ`. +Private branch: `codex/life-native-p0-owned-finalization`. +Exact base: `bf31f983205175481fcb659caa4dfb70ef43e361`. +Governance: `7b227c49ef2ec044b702126cc41c9add847eed01`. +Final implementation/candidate source commit: `bea5ce75f788c4035031ba81e69d8de36eda3f92`. + +The source commit freezes the final probe, runner, registry and measured receipts. +This report and final certification are a subsequent documentation commit; its +exact packaging hash is supplied with the final handoff and is recoverable with +`git log -1 --format=%H -- docs/internal/extensions/lifecycle-native-p0/REPORT.md`. +The document does not pretend to contain its own future commit hash. This follows +the source-freeze/report separation already recorded in WDD-20260912-NATIVE1-013. +No executable source changes occur in that packaging commit. + +The fresh checkout was clean and distinct from the dirty primary and experiment +source. Both initial and exact-base preflights passed with actual runtime skills +`rmq-audit-prompt,rmq-coordinator,rmq-proof-sprint`; the required role was +`rmq-proof-sprint`. [START.json](START.json) is the launch identity receipt. +All work is local and unpublished. No push, merge, production ABI change, +toolchain installation or coordinator acceptance occurred. + +Complete changed paths from the exact base: + +- `native/packed-rmq/tests/lifecycle_storage_probe.c` +- `scripts/packed_native_lifecycle_storage_replay.ps1` +- `docs/internal/DESIGN_DECISIONS.md` (append) +- `docs/internal/WORKFLOW_DESIGN_DECISIONS.md` (append) +- `docs/internal/extensions/lifecycle-native-p0/.gitattributes` +- `docs/internal/extensions/lifecycle-native-p0/START.json` +- `docs/internal/extensions/lifecycle-native-p0/REQUIREMENTS.json` +- `docs/internal/extensions/lifecycle-native-p0/ACCEPTANCE_ROWS.txt` +- `docs/internal/extensions/lifecycle-native-p0/ACCEPTANCE_MATRIX.md` +- `docs/internal/extensions/lifecycle-native-p0/VERIFY_CONTRACT.ps1` +- `docs/internal/extensions/lifecycle-native-p0/BASELINE.json` +- `docs/internal/extensions/lifecycle-native-p0/RUNTIME_SOURCE.json` +- `docs/internal/extensions/lifecycle-native-p0/BOUNDARY.md` +- `docs/internal/extensions/lifecycle-native-p0/REGISTRY.json` +- `docs/internal/extensions/lifecycle-native-p0/RESULTS.json` +- `docs/internal/extensions/lifecycle-native-p0/REPORT.md` +- `docs/internal/extensions/lifecycle-native-p0/CERTIFICATION.json` + +## Result and measured boundary + +The final complete owned replay passed **23 operational cases, 58 bounded +stages and 65 checks**, actual runner and outer wrapper exits 0, in **161.682 s**. +It held `Local\RMQLifecycleImplementationHeavy20260920` throughout. Complete +numeric projections and all stage exits, deadlines, raw-output paths and hashes +are in [RESULTS.json](RESULTS.json). Its raw source receipt is +`C:/Users/poin/.codex/worktrees/af4b/RMQ/.lake/lifecycle-native-p0/runs/7c97f92144714f9c9d126762635d07b4/SUMMARY.json`. +Outer ownership evidence is +`C:/Users/poin/.codex/worktrees/af4b/RMQ/.lake/lifecycle-native-p0/final-5a155de9bddb4157bb5ff71eb8d515aa/receipt.json`. + +The independent input is `[101,-7,303,303,505,-19]`, represented by six distinct +destructor-counted external objects. The two equal values have distinct source +IDs. All ordinary input arrays start at capacity 32; empty-input pop cases start +with size zero and that same explicit capacity. Snapshots traverse only registered +live owners and store numbers, never additional Lean references. + +| Handoff observation | Output size/capacity | Output requested bytes | All registered array bytes | Live elements / element references | Old array reachable | +| --- | --- | --- | --- | --- | --- | +| Unique shrink to two | 2 / 32 | 280 | 280 | 2 / 2 | Yes | +| Shared shrink to two | 2 / 32 | 280 | 560 | 6 / 8 | Yes | +| Exclusive replacement, positions [1,5) | 4 / 4 | 56 | 56 | 4 / 4 | No | +| Same replacement with old alias | 4 / 4 | 56 | 336 | 6 / 10 | Yes | +| Empty replacement | 0 / 0 | 24 | 24 | 0 / 0 | No | +| Tail replacement with discarded-element alias | 2 / 2 | 40 | 40 | 3 / 3 | No | + +The requested-byte equation on this checked x64 shape is +`24 + 8 * lean_array_capacity(a)`. It is not derived from logical size. +Element reference counts read the actual single-thread runtime `m_rc` of live +objects. Destructor counters record actual external-object destruction. The +table excludes element-object bytes, static test payloads, runtime global +support, nested production arrays, allocator overhead and RSS. Old-array +reachability concerns the probe's registered owners; absence of arbitrary +foreign aliases is not inferred. Empty-container deallocation is source-backed +by the runtime release path, not measured by a nonexistent element destructor. + +The consuming route allocates `lean_alloc_array(0,m)`, acquires each selected +reference with `lean_array_uget`, initializes at most m entries with push, then +releases the old owner. Source positions cover prefix, an interval overlapping +the hypothetical in-place destination, tail and empty output. Temporary +source-plus-output storage is a distinct peak (336 requested array bytes for +the four-element replacement), while final exclusive retention is 56. + +Five injected failure stages have independently checked pre-cleanup states: +before allocation (no output), after allocation (output size zero), mid-copy +(size two), before handoff (full output and live source), and after consumption +(full output and absent source). Controlled failure consumes/cleans source and +initialized output, with an explicit retained-alias case. An omitted cleanup +action is measured and rejected before the harness repairs it. + +The separate `--fatal-oom` mode directly invokes the pinned runtime's fatal +handler. It exits 1 with exactly `INTERNAL PANIC: out of memory\n`, no stdout, +and `cleanupClaim=false`. This is a fatal-handler observation, not actual +allocator exhaustion or a recovery guarantee. All destructor-counted semantic +fixtures finish restored, with zero registered owners and exactly one destructor +call per allocated token. + +## Exact predicates, mutations and executable reach + +There is no new Lean theorem, formal machine or kernel trust assumption. +These are C runtime measurements plus independently checked operational +predicates. Let S be the measured handoff, n the fixture input count, b the +selected starting position and m its length, with `0 <= b`, `b+m <= n <= 6`. +All registered cases satisfy these guards; no claim quantifies over arbitrary +foreign programs or all allocator states. + +The strict successful-transfer predicate P requires: output values and source +IDs equal the independently specified interval; output size m and capacity at +most m; requested output bytes at most 24+8m; a unique new output container; +no source owner, old array alias or separate element alias; and, for every token +ID i in 0..5, actual reference count equal to the selected-interval indicator +and destructor count one exactly for discarded allocated tokens. The C +`transfer_predicate` and PowerShell `Get-LNMeasuredFailure` evaluate these +same projections. `Assert-LNSnapshot` additionally reconstructs counts from +actual observed array entries, deduplicating old array aliases. + +The cleanup predicate requires absent source/output owners; exactly the allowed +old alias (0 or 1), preserving original values with owner RC 1 when present; +and the corresponding exact element reference/destructor projections. +The alias-aware transfer predicate adds its declared old-array or element +reference contributions and never labels that result exclusive. + +| Negative operational fixture | Matching positive / full guard | P versus Q and exact rejecting surface | +| --- | --- | --- | +| `negative-shrink` | `replace-prefix`, n=6,b=0,m=2, aliases=0 | Q is the same strict P; actual shrink leaves capacity 32, so `capacity`, exit 3. | +| `negative-alias` | `replace-overlap`, n=6,b=1,m=4, allowed aliases=0 | Q is the same strict P; an actual old alias remains, so `ownership`, exit 3. The alias-aware positive is not substituted for P. | +| `negative-cleanup` | `fail-handoff`, n=6,b=1,m=4, old alias=0, stage=4 | Q is the same cleanup predicate; actual omission of output release leaves the buffer live, so `cleanup`, exit 3, before repair. | +| `negative-value` | `replace-overlap`, n=6,b=1,m=4, aliases=0 | Q is the same strict P; the first read copies position 0 instead of 1, so `values`, exit 3. | + +The registry fixes ordered IDs, all eight case-input fields, expected exits and +failure surfaces. The runner checks both C's complete tuple and actual stage +states. Relabeling real allocation-only failure output as mid-copy, or real +pre-consumption output as post-consumption failure, rejects at +`MEASUREMENT: intermediate`. This repairs the review finding that identical +phase names alone could pass without exercising the assigned cleanup stage. + +All executable expected values originate in the fixed registry/PowerShell +specification, never the implementation's result. The new C binary executes +the actual runtime array/RC operations; old RMQ replay is not its oracle. +There are no production/public theorem mutations or new public propositions, +so the inherited exact-type public consumer clause has no applicable target. +The committed operational mutation branches, registry and runner replay every +claimed native negative and repair omitted cleanup before exiting. No tracked +source is patched during replay; all checked source/tool/artifact hashes match +before and after. + +## Source grounding and consuming recommendation + +[RUNTIME_SOURCE.json](RUNTIME_SOURCE.json) records the exact runtime C++ source at +installed compiler commit `ba2cbbf09d4978f416e0ebd1fceeebc2c4138c05`. +The installed header defines size/capacity/requested bytes, reference-acquiring +array reads, shared-array copying and pop. Installed `Array.Basic.shrink` is +repeated pop. Runtime `lean_copy_expand_array(false)` preserves capacity and +acquires references when shared; destruction traverses initialized logical +entries then dispatches capacity-based deallocation. Source review and measured +release paths are distinct from a proof of allocator correctness. + +[BOUNDARY.md](BOUNDARY.md) gives the source-line mapping and exact relevant +existing propositions. In particular: + +- `Construction.ExecState` owns numeric registers, numeric memory, separate + optional Int keys and Int key registers, plus PC/status. `ArrayRun` also + retains ordinary categories/writes/reserves/result observations. +- `BuilderRunFacts.outputCells`, under final status `halted outBase`, gives + `s0.extent <= outBase`, final extent `outBase + (buildMemory xs).length`, + and exact output values for every in-range i. `inputRetained` explicitly + preserves original numeric cells and all keys. `arrayReflects` equates + executable projections and final abstraction under the stated initial-state + and 400-register-bank premises. None supplies native capacity or uniqueness. +- `Native.StorageImage` stores width/input length/register count, code and + memory. Its memory/code contain nested `Array UInt8` words. The loaded native + refinement requires canonical memory/state, exact encoded code, fitting + instructions, bounded register writes and safe reference execution on the same + decoded memory. +- Existing Rust `NativeImage` owns a `LoadOwner`; C exposes a borrowed image + and increments it for queries while retaining the load owner. This is immutable + reuse. Existing `canonicalImage` uses the original query program; the probe + does not imply an already implemented compact lifecycle adapter. + +Recommend an explicit consuming success/controlled-failure boundary, with all +construction array and observation roots inventoried. Acquire output references +before source release; publish only the reviewed output on success; release +initialized output/source on controlled failure. State whether array and element +aliases are prohibited or separately accounted. Account for transient old-plus-new +storage separately and prove/measure nested production capacities. The output +must be the exact image consumed by the reviewed formal query refinement. +Do not freeze a production BuilderOwner-to-QueryOwner ABI before LIFE-1's formal +interface review. The generic C buffer is evidence for ownership mechanics, not +a replacement for that formal or production adapter work. + +## Verification, provenance and limits + +Final-required evidence is indexed by [CERTIFICATION.json](CERTIFICATION.json). +The command ledger distinguishes the following checks: + +| Role | Command or executable surface | Result / scope | +| --- | --- | --- | +| Development | Bounded compiler startup, exact `pop-unique`, then focused `-SelfTest` | Passed after diagnosed header/runner repairs; full failed attempts retained. | +| Final native | `packed_native_lifecycle_storage_replay.ps1 -SelfTest` with Cases omitted | 23 cases, 58 stages, 65 checks; 161.682 s; exits 0; final frozen C/script/registry. | +| Native stage limits | Compiler 120 s; probes and shape/selector stages 30 s; descendant sleeper 8 s | Exact per-stage limits/exits/durations are in RESULTS. Overall owned deadline 1200 s. | +| Baseline regression | Direct pinned `lake.exe build`, source-verified independent copied cache, required mutex | Exit 0; native child 1.071 s, owned wrapper 2.931 s, 7200 s deadline. 1,125 matching source/config files, 4,208 copied artifacts; 188 complete warning blocks match prior baseline, empty stderr. | +| Frozen contract | `VERIFY_CONTRACT.ps1` | 12 exact ordered IDs, eight columns, full prompt cells and frozen strict UTF-8 row bytes. | +| Source-commit policy | Strict design with exact base and `-Head bea5ce75...`; committed-base whitespace | Exit 0, clean source commit, all 15 source-freeze paths classified. | +| Whole-repository claims | `scripts/claim_drift_scan.ps1 -Strict`, default roots, after draft report creation | Exit 0; 3,479 hits, zero strict failures; 2,211.841 s with a 3,600 s owned deadline; complete stdout/stderr retained. | +| Final package | Whole-base and per-commit strict design; strict claim scan after report creation; working/committed whitespace; raw Git/source bytes; final scope and clean status | Recorded in CERTIFICATION and final packaging receipt. | +| Trust hygiene | Required forbidden-token/Mathlib and native-decision scans over RMQ/lakefile | Both exit 1 meaning no matches; stderr empty. No Lean/lakefile changes or new axiom-bearing surfaces. | +| Conditional campaign | Aggregate gate, full existing native replay, independent fresh-blind final audit | Aggregate and audit are later coordinator campaign gates. Existing native replay is conditional on modifying predecessor native code, which did not occur. | + +The compiler remains installed Lean leanc/Clang 19.1.2 targeting +`x86_64-w64-windows-gnu`. The bundled distribution lacks general C standard +headers; the successful command uses the existing matching Strawberry x64 +MinGW standard headers plus an exact copied `mm_malloc.h`, leaving Clang's +own atomic definitions intact. It records 39 included headers, the actual link +map, 42 conservative archive/object link inputs, relevant binaries and source +headers; all are rehashed after replay. No installation was needed. + +Earlier attempts are retained below the same `.lake/lifecycle-native-p0/runs` +root: `785d1a1760fd4f7d8577046bf0b8aab0` (launcher emitted a task-return +object), `44feaf2019f0445f9830f2d6976a96bc` (missing stdio), +`37d35eb5db5f4f46a5af7c90d13f925b` (missing mm_malloc), and +`3744e3da42f24a21b9d66c3b91a713c1` (whole GCC builtin include caused atomic +header conflict). Each was rejected; each retry made the stated material +environment/runner correction. Development selector newline expectations were +corrected to actual C stream bytes. No failed attempt counts as native evidence. + +Raw stdout/stderr are copied as byte streams before a summary. Native and +launcher exits are separately checked. Mixed stderr, extra stdout, false verdict +labels/summaries and selector/registry anomalies reject. The output-limit control +retains oversized bytes and rejects; the final post-drain size check is also +source-reviewed. Do not infer that every overflow run traversed that final branch: +polling may catch overflow earlier. The sleeper proves root and descendant +absence after owned termination; a forcibly killed native child may have no +ordinary-exit receipt, which is explicitly distinguished from a successful +semantic run. The fatal-handler process is likewise separate. + +The executed host is PowerShell 7.6.5 on Windows 10.0.26200. Only this Windows +environment is certified here. The runner fails explicitly as +UNCOVERED on unsupported operating systems; it claims no POSIX test result. +C/runtime/compiler correctness, allocation availability for successful fixtures, +single-thread ownership and the declared registered-root model remain live +assumptions. Payload bits, proof fields, model ticks, runtime state, requested +allocation bytes and wall-clock duration remain distinct. C copying and release +loops are not single charged word-RAM instructions. Arbitrary Lean Int storage +is not silently treated as finite machine words. + +Full baseline outputs/provenance remain under +`C:/Users/poin/.codex/worktrees/af4b/RMQ/.lake/lifecycle-native-baseline/`; +[BASELINE.json](BASELINE.json) pins them. Baseline source was verified against +the clean exact-governance warm tree at +`C:/Users/poin/Documents/RMQ/.claude/worktrees/wf1-whole-project-audit/.lake/cold`. +Caches were copied and individually hashed, never shared. Subsequent C/docs +edits do not invalidate unchanged Lean-source regression evidence; no duplicate +build or aggregate was run. + +The default-root claim scan used source commit `bea5ce75...` and draft report +SHA-256 `43F14694FC97D7B1105170E3ED36A1F38F554749E04058D60B69F00E591E620C`. +The first invocation was interrupted because `Write-Host` bypassed its draft +redirection; it has no successful-exit claim. The corrected owned invocation +retained all 4,118,433 stdout bytes and empty stderr, and exited 0. Its long +runtime came from the unchanged paragraph regex over inherited records. A prior +same-policy, same-large-file run at `d0b4cef57e87540f4e333d15a5564bda8834227d` +took 1,265.16 s; that was a reference measurement, not a deadline guarantee. + +Final claim coverage composes that completed default-root PASS with a subsequent +unchanged-policy scan of the entire owned evidence directory and both decision +ledgers. The scanner evaluates each term and required attribution within one +file (`claim_drift_scan.ps1:338-456`); its final verdict only aggregates failures. +All 2,910 files outside that final rescan retain identical paths and bytes, and +the scanner, policy, ripgrep identity/configuration, repository working directory +and exclusion mode remain unchanged. This is completed full-scan plus final +changed-file coverage, not a second default-root execution or an added hit count. +Exact final package checks and content hashes are retained at +`C:/Users/poin/.codex/worktrees/af4b/RMQ/.lake/lifecycle-native-p0/checks/package-postcommit/receipt.json`. +The 230 recorded native/baseline evidence files were also rehashed successfully. + +## Frozen-row dispositions and proof/ownership digestion + +[ACCEPTANCE_MATRIX.md](ACCEPTANCE_MATRIX.md) preserves all frozen rows exactly +and appends evidence; `ACCEPTANCE_ROWS.txt` SHA-256 is +`F45113AE6BF3F769105A748B3D0A61EA99532A05A715410F11EF29E7E518EC29`. +`REQUIREMENTS.json` SHA-256 is +`0983881A85F9A3B42ECD54C0BFB18170C3BE3E5A65602CDE66547042CA5421C9`. +The local LF attribute fixes row transport; exact Git bytes and actual working +bytes are checked separately, not conflated with normalized historical logs. + +| Frozen ID | Disposition and evidence | +| --- | --- | +| LN0-01 | Closed: actual pinned runtime operations, distinct size/capacity/requested bytes/reference observations, source and compiler identities. | +| LN0-02 | Closed: unique/shared pop/shrink, surviving values, tail references, backing capacity, explicit owner/alias release and restoration. | +| LN0-03 | Closed: bounded replacement including empty/overlap/tail/aliases, all five measured failure pre-states, cleanup and separate fatal-handler result. | +| LN0-04 | Closed: exact registry; operational capacity/alias/cleanup/value negatives and matching positive predicates; independent measured verdict. | +| LN0-05 | Closed: owned bounded processes, raw streams and exits, mixed diagnostics, selectors, output bound and descendant cleanup; explicit Windows scope. | +| LN0-06 | Closed: source-grounded resource-to-owner recommendation in BOUNDARY; formal review precedes production ABI. | +| INV-SEMANTIC-NONVACUITY | Closed: predicates reconstruct operational projections, intermediate states and actual reference/destructor effects; no label-only liveness. | +| INV-ORACLE-INDEPENDENCE | Closed: frozen independent input/interval/source-ID specification, including wrong-copy negative. | +| INV-CATEGORY-SEPARATION | Closed: native measured scope and remaining formal/allocator/Int distinctions are explicit. | +| INV-MUTATION-REPRODUCIBILITY | Closed: committed runner/registry/operational mutation cases, exact surfaces, positive controls, post-observation cleanup and source restoration. | +| CHK-FINAL | Closed in local review: complete native replay and baseline, completed default-root scan plus final changed-file scan, frozen contract, strict design, hygiene, whitespace, exact source/evidence/report identities; CERTIFICATION and the exact packaging receipt retain outcomes. | +| CHK-SCOPE | Closed in local review: exact-base private branch, 17 assigned paths, append-only ledgers, all frozen row bytes preserved, clean committed packaging verified at handoff; no publication or coordinator acceptance. | + +Conceptually, the work separates losing a reference, shortening a logical array, +and reducing retained allocation capacity. In plain English, deleting four list +positions can destroy four values while leaving the entire old backing buffer. +Copying the required values to an exactly sized buffer and releasing the old +owner reduces the retained container, but an old alias prevents that reduction. + +For a worked case, copying positions [1,5) gives `[-7,303,303,505]`. +Before old-owner release, selected objects have two references. Afterwards, IDs +0 and 5 are destroyed, four output objects remain with one reference each, and +only the 56-byte output container is reachable through the probe's roots. Retain +an old array alias and the same values instead coexist with 336 array bytes and +ten element references. This difference is observed, not inferred from a label. + +A skeptical reviewer should next inspect whether the eventual compiled adapter +retires every construction root and transfers the exact reviewed image; whether +nested production headers/limbs and alias enforcement meet the retained succinct +target; and whether the formal lifecycle's charged transitions compose with that +native boundary. Those are the explicitly downstream adapter/campaign phases, +not unmet local probe requirements. No local candidate status closes LIFE-1, +the lifecycle roadmap node, native heap verification or publication. + +DD-20260920-LIFE-NATIVE-P0-001 records representation/ownership choices; +WDD-20260920-LIFE-NATIVE-P0-001 records frozen rows, measured verdict reach, +header/dependency provenance, failure feedback and process discipline. A bounded +independent source reviewer checked the C lifetimes and matching predicates, +found the three runner issues described above, and confirmed their repairs on +the final hashes. That review is not a fresh-blind final campaign audit. +WDD-20260920-LIFE-NATIVE-P0-002 records the source/report packaging boundary and +the full-scan plus final changed-file certification method. No representation +decision changes in the documentation-only packaging commit. + +## Source and artifact hashes + +| Artifact | SHA-256 | +| --- | --- | +| Final C probe | `5F32F4A91B21697F86B4F2FEA855CD050E59E330CE6C6FFDA28898353B66D7B1` | +| Final replay script | `077BF8D478141F8891AB6F9C2E332CBF8C8F75ACA32C722B29BD307924957B8E` | +| Final registry | `6CD97F40E7C39D2212A8C8705D264D4832DCF2542815B72CD927906A01DC8B20` | +| Compiled probe, 7,091,712 bytes | `67E6A077C19D0D5DE89F55E28097339EA7162FDA3664F99230C179443DCE2C7C` | +| Compact RESULTS.json | `6440A963BE7A0E65222F86AFE3CFB89E4BEE1B6BDCD0226DC0D5CDA88D296FDD` | +| Reviewed exact-commit runtime object.cpp | `44C1430D9C6DA2FE9FDE073D407F9FD58860D869D09B8C7EA0BC0E27D85916FB` | + +All remaining runtime/header/compiler/raw-output hashes are carried by RESULTS, +its pinned full summary and BASELINE. The final report hash and byte length are +issued after writing this entire report, in the final certification/handoff; +they are not recursively embedded into the report's own bytes. diff --git a/docs/internal/extensions/lifecycle-native-p0/REQUIREMENTS.json b/docs/internal/extensions/lifecycle-native-p0/REQUIREMENTS.json new file mode 100644 index 00000000..934885ad --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/REQUIREMENTS.json @@ -0,0 +1,50 @@ +[ + [ + "LN0-01", + "Implement a reproducible probe of the pinned Lean 4.22 runtime array ownership operations, without altering the production RMQ ABI. Record logical size, retained capacity, requested container bytes and live element references as distinct quantities. Inspect actual runtime definitions and record compiler/runtime/header identity; do not infer capacity from Array.size." + ], + [ + "LN0-02", + "Exercise unique and shared owners with destructor-counted elements. Demonstrate the actual effects of pop/shrink on surviving values, tail element references and retained backing capacity, without accessing freed objects. Distinguish release of one owner from reclamation when another alias remains live." + ], + [ + "LN0-03", + "Exercise a consuming replacement-buffer route: copy surviving output values into a newly allocated bounded-capacity buffer, release the old owner, and measure which old allocations/elements remain reachable. Include success, empty output, overlap-relevant source positions, alias-retained and deterministically injected handoff/allocation-stage failure cleanup. Do not assume actual Lean allocator failure is recoverable; a fatal process outcome is reported separately. Treat observed allocator/requested capacity separately from a universal native heap theorem." + ], + [ + "LN0-04", + "Commit an exact replay registry and positive/negative controls for logical shrink falsely labeled reclamation, retained alias falsely labeled exclusive consumption, and an omitted cleanup action. Validation executes the actual pinned runtime operations and the owned measurement/verdict path; predecessor RMQ replay is regression evidence only. The verdict must depend on observed value/ownership/capacity projections, not labels or a prewritten expected log; use the same positive predicate or a checked/explicit measured implication." + ], + [ + "LN0-05", + "Use bounded owned compiler/probe processes, preserve full stdout/stderr and actual exits, reject unexpected or mixed diagnostics, validate focused/unknown/empty selector behavior, and exercise cleanup. A platform/toolchain inability is uncovered, not success. No credit purchase, package installation or persistent service is needed as an assumed prerequisite." + ], + [ + "LN0-06", + "Deliver a source-grounded consuming-boundary recommendation mapping Construction.ExecState resources and Native.StorageImage/NativeImage ownership to later transfer obligations. Specify success/failure ownership, aliases, retained observations and capacity. Do not implement a speculative production BuilderOwner-to-QueryOwner ABI before the formal lifecycle interface is reviewed." + ], + [ + "INV-SEMANTIC-NONVACUITY", + "semantic coverage, liveness, ownership, and refinement predicates are derived from the operational construction they describe. A predicate defined to be `True`, an enumeration restated as membership, or a separately hand-written consumer label does not establish operational liveness by itself;" + ], + [ + "INV-ORACLE-INDEPENDENCE", + "executable fixtures and edge-case expected values come from an independent specification or a theorem already connected to it, never from the implementation result being tested;" + ], + [ + "INV-CATEGORY-SEPARATION", + "payload bits, proof fields, model ticks, machine state, Lean runtime, and measured performance remain distinct." + ], + [ + "INV-MUTATION-REPRODUCIBILITY", + "when acceptance relies on an exhaustive, production, or public-dependency mutation campaign, the candidate contains a versioned runner or fixtures that replay every claimed case, check the exact expected failure/acceptance surface, restore tracked state, and leave the tree clean. Report prose, copied terminal output, and dangling Git objects are not replayable evidence. A public theorem additionally has a checked exact-type consumer that fails when the advertised dependency is removed; `#print axioms` over the theorem's current type is not such a consumer." + ], + [ + "CHK-FINAL", + "Run the final-required checks on the final submitted content, with exact identities, complete outcomes and declared platform limits." + ], + [ + "CHK-SCOPE", + "Keep the assigned write scope, clean committed tree, exact base, full frozen row integrity and truthful local-versus-campaign status." + ] +] diff --git a/docs/internal/extensions/lifecycle-native-p0/RESULTS.json b/docs/internal/extensions/lifecycle-native-p0/RESULTS.json new file mode 100644 index 00000000..bca83196 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/RESULTS.json @@ -0,0 +1 @@ +{"status":"PASS","sourceBase":"bf31f983205175481fcb659caa4dfb70ef43e361","runRoot":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4","outerReceipt":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\final-5a155de9bddb4157bb5ff71eb8d515aa/receipt.json","bytes":902,"sha256":"79B0B691D735A55A64BB82F156DEDAB68C97DB4BA23048F2FFB35919575DEAFA"},"rawSummary":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4/SUMMARY.json","bytes":131413,"sha256":"0E7DCC42E1EA66C0FF1C8A8AD7ED791FEA786189FA6E38A52BF8B5B55954CD12"},"outerStdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\final-5a155de9bddb4157bb5ff71eb8d515aa/runner.stdout.log","bytes":177,"sha256":"614A66220903F98BC00C2A83BAE5F93316BCACE7DB528CDA85EC2F0B5A377456"},"outerStderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\final-5a155de9bddb4157bb5ff71eb8d515aa/runner.stderr.log","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"},"outerDurationSeconds":161.682,"mutex":"Local\\RMQLifecycleImplementationHeavy20260920","mutexAcquiredUtc":"2026-09-21T00:02:49.7502538Z","mutexReleasedUtc":"2026-09-21T00:05:31.6285686Z","actualRunnerExit":0,"sourcePins":[{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\scripts\\packed_native_lifecycle_storage_replay.ps1","bytes":41479,"sha256":"077BF8D478141F8891AB6F9C2E332CBF8C8F75ACA32C722B29BD307924957B8E"},{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\docs\\internal\\extensions\\lifecycle-native-p0\\REGISTRY.json","bytes":5899,"sha256":"6CD97F40E7C39D2212A8C8705D264D4832DCF2542815B72CD927906A01DC8B20"},{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\native\\packed-rmq\\tests\\lifecycle_storage_probe.c","bytes":14720,"sha256":"5F32F4A91B21697F86B4F2FEA855CD050E59E330CE6C6FFDA28898353B66D7B1"},{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\scripts\\owned_process_tree.ps1","bytes":47060,"sha256":"6690AD4F9E3AEE9596E53E89D3D242E4BE59C0A04733BC50184AE35B292FF90E"},{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\lean-toolchain","bytes":28,"sha256":"AD3E6363C78908C80953282BAF57162702F1134173A5247AAD3DBFEA108A525F"}],"runtimeIdentities":[{"path":"C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\lean.exe","bytes":82432,"sha256":"9B5AF669D8DC9B5826A1F5427584915EECA659E9BF34C7EE72667B93C0BFDCB0"},{"path":"C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\leanc.exe","bytes":107520,"sha256":"DE2FDFEA989B9A771DA37E44EFD0BD50C00A2E2835EF9A2408F44E2385EA7618"},{"path":"C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\clang.exe","bytes":224256,"sha256":"64B1E469B15149BD23039F1D121DE6E14F4AEC84BFF000952CA85968E56CE391"},{"path":"C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\ld.lld.exe","bytes":5927424,"sha256":"6582CC45822AF5CF9A9C6245E75B85C445759C761F9B793F47BA919AD36AA643"},{"path":"C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libInit_shared.dll","bytes":18534912,"sha256":"5300B06EA3A45146C22996B0591CC6475ACB5B6B77802EDBECD65BAAD6485386"},{"path":"C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libleanshared.dll","bytes":75793408,"sha256":"54E0F641AE412B687BBC64EA1C069A9954E754775ED0D3379C9847BC3B9FDA89"},{"path":"C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libleanshared_1.dll","bytes":45882368,"sha256":"1378336D32450B713FDFDA31BA2829E34831FAE74BA3E503A49FB2EE96B65F5A"},{"path":"C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\include\\lean\\lean.h","bytes":123151,"sha256":"C9932086EF1625DE0FBA02453F53B8F6A3571BA88960B975C9E39B724F24CC4D"},{"path":"C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\src\\lean\\Init\\Data\\Array\\Basic.lean","bytes":75317,"sha256":"4F5375CAAD49227982FB6002C5647438C1C6E7553B48AF97EC52E46096DE73D1"},{"path":"C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\lib\\lean\\libleanrt.a","bytes":1020012,"sha256":"FB166090D0300BC4E19E3EB90F132F1B44997CC1AADD2785E03DD65CD5B38A45"}],"shell":{"path":"C:\\Users\\poin\\.cache\\codex-runtimes\\codex-primary-runtime\\dependencies\\native\\powershell\\pwsh.exe","bytes":301368,"sha256":"362A356CE7F0940EC74F73A8FC2C990A2CC24A38A11C90BBD8ECA947110AD139"},"compilerVersion":"clang version 19.1.2\nTarget: x86_64-w64-windows-gnu\nThread model: posix\nInstalledDir: C:/Users/poin/.elan/toolchains/leanprover--lean4---v4.22.0/bin\n","leanVersion":"Lean (version 4.22.0, x86_64-w64-windows-gnu, commit ba2cbbf09d4978f416e0ebd1fceeebc2c4138c05, Release)\n","includedHeaderCount":39,"linkInputCount":42,"binary":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\lifecycle_storage_probe.exe","bytes":7091712,"sha256":"67E6A077C19D0D5DE89F55E28097339EA7162FDA3664F99230C179443DCE2C7C"},"linkMap":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\link.map","bytes":4381803,"sha256":"AAAE18A7A7406EFE11E6AEB8004F4ABBB2C1C883F66F338926B87D606668A01B"},"platformLimit":"Windows pinned Lean runtime measurements; POSIX and universal heap claims uncovered","semanticCaseCount":23,"checkCount":65,"stageCount":58,"checks":[{"id":"fatal-runtime-handler","cleanupClaim":false,"actualExit":1,"outcome":"fatal-process-observed","scope":"Direct fatal-handler invocation; neither actual exhaustion nor recoverable allocator failure"},{"id":"pop-unique","expectedExit":0,"failure":"none","outcome":"matched"},{"id":"shrink-unique","expectedExit":0,"failure":"none","outcome":"matched"},{"id":"pop-shared","expectedExit":0,"failure":"none","outcome":"matched"},{"id":"shrink-shared","expectedExit":0,"failure":"none","outcome":"matched"},{"id":"pop-empty-unique","expectedExit":0,"failure":"none","outcome":"matched"},{"id":"pop-empty-shared","expectedExit":0,"failure":"none","outcome":"matched"},{"id":"shrink-noop","expectedExit":0,"failure":"none","outcome":"matched"},{"id":"replace-prefix","expectedExit":0,"failure":"none","outcome":"matched"},{"id":"replace-overlap","expectedExit":0,"failure":"none","outcome":"matched"},{"id":"replace-tail","expectedExit":0,"failure":"none","outcome":"matched"},{"id":"replace-empty","expectedExit":0,"failure":"none","outcome":"matched"},{"id":"replace-alias","expectedExit":0,"failure":"none","outcome":"matched"},{"id":"replace-element-alias","expectedExit":0,"failure":"none","outcome":"matched"},{"id":"fail-alloc","expectedExit":0,"failure":"none","outcome":"matched"},{"id":"fail-after-alloc","expectedExit":0,"failure":"none","outcome":"matched"},{"id":"fail-mid-copy","expectedExit":0,"failure":"none","outcome":"matched"},{"id":"fail-handoff","expectedExit":0,"failure":"none","outcome":"matched"},{"id":"fail-after-consume","expectedExit":0,"failure":"none","outcome":"matched"},{"id":"fail-alias","expectedExit":0,"failure":"none","outcome":"matched"},{"id":"negative-shrink","expectedExit":3,"failure":"capacity","outcome":"matched"},{"id":"negative-alias","expectedExit":3,"failure":"ownership","outcome":"matched"},{"id":"negative-cleanup","expectedExit":3,"failure":"cleanup","outcome":"matched"},{"id":"negative-value","expectedExit":3,"failure":"values","outcome":"matched"},{"id":"selector-omitted","surface":"","outcome":"matched"},{"id":"selector-focused","surface":"","outcome":"matched"},{"id":"selector-reordered","surface":"","outcome":"matched"},{"id":"selector-empty","surface":"SELECTOR: explicit empty selector","outcome":"matched"},{"id":"selector-whitespace","surface":"SELECTOR: explicit empty selector","outcome":"matched"},{"id":"selector-unknown","surface":"SELECTOR: unknown ID","outcome":"matched"},{"id":"selector-zero","surface":"SELECTOR: unknown ID","outcome":"matched"},{"id":"selector-case","surface":"SELECTOR: unknown ID","outcome":"matched"},{"id":"selector-duplicate","surface":"SELECTOR: duplicate ID","outcome":"matched"},{"id":"selector-missing","surface":"SELECTOR: missing ID","outcome":"matched"},{"id":"registry-missing","surface":"REGISTRY: cardinality differs","outcome":"expected-reject"},{"id":"registry-duplicate","surface":"REGISTRY: duplicate ID","outcome":"expected-reject"},{"id":"registry-unknown","surface":"REGISTRY: ordered IDs differ","outcome":"expected-reject"},{"id":"registry-reordered","surface":"REGISTRY: ordered IDs differ","outcome":"expected-reject"},{"id":"registry-mapping","surface":"REGISTRY: input mapping differs","outcome":"expected-reject"},{"id":"registry-unknown-key","surface":"REGISTRY: property set differs","outcome":"expected-reject"},{"id":"registry-missing-key","surface":"REGISTRY: property set differs","outcome":"expected-reject"},{"id":"native-missing-command","surface":"SELECTOR: invalid invocation","outcome":"expected-reject"},{"id":"native-missing-id","surface":"SELECTOR: invalid invocation","outcome":"expected-reject"},{"id":"native-empty","surface":"SELECTOR: invalid invocation","outcome":"expected-reject"},{"id":"native-whitespace","surface":"SELECTOR: unknown case","outcome":"expected-reject"},{"id":"native-unknown","surface":"SELECTOR: unknown case","outcome":"expected-reject"},{"id":"native-duplicate","surface":"SELECTOR: invalid invocation","outcome":"expected-reject"},{"id":"verdict-control-replace-prefix","surface":"none","outcome":"measured-control"},{"id":"mixed-stderr-replace-prefix","surface":"DIAGNOSTIC:","outcome":"expected-reject"},{"id":"mixed-stdout-replace-prefix","surface":"DIAGNOSTIC:","outcome":"expected-reject"},{"id":"false-label-replace-prefix","surface":"MEASUREMENT:","outcome":"expected-reject"},{"id":"false-summary-replace-prefix","surface":"MEASUREMENT:","outcome":"expected-reject"},{"id":"verdict-control-negative-shrink","surface":"capacity","outcome":"measured-control"},{"id":"mixed-stderr-negative-shrink","surface":"DIAGNOSTIC:","outcome":"expected-reject"},{"id":"mixed-stdout-negative-shrink","surface":"DIAGNOSTIC:","outcome":"expected-reject"},{"id":"false-label-negative-shrink","surface":"MEASUREMENT:","outcome":"expected-reject"},{"id":"false-summary-negative-shrink","surface":"MEASUREMENT:","outcome":"expected-reject"},{"id":"omitted-stage-fail-mid-copy","surface":"MEASUREMENT: intermediate","outcome":"expected-reject"},{"id":"stage-control-fail-after-alloc","challenged":"fail-mid-copy","outcome":"actual-boundary-accepts"},{"id":"omitted-stage-fail-after-consume","surface":"MEASUREMENT: intermediate","outcome":"expected-reject"},{"id":"stage-control-fail-handoff","challenged":"fail-after-consume","outcome":"actual-boundary-accepts"},{"id":"fast-overflow-verdict","surface":"PROCESS:","outcome":"expected-reject"},{"id":"fast-overflow","actualChildExit":null,"bytes":9437184,"outcome":"expected-reject"},{"id":"timeout-no-success","surface":"PROCESS:","outcome":"expected-reject"},{"id":"owned-descendant-timeout","nativeRoot":27376,"actualExitAvailable":false,"outcome":"expected-timeout-root-and-descendant-absent","grandchild":26824}],"cases":[{"id":"pop-unique","verdict":"ACCEPT","failure":"none","handoff":{"phase":"handoff","sizes":[0,0,5],"capacities":[0,0,32],"requestedBytes":[0,0,280],"ownerRC":[0,0,1],"oldRoots":[0,0,1],"outputValues":[101,-7,303,303,505],"outputIds":[0,1,2,3,4],"destroyed":[0,0,0,0,0,1],"elementRC":[1,1,1,1,1,0],"liveElements":5,"elementReferences":5,"uniqueArrays":1,"totalContainerBytes":280,"oldReachable":1,"externalElement":-1},"failureBeforeCleanup":null,"peakObservedContainerBytes":280.0,"restoredDestroyed":[1,1,1,1,1,1],"cleanupComplete":true},{"id":"shrink-unique","verdict":"ACCEPT","failure":"none","handoff":{"phase":"handoff","sizes":[0,0,2],"capacities":[0,0,32],"requestedBytes":[0,0,280],"ownerRC":[0,0,1],"oldRoots":[0,0,1],"outputValues":[101,-7],"outputIds":[0,1],"destroyed":[0,0,1,1,1,1],"elementRC":[1,1,0,0,0,0],"liveElements":2,"elementReferences":2,"uniqueArrays":1,"totalContainerBytes":280,"oldReachable":1,"externalElement":-1},"failureBeforeCleanup":null,"peakObservedContainerBytes":280.0,"restoredDestroyed":[1,1,1,1,1,1],"cleanupComplete":true},{"id":"pop-shared","verdict":"ACCEPT","failure":"none","handoff":{"phase":"handoff","sizes":[0,6,5],"capacities":[0,32,32],"requestedBytes":[0,280,280],"ownerRC":[0,1,1],"oldRoots":[0,1,0],"outputValues":[101,-7,303,303,505],"outputIds":[0,1,2,3,4],"destroyed":[0,0,0,0,0,0],"elementRC":[2,2,2,2,2,1],"liveElements":6,"elementReferences":11,"uniqueArrays":2,"totalContainerBytes":560,"oldReachable":1,"externalElement":-1},"failureBeforeCleanup":null,"peakObservedContainerBytes":560.0,"restoredDestroyed":[1,1,1,1,1,1],"cleanupComplete":true},{"id":"shrink-shared","verdict":"ACCEPT","failure":"none","handoff":{"phase":"handoff","sizes":[0,6,2],"capacities":[0,32,32],"requestedBytes":[0,280,280],"ownerRC":[0,1,1],"oldRoots":[0,1,0],"outputValues":[101,-7],"outputIds":[0,1],"destroyed":[0,0,0,0,0,0],"elementRC":[2,2,1,1,1,1],"liveElements":6,"elementReferences":8,"uniqueArrays":2,"totalContainerBytes":560,"oldReachable":1,"externalElement":-1},"failureBeforeCleanup":null,"peakObservedContainerBytes":560.0,"restoredDestroyed":[1,1,1,1,1,1],"cleanupComplete":true},{"id":"pop-empty-unique","verdict":"ACCEPT","failure":"none","handoff":{"phase":"handoff","sizes":[0,0,0],"capacities":[0,0,32],"requestedBytes":[0,0,280],"ownerRC":[0,0,1],"oldRoots":[0,0,1],"outputValues":[],"outputIds":[],"destroyed":[0,0,0,0,0,0],"elementRC":[0,0,0,0,0,0],"liveElements":0,"elementReferences":0,"uniqueArrays":1,"totalContainerBytes":280,"oldReachable":1,"externalElement":-1},"failureBeforeCleanup":null,"peakObservedContainerBytes":280.0,"restoredDestroyed":[0,0,0,0,0,0],"cleanupComplete":true},{"id":"pop-empty-shared","verdict":"ACCEPT","failure":"none","handoff":{"phase":"handoff","sizes":[0,0,0],"capacities":[0,32,32],"requestedBytes":[0,280,280],"ownerRC":[0,1,1],"oldRoots":[0,1,0],"outputValues":[],"outputIds":[],"destroyed":[0,0,0,0,0,0],"elementRC":[0,0,0,0,0,0],"liveElements":0,"elementReferences":0,"uniqueArrays":2,"totalContainerBytes":560,"oldReachable":1,"externalElement":-1},"failureBeforeCleanup":null,"peakObservedContainerBytes":560.0,"restoredDestroyed":[0,0,0,0,0,0],"cleanupComplete":true},{"id":"shrink-noop","verdict":"ACCEPT","failure":"none","handoff":{"phase":"handoff","sizes":[0,0,6],"capacities":[0,0,32],"requestedBytes":[0,0,280],"ownerRC":[0,0,1],"oldRoots":[0,0,1],"outputValues":[101,-7,303,303,505,-19],"outputIds":[0,1,2,3,4,5],"destroyed":[0,0,0,0,0,0],"elementRC":[1,1,1,1,1,1],"liveElements":6,"elementReferences":6,"uniqueArrays":1,"totalContainerBytes":280,"oldReachable":1,"externalElement":-1},"failureBeforeCleanup":null,"peakObservedContainerBytes":280.0,"restoredDestroyed":[1,1,1,1,1,1],"cleanupComplete":true},{"id":"replace-prefix","verdict":"ACCEPT","failure":"none","handoff":{"phase":"handoff","sizes":[0,0,2],"capacities":[0,0,2],"requestedBytes":[0,0,40],"ownerRC":[0,0,1],"oldRoots":[0,0,0],"outputValues":[101,-7],"outputIds":[0,1],"destroyed":[0,0,1,1,1,1],"elementRC":[1,1,0,0,0,0],"liveElements":2,"elementReferences":2,"uniqueArrays":1,"totalContainerBytes":40,"oldReachable":0,"externalElement":-1},"failureBeforeCleanup":null,"peakObservedContainerBytes":320.0,"restoredDestroyed":[1,1,1,1,1,1],"cleanupComplete":true},{"id":"replace-overlap","verdict":"ACCEPT","failure":"none","handoff":{"phase":"handoff","sizes":[0,0,4],"capacities":[0,0,4],"requestedBytes":[0,0,56],"ownerRC":[0,0,1],"oldRoots":[0,0,0],"outputValues":[-7,303,303,505],"outputIds":[1,2,3,4],"destroyed":[1,0,0,0,0,1],"elementRC":[0,1,1,1,1,0],"liveElements":4,"elementReferences":4,"uniqueArrays":1,"totalContainerBytes":56,"oldReachable":0,"externalElement":-1},"failureBeforeCleanup":null,"peakObservedContainerBytes":336.0,"restoredDestroyed":[1,1,1,1,1,1],"cleanupComplete":true},{"id":"replace-tail","verdict":"ACCEPT","failure":"none","handoff":{"phase":"handoff","sizes":[0,0,2],"capacities":[0,0,2],"requestedBytes":[0,0,40],"ownerRC":[0,0,1],"oldRoots":[0,0,0],"outputValues":[505,-19],"outputIds":[4,5],"destroyed":[1,1,1,1,0,0],"elementRC":[0,0,0,0,1,1],"liveElements":2,"elementReferences":2,"uniqueArrays":1,"totalContainerBytes":40,"oldReachable":0,"externalElement":-1},"failureBeforeCleanup":null,"peakObservedContainerBytes":320.0,"restoredDestroyed":[1,1,1,1,1,1],"cleanupComplete":true},{"id":"replace-empty","verdict":"ACCEPT","failure":"none","handoff":{"phase":"handoff","sizes":[0,0,0],"capacities":[0,0,0],"requestedBytes":[0,0,24],"ownerRC":[0,0,1],"oldRoots":[0,0,0],"outputValues":[],"outputIds":[],"destroyed":[1,1,1,1,1,1],"elementRC":[0,0,0,0,0,0],"liveElements":0,"elementReferences":0,"uniqueArrays":1,"totalContainerBytes":24,"oldReachable":0,"externalElement":-1},"failureBeforeCleanup":null,"peakObservedContainerBytes":304.0,"restoredDestroyed":[1,1,1,1,1,1],"cleanupComplete":true},{"id":"replace-alias","verdict":"ACCEPT","failure":"none","handoff":{"phase":"handoff","sizes":[0,6,4],"capacities":[0,32,4],"requestedBytes":[0,280,56],"ownerRC":[0,1,1],"oldRoots":[0,1,0],"outputValues":[-7,303,303,505],"outputIds":[1,2,3,4],"destroyed":[0,0,0,0,0,0],"elementRC":[1,2,2,2,2,1],"liveElements":6,"elementReferences":10,"uniqueArrays":2,"totalContainerBytes":336,"oldReachable":1,"externalElement":-1},"failureBeforeCleanup":null,"peakObservedContainerBytes":336.0,"restoredDestroyed":[1,1,1,1,1,1],"cleanupComplete":true},{"id":"replace-element-alias","verdict":"ACCEPT","failure":"none","handoff":{"phase":"handoff","sizes":[0,0,2],"capacities":[0,0,2],"requestedBytes":[0,0,40],"ownerRC":[0,0,1],"oldRoots":[0,0,0],"outputValues":[505,-19],"outputIds":[4,5],"destroyed":[0,1,1,1,0,0],"elementRC":[1,0,0,0,1,1],"liveElements":3,"elementReferences":3,"uniqueArrays":1,"totalContainerBytes":40,"oldReachable":0,"externalElement":0},"failureBeforeCleanup":null,"peakObservedContainerBytes":320.0,"restoredDestroyed":[1,1,1,1,1,1],"cleanupComplete":true},{"id":"fail-alloc","verdict":"ACCEPT","failure":"none","handoff":{"phase":"handoff","sizes":[0,0,0],"capacities":[0,0,0],"requestedBytes":[0,0,0],"ownerRC":[0,0,0],"oldRoots":[0,0,0],"outputValues":[],"outputIds":[],"destroyed":[1,1,1,1,1,1],"elementRC":[0,0,0,0,0,0],"liveElements":0,"elementReferences":0,"uniqueArrays":0,"totalContainerBytes":0,"oldReachable":0,"externalElement":-1},"failureBeforeCleanup":{"phase":"failure-before-cleanup","sizes":[6,0,0],"capacities":[32,0,0],"requestedBytes":[280,0,0],"ownerRC":[1,0,0],"oldRoots":[1,0,0],"outputValues":[],"outputIds":[],"destroyed":[0,0,0,0,0,0],"elementRC":[1,1,1,1,1,1],"liveElements":6,"elementReferences":6,"uniqueArrays":1,"totalContainerBytes":280,"oldReachable":1,"externalElement":-1},"peakObservedContainerBytes":280.0,"restoredDestroyed":[1,1,1,1,1,1],"cleanupComplete":true},{"id":"fail-after-alloc","verdict":"ACCEPT","failure":"none","handoff":{"phase":"handoff","sizes":[0,0,0],"capacities":[0,0,0],"requestedBytes":[0,0,0],"ownerRC":[0,0,0],"oldRoots":[0,0,0],"outputValues":[],"outputIds":[],"destroyed":[1,1,1,1,1,1],"elementRC":[0,0,0,0,0,0],"liveElements":0,"elementReferences":0,"uniqueArrays":0,"totalContainerBytes":0,"oldReachable":0,"externalElement":-1},"failureBeforeCleanup":{"phase":"failure-before-cleanup","sizes":[6,0,0],"capacities":[32,0,4],"requestedBytes":[280,0,56],"ownerRC":[1,0,1],"oldRoots":[1,0,0],"outputValues":[],"outputIds":[],"destroyed":[0,0,0,0,0,0],"elementRC":[1,1,1,1,1,1],"liveElements":6,"elementReferences":6,"uniqueArrays":2,"totalContainerBytes":336,"oldReachable":1,"externalElement":-1},"peakObservedContainerBytes":336.0,"restoredDestroyed":[1,1,1,1,1,1],"cleanupComplete":true},{"id":"fail-mid-copy","verdict":"ACCEPT","failure":"none","handoff":{"phase":"handoff","sizes":[0,0,0],"capacities":[0,0,0],"requestedBytes":[0,0,0],"ownerRC":[0,0,0],"oldRoots":[0,0,0],"outputValues":[],"outputIds":[],"destroyed":[1,1,1,1,1,1],"elementRC":[0,0,0,0,0,0],"liveElements":0,"elementReferences":0,"uniqueArrays":0,"totalContainerBytes":0,"oldReachable":0,"externalElement":-1},"failureBeforeCleanup":{"phase":"failure-before-cleanup","sizes":[6,0,2],"capacities":[32,0,4],"requestedBytes":[280,0,56],"ownerRC":[1,0,1],"oldRoots":[1,0,0],"outputValues":[-7,303],"outputIds":[1,2],"destroyed":[0,0,0,0,0,0],"elementRC":[1,2,2,1,1,1],"liveElements":6,"elementReferences":8,"uniqueArrays":2,"totalContainerBytes":336,"oldReachable":1,"externalElement":-1},"peakObservedContainerBytes":336.0,"restoredDestroyed":[1,1,1,1,1,1],"cleanupComplete":true},{"id":"fail-handoff","verdict":"ACCEPT","failure":"none","handoff":{"phase":"handoff","sizes":[0,0,0],"capacities":[0,0,0],"requestedBytes":[0,0,0],"ownerRC":[0,0,0],"oldRoots":[0,0,0],"outputValues":[],"outputIds":[],"destroyed":[1,1,1,1,1,1],"elementRC":[0,0,0,0,0,0],"liveElements":0,"elementReferences":0,"uniqueArrays":0,"totalContainerBytes":0,"oldReachable":0,"externalElement":-1},"failureBeforeCleanup":{"phase":"failure-before-cleanup","sizes":[6,0,4],"capacities":[32,0,4],"requestedBytes":[280,0,56],"ownerRC":[1,0,1],"oldRoots":[1,0,0],"outputValues":[-7,303,303,505],"outputIds":[1,2,3,4],"destroyed":[0,0,0,0,0,0],"elementRC":[1,2,2,2,2,1],"liveElements":6,"elementReferences":10,"uniqueArrays":2,"totalContainerBytes":336,"oldReachable":1,"externalElement":-1},"peakObservedContainerBytes":336.0,"restoredDestroyed":[1,1,1,1,1,1],"cleanupComplete":true},{"id":"fail-after-consume","verdict":"ACCEPT","failure":"none","handoff":{"phase":"handoff","sizes":[0,0,0],"capacities":[0,0,0],"requestedBytes":[0,0,0],"ownerRC":[0,0,0],"oldRoots":[0,0,0],"outputValues":[],"outputIds":[],"destroyed":[1,1,1,1,1,1],"elementRC":[0,0,0,0,0,0],"liveElements":0,"elementReferences":0,"uniqueArrays":0,"totalContainerBytes":0,"oldReachable":0,"externalElement":-1},"failureBeforeCleanup":{"phase":"failure-before-cleanup","sizes":[0,0,4],"capacities":[0,0,4],"requestedBytes":[0,0,56],"ownerRC":[0,0,1],"oldRoots":[0,0,0],"outputValues":[-7,303,303,505],"outputIds":[1,2,3,4],"destroyed":[1,0,0,0,0,1],"elementRC":[0,1,1,1,1,0],"liveElements":4,"elementReferences":4,"uniqueArrays":1,"totalContainerBytes":56,"oldReachable":0,"externalElement":-1},"peakObservedContainerBytes":336.0,"restoredDestroyed":[1,1,1,1,1,1],"cleanupComplete":true},{"id":"fail-alias","verdict":"ACCEPT","failure":"none","handoff":{"phase":"handoff","sizes":[0,6,0],"capacities":[0,32,0],"requestedBytes":[0,280,0],"ownerRC":[0,1,0],"oldRoots":[0,1,0],"outputValues":[],"outputIds":[],"destroyed":[0,0,0,0,0,0],"elementRC":[1,1,1,1,1,1],"liveElements":6,"elementReferences":6,"uniqueArrays":1,"totalContainerBytes":280,"oldReachable":1,"externalElement":-1},"failureBeforeCleanup":{"phase":"failure-before-cleanup","sizes":[6,6,2],"capacities":[32,32,4],"requestedBytes":[280,280,56],"ownerRC":[2,2,1],"oldRoots":[1,1,0],"outputValues":[-7,303],"outputIds":[1,2],"destroyed":[0,0,0,0,0,0],"elementRC":[1,2,2,1,1,1],"liveElements":6,"elementReferences":8,"uniqueArrays":2,"totalContainerBytes":336,"oldReachable":1,"externalElement":-1},"peakObservedContainerBytes":336.0,"restoredDestroyed":[1,1,1,1,1,1],"cleanupComplete":true},{"id":"negative-shrink","verdict":"REJECT","failure":"capacity","handoff":{"phase":"handoff","sizes":[0,0,2],"capacities":[0,0,32],"requestedBytes":[0,0,280],"ownerRC":[0,0,1],"oldRoots":[0,0,1],"outputValues":[101,-7],"outputIds":[0,1],"destroyed":[0,0,1,1,1,1],"elementRC":[1,1,0,0,0,0],"liveElements":2,"elementReferences":2,"uniqueArrays":1,"totalContainerBytes":280,"oldReachable":1,"externalElement":-1},"failureBeforeCleanup":null,"peakObservedContainerBytes":280.0,"restoredDestroyed":[1,1,1,1,1,1],"cleanupComplete":true},{"id":"negative-alias","verdict":"REJECT","failure":"ownership","handoff":{"phase":"handoff","sizes":[0,6,4],"capacities":[0,32,4],"requestedBytes":[0,280,56],"ownerRC":[0,1,1],"oldRoots":[0,1,0],"outputValues":[-7,303,303,505],"outputIds":[1,2,3,4],"destroyed":[0,0,0,0,0,0],"elementRC":[1,2,2,2,2,1],"liveElements":6,"elementReferences":10,"uniqueArrays":2,"totalContainerBytes":336,"oldReachable":1,"externalElement":-1},"failureBeforeCleanup":null,"peakObservedContainerBytes":336.0,"restoredDestroyed":[1,1,1,1,1,1],"cleanupComplete":true},{"id":"negative-cleanup","verdict":"REJECT","failure":"cleanup","handoff":{"phase":"handoff","sizes":[0,0,4],"capacities":[0,0,4],"requestedBytes":[0,0,56],"ownerRC":[0,0,1],"oldRoots":[0,0,0],"outputValues":[-7,303,303,505],"outputIds":[1,2,3,4],"destroyed":[1,0,0,0,0,1],"elementRC":[0,1,1,1,1,0],"liveElements":4,"elementReferences":4,"uniqueArrays":1,"totalContainerBytes":56,"oldReachable":0,"externalElement":-1},"failureBeforeCleanup":{"phase":"failure-before-cleanup","sizes":[6,0,4],"capacities":[32,0,4],"requestedBytes":[280,0,56],"ownerRC":[1,0,1],"oldRoots":[1,0,0],"outputValues":[-7,303,303,505],"outputIds":[1,2,3,4],"destroyed":[0,0,0,0,0,0],"elementRC":[1,2,2,2,2,1],"liveElements":6,"elementReferences":10,"uniqueArrays":2,"totalContainerBytes":336,"oldReachable":1,"externalElement":-1},"peakObservedContainerBytes":336.0,"restoredDestroyed":[1,1,1,1,1,1],"cleanupComplete":true},{"id":"negative-value","verdict":"REJECT","failure":"values","handoff":{"phase":"handoff","sizes":[0,0,4],"capacities":[0,0,4],"requestedBytes":[0,0,56],"ownerRC":[0,0,1],"oldRoots":[0,0,0],"outputValues":[101,303,303,505],"outputIds":[0,2,3,4],"destroyed":[0,1,0,0,0,1],"elementRC":[1,0,1,1,1,0],"liveElements":4,"elementReferences":4,"uniqueArrays":1,"totalContainerBytes":56,"oldReachable":0,"externalElement":-1},"failureBeforeCleanup":null,"peakObservedContainerBytes":336.0,"restoredDestroyed":[1,1,1,1,1,1],"cleanupComplete":true}],"stages":[{"name":"lean-version","deadlineSeconds":30,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":1.824,"nativeDurationSeconds":0.1955109,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\000-lean-version.stdout","bytes":104,"sha256":"012CB0E57A2A4871E22AE1AC4B6FE2CE4AD2177741BC5D866036EC23EBF823E7"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\000-lean-version.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"clang-version","deadlineSeconds":30,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":1.591,"nativeDurationSeconds":0.2211115,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\001-clang-version.stdout","bytes":149,"sha256":"8FF3DC4E730B50E90AD13250BC1BA1FCB85B4CEFB48B546C3ABC70DBA4230027"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\001-clang-version.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"compile","deadlineSeconds":120,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":2.538,"nativeDurationSeconds":1.0825816,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\002-compile.stdout","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\002-compile.stderr","bytes":4699,"sha256":"BDB4A5C856E696C0EF70B9A3C0F0C7B2C392E45939A7C8E4F9929C0C3424F2D7"}},{"name":"startup","deadlineSeconds":30,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":2.479,"nativeDurationSeconds":1.1529873,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\003-startup.stdout","bytes":72,"sha256":"CC20EF902EDB31E2B6992EF825142E1CDD506C98376A1D462FB7983DBD02D8B0"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\003-startup.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"native-list","deadlineSeconds":30,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":2.207,"nativeDurationSeconds":0.7109077,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\004-native-list.stdout","bytes":387,"sha256":"F66EC105E8183EA73EB223D24C560C7D6D7EC505A95A7C768E97D34520D8760C"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\004-native-list.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"fatal-runtime-handler","deadlineSeconds":30,"nativeExit":1,"launcherExit":1,"timedOut":false,"durationSeconds":1.655,"nativeDurationSeconds":0.1067422,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\005-fatal-runtime-handler.stdout","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\005-fatal-runtime-handler.stderr","bytes":30,"sha256":"CF6E327209E0B84B54D21E7F94DEE3B0DBCB5DC178DEAEF11D95B6585D4C47E5"}},{"name":"pop-unique","deadlineSeconds":30,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":1.712,"nativeDurationSeconds":0.1299614,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\006-pop-unique.stdout","bytes":1631,"sha256":"DBEF0018246A7099307D464DD441D7B5BE78C8DFF369788D46233DCF372E733C"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\006-pop-unique.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"shrink-unique","deadlineSeconds":30,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":1.722,"nativeDurationSeconds":0.1058229,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\007-shrink-unique.stdout","bytes":1604,"sha256":"B9CC9C92821FC51FA3FC93FDE2AFB74AF11561E9310F63CD71973CE9C249D71B"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\007-shrink-unique.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"pop-shared","deadlineSeconds":30,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":1.822,"nativeDurationSeconds":0.1166624,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\008-pop-shared.stdout","bytes":1704,"sha256":"208107EF752A1D51AF15440BD3345DC4B02630AE4C347FFEEA499F9882877A65"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\008-pop-shared.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"shrink-shared","deadlineSeconds":30,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":1.841,"nativeDurationSeconds":0.1036028,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\009-shrink-shared.stdout","bytes":1676,"sha256":"ACCD336A2BC388AC10EF52C5636B4C699BECAA90F6B267973E161CB0EF661174"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\009-shrink-shared.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"pop-empty-unique","deadlineSeconds":30,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":1.618,"nativeDurationSeconds":0.0900453,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\010-pop-empty-unique.stdout","bytes":1559,"sha256":"F33232D51B679364F67D789FAC0B860AAEC8A916BC510B408CA7BE8CF03BD85D"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\010-pop-empty-unique.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"pop-empty-shared","deadlineSeconds":30,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":1.679,"nativeDurationSeconds":0.1003828,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\011-pop-empty-shared.stdout","bytes":1565,"sha256":"114095E50C26F1C88D41A700A9578C419355BF87B7844FFD6F51B632EF2C3064"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\011-pop-empty-shared.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"shrink-noop","deadlineSeconds":30,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":1.852,"nativeDurationSeconds":0.1298656,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\012-shrink-noop.stdout","bytes":1642,"sha256":"B10080A4B804709EF818228FDC3E7F3CB024012071D18A0610B367F1C0C5C053"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\012-shrink-noop.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"replace-prefix","deadlineSeconds":30,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":2.144,"nativeDurationSeconds":0.1443932,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\013-replace-prefix.stdout","bytes":2572,"sha256":"98168629717637DD394076C0F55BDF95C89C4741DABF116D934B9CBF98101DBB"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\013-replace-prefix.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"replace-overlap","deadlineSeconds":30,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":2.371,"nativeDurationSeconds":0.1348134,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\014-replace-overlap.stdout","bytes":2606,"sha256":"69CF3E53F85E9E09B2C3CFE4EF6685AADD539644F5498735D0BBD40AC916F034"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\014-replace-overlap.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"replace-tail","deadlineSeconds":30,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":2.07,"nativeDurationSeconds":0.1353548,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\015-replace-tail.stdout","bytes":2573,"sha256":"021327A3FFE95D1A70722BABD7A584EFA0809FBFE6A33CA7943AE647153D8AC6"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\015-replace-tail.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"replace-empty","deadlineSeconds":30,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":1.629,"nativeDurationSeconds":0.0882141,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\016-replace-empty.stdout","bytes":2547,"sha256":"9D0B14A7E8BC17895CA7952838EBFFBB20697197F2A7752E4AEBE35C082398F9"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\016-replace-empty.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"replace-alias","deadlineSeconds":30,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":1.521,"nativeDurationSeconds":0.0787251,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\017-replace-alias.stdout","bytes":2750,"sha256":"C8F4749C0B8C36CA12FE5062E5939D00E744D140C6D99EEB522C867561D84A88"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\017-replace-alias.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"replace-element-alias","deadlineSeconds":30,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":1.467,"nativeDurationSeconds":0.0831773,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\018-replace-element-alias.stdout","bytes":2578,"sha256":"3CAB4C08C0D495DF917C1A66AFEDB5156BEDB3ED94342D5060941B39A6CD6507"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\018-replace-element-alias.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"fail-alloc","deadlineSeconds":30,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":1.306,"nativeDurationSeconds":0.0685461,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\019-fail-alloc.stdout","bytes":2089,"sha256":"0AA4F5786D0BB0C48DE7B4A12703FE5835DD301889A83CB0028C47C769781B11"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\019-fail-alloc.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"fail-after-alloc","deadlineSeconds":30,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":1.324,"nativeDurationSeconds":0.0716444,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\020-fail-after-alloc.stdout","bytes":2578,"sha256":"13B336EFCE1F07C0F4C917453C11571620DC2976F291889142297135A487EF04"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\020-fail-after-alloc.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"fail-mid-copy","deadlineSeconds":30,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":1.28,"nativeDurationSeconds":0.0757857,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\021-fail-mid-copy.stdout","bytes":2584,"sha256":"79AB51539C7FDDD84715469F0FE9EEDEAD8594AEC1C8F53EE4EA570BECD1BAA9"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\021-fail-mid-copy.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"fail-handoff","deadlineSeconds":30,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":1.4,"nativeDurationSeconds":0.0700372,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\022-fail-handoff.stdout","bytes":3097,"sha256":"4924D43062E84934609B0287ED7909DCDC9FE67B723631B3A9933ECFB5231D45"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\022-fail-handoff.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"fail-after-consume","deadlineSeconds":30,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":1.276,"nativeDurationSeconds":0.0681173,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\023-fail-after-consume.stdout","bytes":3065,"sha256":"5B24A4953B35EE51244A2BC6AD2E85F7F7082C8DEE0F87F9DE11F6532E08393F"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\023-fail-after-consume.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"fail-alias","deadlineSeconds":30,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":1.316,"nativeDurationSeconds":0.0773289,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\024-fail-alias.stdout","bytes":2727,"sha256":"E782E0A7BF3FFE85B59C49EDE28140A1C381143845EB36C759A27BA4BB98DD94"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\024-fail-alias.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"negative-shrink","deadlineSeconds":30,"nativeExit":3,"launcherExit":3,"timedOut":false,"durationSeconds":1.39,"nativeDurationSeconds":0.0792029,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\025-negative-shrink.stdout","bytes":1610,"sha256":"004C0187E6C070DA7D5E3C7A1DCC8061C5B270D870B57BCDED9402BCF6724CE2"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\025-negative-shrink.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"negative-alias","deadlineSeconds":30,"nativeExit":3,"launcherExit":3,"timedOut":false,"durationSeconds":1.526,"nativeDurationSeconds":0.0989581,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\026-negative-alias.stdout","bytes":2756,"sha256":"3441AB06690EBEC1198985CF10E7F10ECD3BD1A5B9130718D566E682CF1AB9E5"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\026-negative-alias.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"negative-cleanup","deadlineSeconds":30,"nativeExit":3,"launcherExit":3,"timedOut":false,"durationSeconds":1.78,"nativeDurationSeconds":0.1185225,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\027-negative-cleanup.stdout","bytes":3127,"sha256":"309DA536A1FA1A4DA53AFA4C80136530D4741D63150CBB96163C8CAF63674E07"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\027-negative-cleanup.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"negative-value","deadlineSeconds":30,"nativeExit":3,"launcherExit":3,"timedOut":false,"durationSeconds":1.628,"nativeDurationSeconds":0.0869624,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\028-negative-value.stdout","bytes":2609,"sha256":"201A7DCC90CE5A7CE2D5AEBB4B72DF8744D283A3EB9BB96A2AEC396D1FE4BAB2"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\028-negative-value.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"selector-omitted","deadlineSeconds":30,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":3.23,"nativeDurationSeconds":1.7021695,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\029-selector-omitted.stdout","bytes":387,"sha256":"F66EC105E8183EA73EB223D24C560C7D6D7EC505A95A7C768E97D34520D8760C"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\029-selector-omitted.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"selector-focused","deadlineSeconds":30,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":4.233,"nativeDurationSeconds":2.2500964,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\030-selector-focused.stdout","bytes":16,"sha256":"A0F3B8C38F88EAC43A54E43FC30BE640A2B622F39CADFACBACC0B0E8F6A1D355"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\030-selector-focused.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"selector-reordered","deadlineSeconds":30,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":4.004,"nativeDurationSeconds":2.2056126,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\031-selector-reordered.stdout","bytes":32,"sha256":"9592DD23F356524B72F96021B7A69885E6B50754166902AD69E235337796FE0E"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\031-selector-reordered.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"selector-empty","deadlineSeconds":30,"nativeExit":1,"launcherExit":1,"timedOut":false,"durationSeconds":4.868,"nativeDurationSeconds":2.5556954,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\032-selector-empty.stdout","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\032-selector-empty.stderr","bytes":35,"sha256":"D2DEA1942164DD813E43F9C2C5B1DD3732F5E4D486FE97F59DCBB8EB7F32582D"}},{"name":"selector-whitespace","deadlineSeconds":30,"nativeExit":1,"launcherExit":1,"timedOut":false,"durationSeconds":3.729,"nativeDurationSeconds":1.8874129,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\033-selector-whitespace.stdout","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\033-selector-whitespace.stderr","bytes":35,"sha256":"D2DEA1942164DD813E43F9C2C5B1DD3732F5E4D486FE97F59DCBB8EB7F32582D"}},{"name":"selector-unknown","deadlineSeconds":30,"nativeExit":1,"launcherExit":1,"timedOut":false,"durationSeconds":3.261,"nativeDurationSeconds":1.8450251,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\034-selector-unknown.stdout","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\034-selector-unknown.stderr","bytes":22,"sha256":"DE53F6A0FDCA377F4DB656F839DBB611E5E36DC754C22A8654A081B3E9060130"}},{"name":"selector-zero","deadlineSeconds":30,"nativeExit":1,"launcherExit":1,"timedOut":false,"durationSeconds":5.08,"nativeDurationSeconds":2.841123,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\035-selector-zero.stdout","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\035-selector-zero.stderr","bytes":22,"sha256":"DE53F6A0FDCA377F4DB656F839DBB611E5E36DC754C22A8654A081B3E9060130"}},{"name":"selector-case","deadlineSeconds":30,"nativeExit":1,"launcherExit":1,"timedOut":false,"durationSeconds":5.182,"nativeDurationSeconds":2.7109413,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\036-selector-case.stdout","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\036-selector-case.stderr","bytes":22,"sha256":"DE53F6A0FDCA377F4DB656F839DBB611E5E36DC754C22A8654A081B3E9060130"}},{"name":"selector-duplicate","deadlineSeconds":30,"nativeExit":1,"launcherExit":1,"timedOut":false,"durationSeconds":3.823,"nativeDurationSeconds":1.9405512,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\037-selector-duplicate.stdout","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\037-selector-duplicate.stderr","bytes":24,"sha256":"BCF28AA9F7E14C7782519AE1EE9CFE0ED95DECB38BC182CF8B1F22CDC42CFDB4"}},{"name":"selector-missing","deadlineSeconds":30,"nativeExit":1,"launcherExit":1,"timedOut":false,"durationSeconds":3.829,"nativeDurationSeconds":1.9711072,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\038-selector-missing.stdout","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\038-selector-missing.stderr","bytes":22,"sha256":"5B3BAC5A886A8C095DA5366ED2E7B1085567173B26BE3981CD9F991536773C86"}},{"name":"registry-missing","deadlineSeconds":30,"nativeExit":1,"launcherExit":1,"timedOut":false,"durationSeconds":3.468,"nativeDurationSeconds":1.7454377,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\039-registry-missing.stdout","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\039-registry-missing.stderr","bytes":31,"sha256":"C35464735732442E7429C40609A9903C0B7AB9C32524D77E2035DA2A7A95B4D3"}},{"name":"registry-duplicate","deadlineSeconds":30,"nativeExit":1,"launcherExit":1,"timedOut":false,"durationSeconds":4.088,"nativeDurationSeconds":2.2908363,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\040-registry-duplicate.stdout","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\040-registry-duplicate.stderr","bytes":24,"sha256":"8EC83C8933A1D7A83B1A3EBC5C33CC8840481F05B19B76C5DB2D0AD53ACEE0C7"}},{"name":"registry-unknown","deadlineSeconds":30,"nativeExit":1,"launcherExit":1,"timedOut":false,"durationSeconds":5.402,"nativeDurationSeconds":2.7264288,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\041-registry-unknown.stdout","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\041-registry-unknown.stderr","bytes":30,"sha256":"3915DBA35C2B422B8A78DB621854D2E890C1A54FF9CD4BF4711154D47AD02065"}},{"name":"registry-reordered","deadlineSeconds":30,"nativeExit":1,"launcherExit":1,"timedOut":false,"durationSeconds":5.008,"nativeDurationSeconds":2.4491381,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\042-registry-reordered.stdout","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\042-registry-reordered.stderr","bytes":30,"sha256":"3915DBA35C2B422B8A78DB621854D2E890C1A54FF9CD4BF4711154D47AD02065"}},{"name":"registry-mapping","deadlineSeconds":30,"nativeExit":1,"launcherExit":1,"timedOut":false,"durationSeconds":4.44,"nativeDurationSeconds":2.3876943,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\043-registry-mapping.stdout","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\043-registry-mapping.stderr","bytes":33,"sha256":"439B4986F565EA0056CFAC34BA293B14DBB55CD204CFF1FD54BEDB3697842177"}},{"name":"registry-unknown-key","deadlineSeconds":30,"nativeExit":1,"launcherExit":1,"timedOut":false,"durationSeconds":3.937,"nativeDurationSeconds":2.0960926,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\044-registry-unknown-key.stdout","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\044-registry-unknown-key.stderr","bytes":32,"sha256":"84D96FC588FDA88B1E2BC317094B48562951D49E4698C3EACED76776DCE692A6"}},{"name":"registry-missing-key","deadlineSeconds":30,"nativeExit":1,"launcherExit":1,"timedOut":false,"durationSeconds":4.611,"nativeDurationSeconds":2.281458,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\045-registry-missing-key.stdout","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\045-registry-missing-key.stderr","bytes":32,"sha256":"84D96FC588FDA88B1E2BC317094B48562951D49E4698C3EACED76776DCE692A6"}},{"name":"native-missing-command","deadlineSeconds":30,"nativeExit":2,"launcherExit":2,"timedOut":false,"durationSeconds":1.758,"nativeDurationSeconds":0.0884219,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\046-native-missing-command.stdout","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\046-native-missing-command.stderr","bytes":30,"sha256":"868D89BB36F0A7B447185A94B8826B21C729B02E4942BC781F7E075B2912D1C1"}},{"name":"native-missing-id","deadlineSeconds":30,"nativeExit":2,"launcherExit":2,"timedOut":false,"durationSeconds":1.583,"nativeDurationSeconds":0.084572,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\047-native-missing-id.stdout","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\047-native-missing-id.stderr","bytes":30,"sha256":"868D89BB36F0A7B447185A94B8826B21C729B02E4942BC781F7E075B2912D1C1"}},{"name":"native-empty","deadlineSeconds":30,"nativeExit":2,"launcherExit":2,"timedOut":false,"durationSeconds":1.732,"nativeDurationSeconds":0.0997855,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\048-native-empty.stdout","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\048-native-empty.stderr","bytes":30,"sha256":"868D89BB36F0A7B447185A94B8826B21C729B02E4942BC781F7E075B2912D1C1"}},{"name":"native-whitespace","deadlineSeconds":30,"nativeExit":2,"launcherExit":2,"timedOut":false,"durationSeconds":1.947,"nativeDurationSeconds":0.1112956,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\049-native-whitespace.stdout","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\049-native-whitespace.stderr","bytes":24,"sha256":"9ADD3DE3E8CAB26B99A26134B6E2681C4D84E5D6044100C38718CAC168BACFCD"}},{"name":"native-unknown","deadlineSeconds":30,"nativeExit":2,"launcherExit":2,"timedOut":false,"durationSeconds":1.932,"nativeDurationSeconds":0.1113394,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\050-native-unknown.stdout","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\050-native-unknown.stderr","bytes":24,"sha256":"9ADD3DE3E8CAB26B99A26134B6E2681C4D84E5D6044100C38718CAC168BACFCD"}},{"name":"native-duplicate","deadlineSeconds":30,"nativeExit":2,"launcherExit":2,"timedOut":false,"durationSeconds":1.948,"nativeDurationSeconds":0.1089858,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\051-native-duplicate.stdout","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\051-native-duplicate.stderr","bytes":30,"sha256":"868D89BB36F0A7B447185A94B8826B21C729B02E4942BC781F7E075B2912D1C1"}},{"name":"verdict-control-replace-prefix","deadlineSeconds":30,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":1.685,"nativeDurationSeconds":0.1015717,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\052-verdict-control-replace-prefix.stdout","bytes":2572,"sha256":"98168629717637DD394076C0F55BDF95C89C4741DABF116D934B9CBF98101DBB"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\052-verdict-control-replace-prefix.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"verdict-control-negative-shrink","deadlineSeconds":30,"nativeExit":3,"launcherExit":3,"timedOut":false,"durationSeconds":1.422,"nativeDurationSeconds":0.0732747,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\053-verdict-control-negative-shrink.stdout","bytes":1610,"sha256":"004C0187E6C070DA7D5E3C7A1DCC8061C5B270D870B57BCDED9402BCF6724CE2"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\053-verdict-control-negative-shrink.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"stage-control-fail-after-alloc","deadlineSeconds":30,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":1.264,"nativeDurationSeconds":0.063335,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\054-stage-control-fail-after-alloc.stdout","bytes":2578,"sha256":"13B336EFCE1F07C0F4C917453C11571620DC2976F291889142297135A487EF04"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\054-stage-control-fail-after-alloc.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"stage-control-fail-handoff","deadlineSeconds":30,"nativeExit":0,"launcherExit":0,"timedOut":false,"durationSeconds":1.248,"nativeDurationSeconds":0.063489,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\055-stage-control-fail-handoff.stdout","bytes":3097,"sha256":"4924D43062E84934609B0287ED7909DCDC9FE67B723631B3A9933ECFB5231D45"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\055-stage-control-fail-handoff.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"fast-overflow","deadlineSeconds":30,"nativeExit":null,"launcherExit":125,"timedOut":false,"durationSeconds":2.252,"nativeDurationSeconds":null,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\056-fast-overflow.stdout","bytes":9437184,"sha256":"D2EE4703CD9698945CA7B9FE1689EA3095597EAC1A0AFD8DBA00CAC7894FDC43"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\056-fast-overflow.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}},{"name":"owned-descendant-timeout","deadlineSeconds":8,"nativeExit":null,"launcherExit":-1,"timedOut":true,"durationSeconds":8.055,"nativeDurationSeconds":null,"stdout":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\057-owned-descendant-timeout.stdout","bytes":26,"sha256":"B7B7D13E43824FE2C692287C8E437AF594FEB198C3EC13E3C88217CBC81CE7CE"},"stderr":{"path":"C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\runs\\7c97f92144714f9c9d126762635d07b4\\057-owned-descendant-timeout.stderr","bytes":0,"sha256":"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"}}]} diff --git a/docs/internal/extensions/lifecycle-native-p0/RUNTIME_SOURCE.json b/docs/internal/extensions/lifecycle-native-p0/RUNTIME_SOURCE.json new file mode 100644 index 00000000..93989d23 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/RUNTIME_SOURCE.json @@ -0,0 +1,17 @@ +{ + "url": "https://raw.githubusercontent.com/leanprover/lean4/ba2cbbf09d4978f416e0ebd1fceeebc2c4138c05/src/runtime/object.cpp", + "runtimeCommit": "ba2cbbf09d4978f416e0ebd1fceeebc2c4138c05", + "localPath": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ\\.lake\\lifecycle-native-p0\\lean-4.22-object.cpp", + "sha256": "44C1430D9C6DA2FE9FDE073D407F9FD58860D869D09B8C7EA0BC0E27D85916FB", + "bytes": 88248, + "provenance": "Public exact-commit source retrieved for review; runtime binaries remain installed release artifacts, not rebuilt from this source.", + "review": [ + "90: out-of-memory handler invokes internal panic; 84-87 print diagnostic and exit1 unless abort policy overrides.", + "213-221: dealloc dispatches by runtime allocator build configuration; no RSS guarantee.", + "293-310: lean_alloc_object uses runtime allocator and routes null allocation to fatal handler.", + "332-337: array destruction decrements only initialized logical entries and deallocates using capacity-based byte size.", + "365-367: external destruction invokes test finalizer then frees external object.", + "2525-2545: copy_expand_array(false) preserves original capacity; shared branch increments every initialized element then drops one old owner.", + "2548-2565: push uses existing capacity if exclusive and space remains; replacement capacity m filled at most m therefore never expands." + ] +} diff --git a/docs/internal/extensions/lifecycle-native-p0/START.json b/docs/internal/extensions/lifecycle-native-p0/START.json new file mode 100644 index 00000000..dd481854 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/START.json @@ -0,0 +1,32 @@ +{ + "handle": "LIFE-NATIVE-P0", + "title": "(LIFE-NATIVE-P0) Validate native finalization ownership and capacity", + "task_id": "01a0c12b-88c6-7ef2-bd68-bf63cd80b872", + "coordinator_task_id": "01a0830e-2777-7e50-a800-02929dc6d724", + "worktree": "C:\\Users\\poin\\.codex\\worktrees\\af4b\\RMQ", + "base": "bf31f983205175481fcb659caa4dfb70ef43e361", + "branch": "codex/life-native-p0-owned-finalization", + "governance": "7b227c49ef2ec044b702126cc41c9add847eed01", + "runtime_skills": [ + "rmq-audit-prompt", + "rmq-coordinator", + "rmq-proof-sprint" + ], + "required_skills": [ + "rmq-proof-sprint" + ], + "preflight": "PASS at governance checkout and again at exact base", + "initial_clean": true, + "isolated_from": [ + "C:\\Users\\poin\\Documents\\RMQ", + "C:\\Users\\poin\\Documents\\RMQ\\lifecycle-experiments-20260920\\source" + ], + "scope": [ + "native/packed-rmq/tests/lifecycle_storage_probe.c", + "scripts/packed_native_lifecycle_storage_replay.ps1", + "docs/internal/extensions/lifecycle-native-p0/", + "docs/internal/DESIGN_DECISIONS.md (append)", + "docs/internal/WORKFLOW_DESIGN_DECISIONS.md (append)" + ], + "status": "IMPLEMENTING" +} diff --git a/docs/internal/extensions/lifecycle-native-p0/VERIFY_CONTRACT.ps1 b/docs/internal/extensions/lifecycle-native-p0/VERIFY_CONTRACT.ps1 new file mode 100644 index 00000000..67f044f9 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/VERIFY_CONTRACT.ps1 @@ -0,0 +1,43 @@ +[CmdletBinding()] +param() +$ErrorActionPreference = 'Stop' +$strictUtf8 = [Text.UTF8Encoding]::new($false, $true) +$expectedIds = @('LN0-01','LN0-02','LN0-03','LN0-04','LN0-05','LN0-06', + 'INV-SEMANTIC-NONVACUITY','INV-ORACLE-INDEPENDENCE','INV-CATEGORY-SEPARATION', + 'INV-MUTATION-REPRODUCIBILITY','CHK-FINAL','CHK-SCOPE') +$pins = @{ + 'ACCEPTANCE_ROWS.txt' = 'F45113AE6BF3F769105A748B3D0A61EA99532A05A715410F11EF29E7E518EC29' + 'REQUIREMENTS.json' = '0983881A85F9A3B42ECD54C0BFB18170C3BE3E5A65602CDE66547042CA5421C9' +} +foreach ($entry in $pins.GetEnumerator()) { + if ((Get-FileHash -LiteralPath (Join-Path $PSScriptRoot $entry.Key)).Hash -cne $entry.Value) { + throw "Frozen prompt baseline changed: $($entry.Key)" + } +} +$requirements = $strictUtf8.GetString([IO.File]::ReadAllBytes( + (Join-Path $PSScriptRoot 'REQUIREMENTS.json'))) | ConvertFrom-Json +$matrix = $strictUtf8.GetString([IO.File]::ReadAllBytes( + (Join-Path $PSScriptRoot 'ACCEPTANCE_MATRIX.md'))) +$baseline = [IO.File]::ReadAllBytes((Join-Path $PSScriptRoot 'ACCEPTANCE_ROWS.txt')) +$rows = @($matrix.Split("`n") | Where-Object { $_ -match '^\| `(?:LN0-|INV-|CHK-)' }) +if ($rows.Count -ne $expectedIds.Count -or $requirements.Count -ne $expectedIds.Count) { + throw 'Frozen row count changed' +} +$seen = @{} +for ($index=0; $index -lt $rows.Count; $index++) { + $cells = $rows[$index].Split('|') + if ($cells.Count -ne 10 -or $cells[0] -cne '' -or $cells[9] -cne '') { + throw "Expected all eight columns on row $index" + } + $id = $cells[1].Trim().Trim('`') + if ($seen.ContainsKey($id) -or $id -cne $expectedIds[$index] -or + $id -cne $requirements[$index][0]) { throw "Missing, unknown, duplicate or reordered ID: $id" } + $seen[$id] = $true + if ($cells[2].Trim() -cne $requirements[$index][1]) { throw "Full requirement differs: $id" } +} +$candidate = $strictUtf8.GetBytes(($rows -join "`n") + "`n") +if ($candidate.Length -ne $baseline.Length) { throw 'Frozen row byte length differs' } +for ($index=0; $index -lt $baseline.Length; $index++) { + if ($candidate[$index] -ne $baseline[$index]) { throw "Frozen row byte differs at $index" } +} +Write-Output 'CONTRACT PASS: 12 exact ordered IDs, all eight columns, full prompt requirements, frozen UTF-8 row bytes' diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r1/ACCEPTANCE_MATRIX.md b/docs/internal/extensions/lifecycle-native-p0/repair-r1/ACCEPTANCE_MATRIX.md new file mode 100644 index 00000000..80a02343 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r1/ACCEPTANCE_MATRIX.md @@ -0,0 +1,32 @@ +# LIFE-NATIVE-P0-R1 frozen acceptance matrix + +Frozen from the canonical template before runner edits. Historical inherited rows remain byte-identical; dispositions are appended. + +| ID | Exact frozen requirement | Scope | Evidence needed (exact proposition/check) | Named consumer and identity/composition chain | Anti-vacuity challenge attempted and outcome | Evidence obtained | Status / residual gap | +| --- | --- | --- | --- | --- | --- | --- | --- | +| `LN0-01` | Implement a reproducible probe of the pinned Lean 4.22 runtime array ownership operations, without altering the production RMQ ABI. Record logical size, retained capacity, requested container bytes and live element references as distinct quantities. Inspect actual runtime definitions and record compiler/runtime/header identity; do not infer capacity from Array.size. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-02` | Exercise unique and shared owners with destructor-counted elements. Demonstrate the actual effects of pop/shrink on surviving values, tail element references and retained backing capacity, without accessing freed objects. Distinguish release of one owner from reclamation when another alias remains live. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-03` | Exercise a consuming replacement-buffer route: copy surviving output values into a newly allocated bounded-capacity buffer, release the old owner, and measure which old allocations/elements remain reachable. Include success, empty output, overlap-relevant source positions, alias-retained and deterministically injected handoff/allocation-stage failure cleanup. Do not assume actual Lean allocator failure is recoverable; a fatal process outcome is reported separately. Treat observed allocator/requested capacity separately from a universal native heap theorem. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-04` | Commit an exact replay registry and positive/negative controls for logical shrink falsely labeled reclamation, retained alias falsely labeled exclusive consumption, and an omitted cleanup action. Validation executes the actual pinned runtime operations and the owned measurement/verdict path; predecessor RMQ replay is regression evidence only. The verdict must depend on observed value/ownership/capacity projections, not labels or a prewritten expected log; use the same positive predicate or a checked/explicit measured implication. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-05` | Use bounded owned compiler/probe processes, preserve full stdout/stderr and actual exits, reject unexpected or mixed diagnostics, validate focused/unknown/empty selector behavior, and exercise cleanup. A platform/toolchain inability is uncovered, not success. No credit purchase, package installation or persistent service is needed as an assumed prerequisite. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-06` | Deliver a source-grounded consuming-boundary recommendation mapping Construction.ExecState resources and Native.StorageImage/NativeImage ownership to later transfer obligations. Specify success/failure ownership, aliases, retained observations and capacity. Do not implement a speculative production BuilderOwner-to-QueryOwner ABI before the formal lifecycle interface is reviewed. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-SEMANTIC-NONVACUITY` | semantic coverage, liveness, ownership, and refinement predicates are derived from the operational construction they describe. A predicate defined to be `True`, an enumeration restated as membership, or a separately hand-written consumer label does not establish operational liveness by itself; | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-ORACLE-INDEPENDENCE` | executable fixtures and edge-case expected values come from an independent specification or a theorem already connected to it, never from the implementation result being tested; | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-CATEGORY-SEPARATION` | payload bits, proof fields, model ticks, machine state, Lean runtime, and measured performance remain distinct. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-MUTATION-REPRODUCIBILITY` | when acceptance relies on an exhaustive, production, or public-dependency mutation campaign, the candidate contains a versioned runner or fixtures that replay every claimed case, check the exact expected failure/acceptance surface, restore tracked state, and leave the tree clean. Report prose, copied terminal output, and dangling Git objects are not replayable evidence. A public theorem additionally has a checked exact-type consumer that fails when the advertised dependency is removed; `#print axioms` over the theorem's current type is not such a consumer. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `CHK-FINAL` | Run the final-required checks on the final submitted content, with exact identities, complete outcomes and declared platform limits. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `CHK-SCOPE` | Keep the assigned write scope, clean committed tree, exact base, full frozen row integrity and truthful local-versus-campaign status. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `NP0R1-INTEGRITY` | Every entered native replay verification lifecycle records and enforces an independent final integrity outcome in finally, including prior compiler/probe errors, unexpected diagnostics, timeout and partially initialized identity inventories. Verify every captured source/tool/generated-artifact pin and the declared live tracked/index/untracked baseline; absence of required final verification is failure or explicitly uncovered, never success. Preserve the original stage error separately from integrity errors. Detect unexpected changes without silently overwriting unrelated user data. Commit positive and changed-pin/tree controls through the actual production verifier/finalization path, including failure plus integrity failure, success plus integrity failure, and an ordinary failed stage with intact inputs. All owned fixture mutations are restored in their own finally and leave the real candidate unchanged. Keep existing owned-process cleanup and exact diagnostics/exits. | Local verification repair | Production finalizer and exact dependency checks | Captured run inputs -> final verification -> success/receipt | Isolated unchanged, tampered, failed-stage and incomplete inventories | Pending; append evidence | Open at freeze | +| `NP0R1-TOOLCHAIN` | Bind the substantive local implementation dependencies of the actually invoked pinned compiler/runtime to the replay receipt and final identity verification. In particular include clang's normal-import libclang-cpp.dll, libLLVM-19.dll and libc++.dll and inspect the invoked tools' remaining local non-system dependency closure; state the external OS/system-library and dynamic-loading boundary honestly. Include the generated link map in final available-artifact integrity checks. Commit a completeness/tamper control using actual dependency inventory and isolated manifest/file fixtures, without modifying installed tools. The original bea5ce75 runner/receipt must fail the new completeness predicate for the independently measured missing dependencies while a complete unchanged inventory passes. No installation, runtime upgrade, tool replacement or claim of universal loader/compiler verification. | Local verification repair | Production finalizer and exact dependency checks | Captured run inputs -> final verification -> success/receipt | Isolated unchanged, tampered, failed-stage and incomplete inventories | Pending; append evidence | Open at freeze | + +## Verification plan + +Development: strict frozen-row and scope checks, isolated production finalizer and dependency controls, bounded startup and real one-case selection. Final: frozen full native SelfTest under Local\RMQLifecycleImplementationHeavy20260920, outer 1200 s (prior 113-162 s), unchanged compiler/probe/descendant 120/30/8 s; exact 23 cases and 65 inherited checks; pin/tree integrity; diff, per-commit/exact-base strict design, final claim coverage and hygiene. Claims compose verified original full coverage with unchanged-policy changed-root rescan only if outside paths/bytes and scanner environment match; otherwise full scan with 7200 s deadline. Conditional: no new Lean build if all formal/toolchain bytes and baseline receipts verify; aggregate and fresh-blind campaign audit remain coordinator-owned. + +Target: repair integrity/provenance for the existing ownership probe and future reviewed adapter. No Lean/C/ABI mutation or changed semantic oracle. Stop only on closure, exact obstruction, external blocker or redirection. + +## Repair-r1 final evidence (append-only) + +All fourteen frozen rows are CANDIDATE_COMPLETE at this local rung. REPORT.md gives each disposition, complete native/integrity/dependency predicates and guards, production reach, independent stage/integrity outcomes, identities, limitations and downstream requirements. RESULTS.json pins the full 23-case/65-check/58-stage replay, the real one-case selector, fifteen integrity controls, dependency controls and initial source checks. Postcommit certification retains the final exact-base/per-commit design, hygiene, whitespace, frozen-row, clean-tree and unchanged-policy claim outcomes. Historical pending cells above are deliberately unchanged. + +Source freeze: 1811eeb9e2f783cc455e44a618a99af77b0172ed; certification correction: fda02922bf9e8c0707b9913013d3c16c80afe7c9. All native C/Lean/registry/old receipt bytes remain preserved; no new theorem, ABI, aggregate or campaign acceptance claim is made. diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r1/ACCEPTANCE_ROWS.txt b/docs/internal/extensions/lifecycle-native-p0/repair-r1/ACCEPTANCE_ROWS.txt new file mode 100644 index 00000000..64ba642b --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r1/ACCEPTANCE_ROWS.txt @@ -0,0 +1,14 @@ +| `LN0-01` | Implement a reproducible probe of the pinned Lean 4.22 runtime array ownership operations, without altering the production RMQ ABI. Record logical size, retained capacity, requested container bytes and live element references as distinct quantities. Inspect actual runtime definitions and record compiler/runtime/header identity; do not infer capacity from Array.size. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-02` | Exercise unique and shared owners with destructor-counted elements. Demonstrate the actual effects of pop/shrink on surviving values, tail element references and retained backing capacity, without accessing freed objects. Distinguish release of one owner from reclamation when another alias remains live. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-03` | Exercise a consuming replacement-buffer route: copy surviving output values into a newly allocated bounded-capacity buffer, release the old owner, and measure which old allocations/elements remain reachable. Include success, empty output, overlap-relevant source positions, alias-retained and deterministically injected handoff/allocation-stage failure cleanup. Do not assume actual Lean allocator failure is recoverable; a fatal process outcome is reported separately. Treat observed allocator/requested capacity separately from a universal native heap theorem. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-04` | Commit an exact replay registry and positive/negative controls for logical shrink falsely labeled reclamation, retained alias falsely labeled exclusive consumption, and an omitted cleanup action. Validation executes the actual pinned runtime operations and the owned measurement/verdict path; predecessor RMQ replay is regression evidence only. The verdict must depend on observed value/ownership/capacity projections, not labels or a prewritten expected log; use the same positive predicate or a checked/explicit measured implication. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-05` | Use bounded owned compiler/probe processes, preserve full stdout/stderr and actual exits, reject unexpected or mixed diagnostics, validate focused/unknown/empty selector behavior, and exercise cleanup. A platform/toolchain inability is uncovered, not success. No credit purchase, package installation or persistent service is needed as an assumed prerequisite. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-06` | Deliver a source-grounded consuming-boundary recommendation mapping Construction.ExecState resources and Native.StorageImage/NativeImage ownership to later transfer obligations. Specify success/failure ownership, aliases, retained observations and capacity. Do not implement a speculative production BuilderOwner-to-QueryOwner ABI before the formal lifecycle interface is reviewed. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-SEMANTIC-NONVACUITY` | semantic coverage, liveness, ownership, and refinement predicates are derived from the operational construction they describe. A predicate defined to be `True`, an enumeration restated as membership, or a separately hand-written consumer label does not establish operational liveness by itself; | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-ORACLE-INDEPENDENCE` | executable fixtures and edge-case expected values come from an independent specification or a theorem already connected to it, never from the implementation result being tested; | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-CATEGORY-SEPARATION` | payload bits, proof fields, model ticks, machine state, Lean runtime, and measured performance remain distinct. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-MUTATION-REPRODUCIBILITY` | when acceptance relies on an exhaustive, production, or public-dependency mutation campaign, the candidate contains a versioned runner or fixtures that replay every claimed case, check the exact expected failure/acceptance surface, restore tracked state, and leave the tree clean. Report prose, copied terminal output, and dangling Git objects are not replayable evidence. A public theorem additionally has a checked exact-type consumer that fails when the advertised dependency is removed; `#print axioms` over the theorem's current type is not such a consumer. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `CHK-FINAL` | Run the final-required checks on the final submitted content, with exact identities, complete outcomes and declared platform limits. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `CHK-SCOPE` | Keep the assigned write scope, clean committed tree, exact base, full frozen row integrity and truthful local-versus-campaign status. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `NP0R1-INTEGRITY` | Every entered native replay verification lifecycle records and enforces an independent final integrity outcome in finally, including prior compiler/probe errors, unexpected diagnostics, timeout and partially initialized identity inventories. Verify every captured source/tool/generated-artifact pin and the declared live tracked/index/untracked baseline; absence of required final verification is failure or explicitly uncovered, never success. Preserve the original stage error separately from integrity errors. Detect unexpected changes without silently overwriting unrelated user data. Commit positive and changed-pin/tree controls through the actual production verifier/finalization path, including failure plus integrity failure, success plus integrity failure, and an ordinary failed stage with intact inputs. All owned fixture mutations are restored in their own finally and leave the real candidate unchanged. Keep existing owned-process cleanup and exact diagnostics/exits. | Local verification repair | Production finalizer and exact dependency checks | Captured run inputs -> final verification -> success/receipt | Isolated unchanged, tampered, failed-stage and incomplete inventories | Pending; append evidence | Open at freeze | +| `NP0R1-TOOLCHAIN` | Bind the substantive local implementation dependencies of the actually invoked pinned compiler/runtime to the replay receipt and final identity verification. In particular include clang's normal-import libclang-cpp.dll, libLLVM-19.dll and libc++.dll and inspect the invoked tools' remaining local non-system dependency closure; state the external OS/system-library and dynamic-loading boundary honestly. Include the generated link map in final available-artifact integrity checks. Commit a completeness/tamper control using actual dependency inventory and isolated manifest/file fixtures, without modifying installed tools. The original bea5ce75 runner/receipt must fail the new completeness predicate for the independently measured missing dependencies while a complete unchanged inventory passes. No installation, runtime upgrade, tool replacement or claim of universal loader/compiler verification. | Local verification repair | Production finalizer and exact dependency checks | Captured run inputs -> final verification -> success/receipt | Isolated unchanged, tampered, failed-stage and incomplete inventories | Pending; append evidence | Open at freeze | diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r1/REPORT.md b/docs/internal/extensions/lifecycle-native-p0/repair-r1/REPORT.md new file mode 100644 index 00000000..24aa7738 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r1/REPORT.md @@ -0,0 +1,354 @@ +Status: CANDIDATE_COMPLETE +I found no assigned or inherited acceptance criterion unmet; coordinator acceptance is still required. + +# LIFE-NATIVE-P0-R1 native replay integrity and compiler provenance + +Handle LIFE-NATIVE-P0-R1; task title `(LIFE-NATIVE-P0-R1) Repair native replay integrity and compiler provenance`. +Worktree `C:/Users/poin/.codex/worktrees/587c/RMQ`; private branch +`codex/life-native-p0-r1-certification`; exact base +`0c873072e84be9e1d65edab1985bcff1d23abef1`; governance +`7b227c49ef2ec044b702126cc41c9add847eed01`. + +Core implementation/source freeze is `1811eeb9e2f783cc455e44a618a99af77b0172ed`. +Certification-wrapper/timeout-control correction is `fda02922bf9e8c0707b9913013d3c16c80afe7c9`. +The full native replay uses that corrected clean source tree. This report, +append-only matrix evidence and compact RESULTS are subsequent documentation +packaging. Its exact commit, report bytes/hash and postcommit checks are issued +in the handoff and retained local certification receipt, avoiding a self-hash. +No executable change occurs in report packaging. START.json records the clean +exact-base launch and successful canonical skill preflight with the actual three +RMQ skills and required rmq-proof-sprint role. + +The assigned local rung repairs the existing native prerequisite verifier. It +does not implement LIFE-1, a production consuming adapter, or the complete +formal/native lifecycle node. Both reviewed producers still precede the adapter; +the final adapter/formal candidate precedes aggregate and fresh-blind audit; +coordinator acceptance precedes any separately authorized integration/publication. +There was no push, merge, installed-tool mutation, package installation or external +auditor bridge use. + +## Changed and preserved surfaces + +- `docs/internal/WORKFLOW_DESIGN_DECISIONS.md` +- `docs/internal/extensions/lifecycle-native-p0/repair-r1/ACCEPTANCE_MATRIX.md` +- `docs/internal/extensions/lifecycle-native-p0/repair-r1/ACCEPTANCE_ROWS.txt` +- `docs/internal/extensions/lifecycle-native-p0/repair-r1/REPORT.md` +- `docs/internal/extensions/lifecycle-native-p0/repair-r1/RESULTS.json` +- `docs/internal/extensions/lifecycle-native-p0/repair-r1/SOURCE_REVIEW.md` +- `docs/internal/extensions/lifecycle-native-p0/repair-r1/START.json` +- `docs/internal/extensions/lifecycle-native-p0/repair-r1/dependency_controls.ps1` +- `docs/internal/extensions/lifecycle-native-p0/repair-r1/final_checks.ps1` +- `docs/internal/extensions/lifecycle-native-p0/repair-r1/freeze_contract.py` +- `docs/internal/extensions/lifecycle-native-p0/repair-r1/integrity_controls.ps1` +- `docs/internal/extensions/lifecycle-native-p0/repair-r1/run_owned.ps1` +- `docs/internal/extensions/lifecycle-native-p0/repair-r1/verify_contract.py` +- `scripts/packed_native_lifecycle_integrity_check.ps1` +- `scripts/packed_native_lifecycle_storage_replay.ps1` + +All changes are owned. WORKFLOW_DESIGN_DECISIONS.md has append-only entries +R1-001 (integrity/provenance/control design), R1-002 (diagnosed wrapper/timeout +corrections), and R1-003 (final packaging/verification). No model, C, Lean or ABI +decision changed, so DESIGN_DECISIONS.md was preserved. BOUNDARY.md was preserved; +the optional lean_array_uget citation correction was not made. Current-public, +source-comment and dependency-migration inventories are not applicable to this +additive internal verification repair. + +The complete twelve historical eight-column rows are unchanged strict UTF-8 +bytes from the exact base, including their historical pending statuses. Two +complete repair rows were frozen before runner edits. The committed checker +requires exact IDs/order/eight columns/full row bytes, compares inherited +requirement cells to the original supplied prompt, and checks the new literal +requirements against the initial frozen baseline. Missing, duplicate, changed-cell +and mojibake controls reject. Evidence is appended without rewriting a row. + +verify_contract.py binds the exact bea5ce75 runner and RESULTS through raw Git +subprocess bytes, not PowerShell text serialization. The old runner has 41479 +bytes, SHA-256 `077BF8D478141F8891AB6F9C2E332CBF8C8F75ACA32C722B29BD307924957B8E`; +RESULTS is `6440A963BE7A0E65222F86AFE3CFB89E4BEE1B6BDCD0226DC0D5CDA88D296FDD`. +The original pinned raw summary is +`0E7DCC42E1EA66C0FF1C8A8AD7ED791FEA786189FA6E38A52BF8B5B55954CD12`. +Historical source/report/registry/runtime receipts remain unchanged. + +Git and working bytes are deliberately distinguished: the unchanged checkout +uses CRLF filtering for some files (for example lean-toolchain: Git 26 bytes, +working 28). Protected working bytes and the original ledger prefix compare to +`git cat-file --filters` at the exact base; frozen rows and named historical +source fixtures compare raw Git bytes. The repaired runner was explicitly +normalized to LF before source freeze. Runtime receipts hash actual working +bytes; no source mismatch is inferred merely from Windows checkout filtering. + +## Production integrity and exact guards + +Get-LNPin registers each successful capture immediately. A later failing array +or identity-record initializer cannot discard earlier pins. Complete-LNIntegrity +is invoked in the production finally, independently of stage success. It checks +all captured byte lengths/SHA-256 values, continues after individual failures, +then checks the live repository baseline. Capture errors are included separately. +Missing baseline/no captured pins/final-verifier unavailability cannot yield +integrity success. The original `failure` remains distinct from `integrity.errors`; +either an invalid stage or failed integrity makes the final runner exit nonzero. +No integrity check rewrites user data. + +The declared tree baseline consists of HEAD, semantic staged entries, every +tracked working file's bytes or initial missing state, and the complete +nonignored untracked path/byte set. User-global excludes are disabled for the +query. Ignored generated outputs are outside this tree projection and instead +enter explicit artifact pins. The Windows text-host interface rejects multiline +Git path output rather than normalizing it into a successful comparison. +This is entry/final observation, not continuous filesystem surveillance or +attestation against a hostile process that changes and restores inputs between +observations. + +Raw stage stdout/stderr/exit/PID/error/overflow files enter capture before strict +decoding. A malformed UTF-8 stream therefore retains its exact raw identity and +ordinary exit receipt. Generated stage/selector/registry/overflow/sleeper sources +and the fallback header are captured. Compilation has a local finally for +available binary and link-map outputs. Get-LNAvailablePin records capture errors +without throwing over the original compilation-stage error; required raw streams +cannot silently disappear. Existing owned-process cleanup, ordinary-exit and +diagnostic checks remain in force. + +For one entered lifecycle define I to require: no capture error; nonempty captured +inventory; available initial baseline; for every captured pin, an existing final +file with equal length and SHA-256; and equal final HEAD/index/tracked/untracked +projection. The production accepted predicate is A = valid stage outcomes AND I. +The changed-input controls evaluate this identical I, not a weaker label-based +predicate Q. Intact success gives A; exit-seven with intact inputs gives not-A +with I; successful stage plus changed pin gives not-A with not-I; failed stage +plus changed pin retains both independent failures. The domain is the explicit +captured files and declared tree projection, not arbitrary host memory or loaders. + +integrity_controls.ps1 creates isolated repositories and preserves the complete +production function/setup prefix and complete success/catch/finally/summary/exit +suffix. Only the tool/semantic stage-body interval is substituted, and its exact +splice offsets and source hashes are retained. Actual bounded subprocesses still +run through Invoke-LNStage and the actual production validators/finalizer. This +is injected whole-script production-path reach, not the coordinator's earlier +extracted-finally component reproduction. These fixtures certify integrity; +the separate full native replay certifies unchanged C semantics. + +Every owned mutation has an outer finally restoring only fixture files/index, +with independent handling and verification of ignored link maps even if summary +parsing fails. No fixture mutates the real candidate or installed toolchain. +Exact ordinary native/launcher exits, raw stream bytes, timeout establishment, +cleanup and complete expected integrity-error sets prevent an expected error +from concealing another failure. The real candidate is compared before/after. + +| Control ID | Actual runner exit | Stage error | Integrity | +| --- | ---: | --- | --- | +| intact-success | 0 | none | pass | +| intact-stage-error | 1 | PROCESS | pass | +| malformed-stdout-intact | 1 | DIAGNOSTIC | pass | +| stage-error-and-pin-change | 1 | PROCESS | expected failure | +| stage-error-and-capture-error | 1 | PROCESS | expected failure | +| success-and-pin-change | 1 | none | expected failure | +| mixed-diagnostic-and-pin-change | 1 | DIAGNOSTIC | expected failure | +| timeout-and-pin-change | 1 | PROCESS | expected failure | +| success-and-tracked-change | 1 | none | expected failure | +| success-and-index-change | 1 | none | expected failure | +| success-and-untracked-addition | 1 | none | expected failure | +| success-and-untracked-byte-change | 1 | none | expected failure | +| success-and-link-map-change | 1 | none | expected failure | +| partial-identity-and-pin-change | 1 | IDENTITY | expected failure | +| missing-baseline | 1 | none | expected failure | + +All fifteen matched the exact expected outcome; fixture restoration and real-candidate equality passed. + +## Concrete toolchain provenance + +The invoked absolute lean/leanc/clang paths and rejected compiler overrides are +preserved. Installed Leanc source and compiled command/flag strings ground the +clang/lld roots; no compiler-correctness proof is claimed. The new PE decoder +derives normal-import edges from the actual local files and recursively captures +local dependencies before tool execution. Current roots produce eleven local +PE nodes. All current delay-import RVA/size fields are zero; unsupported nonzero +delay imports and unresolved non-system imports prevent a completeness success. + +The original receipt fails the same production coverage predicate for exactly +libclang-cpp.dll, libLLVM-19.dll, libc++.dll and zlib1.dll. The fourth file is a +newly measured transitive/direct-linker omission beyond the coordinator's three +direct clang omissions. The unchanged complete eleven-node inventory passes. +The predicate C(D,M) requires every full canonical local path in measured closure +D to be present in pin inventory M; final I checks its captured bytes/hash. +Completeness membership alone is not presented as tamper detection. + +Committed controls reject removal of each of the eleven entries, reject a +same-basename wrong-path entry, reject the exact old receipt, and pass complete +unchanged inventory. An actual copied zlib1.dll, copied map fixture and manifest +hash mutation reach Complete-LNIntegrity. File mutations require exactly the +changed-pin and tree-change errors; manifest-only tampering requires exactly +the changed-pin error. Each mutation restores in finally, and the restored +fixture passes. Installed tools are rehashed unchanged. + +| Local dependency | Bytes | SHA-256 | +| --- | ---: | --- | +| lean.exe | 82432 | `9B5AF669D8DC9B5826A1F5427584915EECA659E9BF34C7EE72667B93C0BFDCB0` | +| leanc.exe | 107520 | `DE2FDFEA989B9A771DA37E44EFD0BD50C00A2E2835EF9A2408F44E2385EA7618` | +| clang.exe | 224256 | `64B1E469B15149BD23039F1D121DE6E14F4AEC84BFF000952CA85968E56CE391` | +| ld.lld.exe | 5927424 | `6582CC45822AF5CF9A9C6245E75B85C445759C761F9B793F47BA919AD36AA643` | +| libleanshared.dll | 75793408 | `54E0F641AE412B687BBC64EA1C069A9954E754775ED0D3379C9847BC3B9FDA89` | +| libInit_shared.dll | 18534912 | `5300B06EA3A45146C22996B0591CC6475ACB5B6B77802EDBECD65BAAD6485386` | +| libclang-cpp.dll | 82430464 | `D4028A751017B44681373A4BEC8381B120A06083AC688DCDF45F45AEC46783C6` | +| libLLVM-19.dll | 80710656 | `74A1A54619E989CDC1F52EA3F206DA83C3C55DB73594FD1D4D4F2FE6D49CC02D` | +| libc++.dll | 1636864 | `1F3D0FF8504F19E6B6DC98426B58FA60B6A571D027F2C6AC4E169637C63A95DE` | +| zlib1.dll | 110592 | `260997C016819F60CEF902F3E7C0267804785D7B70C87CF541D0E40E6B693C75` | +| libleanshared_1.dll | 45882368 | `1378336D32450B713FDFDA31BA2829E34831FAE74BA3E503A49FB2EE96B65F5A` | + +The boundary includes recorded normal imports resolved beside each binary then +Lean bin. Remaining imports must be present System32 libraries or OS API-set +names. This is not a loader trace: OS library bytes, KnownDLL/API-set/forwarder +resolution, runtime LoadLibrary/plugins, transient substitution, PowerShell/.NET, +Git and compiler correctness remain external assumptions. No universal PE-loader +or compiler verification is claimed. The final available-artifact checks include +the actual generated link map. + +Post-replay inspection of the exact generated probe found only twelve declared +OS imports (ucrtbase, kernel32, icu, bcrypt, advapi32, ws2_32, iphlpapi, userenv, +user32, shell32, ole32 and dbghelp), no additional local non-system dependency, +and zero delay-import metadata. RESULTS pins PROBE_DEPENDENCIES.json and the +exact binary. This remains read-only import inspection, not loader verification. + +## Native semantics preserved + +The C source remains SHA-256 +`5F32F4A91B21697F86B4F2FEA855CD050E59E330CE6C6FFDA28898353B66D7B1`, registry +`6CD97F40E7C39D2212A8C8705D264D4832DCF2542815B72CD927906A01DC8B20`. +The final replay preserves the exact ordered 23 operational IDs, eight-field +mapping, 65 original check identities and 58 original stage identities. RESULTS +compares identities individually against the original raw summary, not only totals. +The committed production registry/selection/measurement predicates are preserved. +SelfTest also re-invokes registered cases for its parser and intermediate-stage +controls; 23 is the complete main registry, not a claim of only 23 native process +invocations. The focused invocation has exactly one requested semantic case. + +Expected values come from independent fixed input [101,-7,303,303,505,-19] and +source-position IDs. For registered intervals, 0 <= b, b+m <= n <= 6. Strict +transfer T(0,0) requires the exact selected values/IDs; logical size m; capacity +at most m and requested bytes at most 24+8m; absent source; fresh output with +owner RC one; absent old-array/element aliases; and each token's reference and +destructor counts equal its selected/discarded status. Alias-aware T(1,0) and +T(0,1) explicitly add those roots and cannot establish exclusive reclamation. +Cleanup F(a) requires absent source/output, exactly the allowed surviving old +alias with original values/RC, and exact reference/destructor contributions. + +Negative shrink uses the same T(0,0) as prefix replacement at (n,b,m)=(6,0,2) +and fails capacity. Negative alias and wrong-value use the same T(0,0) as overlap +replacement at (6,1,4), failing ownership/values. Negative cleanup uses the same +F(0) as fail-handoff at (6,1,4,stage=4), failing cleanup before later repair. +Thus P=Q with the stated guards; no stronger rejection predicate substitutes for +the accepted relation. The actual observer traverses live registered roots, +deduplicates array aliases and retains scalar snapshots, not freed objects. +Five injected failure-stage pre-states, intermediate-stage relabeling, false +summaries/labels and mixed diagnostics remain operationally checked. + +Unique shrink retains capacity 32 and 280 requested outer-array bytes. Exclusive +four-element replacement retains capacity four and 56 requested bytes. With an +old array alias, the same output retains 336 array bytes and ten element +references. These conclusions concern known roots and requested container bytes, +not nested allocation/RSS or a universal heap theorem. The fatal-handler exit +one is separate from actual allocator exhaustion or recoverable OOM cleanup. + +BOUNDARY.md's existing Construction.ExecState/ArrayRun -> output interval -> +Native.StorageImage/NativeImage resource mapping remains the consuming +recommendation. It still requires actual construction/history/key roots and +aliases to be inventoried by the future adapter, and the exact transferred +image to meet the reviewed formal query refinement. No speculative ABI was added. + +## Verification and final dispositions + +| Verification | Actual result | Receipt / raw evidence | +| --- | --- | --- | +| Focused selector and startup | exit 0; 386.932 s; exactly one semantic case; startup 8-byte pointers / 24-byte array header; includes mutex wait | `C:\Users\poin\.codex\worktrees\587c\RMQ\.lake\repair-r1\focused-efc3097b85614680a5abe5244327e80d\RECEIPT.json`; result `C:\Users\poin\.codex\worktrees\587c\RMQ\.lake\lifecycle-native-p0\runs\d741ab8a816040f6b42088b1648d74cc\SUMMARY.json` | +| Full native SelfTest | exit 0; 177.509 s; 23 cases / 65 checks / 58 stages; 616 final pins; unchanged tree | `C:\Users\poin\.codex\worktrees\587c\RMQ\.lake\repair-r1\full-69ab363f7f624a1886a11a8d73fd59ca\RECEIPT.json`; result `C:\Users\poin\.codex\worktrees\587c\RMQ\.lake\lifecycle-native-p0\runs\cf28effe9b7643e9a412747cb66eb0eb\SUMMARY.json` | +| Repair integrity controls | exit 0; 467.010 s; all 15 exact controls | `C:\Users\poin\.codex\worktrees\587c\RMQ\.lake\repair-r1\integrity-95a149cea1a045d3a9b4c72fb6237b8c\RECEIPT.json`; result `C:\Users\poin\.codex\worktrees\587c\RMQ\.lake\repair-r1\controls-0547a391cd1841ad8b4045ba90095392\RESULTS.json` | +| Dependency controls | exit 0; 49.154 s; all 19 named checks | `C:\Users\poin\.codex\worktrees\587c\RMQ\.lake\repair-r1\dependencies-da8c6b99a34b41ee9864e75b6fa91aa1\RECEIPT.json`; result `C:\Users\poin\.codex\worktrees\587c\RMQ\.lake\repair-r1\dependencies-38e1167c78a5420fa8e28c59908e5c52\RESULTS.json` | +| Initial frozen-source checks | exit 0; 20.417 s | `C:\Users\poin\.codex\worktrees\587c\RMQ\.lake\repair-r1\checks-81e725f3bc734cca9615cf637e4e7eba\RECEIPT.json`; result `C:\Users\poin\.codex\worktrees\587c\RMQ\.lake\repair-r1\final-checks-035ab358ce0640c7b4404577a838a121\RESULTS.json` | +| Final committed contract/design/hygiene/whitespace/clean checks | Passed at handoff on final packaging; all commits checked parent-to-commit and exact base | `.lake/repair-r1/package-final-checks/RECEIPT.json`; linked RESULTS/CONTRACT/log pins supply exact timing and outcomes | +| Final strict claim coverage | Passed at handoff after report packaging; original full scan plus verified unchanged-policy final-root rescan | `.lake/repair-r1/package-final-claims/RECEIPT.json`; full stdout/stderr and actual exit | + +RESULTS.json pins every listed runtime receipt and full summary. The postcommit receipts are generated after the report commit, and the local FINAL_CERTIFICATION.json pins those final outcomes and this report without embedding a self-referential hash. Native and fixture summary files preserve the full guards, raw paths and file hashes; no binaries or bulky transcripts are staged. + +Compiler/probe/old-descendant limits remain 120/30/8 seconds. Full native replay +has a 1200-second owned deadline and the required +Local\RMQLifecycleImplementationHeavy20260920 mutex. The new suite has a +2400-second outer safety bound for fifteen isolated repositories; individual +fixture runners have 120-second bounds and native failure stages 30 seconds, +except the established eight-second timeout. All actual ordinary exits and +complete raw output paths/hashes are retained. Forced termination can lack an +ordinary child-exit receipt; null is preserved, not manufactured into an exit. +The existing overflow control's observed branch is reported from its marker; +final-drain coverage is not inferred from polling rejection. +The final marker was exactly `native redirected output limit exceeded`, so this +run exercised polling rejection; it did not establish final-drain branch coverage. + +Development failures remain retained: the first fixture restoration encountered +Git newline conversion and was corrected with fixture-local core.autocrlf=false; +the first staged-mode mutation used invalid shell argument construction and was +corrected; the first raw Git-output retrieval tried helper logs already removed +by the shared helper and was replaced with a fail-closed newline-free interface. +An early contract comparison confused Git LF and checkout CRLF; explicit filtered +working-byte comparison fixed it without changing frozen row comparison. The +source-frozen timeout with no established native PID and wrapper parser failure +were diagnosed in R1-002; their failed receipts are preserved. These are not +passing evidence and no unchanged timeout was blindly retried. + +All 1125 baseline Lean/Lake/toolchain source identities and 251 original evidence +pins were independently rechecked. No Lean/lakefile/toolchain bytes changed, so +the original source-verified baseline build is reused; no standalone new Lake +build or aggregate was run. The campaign aggregate and fresh-blind final audit +remain coordinator-owned. Claim coverage composes the verified original +default-root scan (exit zero, 3479 hits, zero strict failures, 2211.841 seconds) +with the final unchanged-policy scan of the entire lifecycle-native-p0 subtree +and both ledgers. All 2910 outside paths/bytes, scanner/policy/rg identity and +configuration remain equal. Independent production enumeration/path-normalization +checks account for this fresh checkout's absolute root. This is a composition, +not a newly executed full-root scan; no allowance or policy changed. + +| Frozen ID | Local disposition and evidence | +| --- | --- | +| LN0-01 | Closed: pinned runtime operations and distinct projections; complete local compiler normal-import identity plus final checks. | +| LN0-02 | Closed: preserved actual unique/shared pop/shrink/destructor cases, live-root observer and explicit alias measurements. | +| LN0-03 | Closed: preserved consuming replacement, empty/overlap/tail/aliases, five injected cleanup pre-states and separate fatal process. | +| LN0-04 | Closed: exact registry/mapping, operational capacity/ownership/cleanup/value negatives and identical guarded predicates. | +| LN0-05 | Closed: bounded owned processes, exact streams/exits, command-boundary selectors, cleanup and independent final integrity. | +| LN0-06 | Closed: preserved source-grounded boundary recommendation; future adapter remains after formal interface review. | +| INV-SEMANTIC-NONVACUITY | Closed: unchanged measured native projections and actual production finalization controls, not verdict labels. | +| INV-ORACLE-INDEPENDENCE | Closed: unchanged fixed input/position specification; tamper expectations independent of test outputs. | +| INV-CATEGORY-SEPARATION | Closed: explicit native/kernel/model/payload/heap/OS distinctions and bounded domains. | +| INV-MUTATION-REPRODUCIBILITY | Closed: committed operational cases plus isolated integrity/dependency controls, exact failures, positive controls and verified restoration. | +| CHK-FINAL | Closed locally: final native/control evidence, exact source/pins/rows, design/hygiene/whitespace, final claim coverage and postcommit checks. | +| CHK-SCOPE | Closed locally: exact base/private branch, owned paths, unchanged rows/protected files, append-only ledgers, clean packaging, no integration/acceptance claim. | +| NP0R1-INTEGRITY | Closed: independent production finally across success/error/diagnostic/timeout/partial capture, full error separation, pin/tree controls and restoration. | +| NP0R1-TOOLCHAIN | Closed: measured eleven-node closure, four concrete historical omissions, actual map integrity and replayable completeness/tamper controls. | + +## Proof/ownership digestion + +Conceptually, an execution failure and an evidence-integrity failure are now two +independent facts. In plain English, a failed compiler or probe no longer prevents +the runner from checking whether its inputs and captured outputs changed. The +compiler identity also names the large local DLLs that implement its work. + +Nothing changes the old ownership experiment: shortening an array may release +elements while retaining backing capacity; acquiring selected references into a +bounded new buffer and releasing the old owner has a different retained-root +outcome; aliases remain real roots. Live assumptions include the inspected native +runtime/C observer, host process ownership, filesystem/Git observations, local +PE interpretation, OS loading and the finite fixture family. Payload bits, +proof fields, model ticks, runtime work, requested capacity and elapsed time +remain separate. + +The skeptical next campaign question is whether the eventual compiled adapter +retires every construction root and repeatedly queries the same reviewed retained +image with correctly bounded nested storage. That is the explicitly downstream +adapter/formal/campaign join, not an omitted prerequisite-runner repair. Source +review feedback and its concrete closures are in SOURCE_REVIEW.md; none is +represented as a fresh-blind campaign audit or coordinator acceptance. + +| Submitted source/artifact | Bytes | SHA-256 | +| --- | ---: | --- | +| scripts/packed_native_lifecycle_storage_replay.ps1 | 43878 | `C853A0BA7A8410A3A93C337105B97DE272CEC6920F74F9C5444B2196922C25F3` | +| scripts/packed_native_lifecycle_integrity_check.ps1 | 7713 | `F5D607EBD5693B8D4EB9D16B4C3292805476F146CD3E35414F2249CBAA95A696` | +| native/packed-rmq/tests/lifecycle_storage_probe.c | 14720 | `5F32F4A91B21697F86B4F2FEA855CD050E59E330CE6C6FFDA28898353B66D7B1` | +| docs/internal/extensions/lifecycle-native-p0/REGISTRY.json | 5899 | `6CD97F40E7C39D2212A8C8705D264D4832DCF2542815B72CD927906A01DC8B20` | +| ACCEPTANCE_ROWS.txt | 10983 | `74982691E40EB56A10365F66E74877F6518C0A13E959F559E267047BDAC7130E` | +| RESULTS.json | 98423 | `9313E4C20C4326B62F5CF4174BD5D57B54E300480AE48EB97D4AA74F8EBFF8A1` | diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r1/RESULTS.json b/docs/internal/extensions/lifecycle-native-p0/repair-r1/RESULTS.json new file mode 100644 index 00000000..ff80bb06 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r1/RESULTS.json @@ -0,0 +1,2760 @@ +{ + "sourceCommit": "1811eeb9e2f783cc455e44a618a99af77b0172ed", + "verificationCommit": "fda02922bf9e8c0707b9913013d3c16c80afe7c9", + "base": "0c873072e84be9e1d65edab1985bcff1d23abef1", + "native": { + "receipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\full-69ab363f7f624a1886a11a8d73fd59ca\\RECEIPT.json", + "bytes": 2454, + "sha256": "D450FDA94E24329028DA56A9441558D17BAE61F4189CE6727459F6DF79D0D491" + }, + "summary": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\SUMMARY.json", + "bytes": 330225, + "sha256": "059271927D6F21D704779B995A9C88C767A717479BDA235E6041549C3C4C5B7E" + }, + "seconds": 177.509, + "cases": [ + { + "id": "pop-unique", + "mapping": [ + 0, + 6, + 0, + 5, + 0, + 0, + 0, + 0 + ], + "expectedExit": 0, + "failure": "none", + "actualExit": 0, + "stdout": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\006-pop-unique.stdout", + "bytes": 1631, + "sha256": "DBEF0018246A7099307D464DD441D7B5BE78C8DFF369788D46233DCF372E733C" + }, + "stderr": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\006-pop-unique.stderr", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + } + }, + { + "id": "shrink-unique", + "mapping": [ + 1, + 6, + 0, + 2, + 0, + 0, + 0, + 0 + ], + "expectedExit": 0, + "failure": "none", + "actualExit": 0, + "stdout": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\007-shrink-unique.stdout", + "bytes": 1604, + "sha256": "B9CC9C92821FC51FA3FC93FDE2AFB74AF11561E9310F63CD71973CE9C249D71B" + }, + "stderr": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\007-shrink-unique.stderr", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + } + }, + { + "id": "pop-shared", + "mapping": [ + 0, + 6, + 0, + 5, + 1, + 0, + 0, + 0 + ], + "expectedExit": 0, + "failure": "none", + "actualExit": 0, + "stdout": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\008-pop-shared.stdout", + "bytes": 1704, + "sha256": "208107EF752A1D51AF15440BD3345DC4B02630AE4C347FFEEA499F9882877A65" + }, + "stderr": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\008-pop-shared.stderr", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + } + }, + { + "id": "shrink-shared", + "mapping": [ + 1, + 6, + 0, + 2, + 1, + 0, + 0, + 0 + ], + "expectedExit": 0, + "failure": "none", + "actualExit": 0, + "stdout": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\009-shrink-shared.stdout", + "bytes": 1676, + "sha256": "ACCD336A2BC388AC10EF52C5636B4C699BECAA90F6B267973E161CB0EF661174" + }, + "stderr": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\009-shrink-shared.stderr", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + } + }, + { + "id": "pop-empty-unique", + "mapping": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "expectedExit": 0, + "failure": "none", + "actualExit": 0, + "stdout": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\010-pop-empty-unique.stdout", + "bytes": 1559, + "sha256": "F33232D51B679364F67D789FAC0B860AAEC8A916BC510B408CA7BE8CF03BD85D" + }, + "stderr": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\010-pop-empty-unique.stderr", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + } + }, + { + "id": "pop-empty-shared", + "mapping": [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0 + ], + "expectedExit": 0, + "failure": "none", + "actualExit": 0, + "stdout": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\011-pop-empty-shared.stdout", + "bytes": 1565, + "sha256": "114095E50C26F1C88D41A700A9578C419355BF87B7844FFD6F51B632EF2C3064" + }, + "stderr": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\011-pop-empty-shared.stderr", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + } + }, + { + "id": "shrink-noop", + "mapping": [ + 1, + 6, + 0, + 6, + 0, + 0, + 0, + 0 + ], + "expectedExit": 0, + "failure": "none", + "actualExit": 0, + "stdout": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\012-shrink-noop.stdout", + "bytes": 1642, + "sha256": "B10080A4B804709EF818228FDC3E7F3CB024012071D18A0610B367F1C0C5C053" + }, + "stderr": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\012-shrink-noop.stderr", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + } + }, + { + "id": "replace-prefix", + "mapping": [ + 2, + 6, + 0, + 2, + 0, + 0, + 0, + 0 + ], + "expectedExit": 0, + "failure": "none", + "actualExit": 0, + "stdout": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\013-replace-prefix.stdout", + "bytes": 2572, + "sha256": "98168629717637DD394076C0F55BDF95C89C4741DABF116D934B9CBF98101DBB" + }, + "stderr": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\013-replace-prefix.stderr", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + } + }, + { + "id": "replace-overlap", + "mapping": [ + 2, + 6, + 1, + 4, + 0, + 0, + 0, + 0 + ], + "expectedExit": 0, + "failure": "none", + "actualExit": 0, + "stdout": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\014-replace-overlap.stdout", + "bytes": 2606, + "sha256": "69CF3E53F85E9E09B2C3CFE4EF6685AADD539644F5498735D0BBD40AC916F034" + }, + "stderr": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\014-replace-overlap.stderr", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + } + }, + { + "id": "replace-tail", + "mapping": [ + 2, + 6, + 4, + 2, + 0, + 0, + 0, + 0 + ], + "expectedExit": 0, + "failure": "none", + "actualExit": 0, + "stdout": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\015-replace-tail.stdout", + "bytes": 2573, + "sha256": "021327A3FFE95D1A70722BABD7A584EFA0809FBFE6A33CA7943AE647153D8AC6" + }, + "stderr": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\015-replace-tail.stderr", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + } + }, + { + "id": "replace-empty", + "mapping": [ + 2, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "expectedExit": 0, + "failure": "none", + "actualExit": 0, + "stdout": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\016-replace-empty.stdout", + "bytes": 2547, + "sha256": "9D0B14A7E8BC17895CA7952838EBFFBB20697197F2A7752E4AEBE35C082398F9" + }, + "stderr": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\016-replace-empty.stderr", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + } + }, + { + "id": "replace-alias", + "mapping": [ + 2, + 6, + 1, + 4, + 1, + 0, + 0, + 0 + ], + "expectedExit": 0, + "failure": "none", + "actualExit": 0, + "stdout": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\017-replace-alias.stdout", + "bytes": 2750, + "sha256": "C8F4749C0B8C36CA12FE5062E5939D00E744D140C6D99EEB522C867561D84A88" + }, + "stderr": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\017-replace-alias.stderr", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + } + }, + { + "id": "replace-element-alias", + "mapping": [ + 2, + 6, + 4, + 2, + 0, + 1, + 0, + 0 + ], + "expectedExit": 0, + "failure": "none", + "actualExit": 0, + "stdout": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\018-replace-element-alias.stdout", + "bytes": 2578, + "sha256": "3CAB4C08C0D495DF917C1A66AFEDB5156BEDB3ED94342D5060941B39A6CD6507" + }, + "stderr": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\018-replace-element-alias.stderr", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + } + }, + { + "id": "fail-alloc", + "mapping": [ + 3, + 6, + 1, + 4, + 0, + 0, + 1, + 0 + ], + "expectedExit": 0, + "failure": "none", + "actualExit": 0, + "stdout": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\019-fail-alloc.stdout", + "bytes": 2089, + "sha256": "0AA4F5786D0BB0C48DE7B4A12703FE5835DD301889A83CB0028C47C769781B11" + }, + "stderr": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\019-fail-alloc.stderr", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + } + }, + { + "id": "fail-after-alloc", + "mapping": [ + 3, + 6, + 1, + 4, + 0, + 0, + 2, + 0 + ], + "expectedExit": 0, + "failure": "none", + "actualExit": 0, + "stdout": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\020-fail-after-alloc.stdout", + "bytes": 2578, + "sha256": "13B336EFCE1F07C0F4C917453C11571620DC2976F291889142297135A487EF04" + }, + "stderr": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\020-fail-after-alloc.stderr", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + } + }, + { + "id": "fail-mid-copy", + "mapping": [ + 3, + 6, + 1, + 4, + 0, + 0, + 3, + 0 + ], + "expectedExit": 0, + "failure": "none", + "actualExit": 0, + "stdout": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\021-fail-mid-copy.stdout", + "bytes": 2584, + "sha256": "79AB51539C7FDDD84715469F0FE9EEDEAD8594AEC1C8F53EE4EA570BECD1BAA9" + }, + "stderr": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\021-fail-mid-copy.stderr", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + } + }, + { + "id": "fail-handoff", + "mapping": [ + 3, + 6, + 1, + 4, + 0, + 0, + 4, + 0 + ], + "expectedExit": 0, + "failure": "none", + "actualExit": 0, + "stdout": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\022-fail-handoff.stdout", + "bytes": 3097, + "sha256": "4924D43062E84934609B0287ED7909DCDC9FE67B723631B3A9933ECFB5231D45" + }, + "stderr": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\022-fail-handoff.stderr", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + } + }, + { + "id": "fail-after-consume", + "mapping": [ + 3, + 6, + 1, + 4, + 0, + 0, + 5, + 0 + ], + "expectedExit": 0, + "failure": "none", + "actualExit": 0, + "stdout": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\023-fail-after-consume.stdout", + "bytes": 3065, + "sha256": "5B24A4953B35EE51244A2BC6AD2E85F7F7082C8DEE0F87F9DE11F6532E08393F" + }, + "stderr": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\023-fail-after-consume.stderr", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + } + }, + { + "id": "fail-alias", + "mapping": [ + 3, + 6, + 1, + 4, + 1, + 0, + 3, + 0 + ], + "expectedExit": 0, + "failure": "none", + "actualExit": 0, + "stdout": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\024-fail-alias.stdout", + "bytes": 2727, + "sha256": "E782E0A7BF3FFE85B59C49EDE28140A1C381143845EB36C759A27BA4BB98DD94" + }, + "stderr": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\024-fail-alias.stderr", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + } + }, + { + "id": "negative-shrink", + "mapping": [ + 2, + 6, + 0, + 2, + 0, + 0, + 0, + 1 + ], + "expectedExit": 3, + "failure": "capacity", + "actualExit": 3, + "stdout": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\025-negative-shrink.stdout", + "bytes": 1610, + "sha256": "004C0187E6C070DA7D5E3C7A1DCC8061C5B270D870B57BCDED9402BCF6724CE2" + }, + "stderr": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\025-negative-shrink.stderr", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + } + }, + { + "id": "negative-alias", + "mapping": [ + 2, + 6, + 1, + 4, + 1, + 0, + 0, + 2 + ], + "expectedExit": 3, + "failure": "ownership", + "actualExit": 3, + "stdout": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\026-negative-alias.stdout", + "bytes": 2756, + "sha256": "3441AB06690EBEC1198985CF10E7F10ECD3BD1A5B9130718D566E682CF1AB9E5" + }, + "stderr": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\026-negative-alias.stderr", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + } + }, + { + "id": "negative-cleanup", + "mapping": [ + 3, + 6, + 1, + 4, + 0, + 0, + 4, + 3 + ], + "expectedExit": 3, + "failure": "cleanup", + "actualExit": 3, + "stdout": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\027-negative-cleanup.stdout", + "bytes": 3127, + "sha256": "309DA536A1FA1A4DA53AFA4C80136530D4741D63150CBB96163C8CAF63674E07" + }, + "stderr": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\027-negative-cleanup.stderr", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + } + }, + { + "id": "negative-value", + "mapping": [ + 2, + 6, + 1, + 4, + 0, + 0, + 0, + 4 + ], + "expectedExit": 3, + "failure": "values", + "actualExit": 3, + "stdout": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\028-negative-value.stdout", + "bytes": 2609, + "sha256": "201A7DCC90CE5A7CE2D5AEBB4B72DF8744D283A3EB9BB96A2AEC396D1FE4BAB2" + }, + "stderr": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\028-negative-value.stderr", + "bytes": 0, + "sha256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + } + } + ], + "checks": [ + { + "cleanupClaim": false, + "actualExit": 1, + "id": "fatal-runtime-handler", + "outcome": "fatal-process-observed", + "scope": "Direct fatal-handler invocation; neither actual exhaustion nor recoverable allocator failure" + }, + { + "expectedExit": 0, + "id": "pop-unique", + "outcome": "matched", + "failure": "none" + }, + { + "expectedExit": 0, + "id": "shrink-unique", + "outcome": "matched", + "failure": "none" + }, + { + "expectedExit": 0, + "id": "pop-shared", + "outcome": "matched", + "failure": "none" + }, + { + "expectedExit": 0, + "id": "shrink-shared", + "outcome": "matched", + "failure": "none" + }, + { + "expectedExit": 0, + "id": "pop-empty-unique", + "outcome": "matched", + "failure": "none" + }, + { + "expectedExit": 0, + "id": "pop-empty-shared", + "outcome": "matched", + "failure": "none" + }, + { + "expectedExit": 0, + "id": "shrink-noop", + "outcome": "matched", + "failure": "none" + }, + { + "expectedExit": 0, + "id": "replace-prefix", + "outcome": "matched", + "failure": "none" + }, + { + "expectedExit": 0, + "id": "replace-overlap", + "outcome": "matched", + "failure": "none" + }, + { + "expectedExit": 0, + "id": "replace-tail", + "outcome": "matched", + "failure": "none" + }, + { + "expectedExit": 0, + "id": "replace-empty", + "outcome": "matched", + "failure": "none" + }, + { + "expectedExit": 0, + "id": "replace-alias", + "outcome": "matched", + "failure": "none" + }, + { + "expectedExit": 0, + "id": "replace-element-alias", + "outcome": "matched", + "failure": "none" + }, + { + "expectedExit": 0, + "id": "fail-alloc", + "outcome": "matched", + "failure": "none" + }, + { + "expectedExit": 0, + "id": "fail-after-alloc", + "outcome": "matched", + "failure": "none" + }, + { + "expectedExit": 0, + "id": "fail-mid-copy", + "outcome": "matched", + "failure": "none" + }, + { + "expectedExit": 0, + "id": "fail-handoff", + "outcome": "matched", + "failure": "none" + }, + { + "expectedExit": 0, + "id": "fail-after-consume", + "outcome": "matched", + "failure": "none" + }, + { + "expectedExit": 0, + "id": "fail-alias", + "outcome": "matched", + "failure": "none" + }, + { + "expectedExit": 3, + "id": "negative-shrink", + "outcome": "matched", + "failure": "capacity" + }, + { + "expectedExit": 3, + "id": "negative-alias", + "outcome": "matched", + "failure": "ownership" + }, + { + "expectedExit": 3, + "id": "negative-cleanup", + "outcome": "matched", + "failure": "cleanup" + }, + { + "expectedExit": 3, + "id": "negative-value", + "outcome": "matched", + "failure": "values" + }, + { + "id": "selector-omitted", + "outcome": "matched", + "surface": "" + }, + { + "id": "selector-focused", + "outcome": "matched", + "surface": "" + }, + { + "id": "selector-reordered", + "outcome": "matched", + "surface": "" + }, + { + "id": "selector-empty", + "outcome": "matched", + "surface": "SELECTOR: explicit empty selector" + }, + { + "id": "selector-whitespace", + "outcome": "matched", + "surface": "SELECTOR: explicit empty selector" + }, + { + "id": "selector-unknown", + "outcome": "matched", + "surface": "SELECTOR: unknown ID" + }, + { + "id": "selector-zero", + "outcome": "matched", + "surface": "SELECTOR: unknown ID" + }, + { + "id": "selector-case", + "outcome": "matched", + "surface": "SELECTOR: unknown ID" + }, + { + "id": "selector-duplicate", + "outcome": "matched", + "surface": "SELECTOR: duplicate ID" + }, + { + "id": "selector-missing", + "outcome": "matched", + "surface": "SELECTOR: missing ID" + }, + { + "id": "registry-missing", + "outcome": "expected-reject", + "surface": "REGISTRY: cardinality differs" + }, + { + "id": "registry-duplicate", + "outcome": "expected-reject", + "surface": "REGISTRY: duplicate ID" + }, + { + "id": "registry-unknown", + "outcome": "expected-reject", + "surface": "REGISTRY: ordered IDs differ" + }, + { + "id": "registry-reordered", + "outcome": "expected-reject", + "surface": "REGISTRY: ordered IDs differ" + }, + { + "id": "registry-mapping", + "outcome": "expected-reject", + "surface": "REGISTRY: input mapping differs" + }, + { + "id": "registry-unknown-key", + "outcome": "expected-reject", + "surface": "REGISTRY: property set differs" + }, + { + "id": "registry-missing-key", + "outcome": "expected-reject", + "surface": "REGISTRY: property set differs" + }, + { + "id": "native-missing-command", + "outcome": "expected-reject", + "surface": "SELECTOR: invalid invocation" + }, + { + "id": "native-missing-id", + "outcome": "expected-reject", + "surface": "SELECTOR: invalid invocation" + }, + { + "id": "native-empty", + "outcome": "expected-reject", + "surface": "SELECTOR: invalid invocation" + }, + { + "id": "native-whitespace", + "outcome": "expected-reject", + "surface": "SELECTOR: unknown case" + }, + { + "id": "native-unknown", + "outcome": "expected-reject", + "surface": "SELECTOR: unknown case" + }, + { + "id": "native-duplicate", + "outcome": "expected-reject", + "surface": "SELECTOR: invalid invocation" + }, + { + "id": "verdict-control-replace-prefix", + "outcome": "measured-control", + "surface": "none" + }, + { + "id": "mixed-stderr-replace-prefix", + "outcome": "expected-reject", + "surface": "DIAGNOSTIC:" + }, + { + "id": "mixed-stdout-replace-prefix", + "outcome": "expected-reject", + "surface": "DIAGNOSTIC:" + }, + { + "id": "false-label-replace-prefix", + "outcome": "expected-reject", + "surface": "MEASUREMENT:" + }, + { + "id": "false-summary-replace-prefix", + "outcome": "expected-reject", + "surface": "MEASUREMENT:" + }, + { + "id": "verdict-control-negative-shrink", + "outcome": "measured-control", + "surface": "capacity" + }, + { + "id": "mixed-stderr-negative-shrink", + "outcome": "expected-reject", + "surface": "DIAGNOSTIC:" + }, + { + "id": "mixed-stdout-negative-shrink", + "outcome": "expected-reject", + "surface": "DIAGNOSTIC:" + }, + { + "id": "false-label-negative-shrink", + "outcome": "expected-reject", + "surface": "MEASUREMENT:" + }, + { + "id": "false-summary-negative-shrink", + "outcome": "expected-reject", + "surface": "MEASUREMENT:" + }, + { + "id": "omitted-stage-fail-mid-copy", + "outcome": "expected-reject", + "surface": "MEASUREMENT: intermediate" + }, + { + "challenged": "fail-mid-copy", + "id": "stage-control-fail-after-alloc", + "outcome": "actual-boundary-accepts" + }, + { + "id": "omitted-stage-fail-after-consume", + "outcome": "expected-reject", + "surface": "MEASUREMENT: intermediate" + }, + { + "challenged": "fail-after-consume", + "id": "stage-control-fail-handoff", + "outcome": "actual-boundary-accepts" + }, + { + "id": "fast-overflow-verdict", + "outcome": "expected-reject", + "surface": "PROCESS:" + }, + { + "id": "fast-overflow", + "bytes": 9437184, + "outcome": "expected-reject", + "actualChildExit": null + }, + { + "id": "timeout-no-success", + "outcome": "expected-reject", + "surface": "PROCESS:" + }, + { + "actualExitAvailable": false, + "grandchild": 28028, + "id": "owned-descendant-timeout", + "outcome": "expected-timeout-root-and-descendant-absent", + "nativeRoot": 28376 + } + ], + "stages": [ + { + "name": "lean-version", + "deadline": 30, + "actualExit": 0, + "launcherExit": 0, + "seconds": 2.354, + "timedOut": false + }, + { + "name": "clang-version", + "deadline": 30, + "actualExit": 0, + "launcherExit": 0, + "seconds": 1.935, + "timedOut": false + }, + { + "name": "compile", + "deadline": 120, + "actualExit": 0, + "launcherExit": 0, + "seconds": 2.531, + "timedOut": false + }, + { + "name": "startup", + "deadline": 30, + "actualExit": 0, + "launcherExit": 0, + "seconds": 2.342, + "timedOut": false + }, + { + "name": "native-list", + "deadline": 30, + "actualExit": 0, + "launcherExit": 0, + "seconds": 1.988, + "timedOut": false + }, + { + "name": "fatal-runtime-handler", + "deadline": 30, + "actualExit": 1, + "launcherExit": 1, + "seconds": 2.485, + "timedOut": false + }, + { + "name": "pop-unique", + "deadline": 30, + "actualExit": 0, + "launcherExit": 0, + "seconds": 2.133, + "timedOut": false + }, + { + "name": "shrink-unique", + "deadline": 30, + "actualExit": 0, + "launcherExit": 0, + "seconds": 1.929, + "timedOut": false + }, + { + "name": "pop-shared", + "deadline": 30, + "actualExit": 0, + "launcherExit": 0, + "seconds": 1.486, + "timedOut": false + }, + { + "name": "shrink-shared", + "deadline": 30, + "actualExit": 0, + "launcherExit": 0, + "seconds": 1.389, + "timedOut": false + }, + { + "name": "pop-empty-unique", + "deadline": 30, + "actualExit": 0, + "launcherExit": 0, + "seconds": 1.342, + "timedOut": false + }, + { + "name": "pop-empty-shared", + "deadline": 30, + "actualExit": 0, + "launcherExit": 0, + "seconds": 1.343, + "timedOut": false + }, + { + "name": "shrink-noop", + "deadline": 30, + "actualExit": 0, + "launcherExit": 0, + "seconds": 1.374, + "timedOut": false + }, + { + "name": "replace-prefix", + "deadline": 30, + "actualExit": 0, + "launcherExit": 0, + "seconds": 1.367, + "timedOut": false + }, + { + "name": "replace-overlap", + "deadline": 30, + "actualExit": 0, + "launcherExit": 0, + "seconds": 1.385, + "timedOut": false + }, + { + "name": "replace-tail", + "deadline": 30, + "actualExit": 0, + "launcherExit": 0, + "seconds": 1.381, + "timedOut": false + }, + { + "name": "replace-empty", + "deadline": 30, + "actualExit": 0, + "launcherExit": 0, + "seconds": 1.461, + "timedOut": false + }, + { + "name": "replace-alias", + "deadline": 30, + "actualExit": 0, + "launcherExit": 0, + "seconds": 1.518, + "timedOut": false + }, + { + "name": "replace-element-alias", + "deadline": 30, + "actualExit": 0, + "launcherExit": 0, + "seconds": 1.467, + "timedOut": false + }, + { + "name": "fail-alloc", + "deadline": 30, + "actualExit": 0, + "launcherExit": 0, + "seconds": 1.36, + "timedOut": false + }, + { + "name": "fail-after-alloc", + "deadline": 30, + "actualExit": 0, + "launcherExit": 0, + "seconds": 1.412, + "timedOut": false + }, + { + "name": "fail-mid-copy", + "deadline": 30, + "actualExit": 0, + "launcherExit": 0, + "seconds": 1.316, + "timedOut": false + }, + { + "name": "fail-handoff", + "deadline": 30, + "actualExit": 0, + "launcherExit": 0, + "seconds": 1.354, + "timedOut": false + }, + { + "name": "fail-after-consume", + "deadline": 30, + "actualExit": 0, + "launcherExit": 0, + "seconds": 1.274, + "timedOut": false + }, + { + "name": "fail-alias", + "deadline": 30, + "actualExit": 0, + "launcherExit": 0, + "seconds": 1.359, + "timedOut": false + }, + { + "name": "negative-shrink", + "deadline": 30, + "actualExit": 3, + "launcherExit": 3, + "seconds": 1.341, + "timedOut": false + }, + { + "name": "negative-alias", + "deadline": 30, + "actualExit": 3, + "launcherExit": 3, + "seconds": 1.383, + "timedOut": false + }, + { + "name": "negative-cleanup", + "deadline": 30, + "actualExit": 3, + "launcherExit": 3, + "seconds": 1.381, + "timedOut": false + }, + { + "name": "negative-value", + "deadline": 30, + "actualExit": 3, + "launcherExit": 3, + "seconds": 1.352, + "timedOut": false + }, + { + "name": "selector-omitted", + "deadline": 30, + "actualExit": 0, + "launcherExit": 0, + "seconds": 3.396, + "timedOut": false + }, + { + "name": "selector-focused", + "deadline": 30, + "actualExit": 0, + "launcherExit": 0, + "seconds": 3.622, + "timedOut": false + }, + { + "name": "selector-reordered", + "deadline": 30, + "actualExit": 0, + "launcherExit": 0, + "seconds": 4.161, + "timedOut": false + }, + { + "name": "selector-empty", + "deadline": 30, + "actualExit": 1, + "launcherExit": 1, + "seconds": 4.364, + "timedOut": false + }, + { + "name": "selector-whitespace", + "deadline": 30, + "actualExit": 1, + "launcherExit": 1, + "seconds": 4.431, + "timedOut": false + }, + { + "name": "selector-unknown", + "deadline": 30, + "actualExit": 1, + "launcherExit": 1, + "seconds": 3.463, + "timedOut": false + }, + { + "name": "selector-zero", + "deadline": 30, + "actualExit": 1, + "launcherExit": 1, + "seconds": 3.315, + "timedOut": false + }, + { + "name": "selector-case", + "deadline": 30, + "actualExit": 1, + "launcherExit": 1, + "seconds": 3.195, + "timedOut": false + }, + { + "name": "selector-duplicate", + "deadline": 30, + "actualExit": 1, + "launcherExit": 1, + "seconds": 3.92, + "timedOut": false + }, + { + "name": "selector-missing", + "deadline": 30, + "actualExit": 1, + "launcherExit": 1, + "seconds": 3.554, + "timedOut": false + }, + { + "name": "registry-missing", + "deadline": 30, + "actualExit": 1, + "launcherExit": 1, + "seconds": 3.192, + "timedOut": false + }, + { + "name": "registry-duplicate", + "deadline": 30, + "actualExit": 1, + "launcherExit": 1, + "seconds": 3.576, + "timedOut": false + }, + { + "name": "registry-unknown", + "deadline": 30, + "actualExit": 1, + "launcherExit": 1, + "seconds": 3.143, + "timedOut": false + }, + { + "name": "registry-reordered", + "deadline": 30, + "actualExit": 1, + "launcherExit": 1, + "seconds": 3.161, + "timedOut": false + }, + { + "name": "registry-mapping", + "deadline": 30, + "actualExit": 1, + "launcherExit": 1, + "seconds": 3.564, + "timedOut": false + }, + { + "name": "registry-unknown-key", + "deadline": 30, + "actualExit": 1, + "launcherExit": 1, + "seconds": 4.013, + "timedOut": false + }, + { + "name": "registry-missing-key", + "deadline": 30, + "actualExit": 1, + "launcherExit": 1, + "seconds": 4.663, + "timedOut": false + }, + { + "name": "native-missing-command", + "deadline": 30, + "actualExit": 2, + "launcherExit": 2, + "seconds": 1.852, + "timedOut": false + }, + { + "name": "native-missing-id", + "deadline": 30, + "actualExit": 2, + "launcherExit": 2, + "seconds": 1.722, + "timedOut": false + }, + { + "name": "native-empty", + "deadline": 30, + "actualExit": 2, + "launcherExit": 2, + "seconds": 1.508, + "timedOut": false + }, + { + "name": "native-whitespace", + "deadline": 30, + "actualExit": 2, + "launcherExit": 2, + "seconds": 1.381, + "timedOut": false + }, + { + "name": "native-unknown", + "deadline": 30, + "actualExit": 2, + "launcherExit": 2, + "seconds": 1.341, + "timedOut": false + }, + { + "name": "native-duplicate", + "deadline": 30, + "actualExit": 2, + "launcherExit": 2, + "seconds": 1.366, + "timedOut": false + }, + { + "name": "verdict-control-replace-prefix", + "deadline": 30, + "actualExit": 0, + "launcherExit": 0, + "seconds": 1.387, + "timedOut": false + }, + { + "name": "verdict-control-negative-shrink", + "deadline": 30, + "actualExit": 3, + "launcherExit": 3, + "seconds": 1.523, + "timedOut": false + }, + { + "name": "stage-control-fail-after-alloc", + "deadline": 30, + "actualExit": 0, + "launcherExit": 0, + "seconds": 1.479, + "timedOut": false + }, + { + "name": "stage-control-fail-handoff", + "deadline": 30, + "actualExit": 0, + "launcherExit": 0, + "seconds": 1.612, + "timedOut": false + }, + { + "name": "fast-overflow", + "deadline": 30, + "actualExit": null, + "launcherExit": 125, + "seconds": 3.038, + "timedOut": false + }, + { + "name": "owned-descendant-timeout", + "deadline": 8, + "actualExit": null, + "launcherExit": -1, + "seconds": 8.099, + "timedOut": true + } + ], + "integrity": { + "attempted": true, + "success": true, + "checkedPins": 616, + "treeChecked": true, + "errors": [], + "restorationWrites": 0 + }, + "capturedPinCount": 616, + "localDependencies": [ + { + "path": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\lean.exe", + "bytes": 82432, + "sha256": "9B5AF669D8DC9B5826A1F5427584915EECA659E9BF34C7EE72667B93C0BFDCB0" + }, + { + "path": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\leanc.exe", + "bytes": 107520, + "sha256": "DE2FDFEA989B9A771DA37E44EFD0BD50C00A2E2835EF9A2408F44E2385EA7618" + }, + { + "path": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\clang.exe", + "bytes": 224256, + "sha256": "64B1E469B15149BD23039F1D121DE6E14F4AEC84BFF000952CA85968E56CE391" + }, + { + "path": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\ld.lld.exe", + "bytes": 5927424, + "sha256": "6582CC45822AF5CF9A9C6245E75B85C445759C761F9B793F47BA919AD36AA643" + }, + { + "path": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libleanshared.dll", + "bytes": 75793408, + "sha256": "54E0F641AE412B687BBC64EA1C069A9954E754775ED0D3379C9847BC3B9FDA89" + }, + { + "path": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libInit_shared.dll", + "bytes": 18534912, + "sha256": "5300B06EA3A45146C22996B0591CC6475ACB5B6B77802EDBECD65BAAD6485386" + }, + { + "path": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libclang-cpp.dll", + "bytes": 82430464, + "sha256": "D4028A751017B44681373A4BEC8381B120A06083AC688DCDF45F45AEC46783C6" + }, + { + "path": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libLLVM-19.dll", + "bytes": 80710656, + "sha256": "74A1A54619E989CDC1F52EA3F206DA83C3C55DB73594FD1D4D4F2FE6D49CC02D" + }, + { + "path": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libc++.dll", + "bytes": 1636864, + "sha256": "1F3D0FF8504F19E6B6DC98426B58FA60B6A571D027F2C6AC4E169637C63A95DE" + }, + { + "path": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\zlib1.dll", + "bytes": 110592, + "sha256": "260997C016819F60CEF902F3E7C0267804785D7B70C87CF541D0E40E6B693C75" + }, + { + "path": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libleanshared_1.dll", + "bytes": 45882368, + "sha256": "1378336D32450B713FDFDA31BA2829E34831FAE74BA3E503A49FB2EE96B65F5A" + } + ], + "dependencyClosure": { + "roots": [ + "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\lean.exe", + "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\leanc.exe", + "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\clang.exe", + "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\ld.lld.exe" + ], + "nodes": [ + { + "path": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\lean.exe", + "imports": [ + "ucrtbase.dll", + "KERNEL32.dll", + "libleanshared.dll" + ], + "delayRva": 0, + "delaySize": 0 + }, + { + "path": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\leanc.exe", + "imports": [ + "ucrtbase.dll", + "KERNEL32.dll", + "libInit_shared.dll", + "libleanshared.dll" + ], + "delayRva": 0, + "delaySize": 0 + }, + { + "path": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\clang.exe", + "imports": [ + "libclang-cpp.dll", + "libLLVM-19.dll", + "KERNEL32.dll", + "libc++.dll", + "api-ms-win-crt-stdio-l1-1-0.dll", + "api-ms-win-crt-runtime-l1-1-0.dll", + "api-ms-win-crt-heap-l1-1-0.dll", + "api-ms-win-crt-environment-l1-1-0.dll", + "api-ms-win-crt-private-l1-1-0.dll", + "api-ms-win-crt-string-l1-1-0.dll", + "api-ms-win-crt-math-l1-1-0.dll" + ], + "delayRva": 0, + "delaySize": 0 + }, + { + "path": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\ld.lld.exe", + "imports": [ + "libLLVM-19.dll", + "KERNEL32.dll", + "libc++.dll", + "api-ms-win-crt-stdio-l1-1-0.dll", + "api-ms-win-crt-runtime-l1-1-0.dll", + "api-ms-win-crt-heap-l1-1-0.dll", + "api-ms-win-crt-environment-l1-1-0.dll", + "api-ms-win-crt-private-l1-1-0.dll", + "api-ms-win-crt-string-l1-1-0.dll", + "api-ms-win-crt-time-l1-1-0.dll", + "api-ms-win-crt-math-l1-1-0.dll", + "api-ms-win-crt-utility-l1-1-0.dll", + "zlib1.dll" + ], + "delayRva": 0, + "delaySize": 0 + }, + { + "path": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libleanshared.dll", + "imports": [ + "libleanshared_1.dll", + "libInit_shared.dll", + "ucrtbase.dll", + "KERNEL32.dll" + ], + "delayRva": 0, + "delaySize": 0 + }, + { + "path": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libInit_shared.dll", + "imports": [ + "ADVAPI32.dll", + "WS2_32.dll", + "ucrtbase.dll", + "icu.dll", + "bcrypt.dll", + "KERNEL32.dll", + "IPHLPAPI.DLL", + "USERENV.dll", + "USER32.dll", + "SHELL32.dll", + "ole32.dll", + "dbghelp.dll" + ], + "delayRva": 0, + "delaySize": 0 + }, + { + "path": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libclang-cpp.dll", + "imports": [ + "VERSION.dll", + "libLLVM-19.dll", + "KERNEL32.dll", + "libc++.dll", + "api-ms-win-crt-stdio-l1-1-0.dll", + "api-ms-win-crt-runtime-l1-1-0.dll", + "api-ms-win-crt-string-l1-1-0.dll", + "api-ms-win-crt-time-l1-1-0.dll", + "api-ms-win-crt-heap-l1-1-0.dll", + "api-ms-win-crt-math-l1-1-0.dll", + "api-ms-win-crt-environment-l1-1-0.dll", + "api-ms-win-crt-private-l1-1-0.dll", + "api-ms-win-crt-utility-l1-1-0.dll", + "api-ms-win-crt-convert-l1-1-0.dll" + ], + "delayRva": 0, + "delaySize": 0 + }, + { + "path": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libLLVM-19.dll", + "imports": [ + "SHELL32.dll", + "ole32.dll", + "ADVAPI32.dll", + "WS2_32.dll", + "ntdll.dll", + "zlib1.dll", + "KERNEL32.dll", + "libc++.dll", + "api-ms-win-crt-stdio-l1-1-0.dll", + "api-ms-win-crt-runtime-l1-1-0.dll", + "api-ms-win-crt-heap-l1-1-0.dll", + "api-ms-win-crt-string-l1-1-0.dll", + "api-ms-win-crt-private-l1-1-0.dll", + "api-ms-win-crt-time-l1-1-0.dll", + "api-ms-win-crt-math-l1-1-0.dll", + "api-ms-win-crt-convert-l1-1-0.dll", + "api-ms-win-crt-environment-l1-1-0.dll", + "api-ms-win-crt-utility-l1-1-0.dll", + "api-ms-win-crt-filesystem-l1-1-0.dll" + ], + "delayRva": 0, + "delaySize": 0 + }, + { + "path": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libc++.dll", + "imports": [ + "KERNEL32.dll", + "api-ms-win-crt-locale-l1-1-0.dll", + "api-ms-win-crt-stdio-l1-1-0.dll", + "api-ms-win-crt-runtime-l1-1-0.dll", + "api-ms-win-crt-heap-l1-1-0.dll", + "api-ms-win-crt-string-l1-1-0.dll", + "api-ms-win-crt-multibyte-l1-1-0.dll", + "api-ms-win-crt-time-l1-1-0.dll", + "api-ms-win-crt-convert-l1-1-0.dll", + "api-ms-win-crt-utility-l1-1-0.dll", + "api-ms-win-crt-environment-l1-1-0.dll", + "api-ms-win-crt-math-l1-1-0.dll", + "api-ms-win-crt-private-l1-1-0.dll", + "api-ms-win-crt-filesystem-l1-1-0.dll" + ], + "delayRva": 0, + "delaySize": 0 + }, + { + "path": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\zlib1.dll", + "imports": [ + "api-ms-win-crt-convert-l1-1-0.dll", + "api-ms-win-crt-heap-l1-1-0.dll", + "api-ms-win-crt-private-l1-1-0.dll", + "api-ms-win-crt-runtime-l1-1-0.dll", + "api-ms-win-crt-stdio-l1-1-0.dll", + "api-ms-win-crt-string-l1-1-0.dll", + "KERNEL32.dll", + "api-ms-win-crt-utility-l1-1-0.dll", + "api-ms-win-crt-environment-l1-1-0.dll", + "api-ms-win-crt-time-l1-1-0.dll" + ], + "delayRva": 0, + "delaySize": 0 + }, + { + "path": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libleanshared_1.dll", + "imports": [ + "libInit_shared.dll", + "ucrtbase.dll", + "KERNEL32.dll" + ], + "delayRva": 0, + "delaySize": 0 + } + ], + "external": [ + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\lean.exe", + "name": "ucrtbase.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\lean.exe", + "name": "KERNEL32.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\leanc.exe", + "name": "ucrtbase.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\leanc.exe", + "name": "KERNEL32.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\clang.exe", + "name": "KERNEL32.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\clang.exe", + "name": "api-ms-win-crt-stdio-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\clang.exe", + "name": "api-ms-win-crt-runtime-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\clang.exe", + "name": "api-ms-win-crt-heap-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\clang.exe", + "name": "api-ms-win-crt-environment-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\clang.exe", + "name": "api-ms-win-crt-private-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\clang.exe", + "name": "api-ms-win-crt-string-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\clang.exe", + "name": "api-ms-win-crt-math-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\ld.lld.exe", + "name": "KERNEL32.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\ld.lld.exe", + "name": "api-ms-win-crt-stdio-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\ld.lld.exe", + "name": "api-ms-win-crt-runtime-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\ld.lld.exe", + "name": "api-ms-win-crt-heap-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\ld.lld.exe", + "name": "api-ms-win-crt-environment-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\ld.lld.exe", + "name": "api-ms-win-crt-private-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\ld.lld.exe", + "name": "api-ms-win-crt-string-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\ld.lld.exe", + "name": "api-ms-win-crt-time-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\ld.lld.exe", + "name": "api-ms-win-crt-math-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\ld.lld.exe", + "name": "api-ms-win-crt-utility-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libleanshared.dll", + "name": "ucrtbase.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libleanshared.dll", + "name": "KERNEL32.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libInit_shared.dll", + "name": "ADVAPI32.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libInit_shared.dll", + "name": "WS2_32.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libInit_shared.dll", + "name": "ucrtbase.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libInit_shared.dll", + "name": "icu.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libInit_shared.dll", + "name": "bcrypt.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libInit_shared.dll", + "name": "KERNEL32.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libInit_shared.dll", + "name": "IPHLPAPI.DLL", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libInit_shared.dll", + "name": "USERENV.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libInit_shared.dll", + "name": "USER32.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libInit_shared.dll", + "name": "SHELL32.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libInit_shared.dll", + "name": "ole32.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libInit_shared.dll", + "name": "dbghelp.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libclang-cpp.dll", + "name": "VERSION.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libclang-cpp.dll", + "name": "KERNEL32.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libclang-cpp.dll", + "name": "api-ms-win-crt-stdio-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libclang-cpp.dll", + "name": "api-ms-win-crt-runtime-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libclang-cpp.dll", + "name": "api-ms-win-crt-string-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libclang-cpp.dll", + "name": "api-ms-win-crt-time-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libclang-cpp.dll", + "name": "api-ms-win-crt-heap-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libclang-cpp.dll", + "name": "api-ms-win-crt-math-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libclang-cpp.dll", + "name": "api-ms-win-crt-environment-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libclang-cpp.dll", + "name": "api-ms-win-crt-private-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libclang-cpp.dll", + "name": "api-ms-win-crt-utility-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libclang-cpp.dll", + "name": "api-ms-win-crt-convert-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libLLVM-19.dll", + "name": "SHELL32.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libLLVM-19.dll", + "name": "ole32.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libLLVM-19.dll", + "name": "ADVAPI32.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libLLVM-19.dll", + "name": "WS2_32.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libLLVM-19.dll", + "name": "ntdll.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libLLVM-19.dll", + "name": "KERNEL32.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libLLVM-19.dll", + "name": "api-ms-win-crt-stdio-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libLLVM-19.dll", + "name": "api-ms-win-crt-runtime-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libLLVM-19.dll", + "name": "api-ms-win-crt-heap-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libLLVM-19.dll", + "name": "api-ms-win-crt-string-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libLLVM-19.dll", + "name": "api-ms-win-crt-private-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libLLVM-19.dll", + "name": "api-ms-win-crt-time-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libLLVM-19.dll", + "name": "api-ms-win-crt-math-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libLLVM-19.dll", + "name": "api-ms-win-crt-convert-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libLLVM-19.dll", + "name": "api-ms-win-crt-environment-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libLLVM-19.dll", + "name": "api-ms-win-crt-utility-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libLLVM-19.dll", + "name": "api-ms-win-crt-filesystem-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libc++.dll", + "name": "KERNEL32.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libc++.dll", + "name": "api-ms-win-crt-locale-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libc++.dll", + "name": "api-ms-win-crt-stdio-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libc++.dll", + "name": "api-ms-win-crt-runtime-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libc++.dll", + "name": "api-ms-win-crt-heap-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libc++.dll", + "name": "api-ms-win-crt-string-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libc++.dll", + "name": "api-ms-win-crt-multibyte-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libc++.dll", + "name": "api-ms-win-crt-time-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libc++.dll", + "name": "api-ms-win-crt-convert-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libc++.dll", + "name": "api-ms-win-crt-utility-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libc++.dll", + "name": "api-ms-win-crt-environment-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libc++.dll", + "name": "api-ms-win-crt-math-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libc++.dll", + "name": "api-ms-win-crt-private-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libc++.dll", + "name": "api-ms-win-crt-filesystem-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\zlib1.dll", + "name": "api-ms-win-crt-convert-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\zlib1.dll", + "name": "api-ms-win-crt-heap-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\zlib1.dll", + "name": "api-ms-win-crt-private-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\zlib1.dll", + "name": "api-ms-win-crt-runtime-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\zlib1.dll", + "name": "api-ms-win-crt-stdio-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\zlib1.dll", + "name": "api-ms-win-crt-string-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\zlib1.dll", + "name": "KERNEL32.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\zlib1.dll", + "name": "api-ms-win-crt-utility-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\zlib1.dll", + "name": "api-ms-win-crt-environment-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\zlib1.dll", + "name": "api-ms-win-crt-time-l1-1-0.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libleanshared_1.dll", + "name": "ucrtbase.dll", + "boundary": "OS system library/API-set resolution, not pinned" + }, + { + "from": "C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libleanshared_1.dll", + "name": "KERNEL32.dll", + "boundary": "OS system library/API-set resolution, not pinned" + } + ], + "boundary": "Normal imports resolved beside each binary then Lean bin; nonzero delay imports reject. OS/API sets, runtime LoadLibrary/plugin/configuration behavior, Windows search/forwarder semantics, PowerShell/.NET and compiler correctness are external assumptions, not universally verified." + }, + "linkMap": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\link.map", + "bytes": 4381803, + "sha256": "BFA437DB4A9B78DE712BDD56344CFF3607D5C26E815C3750505530C4BC04D820" + } + }, + "focused": { + "receipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\focused-efc3097b85614680a5abe5244327e80d\\RECEIPT.json", + "bytes": 2486, + "sha256": "188AC9C567F67D75FF7F5D40FF2EBC0A4F3A75DC65F0AF95B0BF69D00D5D71E2" + }, + "summary": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\d741ab8a816040f6b42088b1648d74cc\\SUMMARY.json", + "bytes": 117090, + "sha256": "5E79A3E6C0E895886064843690FC0C6AB821871A0E4D2B47960DCF134BD66312" + }, + "seconds": 386.932, + "selected": [ + "pop-unique" + ], + "stageNames": [ + "lean-version", + "clang-version", + "compile", + "startup", + "native-list", + "fatal-runtime-handler", + "pop-unique" + ], + "integrity": { + "attempted": true, + "success": true, + "checkedPins": 191, + "treeChecked": true, + "errors": [], + "restorationWrites": 0 + } + }, + "integrityControls": { + "receipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\integrity-95a149cea1a045d3a9b4c72fb6237b8c\\RECEIPT.json", + "bytes": 2198, + "sha256": "3E55A634609647B3D315D0030539F04E905606EECF6EC9029BD44D8AA20384A4" + }, + "results": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\controls-0547a391cd1841ad8b4045ba90095392\\RESULTS.json", + "bytes": 42543, + "sha256": "9DBE9DA17540D69867498FBDCE65BD4F10811B88F17B832E2EA3519BD44E3640" + }, + "seconds": 467.01, + "controls": [ + { + "id": "intact-success", + "actualExit": 0, + "seconds": 17.754, + "expectedStageError": null, + "expectedIntegrity": true, + "stageFailure": null, + "integrity": { + "attempted": true, + "success": true, + "checkedPins": 17, + "treeChecked": true, + "errors": [], + "restorationWrites": 0 + }, + "summary": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\controls-0547a391cd1841ad8b4045ba90095392\\intact-success\\.lake\\lifecycle-native-p0\\runs\\caab5adc09c149c9bb06a907f2dbab4e\\SUMMARY.json", + "bytes": 10367, + "sha256": "73B22FE31F89A3CBBDE2703999789F6818D7372ED1CAC347A959D45F5F6D261F" + } + }, + { + "id": "intact-stage-error", + "actualExit": 1, + "seconds": 17.477, + "expectedStageError": "PROCESS:", + "expectedIntegrity": true, + "stageFailure": "PROCESS: fixture-stage actual child or launcher exit differs from 0", + "integrity": { + "attempted": true, + "success": true, + "checkedPins": 17, + "treeChecked": true, + "errors": [], + "restorationWrites": 0 + }, + "summary": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\controls-0547a391cd1841ad8b4045ba90095392\\intact-stage-error\\.lake\\lifecycle-native-p0\\runs\\1dda68f2ac5d40ec9e190d3882b3a40b\\SUMMARY.json", + "bytes": 10544, + "sha256": "2DFFCA6E667095A20D868BE2931C1E5AFBD9B6F9E51A9C398A13ED4E1097D178" + } + }, + { + "id": "malformed-stdout-intact", + "actualExit": 1, + "seconds": 18.456, + "expectedStageError": "DIAGNOSTIC:", + "expectedIntegrity": true, + "stageFailure": "DIAGNOSTIC: invalid raw stage evidence for fixture-stage; Exception calling \"ReadAllText\" with \"2\" argument(s): \"Unable to translate bytes [FF] at index 0 from specified code page to Unicode.\"", + "integrity": { + "attempted": true, + "success": true, + "checkedPins": 14, + "treeChecked": true, + "errors": [], + "restorationWrites": 0 + }, + "summary": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\controls-0547a391cd1841ad8b4045ba90095392\\malformed-stdout-intact\\.lake\\lifecycle-native-p0\\runs\\f052295de9e04532bc764a6d68374270\\SUMMARY.json", + "bytes": 7791, + "sha256": "CF533EC96313FFEB2E353AD754FE039B8815E400C556DCE934893999A8B49A23" + } + }, + { + "id": "stage-error-and-pin-change", + "actualExit": 1, + "seconds": 18.042, + "expectedStageError": "PROCESS:", + "expectedIntegrity": false, + "stageFailure": "PROCESS: fixture-stage actual child or launcher exit differs from 0", + "integrity": { + "attempted": true, + "success": false, + "checkedPins": 17, + "treeChecked": true, + "errors": [ + "INTEGRITY: changed captured pin: C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\controls-0547a391cd1841ad8b4045ba90095392\\stage-error-and-pin-change\\native\\packed-rmq\\tests\\lifecycle_storage_probe.c", + "INTEGRITY: live tracked/index/untracked baseline changed" + ], + "restorationWrites": 0 + }, + "summary": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\controls-0547a391cd1841ad8b4045ba90095392\\stage-error-and-pin-change\\.lake\\lifecycle-native-p0\\runs\\a7bd4877e3a141deaaf7d85257fd8623\\SUMMARY.json", + "bytes": 11073, + "sha256": "5E22B065B4488BEA7004A05D698F210BA609EB1F9DC0D9E0E01808A24288EB9E" + } + }, + { + "id": "stage-error-and-capture-error", + "actualExit": 1, + "seconds": 18.747, + "expectedStageError": "PROCESS:", + "expectedIntegrity": false, + "stageFailure": "PROCESS: fixture-stage actual child or launcher exit differs from 0", + "integrity": { + "attempted": true, + "success": false, + "checkedPins": 17, + "treeChecked": true, + "errors": [ + "INTEGRITY: artifact capture failed: C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\controls-0547a391cd1841ad8b4045ba90095392\\stage-error-and-capture-error\\.lake\\lifecycle-native-p0\\runs\\5b2a1404f38d46b28083fe971c028c04\\link.map; The process cannot access the file 'C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\controls-0547a391cd1841ad8b4045ba90095392\\stage-error-and-capture-error\\.lake\\lifecycle-native-p0\\runs\\5b2a1404f38d46b28083fe971c028c04\\link.map' because it is being used by another process." + ], + "restorationWrites": 0 + }, + "summary": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\controls-0547a391cd1841ad8b4045ba90095392\\stage-error-and-capture-error\\.lake\\lifecycle-native-p0\\runs\\5b2a1404f38d46b28083fe971c028c04\\SUMMARY.json", + "bytes": 11420, + "sha256": "B2D6A8FE820E7108FFFA57408C51ADE86D8652DC0337E6C565AA3C1EF393F9E9" + } + }, + { + "id": "success-and-pin-change", + "actualExit": 1, + "seconds": 19.223, + "expectedStageError": null, + "expectedIntegrity": false, + "stageFailure": null, + "integrity": { + "attempted": true, + "success": false, + "checkedPins": 17, + "treeChecked": true, + "errors": [ + "INTEGRITY: changed captured pin: C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\controls-0547a391cd1841ad8b4045ba90095392\\success-and-pin-change\\native\\packed-rmq\\tests\\lifecycle_storage_probe.c", + "INTEGRITY: live tracked/index/untracked baseline changed" + ], + "restorationWrites": 0 + }, + "summary": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\controls-0547a391cd1841ad8b4045ba90095392\\success-and-pin-change\\.lake\\lifecycle-native-p0\\runs\\7ca262f16de24ec1bc079756f32b6bb0\\SUMMARY.json", + "bytes": 10893, + "sha256": "4019EE727FE34372D43512315FBC2647E2BEEB6A14C31CCA150C9FC127CF5B29" + } + }, + { + "id": "mixed-diagnostic-and-pin-change", + "actualExit": 1, + "seconds": 18.136, + "expectedStageError": "DIAGNOSTIC:", + "expectedIntegrity": false, + "stageFailure": "DIAGNOSTIC: unexpected or mixed stderr for fixture-stage", + "integrity": { + "attempted": true, + "success": false, + "checkedPins": 17, + "treeChecked": true, + "errors": [ + "INTEGRITY: changed captured pin: C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\controls-0547a391cd1841ad8b4045ba90095392\\mixed-diagnostic-and-pin-change\\native\\packed-rmq\\tests\\lifecycle_storage_probe.c", + "INTEGRITY: live tracked/index/untracked baseline changed" + ], + "restorationWrites": 0 + }, + "summary": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\controls-0547a391cd1841ad8b4045ba90095392\\mixed-diagnostic-and-pin-change\\.lake\\lifecycle-native-p0\\runs\\bd822ad22d1a476392a24eb2e09b07ed\\SUMMARY.json", + "bytes": 11209, + "sha256": "C8C1AB484ECA421F9D03858C420B370676FFFD0D29E45C3170DD77C2FC3ECB2D" + } + }, + { + "id": "timeout-and-pin-change", + "actualExit": 1, + "seconds": 23.189, + "expectedStageError": "PROCESS:", + "expectedIntegrity": false, + "stageFailure": "PROCESS: fixture-stage was not a completed bounded process; see retained logs", + "integrity": { + "attempted": true, + "success": false, + "checkedPins": 15, + "treeChecked": true, + "errors": [ + "INTEGRITY: changed captured pin: C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\controls-0547a391cd1841ad8b4045ba90095392\\timeout-and-pin-change\\native\\packed-rmq\\tests\\lifecycle_storage_probe.c", + "INTEGRITY: live tracked/index/untracked baseline changed" + ], + "restorationWrites": 0 + }, + "summary": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\controls-0547a391cd1841ad8b4045ba90095392\\timeout-and-pin-change\\.lake\\lifecycle-native-p0\\runs\\90ca7358e18e4398bd809386d11cf990\\SUMMARY.json", + "bytes": 10209, + "sha256": "0ACAB972E6202EFFC841C0B11AFD88A3FB9C3D7D69DCE5992AF6178DC7FCDB36" + } + }, + { + "id": "success-and-tracked-change", + "actualExit": 1, + "seconds": 19.446, + "expectedStageError": null, + "expectedIntegrity": false, + "stageFailure": null, + "integrity": { + "attempted": true, + "success": false, + "checkedPins": 17, + "treeChecked": true, + "errors": [ + "INTEGRITY: live tracked/index/untracked baseline changed" + ], + "restorationWrites": 0 + }, + "summary": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\controls-0547a391cd1841ad8b4045ba90095392\\success-and-tracked-change\\.lake\\lifecycle-native-p0\\runs\\da9a61a9a58248708d3147f9893ec905\\SUMMARY.json", + "bytes": 10776, + "sha256": "BBB5C5EC0AE763E051C6B37BFA2D4343B09BA8FED60093366E0048185672AE1F" + } + }, + { + "id": "success-and-index-change", + "actualExit": 1, + "seconds": 18.911, + "expectedStageError": null, + "expectedIntegrity": false, + "stageFailure": null, + "integrity": { + "attempted": true, + "success": false, + "checkedPins": 17, + "treeChecked": true, + "errors": [ + "INTEGRITY: live tracked/index/untracked baseline changed" + ], + "restorationWrites": 0 + }, + "summary": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\controls-0547a391cd1841ad8b4045ba90095392\\success-and-index-change\\.lake\\lifecycle-native-p0\\runs\\6a93c677fdc24287b54949da22840861\\SUMMARY.json", + "bytes": 10721, + "sha256": "092EEA253AE09B6BB25C755A4D099961CCD69FAC7A94CE98EBF8112AE88B1336" + } + }, + { + "id": "success-and-untracked-addition", + "actualExit": 1, + "seconds": 21.003, + "expectedStageError": null, + "expectedIntegrity": false, + "stageFailure": null, + "integrity": { + "attempted": true, + "success": false, + "checkedPins": 17, + "treeChecked": true, + "errors": [ + "INTEGRITY: live tracked/index/untracked baseline changed" + ], + "restorationWrites": 0 + }, + "summary": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\controls-0547a391cd1841ad8b4045ba90095392\\success-and-untracked-addition\\.lake\\lifecycle-native-p0\\runs\\d61c88710a9a4a61adf1162d02b88173\\SUMMARY.json", + "bytes": 10889, + "sha256": "CCC9CEF81A5BBEEC4B1F6063BDDF1572CD5590D79A3BF3615A86CACDC7365D03" + } + }, + { + "id": "success-and-untracked-byte-change", + "actualExit": 1, + "seconds": 20.734, + "expectedStageError": null, + "expectedIntegrity": false, + "stageFailure": null, + "integrity": { + "attempted": true, + "success": false, + "checkedPins": 17, + "treeChecked": true, + "errors": [ + "INTEGRITY: live tracked/index/untracked baseline changed" + ], + "restorationWrites": 0 + }, + "summary": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\controls-0547a391cd1841ad8b4045ba90095392\\success-and-untracked-byte-change\\.lake\\lifecycle-native-p0\\runs\\a4449de68d484e9fbd9b3596d4f6d24c\\SUMMARY.json", + "bytes": 10973, + "sha256": "550068EC7F5AECCBE19C543E3C427B246152AF25374C81F2B18C21B57ED2E457" + } + }, + { + "id": "success-and-link-map-change", + "actualExit": 1, + "seconds": 16.477, + "expectedStageError": null, + "expectedIntegrity": false, + "stageFailure": null, + "integrity": { + "attempted": true, + "success": false, + "checkedPins": 18, + "treeChecked": true, + "errors": [ + "INTEGRITY: changed captured pin: C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\controls-0547a391cd1841ad8b4045ba90095392\\success-and-link-map-change\\.lake\\lifecycle-native-p0\\runs\\5f661d4620ec463faf7f12d1d00d400f\\link.map" + ], + "restorationWrites": 0 + }, + "summary": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\controls-0547a391cd1841ad8b4045ba90095392\\success-and-link-map-change\\.lake\\lifecycle-native-p0\\runs\\5f661d4620ec463faf7f12d1d00d400f\\SUMMARY.json", + "bytes": 11343, + "sha256": "ECBEF2C2331322B8E7C5AF33D218D51527D2CE5FE41235245130F5ABA604E021" + } + }, + { + "id": "partial-identity-and-pin-change", + "actualExit": 1, + "seconds": 16.872, + "expectedStageError": "IDENTITY:", + "expectedIntegrity": false, + "stageFailure": "IDENTITY: missing file C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\controls-0547a391cd1841ad8b4045ba90095392\\partial-identity-and-pin-change\\missing-tool.exe", + "integrity": { + "attempted": true, + "success": false, + "checkedPins": 18, + "treeChecked": true, + "errors": [ + "INTEGRITY: changed captured pin: C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\controls-0547a391cd1841ad8b4045ba90095392\\partial-identity-and-pin-change\\native\\packed-rmq\\tests\\lifecycle_storage_probe.c", + "INTEGRITY: live tracked/index/untracked baseline changed" + ], + "restorationWrites": 0 + }, + "summary": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\controls-0547a391cd1841ad8b4045ba90095392\\partial-identity-and-pin-change\\.lake\\lifecycle-native-p0\\runs\\cde54efee3bf4870a70f8cbfd2efeb09\\SUMMARY.json", + "bytes": 11664, + "sha256": "30E3A8A18535B87363AB91EE7CFEA06DD4F0598B2B37631479B4347056D3664D" + } + }, + { + "id": "missing-baseline", + "actualExit": 1, + "seconds": 16.07, + "expectedStageError": null, + "expectedIntegrity": false, + "stageFailure": null, + "integrity": { + "attempted": true, + "success": false, + "checkedPins": 17, + "treeChecked": false, + "errors": [ + "INTEGRITY: UNCOVERED; initial tree inventory unavailable" + ], + "restorationWrites": 0 + }, + "summary": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\controls-0547a391cd1841ad8b4045ba90095392\\missing-baseline\\.lake\\lifecycle-native-p0\\runs\\68e2e1c649374cdbbef7938cb6396074\\SUMMARY.json", + "bytes": 10498, + "sha256": "97FD6EE98668113D1CB85F140D344D96A9E5BA347F4302AB648A763597A3D0F8" + } + } + ] + }, + "dependencyControls": { + "receipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\dependencies-da8c6b99a34b41ee9864e75b6fa91aa1\\RECEIPT.json", + "bytes": 2220, + "sha256": "0B657FF8AD8B7D3172CECD9B1160097BDA18F989789A8D0284ACB42056196B10" + }, + "results": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\dependencies-38e1167c78a5420fa8e28c59908e5c52\\RESULTS.json", + "bytes": 37270, + "sha256": "0A22821BD52325C0CB063602C4F49DD9D3E10909677E87DD3A7D79B867D220CF" + }, + "seconds": 49.154, + "missingOld": [ + "libc++.dll", + "libclang-cpp.dll", + "libLLVM-19.dll", + "zlib1.dll" + ], + "controls": [ + { + "outcome": "accept", + "id": "complete-inventory", + "nodes": 11 + }, + { + "outcome": "reject", + "id": "bea5ce75-incomplete", + "surface": "DEPENDENCY: incomplete local inventory: C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libclang-cpp.dll; C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libLLVM-19.dll; C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libc++.dll; C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\zlib1.dll" + }, + { + "outcome": "reject", + "id": "omit-lean.exe", + "surface": "DEPENDENCY: incomplete local inventory: C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\lean.exe" + }, + { + "outcome": "reject", + "id": "omit-leanc.exe", + "surface": "DEPENDENCY: incomplete local inventory: C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\leanc.exe" + }, + { + "outcome": "reject", + "id": "omit-clang.exe", + "surface": "DEPENDENCY: incomplete local inventory: C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\clang.exe" + }, + { + "outcome": "reject", + "id": "omit-ld.lld.exe", + "surface": "DEPENDENCY: incomplete local inventory: C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\ld.lld.exe" + }, + { + "outcome": "reject", + "id": "omit-libleanshared.dll", + "surface": "DEPENDENCY: incomplete local inventory: C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libleanshared.dll" + }, + { + "outcome": "reject", + "id": "omit-libInit_shared.dll", + "surface": "DEPENDENCY: incomplete local inventory: C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libInit_shared.dll" + }, + { + "outcome": "reject", + "id": "omit-libclang-cpp.dll", + "surface": "DEPENDENCY: incomplete local inventory: C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libclang-cpp.dll" + }, + { + "outcome": "reject", + "id": "omit-libLLVM-19.dll", + "surface": "DEPENDENCY: incomplete local inventory: C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libLLVM-19.dll" + }, + { + "outcome": "reject", + "id": "omit-libc++.dll", + "surface": "DEPENDENCY: incomplete local inventory: C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libc++.dll" + }, + { + "outcome": "reject", + "id": "omit-zlib1.dll", + "surface": "DEPENDENCY: incomplete local inventory: C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\zlib1.dll" + }, + { + "outcome": "reject", + "id": "omit-libleanshared_1.dll", + "surface": "DEPENDENCY: incomplete local inventory: C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\libleanshared_1.dll" + }, + { + "outcome": "reject", + "id": "same-name-wrong-path", + "surface": "DEPENDENCY: incomplete local inventory: C:\\Users\\poin\\.elan\\toolchains\\leanprover--lean4---v4.22.0\\bin\\lean.exe" + }, + { + "integrity": { + "attempted": true, + "success": true, + "checkedPins": 2, + "treeChecked": true, + "errors": [], + "restorationWrites": 0 + }, + "outcome": "accept", + "id": "complete-unchanged-finalizer" + }, + { + "integrity": { + "attempted": true, + "success": false, + "checkedPins": 2, + "treeChecked": true, + "errors": [ + "INTEGRITY: changed captured pin: C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\dependencies-38e1167c78a5420fa8e28c59908e5c52\\fixture\\zlib1.dll", + "INTEGRITY: live tracked/index/untracked baseline changed" + ], + "restorationWrites": 0 + }, + "outcome": "reject", + "id": "tamper-zlib1.dll" + }, + { + "integrity": { + "attempted": true, + "success": false, + "checkedPins": 2, + "treeChecked": true, + "errors": [ + "INTEGRITY: changed captured pin: C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\dependencies-38e1167c78a5420fa8e28c59908e5c52\\fixture\\link.map", + "INTEGRITY: live tracked/index/untracked baseline changed" + ], + "restorationWrites": 0 + }, + "outcome": "reject", + "id": "tamper-link.map" + }, + { + "integrity": { + "attempted": true, + "success": false, + "checkedPins": 2, + "treeChecked": true, + "errors": [ + "INTEGRITY: changed captured pin: C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\dependencies-38e1167c78a5420fa8e28c59908e5c52\\fixture\\zlib1.dll" + ], + "restorationWrites": 0 + }, + "outcome": "reject", + "id": "tamper-manifest-hash" + }, + { + "integrity": { + "attempted": true, + "success": true, + "checkedPins": 2, + "treeChecked": true, + "errors": [], + "restorationWrites": 0 + }, + "outcome": "accept", + "id": "restored-finalizer" + } + ] + }, + "sourceChecks": { + "receipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\checks-81e725f3bc734cca9615cf637e4e7eba\\RECEIPT.json", + "bytes": 2167, + "sha256": "31A235A40B9F80F5361A5EE05B42C42DFB76B49E5C802D36740954438BA32B43" + }, + "results": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\final-checks-035ab358ce0640c7b4404577a838a121\\RESULTS.json", + "bytes": 6485, + "sha256": "9302063F542BC0422D454625F20CB8419F2235142D575647F2A860554F8E1701" + }, + "seconds": 20.417 + }, + "sourcePins": [ + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\scripts\\packed_native_lifecycle_storage_replay.ps1", + "bytes": 43878, + "sha256": "C853A0BA7A8410A3A93C337105B97DE272CEC6920F74F9C5444B2196922C25F3" + }, + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\scripts\\packed_native_lifecycle_integrity_check.ps1", + "bytes": 7713, + "sha256": "F5D607EBD5693B8D4EB9D16B4C3292805476F146CD3E35414F2249CBAA95A696" + }, + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\native\\packed-rmq\\tests\\lifecycle_storage_probe.c", + "bytes": 14720, + "sha256": "5F32F4A91B21697F86B4F2FEA855CD050E59E330CE6C6FFDA28898353B66D7B1" + }, + { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\docs\\internal\\extensions\\lifecycle-native-p0\\REGISTRY.json", + "bytes": 5899, + "sha256": "6CD97F40E7C39D2212A8C8705D264D4832DCF2542815B72CD927906A01DC8B20" + } + ], + "originalControlIdentityMatch": true, + "originalMappingPreserved": true, + "probeDependencyInspection": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\repair-r1\\PROBE_DEPENDENCIES.json", + "bytes": 4352, + "sha256": "57EB387713ED09AB3C12834D4AE9E1726869DE0825F71CA9BFBEC20C91F81892" + }, + "binary": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ\\.lake\\lifecycle-native-p0\\runs\\cf28effe9b7643e9a412747cb66eb0eb\\lifecycle_storage_probe.exe", + "bytes": 7091712, + "sha256": "00C52C22FCF1B426BE64C6A0FD47F3C4CC31A7AD17689D221ECE59CF1033F8B7" + } +} diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r1/SOURCE_REVIEW.md b/docs/internal/extensions/lifecycle-native-p0/repair-r1/SOURCE_REVIEW.md new file mode 100644 index 00000000..2ee84e9c --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r1/SOURCE_REVIEW.md @@ -0,0 +1,89 @@ +Status: BOUNDED_READ_ONLY_REVIEW_COMPLETE + +Independent helper: /root/review_dependency, inherited parent model/runtime, +read-only source/inventory review at worktree 587c/RMQ and exact base +0c873072e84be9e1d65edab1985bcff1d23abef1. Governance preflight passed at +7b227c49ef2ec044b702126cc41c9add847eed01 with required rmq-proof-sprint and +actual catalog rmq-audit-prompt, rmq-coordinator, rmq-proof-sprint. No external +auditor bridge was used. This is source review, not campaign acceptance. + +The helper reviewed the complete historical source/receipts and the new runner, +helper and controls. Independent byte inspection derived eleven local PE nodes: +lean.exe, leanc.exe, clang.exe, ld.lld.exe, libInit_shared.dll, +libleanshared.dll, libleanshared_1.dll, libclang-cpp.dll, libLLVM-19.dll, +libc++.dll and zlib1.dll. The original receipt omitted the last four compiler +dependencies. zlib1.dll is imported by ld.lld.exe and libLLVM-19.dll. Every +inspected delay directory is zero. Read-only execution of the production +dependency functions reproduced eleven nodes and complete membership. + +| Missing historical file | Bytes | SHA-256 | +| --- | ---: | --- | +| libclang-cpp.dll | 82430464 | D4028A751017B44681373A4BEC8381B120A06083AC688DCDF45F45AEC46783C6 | +| libLLVM-19.dll | 80710656 | 74A1A54619E989CDC1F52EA3F206DA83C3C55DB73594FD1D4D4F2FE6D49CC02D | +| libc++.dll | 1636864 | 1F3D0FF8504F19E6B6DC98426B58FA60B6A571D027F2C6AC4E169637C63A95DE | +| zlib1.dll | 110592 | 260997C016819F60CEF902F3E7C0267804785D7B70C87CF541D0E40E6B693C75 | + +Installed Leanc.lean and binary strings ground the invoked compiler/linker roots: +leanc uses the compiled ROOT/bin/clang.exe absent the rejected overrides, and +the compiled internal flags include -fuse-ld=lld. This is source reasoning, +not a verified compiler or dynamic loader trace. OS/API-set resolution, dynamic +LoadLibrary behavior and PowerShell/.NET remain external assumptions. + +The historical bea5ce75f788c4035031ba81e69d8de36eda3f92 runner has 41479 bytes, +SHA-256 077BF8D478141F8891AB6F9C2E332CBF8C8F75ACA32C722B29BD307924957B8E. +Original RESULTS has 63804 bytes, +6440A963BE7A0E65222F86AFE3CFB89E4BEE1B6BDCD0226DC0D5CDA88D296FDD. +Its raw summary has 131413 bytes, +0E7DCC42E1EA66C0FF1C8A8AD7ED791FEA786189FA6E38A52BF8B5B55954CD12. +Strict Git byte reads supply these identities; no shell newline serialization +was used. verify_contract.py rechecks the named blobs and retained pins. + +Source-review feedback and implemented responses: + +- Pin raw stage files before strict decoding, since malformed UTF-8/JSON can + otherwise bypass capture. The runner now does so; a raw FF control exercises it. +- Preserve the original stage error if available compile-output capture fails. + Get-LNAvailablePin records independent capture errors, and the production + finalizer consumes them. A real exclusive file lock plus exit-seven stage + exercises the joint failure. +- Compare exact native/launcher exits, streams and complete integrity errors. + Controls now check these, including empty timeout/launcher streams; dependency + file mutations require exactly changed-pin plus tree-change errors and a + manifest-hash mutation exactly the changed-pin error. +- Restore ignored link maps even if summary parsing fails. Restoration now + enumerates confined owned fixture paths independently of summary availability. +- The isolated fixture splice preserves the whole production setup/functions + prefix and catch/finally/verdict suffix. It replaces only the stage body and + executes actual owned subprocesses. It is not an extracted-finally replay. + +The helper found no additional runner architecture defect in its final bounded +check. The last two exact-assertion refinements above were applied by the lead +after that response. Final execution receipts, rather than this review narrative, +determine their outcomes. + +Independent claim/baseline reuse inspection verified 2910 outside-rescan paths +and bytes, 1125 Lean/Lake/toolchain paths with working hashes and HEAD blobs, +and 251 distinct historical evidence pins. Ripgrep outside enumeration contained +2870 identical paths in each worktree; production attribution enumeration 2881; +11640 production path-normalization comparisons agreed. Relevant root ignore +behavior and Git common directory agree. No claim scan or build was run by the +helper. Scanner/policy/rg/config/PowerShell identities match: + +| Context | SHA-256 | +| --- | --- | +| Original outside-file snapshot | 93DE2690CB6509033FC93F3BDD7BA42CEF2E21F9A0AA9761DC04DF511EB0F8F4 | +| Claim scanner | 5310DBA1242B3ED4A0B054A15B1B6911C056C228B2711F3D958EAB539BB3F6F7 | +| Claim policy | 4096C7A708DF686F0AC7B62D935B22C13C1F1212494A3B39FD2ADD127AD43CD9 | +| Ripgrep | BAEE1BC8559B7494F2F2FA61C0AFD48DC32A3A9420D40832B1C53FDE59A31B01 | +| PowerShell 7.6.5 executable | 362A356CE7F0940EC74F73A8FC2C990A2CC24A38A11C90BBD8ECA947110AD139 | + +RIPGREP_CONFIG_PATH is absent. The exact rg executable remains under +C:/Users/poin/AppData/Local/OpenAI/Codex/bin/6dd87ad08d6ff997/rg.exe. +The final coverage composition still requires the final unchanged-policy rescan +of lifecycle-native-p0 and both ledgers. It is not a new default-root scan. + +Digestion: stronger failure evidence and concrete compiler identity do not +strengthen the unchanged finite ownership measurements into a universal heap +bound. The skeptical remaining local question is answered by final production +controls/replay; the consuming adapter and campaign aggregate/audit are separate +downstream work. diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r1/START.json b/docs/internal/extensions/lifecycle-native-p0/repair-r1/START.json new file mode 100644 index 00000000..42019344 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r1/START.json @@ -0,0 +1,25 @@ +{ + "handle": "LIFE-NATIVE-P0-R1", + "worktree": "C:\\Users\\poin\\.codex\\worktrees\\587c\\RMQ", + "base": "0c873072e84be9e1d65edab1985bcff1d23abef1", + "branch": "codex/life-native-p0-r1-certification", + "initialHead": "0c873072e84be9e1d65edab1985bcff1d23abef1", + "initialClean": true, + "governance": "7b227c49ef2ec044b702126cc41c9add847eed01", + "runtimeCatalog": [ + "rmq-audit-prompt", + "rmq-coordinator", + "rmq-proof-sprint" + ], + "requiredSkill": "rmq-proof-sprint", + "preflight": "PASS", + "frozenRowsSha256": "74982691e40eb56a10365f66e74877f6518c0a13e959f559e267047bdac7130e", + "scope": [ + "scripts/packed_native_lifecycle_storage_replay.ps1", + "scripts/packed_native_lifecycle_integrity_check.ps1", + "docs/internal/extensions/lifecycle-native-p0/repair-r1/", + "docs/internal/extensions/lifecycle-native-p0/BOUNDARY.md: optional citation only", + "docs/internal/WORKFLOW_DESIGN_DECISIONS.md: append", + "docs/internal/DESIGN_DECISIONS.md: conditional append" + ] +} diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r1/dependency_controls.ps1 b/docs/internal/extensions/lifecycle-native-p0/repair-r1/dependency_controls.ps1 new file mode 100644 index 00000000..b0cc32b4 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r1/dependency_controls.ps1 @@ -0,0 +1,132 @@ +param([string]$OutputRoot) +$ErrorActionPreference='Stop' +Set-StrictMode -Version Latest +$repo=[IO.Path]::GetFullPath((Join-Path $PSScriptRoot '../../../../..')) +if(-not $OutputRoot){$OutputRoot=Join-Path $repo ('.lake/repair-r1/dependencies-'+[Guid]::NewGuid().ToString('N'))} +[void][IO.Directory]::CreateDirectory($OutputRoot) +$utf8=[Text.UTF8Encoding]::new($false,$true) +# LIFE-1-R3: once OutputRoot exists, every exit path writes RESULTS.json. Every +# installed-tool pin, the historical inputs and the owned fixture are re-checked +# independently in finally; the stage error, every integrity difference and +# every fixture-restoration error are recorded separately. +$captured=[Collections.Generic.List[object]]::new() +function Get-LNPin([string]$Path){$pin=Get-LNRawPin $Path;$captured.Add($pin);return $pin} +$bin='C:/Users/poin/.elan/toolchains/leanprover--lean4---v4.22.0/bin' +$resultsInput=Join-Path $repo 'docs/internal/extensions/lifecycle-native-p0/RESULTS.json' +$inputPins=[Collections.Generic.List[object]]::new() +$closure=$null;$pins=@();$oldPin=$null;$missing=$null;$state=$null +$results=[Collections.Generic.List[object]]::new() +$stageError=$null;$stageRecord=$null;$completed=$false +$integrityErrors=[Collections.Generic.List[string]]::new() +$cleanupErrors=[Collections.Generic.List[string]]::new() +$pinChecks=[Collections.Generic.List[object]]::new() +$fixtureCheck=$null +$durableFailed=$false +try { +. (Join-Path $repo 'scripts/owned_process_tree.ps1') +. (Join-Path $repo 'scripts/packed_native_lifecycle_integrity_check.ps1') +$inputPins.Add((Get-LNRawPin $resultsInput)) +$closure=Get-LNDependencyClosure @('lean.exe','leanc.exe','clang.exe','ld.lld.exe'|ForEach-Object {Join-Path $bin $_}) $bin +$pins=@($captured.ToArray()) +Assert-LNDependencyCoverage $closure $pins +if($closure.nodes.Count -ne 11){throw 'measured closure differs; inspect before changing expectation'} +$results.Add(@{id='complete-inventory';outcome='accept';nodes=$closure.nodes.Count}) +function Reject([string]$Id,[scriptblock]$Action,[string]$Prefix) { + $errorText=$null + try{& $Action}catch{$errorText=$_.Exception.Message} + if($null -eq $errorText -or -not $errorText.StartsWith($Prefix)){throw "control $Id failed: $errorText"} + $results.Add(@{id=$Id;outcome='reject';surface=$errorText}) +} +$oldResults=Get-Content $resultsInput -Raw|ConvertFrom-Json +$oldPin=Get-LNRawPin $oldResults.rawSummary.path +if($oldPin.sha256 -cne $oldResults.rawSummary.sha256 -or $oldPin.bytes -ne $oldResults.rawSummary.bytes){throw 'historical raw summary identity changed'} +$inputPins.Add($oldPin) +$old=Get-Content $oldPin.path -Raw|ConvertFrom-Json +$oldPins=@($old.identity.files)+@($old.identity.linkerInputs)+@($old.identity.includedHeaders) +$missing=@($closure.nodes|Where-Object {$p=$_.path;-not @($oldPins|Where-Object {$_.path -ieq $p}).Count}|ForEach-Object {Split-Path $_.path -Leaf}|Sort-Object) +if(($missing -join ',') -cne 'libc++.dll,libclang-cpp.dll,libLLVM-19.dll,zlib1.dll'){throw 'historical measured omission differs'} +Reject 'bea5ce75-incomplete' {Assert-LNDependencyCoverage $closure $oldPins} 'DEPENDENCY: incomplete local inventory:' +foreach($node in $closure.nodes){ + $rest=@($pins|Where-Object {$_.path -ine $node.path}) + Reject ('omit-'+(Split-Path $node.path -Leaf)) {Assert-LNDependencyCoverage $closure $rest} 'DEPENDENCY: incomplete local inventory:' +} +$wrong=@($pins|ForEach-Object {@{path=$_.path;bytes=$_.bytes;sha256=$_.sha256}}) +$wrong[0].path=Join-Path $OutputRoot (Split-Path $wrong[0].path -Leaf) +Reject 'same-name-wrong-path' {Assert-LNDependencyCoverage $closure $wrong} 'DEPENDENCY: incomplete local inventory:' +# Actual copied compiler dependency and map fixture, never installed mutation. +$fixture=Join-Path $OutputRoot 'fixture' +[void][IO.Directory]::CreateDirectory($fixture) +[IO.File]::WriteAllText((Join-Path $fixture '.gitignore'),".lake/`n",$utf8) +$dll=Join-Path $fixture 'zlib1.dll';$map=Join-Path $fixture 'link.map' +[IO.File]::WriteAllBytes($dll,[IO.File]::ReadAllBytes((Join-Path $bin 'zlib1.dll'))) +[IO.File]::WriteAllText($map,'measured-link-map-fixture',$utf8) +& git -C $fixture init -q +& git -C $fixture config core.autocrlf false +& git -C $fixture -c core.excludesfile= add --all +& git -C $fixture -c user.name=RMQFixture -c user.email=fixture@invalid commit -qm baseline +if($LASTEXITCODE){throw 'fixture initialization failed'} +$state=@{root=$fixture;temp=(Join-Path $fixture '.lake/git');baseline=$null;pins=[Collections.Generic.List[object]]::new();captureErrors=@()} +$state.baseline=Get-LNTreeSnapshot $fixture $state.temp +$state.pins.Add((Get-LNRawPin $dll));$state.pins.Add((Get-LNRawPin $map)) +$intact=Complete-LNIntegrity $state +if(-not $intact.success){throw 'unchanged fixture rejected'} +$results.Add(@{id='complete-unchanged-finalizer';outcome='accept';integrity=$intact}) +foreach($path in @($dll,$map)) { + $bytes=[IO.File]::ReadAllBytes($path) + try { + [IO.File]::WriteAllBytes($path,($bytes+[byte]1)) + $r=Complete-LNIntegrity $state + $expected=@(('INTEGRITY: changed captured pin: '+$path),'INTEGRITY: live tracked/index/untracked baseline changed') + if($r.success -or (@($r.errors|Sort-Object)|ConvertTo-Json -Compress) -cne (@($expected|Sort-Object)|ConvertTo-Json -Compress)){throw 'tamper accepted or wrong/additional surface'} + $results.Add(@{id=('tamper-'+(Split-Path $path -Leaf));outcome='reject';integrity=$r}) + } finally {try{[IO.File]::WriteAllBytes($path,$bytes)}catch{$cleanupErrors.Add('fixture byte restoration '+$path+': '+$_.Exception.Message)}} +} +$originalHash=$state.pins[0].sha256 +try { + $state.pins[0].sha256='0'*64 + $r=Complete-LNIntegrity $state + if($r.success -or $r.errors.Count -ne 1 -or $r.errors[0] -cne ('INTEGRITY: changed captured pin: '+$dll)){throw 'manifest tamper accepted or additional error'} + $results.Add(@{id='tamper-manifest-hash';outcome='reject';integrity=$r}) +} finally {try{$state.pins[0].sha256=$originalHash}catch{$cleanupErrors.Add('fixture manifest restoration: '+$_.Exception.Message)}} +$restored=Complete-LNIntegrity $state +if(-not $restored.success){throw 'fixture restoration failed'} +$results.Add(@{id='restored-finalizer';outcome='accept';integrity=$restored}) +$completed=$true +} catch {$stageError=$_.Exception.Message;$stageRecord=$_} +finally { + # Every captured installed-tool pin (including a partial inventory) and every + # historical input pin, each in its own guard, continuing past failures. + foreach($pin in @($captured.ToArray())+@($inputPins.ToArray())){ + $final=$null;$status='verified' + try { + $final=Get-LNRawPin $pin.path + if($final.sha256 -cne $pin.sha256 -or $final.bytes -ne $pin.bytes){$status='changed';$integrityErrors.Add('INTEGRITY: changed captured pin: '+$pin.path)} + } catch {$status='unreadable-final';$integrityErrors.Add($_.Exception.Message)} + $pinChecks.Add([ordered]@{path=$pin.path;entrySha256=$pin.sha256;finalSha256=$(if($null -ne $final){$final.sha256}else{$null});status=$status}) + } + if(@($inputPins|Where-Object {$_.path -ieq [IO.Path]::GetFullPath($resultsInput)}).Count -eq 0){ + $pinChecks.Add([ordered]@{path=[IO.Path]::GetFullPath($resultsInput);entrySha256=$null;finalSha256=$null;status='not-captured'}) + } + if($null -ne $state -and $null -ne $state.baseline){ + try { + $fixtureCheck=Complete-LNIntegrity $state + foreach($message in @($fixtureCheck.errors)){$cleanupErrors.Add('fixture restoration: '+$message)} + } catch {$cleanupErrors.Add('fixture restoration check: '+$_.Exception.Message)} + } + $passed=$completed -and $null -eq $stageError -and $integrityErrors.Count -eq 0 -and $cleanupErrors.Count -eq 0 + $finalization=[ordered]@{schema='life1-r3-finalization-v1';verdict=$(if($passed){'pass'}else{'fail'});stageError=$stageError + integrityErrors=@($integrityErrors.ToArray());cleanupErrors=@($cleanupErrors.ToArray());pinChecks=@($pinChecks.ToArray()) + fixtureCheck=$fixtureCheck;entryPinCount=($captured.Count+$inputPins.Count);verifiedPinCount=@($pinChecks|Where-Object {$_.status -ceq 'verified'}).Count} + try { + $record=@{closure=$closure;pins=$pins;oldSummary=$oldPin;oldMissing=$missing;controls=@($results.ToArray()); + installedToolsUnchanged=($integrityErrors.Count -eq 0 -and $captured.Count -gt 0);fixtureRestored=($null -ne $fixtureCheck -and $fixtureCheck.success); + finalization=$finalization} + [IO.File]::WriteAllText((Join-Path $OutputRoot 'RESULTS.json'),($record|ConvertTo-Json -Depth 30),$utf8) + } catch {$durableFailed=$true;$passed=$false;[Console]::Error.WriteLine('DEPENDENCY CONTROLS: durable result write failed: '+$_.Exception.Message)} +} +if(-not $passed){ + foreach($message in @($integrityErrors)+@($cleanupErrors)){[Console]::Error.WriteLine($message)} + if($null -ne $stageRecord){throw $stageRecord} + exit 1 +} +Write-Output ('DEPENDENCY CONTROLS PASS evidence='+$OutputRoot) diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r1/final_checks.ps1 b/docs/internal/extensions/lifecycle-native-p0/repair-r1/final_checks.ps1 new file mode 100644 index 00000000..1454af7b --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r1/final_checks.ps1 @@ -0,0 +1,33 @@ +$ErrorActionPreference='Stop' +$repo=[IO.Path]::GetFullPath((Join-Path $PSScriptRoot '../../../../..')) +Set-Location -LiteralPath $repo +$base='9519b2c1af5e2cf59536b311db5e8dc81376a32f' +$out=Join-Path $repo ('.lake/repair-r1/final-checks-'+[Guid]::NewGuid().ToString('N')) +[void][IO.Directory]::CreateDirectory($out) +$checks=[Collections.Generic.List[object]]::new() +function Check([string]$Name,[string]$File,[string[]]$Arguments,[int]$Expected=0,[switch]$Empty) { + $watch=[Diagnostics.Stopwatch]::StartNew() + $lines=@(& $File @Arguments 2>&1|ForEach-Object {"$_"});$code=$LASTEXITCODE + $watch.Stop() + [IO.File]::WriteAllLines((Join-Path $out ($Name+'.log')),[string[]]$lines,[Text.UTF8Encoding]::new($false)) + $checks.Add(@{name=$Name;file=$File;arguments=$Arguments;exit=$code;expected=$Expected;seconds=$watch.Elapsed.TotalSeconds;log=(Join-Path $out ($Name+'.log'))}) + if($code -ne $Expected -or ($Empty -and $lines.Count)){throw "check failed $Name exit=$code; $($lines -join ' | ')"} + Write-Output ('CHECK PASS '+$Name) +} +Check 'contract' 'python' @((Join-Path $PSScriptRoot '../repair-r3/verify_contract.py'),'--output',(Join-Path $out 'CONTRACT.json')) +Check 'hygiene' 'rg' @('-n','\b(sorry|admit|axiom|unsafe|opaque|implemented_by|partial|extern|noncomputable)\b|import Mathlib','RMQ','lakefile.toml') 1 -Empty +Check 'native-decision' 'rg' @('-n','native_decide|Lean\.ofReduceBool','RMQ') 1 -Empty +Check 'working-whitespace' 'git' @('diff','--check') +Check 'range-whitespace' 'git' @('diff','--check',($base+'..HEAD')) +$shell=(Get-Process -Id $PID).Path +Check 'design-whole' $shell @('-NoProfile','-File','scripts/design_decision_check.ps1','-Strict','-Base',$base) +$commits=@(& git rev-list --reverse ($base+'..HEAD')) +foreach($commit in $commits) { + $parent=(& git rev-parse ($commit+'^')).Trim() + Check ('design-'+$commit.Substring(0,12)) $shell @('-NoProfile','-File','scripts/design_decision_check.ps1','-Strict','-Base',$parent,'-Head',$commit) +} +Check 'clean' 'git' @('-c','core.excludesfile=','status','--porcelain=v1','--untracked-files=all') 0 -Empty +$pins=@(Get-ChildItem -LiteralPath $out -File|ForEach-Object {@{path=$_.FullName;bytes=$_.Length;sha256=(Get-FileHash $_.FullName).Hash}}) +$record=@{head=(& git rev-parse HEAD).Trim();base=$base;checks=@($checks.ToArray());pins=$pins} +[IO.File]::WriteAllText((Join-Path $out 'RESULTS.json'),($record|ConvertTo-Json -Depth 12),[Text.UTF8Encoding]::new($false)) +Write-Output ('FINAL CHECKS evidence='+$out) diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r1/freeze_contract.py b/docs/internal/extensions/lifecycle-native-p0/repair-r1/freeze_contract.py new file mode 100644 index 00000000..94751a05 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r1/freeze_contract.py @@ -0,0 +1,33 @@ +"""One-time pre-edit freeze; strict Git bytes, never PowerShell text serialization.""" +import hashlib, json, pathlib, subprocess + +ROOT = pathlib.Path(__file__).resolve().parents[5] +OUT = pathlib.Path(__file__).resolve().parent +BASE = '0c873072e84be9e1d65edab1985bcff1d23abef1' +P = 'docs/internal/extensions/lifecycle-native-p0/ACCEPTANCE_MATRIX.md' +raw = subprocess.check_output(['git', '-C', str(ROOT), 'show', f'{BASE}:{P}']) +raw.decode('utf-8', errors='strict') +rows = [r for r in raw.splitlines() if r.startswith(b'| `')] +assert len(rows) == 12 and all(len(r.split(b'|')) == 10 for r in rows) +requirements = { + 'NP0R1-INTEGRITY': 'Every entered native replay verification lifecycle records and enforces an independent final integrity outcome in finally, including prior compiler/probe errors, unexpected diagnostics, timeout and partially initialized identity inventories. Verify every captured source/tool/generated-artifact pin and the declared live tracked/index/untracked baseline; absence of required final verification is failure or explicitly uncovered, never success. Preserve the original stage error separately from integrity errors. Detect unexpected changes without silently overwriting unrelated user data. Commit positive and changed-pin/tree controls through the actual production verifier/finalization path, including failure plus integrity failure, success plus integrity failure, and an ordinary failed stage with intact inputs. All owned fixture mutations are restored in their own finally and leave the real candidate unchanged. Keep existing owned-process cleanup and exact diagnostics/exits.', + 'NP0R1-TOOLCHAIN': "Bind the substantive local implementation dependencies of the actually invoked pinned compiler/runtime to the replay receipt and final identity verification. In particular include clang's normal-import libclang-cpp.dll, libLLVM-19.dll and libc++.dll and inspect the invoked tools' remaining local non-system dependency closure; state the external OS/system-library and dynamic-loading boundary honestly. Include the generated link map in final available-artifact integrity checks. Commit a completeness/tamper control using actual dependency inventory and isolated manifest/file fixtures, without modifying installed tools. The original bea5ce75 runner/receipt must fail the new completeness predicate for the independently measured missing dependencies while a complete unchanged inventory passes. No installation, runtime upgrade, tool replacement or claim of universal loader/compiler verification." +} +for key, req in requirements.items(): + rows.append(f'| `{key}` | {req} | Local verification repair | Production finalizer and exact dependency checks | Captured run inputs -> final verification -> success/receipt | Isolated unchanged, tampered, failed-stage and incomplete inventories | Pending; append evidence | Open at freeze |'.encode()) +frozen = b'\n'.join(rows) + b'\n' +for name in ('ACCEPTANCE_ROWS.txt', 'ACCEPTANCE_MATRIX.md', 'START.json'): + assert not (OUT / name).exists(), f'refuse to overwrite freeze: {name}' +(OUT / 'ACCEPTANCE_ROWS.txt').write_bytes(frozen) +header = b'# LIFE-NATIVE-P0-R1 frozen acceptance matrix\n\nFrozen from the canonical template before runner edits. Historical inherited rows remain byte-identical; dispositions are appended.\n\n' +header += b'| ID | Exact frozen requirement | Scope | Evidence needed (exact proposition/check) | Named consumer and identity/composition chain | Anti-vacuity challenge attempted and outcome | Evidence obtained | Status / residual gap |\n| --- | --- | --- | --- | --- | --- | --- | --- |\n' +plan = b'\n## Verification plan\n\nDevelopment: strict frozen-row and scope checks, isolated production finalizer and dependency controls, bounded startup and real one-case selection. Final: frozen full native SelfTest under Local\\RMQLifecycleImplementationHeavy20260920, outer 1200 s (prior 113-162 s), unchanged compiler/probe/descendant 120/30/8 s; exact 23 cases and 65 inherited checks; pin/tree integrity; diff, per-commit/exact-base strict design, final claim coverage and hygiene. Claims compose verified original full coverage with unchanged-policy changed-root rescan only if outside paths/bytes and scanner environment match; otherwise full scan with 7200 s deadline. Conditional: no new Lean build if all formal/toolchain bytes and baseline receipts verify; aggregate and fresh-blind campaign audit remain coordinator-owned.\n\nTarget: repair integrity/provenance for the existing ownership probe and future reviewed adapter. No Lean/C/ABI mutation or changed semantic oracle. Stop only on closure, exact obstruction, external blocker or redirection.\n' +(OUT / 'ACCEPTANCE_MATRIX.md').write_bytes(header + frozen + plan) +start = dict(handle='LIFE-NATIVE-P0-R1', worktree=str(ROOT), base=BASE, + branch=subprocess.check_output(['git', '-C', str(ROOT), 'branch', '--show-current'], text=True).strip(), + initialHead=BASE, initialClean=True, governance='7b227c49ef2ec044b702126cc41c9add847eed01', + runtimeCatalog=['rmq-audit-prompt','rmq-coordinator','rmq-proof-sprint'], requiredSkill='rmq-proof-sprint', preflight='PASS', + frozenRowsSha256=hashlib.sha256(frozen).hexdigest(), + scope=['scripts/packed_native_lifecycle_storage_replay.ps1','scripts/packed_native_lifecycle_integrity_check.ps1','docs/internal/extensions/lifecycle-native-p0/repair-r1/','docs/internal/extensions/lifecycle-native-p0/BOUNDARY.md: optional citation only','docs/internal/WORKFLOW_DESIGN_DECISIONS.md: append','docs/internal/DESIGN_DECISIONS.md: conditional append']) +(OUT/'START.json').write_text(json.dumps(start, indent=2)+'\n', encoding='utf-8') +print(json.dumps(start, indent=2)) diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r1/integrity_controls.ps1 b/docs/internal/extensions/lifecycle-native-p0/repair-r1/integrity_controls.ps1 new file mode 100644 index 00000000..1e663480 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r1/integrity_controls.ps1 @@ -0,0 +1,261 @@ +param([string]$OutputRoot,[string[]]$ControlIds) +$ErrorActionPreference='Stop' +Set-StrictMode -Version Latest +$repo=[IO.Path]::GetFullPath((Join-Path $PSScriptRoot '../../../../..')) +if(-not $OutputRoot){$OutputRoot=Join-Path $repo ('.lake/repair-r1/controls-'+[Guid]::NewGuid().ToString('N'))} +[void][IO.Directory]::CreateDirectory($OutputRoot) +$utf8=[Text.UTF8Encoding]::new($false,$true) +# LIFE-1-R3: once OutputRoot exists, every exit path writes RESULTS.json. The +# real-candidate tree snapshot and every live source this harness reads or copies +# are compared independently in finally; the stage error, every integrity +# difference and every fixture-restoration error are recorded separately. +$production=Join-Path $repo 'scripts/packed_native_lifecycle_storage_replay.ps1' +$livePaths=@('scripts/packed_native_lifecycle_storage_replay.ps1','scripts/packed_native_lifecycle_integrity_check.ps1', + 'scripts/owned_process_tree.ps1','scripts/packed_native_lifecycle_stream_check.ps1', + 'native/packed-rmq/tests/lifecycle_storage_probe.c','lean-toolchain','docs/internal/extensions/lifecycle-native-p0/REGISTRY.json') +$entryPins=[ordered]@{} +$records=[Collections.Generic.List[object]]::new() +$candidateBefore=$null +$start=-1;$stop=-1 +$stageError=$null;$stageRecord=$null;$completed=$false +$integrityErrors=[Collections.Generic.List[string]]::new() +$cleanupErrors=[Collections.Generic.List[string]]::new() +$pinChecks=[Collections.Generic.List[object]]::new() +$treeCheck=[ordered]@{attempted=$false;equal=$false;error=$null} +$finalPins=[ordered]@{} +$durableFailed=$false +try { +. (Join-Path $repo 'scripts/owned_process_tree.ps1') +. (Join-Path $repo 'scripts/packed_native_lifecycle_integrity_check.ps1') +. (Join-Path $repo 'scripts/packed_native_lifecycle_stream_check.ps1') +$shell=(Get-Process -Id $PID).Path +$candidateBefore=Get-LNTreeSnapshot $repo (Join-Path $OutputRoot 'candidate-before') +foreach($relative in $livePaths){$entryPins[$relative]=Get-LNRawPin (Join-Path $repo $relative)} +$source=[IO.File]::ReadAllText($production,$utf8) +$start=$source.IndexOf(' $LeanRoot = [IO.Path]::GetFullPath($LeanRoot)') +$stop=$source.LastIndexOf(' $taskSuccess = $true') +if($start -lt 0 -or $stop -le $start){throw 'fixture splice anchors unavailable'} +$prefix=$source.Substring(0,$start);$suffix=$source.Substring($stop) +$cases=@( + @{id='intact-success';stage='exit 0';mutation='';error=$null;integrity=$true}, + @{id='intact-stage-error';stage='exit 7';mutation='';error='PROCESS:';integrity=$true}, + @{id='malformed-stdout-intact';stage='[Console]::OpenStandardOutput().WriteByte(255);exit 0';mutation='';error='DIAGNOSTIC:';integrity=$true}, + @{id='stage-error-and-pin-change';stage='exit 7';mutation='pin';error='PROCESS:';integrity=$false}, + @{id='stage-error-and-capture-error';stage='exit 7';mutation='capture';error='PROCESS:';integrity=$false}, + @{id='success-and-pin-change';stage='exit 0';mutation='pin';error=$null;integrity=$false}, + @{id='mixed-diagnostic-and-pin-change';stage="[Console]::Error.WriteLine('unexpected');exit 0";mutation='pin';error='DIAGNOSTIC:';integrity=$false}, + @{id='timeout-and-pin-change';stage='Start-Sleep -Seconds 120';mutation='pin';error='PROCESS:';integrity=$false;deadline=8}, + @{id='success-and-tracked-change';stage='exit 0';mutation='tracked';error=$null;integrity=$false}, + @{id='success-and-index-change';stage='exit 0';mutation='index';error=$null;integrity=$false}, + @{id='success-and-untracked-addition';stage='exit 0';mutation='untracked';error=$null;integrity=$false}, + @{id='success-and-untracked-byte-change';stage='exit 0';mutation='untracked-bytes';error=$null;integrity=$false}, + @{id='success-and-link-map-change';stage='exit 0';mutation='map';error=$null;integrity=$false}, + @{id='partial-identity-and-pin-change';stage='exit 0';mutation='partial';error='IDENTITY:';integrity=$false}, + @{id='missing-baseline';stage='exit 0';mutation='baseline';error=$null;integrity=$false} +) +if($PSBoundParameters.ContainsKey('ControlIds')) { + if(-not $ControlIds.Count -or @($ControlIds|Select-Object -Unique).Count -ne $ControlIds.Count){throw 'invalid control selector'} + foreach($id in $ControlIds){if($id -cnotin $cases.id){throw 'unknown control selector'}} + $cases=@($cases|Where-Object {$_.id -cin $ControlIds}) +} +foreach($case in $cases) { + $fixture=Join-Path $OutputRoot $case.id + [void][IO.Directory]::CreateDirectory($fixture) + $paths=@('scripts/packed_native_lifecycle_storage_replay.ps1','scripts/packed_native_lifecycle_integrity_check.ps1', + 'scripts/owned_process_tree.ps1','native/packed-rmq/tests/lifecycle_storage_probe.c','lean-toolchain', + 'docs/internal/extensions/lifecycle-native-p0/REGISTRY.json') + foreach($relative in $paths){ + $dest=Join-Path $fixture $relative + [void][IO.Directory]::CreateDirectory((Split-Path $dest -Parent)) + [IO.File]::WriteAllBytes($dest,[IO.File]::ReadAllBytes((Join-Path $repo $relative))) + } + [IO.File]::WriteAllText((Join-Path $fixture '.gitignore'),".lake/`n",$utf8) + [IO.File]::WriteAllText((Join-Path $fixture 'tracked.txt'),'original',$utf8) + $mutation=switch($case.mutation) { + 'pin' {"[IO.File]::AppendAllText((Join-Path `$taskRoot 'native/packed-rmq/tests/lifecycle_storage_probe.c'),'fixture-change')"} + 'tracked' {"[IO.File]::WriteAllText((Join-Path `$taskRoot 'tracked.txt'),'changed')"} + 'index' {'$blob=(& git -C $taskRoot rev-parse HEAD:tracked.txt).Trim(); & git -C $taskRoot update-index --cacheinfo ("100755,"+$blob+",tracked.txt"); if($LASTEXITCODE){throw "fixture index change failed"}'} + 'untracked' {"[IO.File]::WriteAllText((Join-Path `$taskRoot 'new.txt'),'unexpected')"} + 'untracked-bytes' {"[IO.File]::WriteAllText((Join-Path `$taskRoot 'existing-untracked.txt'),'changed')"} + 'map' {"`$map=Join-Path `$taskRunRoot 'link.map';[IO.File]::WriteAllText(`$map,'original');`$null=Get-LNPin `$map;[IO.File]::WriteAllText(`$map,'changed')"} + 'capture' {'$map=Join-Path $taskRunRoot "link.map";[IO.File]::WriteAllText($map,"original");$lock=[IO.File]::Open($map,[IO.FileMode]::Open,[IO.FileAccess]::ReadWrite,[IO.FileShare]::None);try {$null=Get-LNAvailablePin $map}finally{$lock.Dispose()}'} + 'partial' {"[IO.File]::AppendAllText((Join-Path `$taskRoot 'native/packed-rmq/tests/lifecycle_storage_probe.c'),'fixture-change');`$taskIdentity=@{files=@((Get-LNPin `$taskScript),(Get-LNPin (Join-Path `$taskRoot 'missing-tool.exe')))}"} + 'baseline' {'$taskIntegrityState.baseline=$null'} + default {''} + } + $deadline=if($case.ContainsKey('deadline')){$case.deadline}else{30} + # Replace ONLY the tool/semantic stage body. All initialization, source capture, + # Invoke-LNStage, production validators, catch, finally and final verdict remain. + # Each test child is a real owned process; this is not an extracted-finally test. + $body=@" + `$fixtureStage=Join-Path `$taskRunRoot 'fixture-stage.ps1' + [IO.File]::WriteAllText(`$fixtureStage,'$($case.stage.Replace("'","''"))',`$taskEncoding) + `$null=Get-LNPin `$fixtureStage + `$r=Invoke-LNStage 'fixture-stage' `$taskShell @('-NoProfile','-File',`$fixtureStage) $deadline + $mutation + Assert-LNProcess `$r 0 + Assert-LNNoStderr `$r +"@ + $derived=$prefix+$body+"`n"+$suffix + if(-not $derived.StartsWith($prefix) -or -not $derived.EndsWith($suffix)){throw 'fixture changed production finalization'} + [IO.File]::WriteAllText((Join-Path $fixture $paths[0]),$derived,$utf8) + & git -C $fixture init -q + & git -C $fixture config core.autocrlf false + & git -C $fixture -c core.excludesfile= add --all + & git -C $fixture -c user.name=RMQFixture -c user.email=fixture@invalid commit -qm baseline + if($LASTEXITCODE){throw 'isolated fixture initialization failed'} + [IO.File]::WriteAllText((Join-Path $fixture 'existing-untracked.txt'),'original',$utf8) + $before=Get-LNTreeSnapshot $fixture (Join-Path $fixture '.lake/before') + $run=$null;$summary=$null;$caseError=$null + $restoreErrors=[Collections.Generic.List[string]]::new() + try { + $capture=Invoke-LNStreamCapture $repo $shell @('-NoProfile','-File',(Join-Path $fixture $paths[0]),'-Cases','pop-unique') ` + $fixture (Join-Path $fixture '.lake/outer') 120 $case.id + $run=$capture.launcher + if($run.TimedOut -or $run.OutputLimitExceeded){throw 'fixture outer deadline/output failure'} + $summaries=@(Get-ChildItem -LiteralPath (Join-Path $fixture '.lake/lifecycle-native-p0/runs') -Filter SUMMARY.json -Recurse -File) + if($summaries.Count -ne 1){throw 'fixture final receipt absent/ambiguous'} + $summary=[IO.File]::ReadAllText($summaries[0].FullName,$utf8)|ConvertFrom-Json + $expectedSuccess=$case.integrity -and $null -eq $case.error + if($summary.success -ne $expectedSuccess -or $run.ExitCode -ne $(if($expectedSuccess){0}else{1})){throw "wrong final verdict: $($case.id)"} + if(-not $summary.integrity.attempted -or $summary.integrity.success -ne $case.integrity -or $summary.integrity.checkedPins -lt 8){throw "wrong independent integrity: $($case.id)"} + if($null -eq $case.error){if($null -ne $summary.failure){throw "unexpected stage error $($summary.failure)"}} + elseif(-not $summary.failure.StartsWith($case.error)){throw "original stage error lost: $($case.id)"} + if($case.id -eq 'malformed-stdout-intact' -and -not @($summary.capturedPins|Where-Object {$_.path -like '*fixture-stage.stdout' -and $_.bytes -eq 1}).Count){throw 'malformed raw bytes were not pinned'} + if($case.mutation -in @('pin','partial','map') -and -not @($summary.integrity.errors|Where-Object {$_ -like 'INTEGRITY: changed captured pin:*'}).Count){throw 'changed pin surface absent'} + if($case.mutation -in @('tracked','index','untracked','untracked-bytes','pin','partial') -and $summary.integrity.errors -notcontains 'INTEGRITY: live tracked/index/untracked baseline changed'){throw 'tree surface absent'} + if($case.id -eq 'timeout-and-pin-change' -and -not $summary.stages[0].launcher.TimedOut){throw 'timeout not reached'} + # Exact ordinary exits/raw bytes prevent an unrelated process failure from + # satisfying an expected PROCESS/DIAGNOSTIC prefix. + $rawStem=Join-Path $summary.runRoot '000-fixture-stage' + $rawOut=[IO.File]::ReadAllBytes($rawStem+'.stdout') + $rawErr=[IO.File]::ReadAllBytes($rawStem+'.stderr') + $timeout=$case.id -eq 'timeout-and-pin-change' + $malformed=$case.id -eq 'malformed-stdout-intact' + if(-not $timeout){ + $actual=Get-Content ($rawStem+'.exit.json') -Raw|ConvertFrom-Json + $exit=if($case.stage -ceq 'exit 7'){7}else{0} + if($actual.exitCode -ne $exit){throw 'unexpected actual native exit'} + $expectedOut=if($malformed){'FF'}else{''} + if([BitConverter]::ToString($rawOut) -cne $expectedOut){throw 'unexpected raw stdout'} + $expectedErr=if($case.id -eq 'mixed-diagnostic-and-pin-change'){"unexpected`r`n"}else{''} + if($utf8.GetString($rawErr) -cne $expectedErr){throw 'unexpected raw stderr'} + } elseif($rawOut.Length -ne 0 -or $rawErr.Length -ne 0){throw 'unexpected timeout raw output'} + if(-not $malformed){ + if($summary.stages.Count -ne 1){throw 'fixture did not reach exactly one real stage'} + $s=$summary.stages[0] + if(@($s.launcher.StandardOutput).Count -ne 0 -or @($s.launcher.StandardError).Count -ne 0){throw 'unexpected launcher streams'} + if($s.launcherError -or $s.childError -or $s.launcher.OutputLimitExceeded -or $s.nativeOutputLimitExceeded -or $s.launcher.TimedOut -ne $timeout){throw 'unexpected process failure'} + if(-not $timeout -and ($s.launcher.ExitCode -ne $exit -or $s.child.exitCode -ne $exit)){throw 'ordinary exit mismatch'} + if($timeout -and ($null -eq $s.nativePid -or $null -ne (Get-Process -Id $s.nativePid -ErrorAction SilentlyContinue))){throw 'timeout native process not established/cleaned'} + } + $expectedErrors=@() + if($case.mutation -in @('pin','partial')){$expectedErrors+=('INTEGRITY: changed captured pin: '+(Join-Path $fixture 'native/packed-rmq/tests/lifecycle_storage_probe.c'))} + if($case.mutation -eq 'map'){$expectedErrors+=('INTEGRITY: changed captured pin: '+(Join-Path $summary.runRoot 'link.map'))} + if($case.mutation -in @('tracked','index','untracked','untracked-bytes','pin','partial')){$expectedErrors+='INTEGRITY: live tracked/index/untracked baseline changed'} + if($case.mutation -eq 'baseline'){$expectedErrors+='INTEGRITY: UNCOVERED; initial tree inventory unavailable'} + if($case.mutation -eq 'capture'){ + # Derive the runtime-specific message from the same independently known + # exclusive-lock operation, never from the summary's claimed suffix. + $map=Join-Path $summary.runRoot 'link.map' + $lock=[IO.File]::Open($map,[IO.FileMode]::Open,[IO.FileAccess]::ReadWrite,[IO.FileShare]::None) + $captureFailure=$null + try {try {$null=Get-FileHash -LiteralPath $map -Algorithm SHA256}catch{$captureFailure=$_.Exception.Message}} + finally {$lock.Dispose()} + if($null -eq $captureFailure){throw 'expected exclusive-lock hash failure absent'} + $expectedErrors=@('INTEGRITY: artifact capture failed: '+$map+'; '+$captureFailure) + } + if((@($summary.integrity.errors|Sort-Object)|ConvertTo-Json -Compress) -cne (@($expectedErrors|Sort-Object)|ConvertTo-Json -Compress)){throw 'unexpected additional/missing integrity failure'} + $exactFailure=if($case.stage -ceq 'exit 7'){'PROCESS: fixture-stage actual child or launcher exit differs from 0'}elseif($timeout){'PROCESS: fixture-stage was not a completed bounded process; see retained logs'}elseif($case.id -eq 'mixed-diagnostic-and-pin-change'){'DIAGNOSTIC: unexpected or mixed stderr for fixture-stage'}elseif($case.mutation -eq 'partial'){'IDENTITY: missing file '+(Join-Path $fixture 'missing-tool.exe')}else{$null} + if($malformed){ + $decodeFailure=$null + try {$null=[IO.File]::ReadAllText($rawStem+'.stdout',$utf8)}catch{$decodeFailure=$_.Exception.Message} + if($null -eq $decodeFailure){throw 'expected strict UTF-8 decode failure absent'} + $exactFailure='DIAGNOSTIC: invalid raw stage evidence for fixture-stage; '+$decodeFailure + } + if($summary.failure -cne $exactFailure){throw 'unexpected independent stage failure'} + $nl=[Environment]::NewLine + $expectedStdout='LIFECYCLE-REPLAY evidence='+$summary.runRoot+$nl + if($expectedSuccess){$expectedStdout+='LIFECYCLE-REPLAY PASS cases=1 selfTest=False'+$nl} + $expectedStderr=if($null -ne $exactFailure){$exactFailure+$nl}else{''} + foreach($message in $expectedErrors){$expectedStderr+=$message+$nl} + Assert-LNOuterCapture $capture $expectedStdout $expectedStderr $(if($expectedSuccess){0}else{1}) ('integrity-'+$case.id) + $records.Add(@{id=$case.id;expectedSuccess=$expectedSuccess;expectedStageError=$case.error;expectedIntegrity=$case.integrity; + actualExit=$run.ExitCode;seconds=$run.DurationSeconds;summary=Get-LNRawPin $summaries[0].FullName;integrity=$summary.integrity; + stageFailure=$summary.failure;fixtureSource=Get-LNRawPin (Join-Path $fixture $paths[0]);outer=$run;capture=$capture; + streamContract=@{expectedStdout=$expectedStdout;expectedStderr=$expectedStderr;expectedExit=$(if($expectedSuccess){0}else{1});validated=$true}}) + } catch {$caseError=$_} + finally { + # This exact fixture directory was created above. Restore only owned fixture + # files/index; never reset the real worktree or touch an installed tool. + # Every step is guarded and exit-checked; restoration errors never replace + # the case error. + try{& git -C $fixture update-index --no-assume-unchanged tracked.txt;if($LASTEXITCODE){$restoreErrors.Add('git update-index exit '+$LASTEXITCODE)}}catch{$restoreErrors.Add('git update-index: '+$_.Exception.Message)} + try{& git -C $fixture restore --source=HEAD --staged --worktree -- $paths 'tracked.txt' '.gitignore';if($LASTEXITCODE){$restoreErrors.Add('git restore exit '+$LASTEXITCODE)}}catch{$restoreErrors.Add('git restore: '+$_.Exception.Message)} + try{if([IO.File]::Exists((Join-Path $fixture 'new.txt'))){[IO.File]::Delete((Join-Path $fixture 'new.txt'))}}catch{$restoreErrors.Add('untracked removal: '+$_.Exception.Message)} + try{[IO.File]::WriteAllText((Join-Path $fixture 'existing-untracked.txt'),'original',$utf8)}catch{$restoreErrors.Add('untracked restoration: '+$_.Exception.Message)} + try { + $ownedRuns=Join-Path $fixture '.lake/lifecycle-native-p0/runs' + if([IO.Directory]::Exists($ownedRuns)){ + foreach($map in @(Get-ChildItem -LiteralPath $ownedRuns -Filter link.map -Recurse -File)){ + if(-not $map.FullName.StartsWith($ownedRuns+[IO.Path]::DirectorySeparatorChar,[StringComparison]::OrdinalIgnoreCase)){throw 'fixture map escaped owned root'} + [IO.File]::WriteAllText($map.FullName,'original') + if([IO.File]::ReadAllText($map.FullName) -cne 'original'){throw 'ignored map restoration failed'} + } + } + } catch {$restoreErrors.Add($_.Exception.Message)} + try { + $after=Get-LNTreeSnapshot $fixture (Join-Path $fixture '.lake/after') + if(($before|ConvertTo-Json -Depth 10 -Compress) -cne ($after|ConvertTo-Json -Depth 10 -Compress)){$restoreErrors.Add('owned fixture restoration failed')} + } catch {$restoreErrors.Add('owned fixture snapshot: '+$_.Exception.Message)} + foreach($message in $restoreErrors){$cleanupErrors.Add($case.id+': '+$message)} + } + if($null -ne $caseError){throw $caseError} + if($restoreErrors.Count){break} + Write-Output ('CONTROL PASS '+$case.id) +} +if($cleanupErrors.Count -eq 0){$completed=$true} +} catch {$stageError=$_.Exception.Message;$stageRecord=$_} +finally { + foreach($relative in $livePaths){ + $entry=if($entryPins.Contains($relative)){$entryPins[$relative]}else{$null} + $final=$null;$status='not-captured' + if($null -ne $entry){ + $status='verified' + try { + $final=Get-LNRawPin (Join-Path $repo $relative) + $finalPins[$relative]=$final + if($final.bytes -ne $entry.bytes -or $final.sha256 -cne $entry.sha256){$status='changed';$integrityErrors.Add('INTEGRITY: changed captured pin: '+$entry.path)} + } catch {$status='unreadable-final';$integrityErrors.Add($_.Exception.Message)} + } + $pinChecks.Add([ordered]@{path=$relative;entrySha256=$(if($null -ne $entry){$entry.sha256}else{$null});finalSha256=$(if($null -ne $final){$final.sha256}else{$null});status=$status}) + } + if($null -ne $candidateBefore){ + $treeCheck.attempted=$true + try { + $candidateAfter=Get-LNTreeSnapshot $repo (Join-Path $OutputRoot 'candidate-after') + $treeCheck.equal=(($candidateBefore|ConvertTo-Json -Depth 10 -Compress) -ceq ($candidateAfter|ConvertTo-Json -Depth 10 -Compress)) + if(-not $treeCheck.equal){$integrityErrors.Add('real candidate changed')} + } catch {$treeCheck.error=$_.Exception.Message;$integrityErrors.Add('real candidate snapshot failed: '+$_.Exception.Message)} + } + $passed=$completed -and $null -eq $stageError -and $integrityErrors.Count -eq 0 -and $cleanupErrors.Count -eq 0 + $finalization=[ordered]@{schema='life1-r3-finalization-v1';verdict=$(if($passed){'pass'}else{'fail'});stageError=$stageError + integrityErrors=@($integrityErrors.ToArray());cleanupErrors=@($cleanupErrors.ToArray());pinChecks=@($pinChecks.ToArray());treeCheck=$treeCheck + entryPinCount=$entryPins.Count;verifiedPinCount=@($pinChecks|Where-Object {$_.status -ceq 'verified'}).Count} + try { + # LIFE-1-R4: entry pins are labelled entry*; `source` and `helper` keep their + # eb8e4f25 meaning, the post-run pin observed in finalization (null if unreadable). + $result=@{entrySource=$(if($entryPins.Contains($livePaths[0])){$entryPins[$livePaths[0]]}else{$null});entryHelper=$(if($entryPins.Contains($livePaths[1])){$entryPins[$livePaths[1]]}else{$null}); + source=$(if($finalPins.Contains($livePaths[0])){$finalPins[$livePaths[0]]}else{$null});helper=$(if($finalPins.Contains($livePaths[1])){$finalPins[$livePaths[1]]}else{$null}); + stageSplice=@{start=$start;stop=$stop;preserved='entire prefix and suffix, including production catch/finally/final verdict; only stage body replaced'}; + controls=@($records.ToArray());fixtureRestoration=($cleanupErrors.Count -eq 0);candidateUnchanged=($treeCheck.attempted -and $treeCheck.equal); + finalization=$finalization} + [IO.File]::WriteAllText((Join-Path $OutputRoot 'RESULTS.json'),($result|ConvertTo-Json -Depth 40),$utf8) + } catch {$durableFailed=$true;$passed=$false;[Console]::Error.WriteLine('INTEGRITY CONTROLS: durable result write failed: '+$_.Exception.Message)} +} +if(-not $passed){ + foreach($message in @($integrityErrors)+@($cleanupErrors)){[Console]::Error.WriteLine($message)} + if($null -ne $stageRecord){throw $stageRecord} + exit 1 +} +Write-Output ('INTEGRITY CONTROLS evidence='+$OutputRoot) diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r1/run_owned.ps1 b/docs/internal/extensions/lifecycle-native-p0/repair-r1/run_owned.ps1 new file mode 100644 index 00000000..248d2fdd --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r1/run_owned.ps1 @@ -0,0 +1,65 @@ +param([ValidateSet('focused','full','integrity','dependencies','claims','checks')][string]$Kind,[string]$OutputRoot) +$ErrorActionPreference='Stop' +if(-not $PSBoundParameters.ContainsKey('Kind') -or [string]::IsNullOrEmpty($Kind)){throw 'STREAM: wrapper Kind is required'} +$Kind=$Kind.ToLowerInvariant() +$repo=[IO.Path]::GetFullPath((Join-Path $PSScriptRoot '../../../../..')) +if(-not $OutputRoot){$OutputRoot=Join-Path $repo ('.lake/repair-r1/'+$Kind+'-'+[Guid]::NewGuid().ToString('N'))} +[void][IO.Directory]::CreateDirectory($OutputRoot) +$utf8=[Text.UTF8Encoding]::new($false,$true) +. (Join-Path $repo 'scripts/owned_process_tree.ps1') +. (Join-Path $repo 'scripts/packed_native_lifecycle_stream_check.ps1') +$claimExpectation=$null +if($Kind -ceq 'claims'){ + . (Join-Path $repo 'docs/internal/extensions/lifecycle-native-p0/repair-r2/claim_expectations.ps1') + $claimExpectation=Get-LNClaimStreamExpectation $repo +} +$runner=Join-Path $repo 'scripts/packed_native_lifecycle_storage_replay.ps1' +$source=[IO.File]::ReadAllText($runner,$utf8) +$match=[regex]::Match($source,"(?s)\`$taskChildScript = @'\r?\n(.*?)\r?\n'@") +if(-not $match.Success){throw 'production raw-stream child missing'} +$child=Join-Path $OutputRoot 'child.ps1' +[IO.File]::WriteAllText($child,$match.Groups[1].Value,$utf8) +$action=switch($Kind){ + 'focused' {"& '$($runner.Replace("'","''"))' -Cases pop-unique; exit `$LASTEXITCODE"} + 'full' {"& '$($runner.Replace("'","''"))' -SelfTest; exit `$LASTEXITCODE"} + 'integrity' {"& '$PSScriptRoot/integrity_controls.ps1'; exit `$LASTEXITCODE"} + 'dependencies' {"& '$PSScriptRoot/dependency_controls.ps1'; exit `$LASTEXITCODE"} + 'claims' {"& '$repo/scripts/claim_drift_scan.ps1' -Strict -Path @('docs/internal/extensions/lifecycle-native-p0','docs/internal/DESIGN_DECISIONS.md','docs/internal/WORKFLOW_DESIGN_DECISIONS.md'); exit `$LASTEXITCODE"} + 'checks' {"& '$PSScriptRoot/final_checks.ps1'; exit `$LASTEXITCODE"} +} +if($Kind -in @('focused','full','integrity','dependencies')){ + $action=@" +`$mutex=[Threading.Mutex]::new(`$false,'Local\RMQLifecycleImplementationHeavy20260920') +`$held=`$false +try { + try{`$held=`$mutex.WaitOne(600000)}catch [Threading.AbandonedMutexException]{`$held=`$true} + if(-not `$held){throw 'host mutex unavailable'} + $action +} finally {if(`$held){`$mutex.ReleaseMutex()};`$mutex.Dispose()} +"@ +} +$inner=Join-Path $OutputRoot 'inner.ps1' +[IO.File]::WriteAllText($inner,("`$ErrorActionPreference='Stop'`nSet-Location -LiteralPath '"+$repo.Replace("'","''")+"'`n"+$action),$utf8) +$shell=(Get-Process -Id $PID).Path +$spec=@{file=$shell;arguments=@('-NoLogo','-NoProfile','-File',$inner);cwd=$repo;environment=@{}; + stdout=(Join-Path $OutputRoot 'stdout.log');stderr=(Join-Path $OutputRoot 'stderr.log');exit=(Join-Path $OutputRoot 'exit.json'); + pid=(Join-Path $OutputRoot 'pid');error=(Join-Path $OutputRoot 'error');overflow=(Join-Path $OutputRoot 'overflow');outputLimit=16777216} +$specPath=Join-Path $OutputRoot 'spec.json' +[IO.File]::WriteAllText($specPath,($spec|ConvertTo-Json -Depth 8),$utf8) +$deadline=if($Kind -eq 'integrity'){2400}elseif($Kind -eq 'claims'){7200}else{1200} +$r=Invoke-LNRetainedLauncher -FilePath $shell -Arguments @('-NoProfile','-File',$child,'-SpecPath',$specPath) ` + -WorkingDirectory $repo -Stage $Kind -DeadlineSeconds $deadline -OutputLimitBytes 16777216 -TempRoot (Join-Path $OutputRoot 'launcher') -ReleaseGatedScript +$record=@{kind=$Kind;command=$action;deadline=$deadline;outer=$r;actual=if([IO.File]::Exists($spec.exit)){Get-Content $spec.exit -Raw|ConvertFrom-Json}else{$null};raw=@()} +if($null -ne $claimExpectation){$record.claimExpectation=@{path=$claimExpectation.EvidencePath;bytes=([IO.FileInfo]$claimExpectation.EvidencePath).Length;sha256=(Get-FileHash -LiteralPath $claimExpectation.EvidencePath).Hash}} +foreach($p in @($spec.stdout,$spec.stderr,$spec.exit,$spec.error,$spec.overflow,$child,$inner,$specPath,$r.RawStandardOutput,$r.RawStandardError)){ + if([IO.File]::Exists($p)){$record.raw+=@{path=$p;bytes=([IO.FileInfo]$p).Length;sha256=(Get-FileHash $p).Hash}} +} +$record.streamValidation=@{validated=$false;failure=$null} +try { + $capture=@{launcher=$r;actual=$record.actual;spec=$spec} + $record.streamValidation=Assert-LNWrapperCapture $capture $Kind $repo $claimExpectation +} catch {$record.streamValidation=@{validated=$false;failure=$_.Exception.Message}} +[IO.File]::WriteAllText((Join-Path $OutputRoot 'RECEIPT.json'),($record|ConvertTo-Json -Depth 15),$utf8) +Write-Output ('OWNED '+$Kind+' exit='+$r.ExitCode+' evidence='+$OutputRoot) +if(-not $record.streamValidation.validated -or $r.TimedOut -or $r.OutputLimitExceeded -or $r.ExitCode -ne 0 -or $null -eq $record.actual -or $record.actual.exitCode -ne 0){exit 1} +exit 0 diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r1/verify_contract.py b/docs/internal/extensions/lifecycle-native-p0/repair-r1/verify_contract.py new file mode 100644 index 00000000..d11ac3b9 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r1/verify_contract.py @@ -0,0 +1,104 @@ +import argparse, ast, hashlib, json, os, pathlib, re, shutil, subprocess + +ROOT = pathlib.Path(__file__).resolve().parents[5] +OUT = pathlib.Path(__file__).resolve().parent +BASE = '0c873072e84be9e1d65edab1985bcff1d23abef1' +SOURCE = 'bea5ce75f788c4035031ba81e69d8de36eda3f92' +OLD = 'docs/internal/extensions/lifecycle-native-p0/' +REVIEW = pathlib.Path('C:/Users/poin/Documents/RMQ/lifecycle-implementation-20260920/native-p0-review') + +def git(*args): + return subprocess.check_output(['git', '-c', 'core.excludesfile=', '-C', str(ROOT), *args]) +def sha(b): return hashlib.sha256(b).hexdigest().upper() +def blob(path, ref=BASE): return git('show', f'{ref}:{path}') +def readj(path): return json.loads(pathlib.Path(path).read_text(encoding='utf-8-sig')) +def pin(path): + b=pathlib.Path(path).read_bytes() + return dict(path=str(path), bytes=len(b), sha256=sha(b)) +def rows(raw): + raw.decode('utf-8', errors='strict') + rs=[r for r in raw.splitlines() if re.match(rb'^\| `(?:LN0-|INV-|CHK-|NP0R1-)',r)] + ids=[] + for r in rs: + cells=r.split(b'|') + assert len(cells)==10, 'eight-column row required' + ids.append(cells[1].strip().strip(b'`').decode()) + assert len(set(ids))==len(ids), 'duplicate IDs' + return dict(zip(ids,rs)) +def verify_rows(raw): + original=rows(blob(OLD+'ACCEPTANCE_MATRIX.md')) + initial=rows((OUT/'ACCEPTANCE_ROWS.txt').read_bytes()) + current=rows(raw) + assert len(original)==12 and len(initial)==14 + assert list(current)==list(initial), 'missing/extra/reordered IDs' + assert all(current[k]==r for k,r in initial.items()), 'frozen row bytes changed' + assert all(current[k]==r for k,r in original.items()), 'inherited row bytes changed' + prompt=pathlib.Path('C:/Users/poin/Documents/RMQ/lifecycle-implementation-20260920/LIFE-NATIVE-P0_PROMPT.md').read_text(encoding='utf-8-sig') + requirements=dict(re.findall(r'^- ([A-Z0-9-]+): (.+)$',prompt,re.M)) + for key in original: + assert current[key].split(b'|')[2].strip().decode()==requirements[key], f'prompt requirement changed: {key}' + module=ast.parse((OUT/'freeze_contract.py').read_text(encoding='utf-8')) + new=next(ast.literal_eval(x.value) for x in module.body if isinstance(x,ast.Assign) and any(isinstance(t,ast.Name) and t.id=='requirements' for t in x.targets)) + for key, req in new.items(): assert current[key].split(b'|')[2].strip().decode()==req + assert sha((OUT/'ACCEPTANCE_ROWS.txt').read_bytes()).lower()==readj(OUT/'START.json')['frozenRowsSha256'] + return list(current) + +def main(): + ap=argparse.ArgumentParser();ap.add_argument('--output', required=True);args=ap.parse_args() + raw=(OUT/'ACCEPTANCE_MATRIX.md').read_bytes();ids=verify_rows(raw) + negatives={ + 'mojibake':raw.replace(b'Implement', '\u00c2\u00acImplement'.encode(),1), + 'changed-cell':raw.replace(b'Open at freeze',b'Closed at freeze',1), + 'duplicate':raw+b'\n'+next(iter(rows(raw).values()))+b'\n', + 'missing':raw.replace(next(iter(rows(raw).values())),b'',1), + } + for name,b in negatives.items(): + try: verify_rows(b) + except (AssertionError,UnicodeError): pass + else: raise AssertionError(f'negative accepted: {name}') + changed=git('diff','--name-only',BASE).decode().splitlines()+git('ls-files','--others','--exclude-standard').decode().splitlines() + allowed={'scripts/packed_native_lifecycle_storage_replay.ps1','scripts/packed_native_lifecycle_integrity_check.ps1','docs/internal/WORKFLOW_DESIGN_DECISIONS.md','docs/internal/DESIGN_DECISIONS.md',OLD+'BOUNDARY.md'} + assert all(p in allowed or p.startswith(OLD+'repair-r1/') for p in changed),changed + for p in ['docs/internal/WORKFLOW_DESIGN_DECISIONS.md','docs/internal/DESIGN_DECISIONS.md']: + assert (ROOT/p).read_bytes().startswith(git('cat-file','--filters',f'{BASE}:{p}')), f'ledger working prefix changed: {p}' + protected=['native/packed-rmq/tests/lifecycle_storage_probe.c','lean-toolchain',OLD+'REGISTRY.json',OLD+'ACCEPTANCE_MATRIX.md',OLD+'ACCEPTANCE_ROWS.txt',OLD+'REQUIREMENTS.json',OLD+'REPORT.md',OLD+'RESULTS.json',OLD+'BASELINE.json',OLD+'CERTIFICATION.json',OLD+'START.json',OLD+'RUNTIME_SOURCE.json'] + for p in protected: assert (ROOT/p).read_bytes()==git('cat-file','--filters',f'{BASE}:{p}'),f'protected working bytes changed {p}' + originalRunner=blob('scripts/packed_native_lifecycle_storage_replay.ps1',SOURCE) + assert sha(originalRunner)=='077BF8D478141F8891AB6F9C2E332CBF8C8F75ACA32C722B29BD307924957B8E' + assert sha(blob(OLD+'RESULTS.json',SOURCE))=='6440A963BE7A0E65222F86AFE3CFB89E4BEE1B6BDCD0226DC0D5CDA88D296FDD' + current=(ROOT/'scripts/packed_native_lifecycle_storage_replay.ps1').read_bytes() + def funcs(b): return dict(re.findall(rb'(?ms)^function ([\w-]+)(.*?)(?=^function |\Z)',b.replace(b'\r\n',b'\n'))) + oldf,newf=funcs(originalRunner),funcs(current) + semantic=['Read-LNRegistry','Resolve-LNSelection','Assert-LNProcess','Read-LNOneJson','Assert-LNNoStderr','Assert-LNRejected','Assert-LNProperties','Get-LNMeasuredFailure','Assert-LNSnapshot','Assert-LNMeasurement'] + for name in semantic: + if name.encode() in oldf: assert oldf[name.encode()]==newf[name.encode()],f'semantic function changed {name}' + review=readj(REVIEW/'IDENTITY_ROWS_PINS.json') + for p,expected in review['pins'].items(): + actual=pin(p);assert actual['bytes']==expected['bytes'] and actual['sha256'].lower()==expected['sha256'].lower(),p + provenance=readj('C:/Users/poin/.codex/worktrees/af4b/RMQ/.lake/lifecycle-native-baseline/source-provenance.json') + actualBlobs={row.split(b'\t',1)[1].decode():row.split(b'\t',1)[0].split()[2].decode() for row in git('ls-tree','-rz','HEAD').split(b'\0') if row} + for entry in provenance['sources']: + p=entry['path'];assert p in actualBlobs + assert pin(ROOT/p)['sha256'].lower()==entry['sha256'].lower(),p + assert actualBlobs[p]==entry['gitBlob'],p + context=readj('C:/Users/poin/.codex/worktrees/af4b/RMQ/.lake/lifecycle-native-p0/checks/default-claim-context.json') + files=[ROOT/'README.md']+[p for d in ['artifact','docs','paper'] for p in (ROOT/d).rglob('*') if p.is_file()] + def excluded(p):return p.startswith(OLD) or p in ['docs/internal/DESIGN_DECISIONS.md','docs/internal/WORKFLOW_DESIGN_DECISIONS.md'] + live={p.relative_to(ROOT).as_posix():p for p in files if not excluded(p.relative_to(ROOT).as_posix())} + assert set(live)=={e['path'] for e in context['files']} + for e in context['files']: + a=pin(live[e['path']]);assert a['bytes']==e['bytes'] and a['sha256']==e['sha256'],e['path'] + for p,key in [('scripts/claim_drift_scan.ps1','scannerSha256'),('docs/internal/CLAIM_DRIFT_POLICY.json','policySha256')]:assert pin(ROOT/p)['sha256']==context[key] + assert pathlib.Path(shutil.which('rg')).resolve()==pathlib.Path(context['ripgrepPath']).resolve() + assert pin(context['ripgrepPath'])['sha256']==context['ripgrepSha256'] + assert (os.environ.get('RIPGREP_CONFIG_PATH') or None)==context['ripgrepConfigPath'] + result=dict(base=BASE,head=git('rev-parse','HEAD').decode().strip(),rows=ids,changedIds=[],negativeControls=list(negatives), + changedPaths=sorted(changed),protectedPaths=protected,sourcePreservation=semantic, + historicalSource=dict(commit=SOURCE,gitBytes=len(originalRunner),sha256=sha(originalRunner),transformation='git show subprocess bytes; no newline serialization'), + originalPinsChecked=len(review['pins']),baselineSources=len(provenance['sources']),outsideClaimPaths=len(live), + claimCoverage='Verified original default-root scan plus pending final unchanged-policy rescan of lifecycle-native-p0 and both ledgers; not a new full scan', + checkoutByteRule='Frozen rows and historical source read as strict Git UTF-8/raw bytes. Protected working files and ledger prefixes compare with git cat-file --filters exact base, explicitly accounting for checkout CRLF. Current working pins are separately measured.', + currentRunner=pin(ROOT/'scripts/packed_native_lifecycle_storage_replay.ps1')) + pathlib.Path(args.output).write_text(json.dumps(result,indent=2)+'\n',encoding='utf-8') + print(f'CONTRACT PASS: {len(ids)} frozen rows, {len(review["pins"])} historical pins, {len(live)} unchanged outside paths, {len(provenance["sources"])} unchanged baseline sources') +if __name__=='__main__':main() diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r2/ACCEPTANCE_MATRIX.md b/docs/internal/extensions/lifecycle-native-p0/repair-r2/ACCEPTANCE_MATRIX.md new file mode 100644 index 00000000..da57544c --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r2/ACCEPTANCE_MATRIX.md @@ -0,0 +1,38 @@ +# LIFE-NATIVE-P0-R2 frozen acceptance matrix + +The fourteen inherited eight-column rows retain exact base bytes and historical pending cells. Evidence is append-only. + +| ID | Exact frozen requirement | Scope | Evidence needed (exact proposition/check) | Named consumer and identity/composition chain | Anti-vacuity challenge attempted and outcome | Evidence obtained | Status / residual gap | +| --- | --- | --- | --- | --- | --- | --- | --- | +| `LN0-01` | Implement a reproducible probe of the pinned Lean 4.22 runtime array ownership operations, without altering the production RMQ ABI. Record logical size, retained capacity, requested container bytes and live element references as distinct quantities. Inspect actual runtime definitions and record compiler/runtime/header identity; do not infer capacity from Array.size. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-02` | Exercise unique and shared owners with destructor-counted elements. Demonstrate the actual effects of pop/shrink on surviving values, tail element references and retained backing capacity, without accessing freed objects. Distinguish release of one owner from reclamation when another alias remains live. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-03` | Exercise a consuming replacement-buffer route: copy surviving output values into a newly allocated bounded-capacity buffer, release the old owner, and measure which old allocations/elements remain reachable. Include success, empty output, overlap-relevant source positions, alias-retained and deterministically injected handoff/allocation-stage failure cleanup. Do not assume actual Lean allocator failure is recoverable; a fatal process outcome is reported separately. Treat observed allocator/requested capacity separately from a universal native heap theorem. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-04` | Commit an exact replay registry and positive/negative controls for logical shrink falsely labeled reclamation, retained alias falsely labeled exclusive consumption, and an omitted cleanup action. Validation executes the actual pinned runtime operations and the owned measurement/verdict path; predecessor RMQ replay is regression evidence only. The verdict must depend on observed value/ownership/capacity projections, not labels or a prewritten expected log; use the same positive predicate or a checked/explicit measured implication. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-05` | Use bounded owned compiler/probe processes, preserve full stdout/stderr and actual exits, reject unexpected or mixed diagnostics, validate focused/unknown/empty selector behavior, and exercise cleanup. A platform/toolchain inability is uncovered, not success. No credit purchase, package installation or persistent service is needed as an assumed prerequisite. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-06` | Deliver a source-grounded consuming-boundary recommendation mapping Construction.ExecState resources and Native.StorageImage/NativeImage ownership to later transfer obligations. Specify success/failure ownership, aliases, retained observations and capacity. Do not implement a speculative production BuilderOwner-to-QueryOwner ABI before the formal lifecycle interface is reviewed. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-SEMANTIC-NONVACUITY` | semantic coverage, liveness, ownership, and refinement predicates are derived from the operational construction they describe. A predicate defined to be `True`, an enumeration restated as membership, or a separately hand-written consumer label does not establish operational liveness by itself; | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-ORACLE-INDEPENDENCE` | executable fixtures and edge-case expected values come from an independent specification or a theorem already connected to it, never from the implementation result being tested; | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-CATEGORY-SEPARATION` | payload bits, proof fields, model ticks, machine state, Lean runtime, and measured performance remain distinct. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-MUTATION-REPRODUCIBILITY` | when acceptance relies on an exhaustive, production, or public-dependency mutation campaign, the candidate contains a versioned runner or fixtures that replay every claimed case, check the exact expected failure/acceptance surface, restore tracked state, and leave the tree clean. Report prose, copied terminal output, and dangling Git objects are not replayable evidence. A public theorem additionally has a checked exact-type consumer that fails when the advertised dependency is removed; `#print axioms` over the theorem's current type is not such a consumer. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `CHK-FINAL` | Run the final-required checks on the final submitted content, with exact identities, complete outcomes and declared platform limits. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `CHK-SCOPE` | Keep the assigned write scope, clean committed tree, exact base, full frozen row integrity and truthful local-versus-campaign status. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `NP0R1-INTEGRITY` | Every entered native replay verification lifecycle records and enforces an independent final integrity outcome in finally, including prior compiler/probe errors, unexpected diagnostics, timeout and partially initialized identity inventories. Verify every captured source/tool/generated-artifact pin and the declared live tracked/index/untracked baseline; absence of required final verification is failure or explicitly uncovered, never success. Preserve the original stage error separately from integrity errors. Detect unexpected changes without silently overwriting unrelated user data. Commit positive and changed-pin/tree controls through the actual production verifier/finalization path, including failure plus integrity failure, success plus integrity failure, and an ordinary failed stage with intact inputs. All owned fixture mutations are restored in their own finally and leave the real candidate unchanged. Keep existing owned-process cleanup and exact diagnostics/exits. | Local verification repair | Production finalizer and exact dependency checks | Captured run inputs -> final verification -> success/receipt | Isolated unchanged, tampered, failed-stage and incomplete inventories | Pending; append evidence | Open at freeze | +| `NP0R1-TOOLCHAIN` | Bind the substantive local implementation dependencies of the actually invoked pinned compiler/runtime to the replay receipt and final identity verification. In particular include clang's normal-import libclang-cpp.dll, libLLVM-19.dll and libc++.dll and inspect the invoked tools' remaining local non-system dependency closure; state the external OS/system-library and dynamic-loading boundary honestly. Include the generated link map in final available-artifact integrity checks. Commit a completeness/tamper control using actual dependency inventory and isolated manifest/file fixtures, without modifying installed tools. The original bea5ce75 runner/receipt must fail the new completeness predicate for the independently measured missing dependencies while a complete unchanged inventory passes. No installation, runtime upgrade, tool replacement or claim of universal loader/compiler verification. | Local verification repair | Production finalizer and exact dependency checks | Captured run inputs -> final verification -> success/receipt | Isolated unchanged, tampered, failed-stage and incomplete inventories | Pending; append evidence | Open at freeze | +| `NP0R2-STREAMS` | The actual native integrity-control harness and certification wrapper reject unexpected or mixed outer process stdout/stderr as well as preserving the existing inner native/launcher stream, summary, integrity and ordinary-exit checks. Define one precise stream contract for each actual caller/profile and use its production predicate in real positive/negative controls. Legitimate expected-error output must pass only with the exact expected diagnostics; extra, missing, duplicate or unrelated lines, misleading success output and mixed streams cannot be hidden by an expected exception, successful JSON or expected exit. Preserve complete raw output and actual exits, bounded ownership, cleanup and finally integrity. Reproduce the exact 2307e3ad counterexample on immutable old source/evidence and show the repaired production verdict rejects that same failure class, including actual outer stderr on successful and expected-failure cases and corresponding stdout controls. Keep all fourteen inherited rows, original operational IDs/predicates, fifteen integrity controls and nineteen dependency controls. Use isolated fixtures and restore only owned fixture state; never mutate installed tools or the live candidate. All supported wrapper profiles have a checked legitimate positive; no blanket empty-stderr rule that rejects legitimate negative-control diagnostics. | Narrow outer diagnostic repair | Exact production stream and exit predicates with replayable controls | Actual owned child capture -> caller-used validator -> certification verdict | Legitimate profiles plus extra, missing, duplicate, mixed and misleading output | Pending; append evidence | Open at freeze | +| `NP0R2-REPORT` | Deliver a complete successor report distinguishing the repaired control/certification boundary from the already-supported production finally/provenance and unchanged finite native ownership experiment. Explicitly correct the historical R1 copied-map wording: dependency_controls.ps1 creates a synthetic text map fixture; actual generated link-map capture and final hashing are separate verified observations. Preserve all historical report/receipt bytes and accurately state source-freeze, final-package, actual command results and remaining native-adapter/formal/campaign obligations. | Narrow outer diagnostic repair | Exact production stream and exit predicates with replayable controls | Actual owned child capture -> caller-used validator -> certification verdict | Legitimate profiles plus extra, missing, duplicate, mixed and misleading output | Pending; append evidence | Open at freeze | + +## Target and verification plan + +Join: reviewed native diagnostic prerequisite feeds the later consuming adapter; formal/native aggregate, blind audit and acceptance remain coordinator-owned. Hard obligation: actual outer stdout/stderr/exit objects must satisfy the same precise caller predicate used by positive and negative controls. Inner production semantics/finally/provenance are protected. No Lean/C/ABI, installed tool, old evidence or live candidate mutation is permitted. + +Development: exact base/scope/row/prompt checks; immutable old two-case reproduction (prior 60 s, 300 s guard); focused legitimate and real extra-stream cases plus component holdouts. Final-required: fifteen integrity controls (prior 467 s, 2400 s outer), full native SelfTest 23/65/58 (prior 178 s, 1200 s), nineteen dependency controls (prior 49 s, 1200 s), focused native selection, every wrapper profile positive and new exact stream registry. Serialize expensive work using Local\RMQLifecycleImplementationHeavy20260920; preserve 120/30/8 s fixture/stage/timeout limits. Complete raw streams/exits, cleanup and fixture restoration are evidence. + +Final certification: successor contract and strict UTF-8 frozen-row mutations, hygiene/native-decision scans, working/range whitespace, exact-base and each-commit strict design, clean identity, report claim coverage. Claims may compose verified original complete coverage with a final unchanged-policy subtree/both-ledger scan only after outside bytes/scanner/policy/rg/config verification (prior subtree 11 s, 1200 s; full fallback prior 2212 s, 7200 s). Historical source hashes bind exact Git objects, current hashes bind current working bytes. Conditional build skipped if protected Lean/C/lake/toolchain and baseline evidence verify. No campaign aggregate slot. Stop only at target closure, precise obstruction, external blocker or explicit redirection. + +## Appended local evidence and dispositions + +All sixteen frozen rows above remain unchanged, including historical pending cells. REPORT.md contains the complete row-by-row object chains and local dispositions. RESULTS.json pins the independently verified source-phase facts and complete local raw pin ledger. Source c3fcc2e0beb08d090382f56d16dbe9446639164a passed all six actual profiles, including the original full 23-case/65-check/58-stage replay, fifteen integrity controls and nineteen dependency controls. Corrected test source 4d6f195b306bd1615aced8c7a7cd1db0d48a8d69 passed fresh checks/claims and all 120 wrapper controls. The eleven new harness controls passed; the immutable exact-base old harness still accepted both unexpected stderr cases, while the repaired caller rejects that class and both stdout companions. Source review findings and their fixes are retained in SOURCE_REVIEW.md. + +The full independent collector verified 1938 distinct pins across 2931 occurrences. Ordinary exits, exact raw streams, expected diagnostics, registry reach and owned restoration were checked. Frozen-row mutations and exact independently pinned prompt requirements passed. All protected source and historical evidence remain intact. The new report corrects the synthetic-map wording and preserves all native/model/platform limits. + +Final submitted-content checks, complete report claim coverage, the final wrapper registry and collector are externally indexed by .lake/repair-r2/FINAL_CERTIFICATION.json, binding the final private package/report bytes without a recursive receipt commit. The handoff is made only after those post-package checks pass. All sixteen rows are locally satisfied at handoff; this is CANDIDATE_COMPLETE, not coordinator acceptance or closure of the later adapter/formal/native campaign node. diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r2/ACCEPTANCE_ROWS.txt b/docs/internal/extensions/lifecycle-native-p0/repair-r2/ACCEPTANCE_ROWS.txt new file mode 100644 index 00000000..9bb864eb --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r2/ACCEPTANCE_ROWS.txt @@ -0,0 +1,16 @@ +| `LN0-01` | Implement a reproducible probe of the pinned Lean 4.22 runtime array ownership operations, without altering the production RMQ ABI. Record logical size, retained capacity, requested container bytes and live element references as distinct quantities. Inspect actual runtime definitions and record compiler/runtime/header identity; do not infer capacity from Array.size. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-02` | Exercise unique and shared owners with destructor-counted elements. Demonstrate the actual effects of pop/shrink on surviving values, tail element references and retained backing capacity, without accessing freed objects. Distinguish release of one owner from reclamation when another alias remains live. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-03` | Exercise a consuming replacement-buffer route: copy surviving output values into a newly allocated bounded-capacity buffer, release the old owner, and measure which old allocations/elements remain reachable. Include success, empty output, overlap-relevant source positions, alias-retained and deterministically injected handoff/allocation-stage failure cleanup. Do not assume actual Lean allocator failure is recoverable; a fatal process outcome is reported separately. Treat observed allocator/requested capacity separately from a universal native heap theorem. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-04` | Commit an exact replay registry and positive/negative controls for logical shrink falsely labeled reclamation, retained alias falsely labeled exclusive consumption, and an omitted cleanup action. Validation executes the actual pinned runtime operations and the owned measurement/verdict path; predecessor RMQ replay is regression evidence only. The verdict must depend on observed value/ownership/capacity projections, not labels or a prewritten expected log; use the same positive predicate or a checked/explicit measured implication. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-05` | Use bounded owned compiler/probe processes, preserve full stdout/stderr and actual exits, reject unexpected or mixed diagnostics, validate focused/unknown/empty selector behavior, and exercise cleanup. A platform/toolchain inability is uncovered, not success. No credit purchase, package installation or persistent service is needed as an assumed prerequisite. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-06` | Deliver a source-grounded consuming-boundary recommendation mapping Construction.ExecState resources and Native.StorageImage/NativeImage ownership to later transfer obligations. Specify success/failure ownership, aliases, retained observations and capacity. Do not implement a speculative production BuilderOwner-to-QueryOwner ABI before the formal lifecycle interface is reviewed. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-SEMANTIC-NONVACUITY` | semantic coverage, liveness, ownership, and refinement predicates are derived from the operational construction they describe. A predicate defined to be `True`, an enumeration restated as membership, or a separately hand-written consumer label does not establish operational liveness by itself; | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-ORACLE-INDEPENDENCE` | executable fixtures and edge-case expected values come from an independent specification or a theorem already connected to it, never from the implementation result being tested; | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-CATEGORY-SEPARATION` | payload bits, proof fields, model ticks, machine state, Lean runtime, and measured performance remain distinct. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-MUTATION-REPRODUCIBILITY` | when acceptance relies on an exhaustive, production, or public-dependency mutation campaign, the candidate contains a versioned runner or fixtures that replay every claimed case, check the exact expected failure/acceptance surface, restore tracked state, and leave the tree clean. Report prose, copied terminal output, and dangling Git objects are not replayable evidence. A public theorem additionally has a checked exact-type consumer that fails when the advertised dependency is removed; `#print axioms` over the theorem's current type is not such a consumer. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `CHK-FINAL` | Run the final-required checks on the final submitted content, with exact identities, complete outcomes and declared platform limits. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `CHK-SCOPE` | Keep the assigned write scope, clean committed tree, exact base, full frozen row integrity and truthful local-versus-campaign status. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `NP0R1-INTEGRITY` | Every entered native replay verification lifecycle records and enforces an independent final integrity outcome in finally, including prior compiler/probe errors, unexpected diagnostics, timeout and partially initialized identity inventories. Verify every captured source/tool/generated-artifact pin and the declared live tracked/index/untracked baseline; absence of required final verification is failure or explicitly uncovered, never success. Preserve the original stage error separately from integrity errors. Detect unexpected changes without silently overwriting unrelated user data. Commit positive and changed-pin/tree controls through the actual production verifier/finalization path, including failure plus integrity failure, success plus integrity failure, and an ordinary failed stage with intact inputs. All owned fixture mutations are restored in their own finally and leave the real candidate unchanged. Keep existing owned-process cleanup and exact diagnostics/exits. | Local verification repair | Production finalizer and exact dependency checks | Captured run inputs -> final verification -> success/receipt | Isolated unchanged, tampered, failed-stage and incomplete inventories | Pending; append evidence | Open at freeze | +| `NP0R1-TOOLCHAIN` | Bind the substantive local implementation dependencies of the actually invoked pinned compiler/runtime to the replay receipt and final identity verification. In particular include clang's normal-import libclang-cpp.dll, libLLVM-19.dll and libc++.dll and inspect the invoked tools' remaining local non-system dependency closure; state the external OS/system-library and dynamic-loading boundary honestly. Include the generated link map in final available-artifact integrity checks. Commit a completeness/tamper control using actual dependency inventory and isolated manifest/file fixtures, without modifying installed tools. The original bea5ce75 runner/receipt must fail the new completeness predicate for the independently measured missing dependencies while a complete unchanged inventory passes. No installation, runtime upgrade, tool replacement or claim of universal loader/compiler verification. | Local verification repair | Production finalizer and exact dependency checks | Captured run inputs -> final verification -> success/receipt | Isolated unchanged, tampered, failed-stage and incomplete inventories | Pending; append evidence | Open at freeze | +| `NP0R2-STREAMS` | The actual native integrity-control harness and certification wrapper reject unexpected or mixed outer process stdout/stderr as well as preserving the existing inner native/launcher stream, summary, integrity and ordinary-exit checks. Define one precise stream contract for each actual caller/profile and use its production predicate in real positive/negative controls. Legitimate expected-error output must pass only with the exact expected diagnostics; extra, missing, duplicate or unrelated lines, misleading success output and mixed streams cannot be hidden by an expected exception, successful JSON or expected exit. Preserve complete raw output and actual exits, bounded ownership, cleanup and finally integrity. Reproduce the exact 2307e3ad counterexample on immutable old source/evidence and show the repaired production verdict rejects that same failure class, including actual outer stderr on successful and expected-failure cases and corresponding stdout controls. Keep all fourteen inherited rows, original operational IDs/predicates, fifteen integrity controls and nineteen dependency controls. Use isolated fixtures and restore only owned fixture state; never mutate installed tools or the live candidate. All supported wrapper profiles have a checked legitimate positive; no blanket empty-stderr rule that rejects legitimate negative-control diagnostics. | Narrow outer diagnostic repair | Exact production stream and exit predicates with replayable controls | Actual owned child capture -> caller-used validator -> certification verdict | Legitimate profiles plus extra, missing, duplicate, mixed and misleading output | Pending; append evidence | Open at freeze | +| `NP0R2-REPORT` | Deliver a complete successor report distinguishing the repaired control/certification boundary from the already-supported production finally/provenance and unchanged finite native ownership experiment. Explicitly correct the historical R1 copied-map wording: dependency_controls.ps1 creates a synthetic text map fixture; actual generated link-map capture and final hashing are separate verified observations. Preserve all historical report/receipt bytes and accurately state source-freeze, final-package, actual command results and remaining native-adapter/formal/campaign obligations. | Narrow outer diagnostic repair | Exact production stream and exit predicates with replayable controls | Actual owned child capture -> caller-used validator -> certification verdict | Legitimate profiles plus extra, missing, duplicate, mixed and misleading output | Pending; append evidence | Open at freeze | diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r2/HARNESS_STREAM_REGISTRY.json b/docs/internal/extensions/lifecycle-native-p0/repair-r2/HARNESS_STREAM_REGISTRY.json new file mode 100644 index 00000000..2838bb47 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r2/HARNESS_STREAM_REGISTRY.json @@ -0,0 +1,99 @@ +{ + "schema": 1, + "controls": [ + { + "id": "success-positive", + "kind": "harness", + "case": "intact-success", + "stream": "none", + "outcome": "accept", + "predicate": "Assert-LNOuterCapture", + "rationale": "Actual integrity_controls -> Assert-LNOuterCapture; exact evidence/PASS, empty stderr, runner exit0, native exit0, integrity true" + }, + { + "id": "error-positive", + "kind": "harness", + "case": "intact-stage-error", + "stream": "none", + "outcome": "accept", + "predicate": "Assert-LNOuterCapture", + "rationale": "Actual integrity_controls -> Assert-LNOuterCapture; exact evidence and PROCESS stderr, runner exit1, native exit7, integrity true" + }, + { + "id": "success-extra-stderr", + "kind": "harness", + "case": "intact-success", + "stream": "stderr", + "outcome": "reject", + "predicate": "Assert-LNOuterCapture", + "rationale": "Same actual integrity predicate and guards; extra derived-runner stderr" + }, + { + "id": "error-extra-stderr", + "kind": "harness", + "case": "intact-stage-error", + "stream": "stderr", + "outcome": "reject", + "predicate": "Assert-LNOuterCapture", + "rationale": "Same actual integrity predicate and guards; extra derived-runner stderr alongside exact PROCESS error" + }, + { + "id": "success-extra-stdout", + "kind": "harness", + "case": "intact-success", + "stream": "stdout", + "outcome": "reject", + "predicate": "Assert-LNOuterCapture", + "rationale": "Same actual integrity predicate and guards; extra derived-runner stdout" + }, + { + "id": "error-extra-stdout", + "kind": "harness", + "case": "intact-stage-error", + "stream": "stdout", + "outcome": "reject", + "predicate": "Assert-LNOuterCapture", + "rationale": "Same actual integrity predicate and guards; extra derived-runner stdout alongside expected failure" + }, + { + "id": "selector-empty", + "kind": "selector", + "stream": "empty", + "outcome": "reject", + "predicate": "command-selector", + "rationale": "Actual harness_stream_controls command binding rejects explicit empty before execution" + }, + { + "id": "selector-unknown", + "kind": "selector", + "stream": "unknown", + "outcome": "reject", + "predicate": "command-selector", + "rationale": "Actual harness_stream_controls command binding rejects unknown before execution" + }, + { + "id": "selector-duplicate", + "kind": "selector", + "stream": "duplicate", + "outcome": "reject", + "predicate": "command-selector", + "rationale": "Actual harness_stream_controls command binding rejects duplicate before execution" + }, + { + "id": "launcher-blank-stdout", + "kind": "launcher", + "stream": "stdout", + "outcome": "reject", + "predicate": "Assert-LNOuterCapture", + "rationale": "Actual retained launcher emits blank stdout; same Assert-LNOuterCapture rejects despite normalized empty array" + }, + { + "id": "launcher-blank-stderr", + "kind": "launcher", + "stream": "stderr", + "outcome": "reject", + "predicate": "Assert-LNOuterCapture", + "rationale": "Actual retained launcher emits blank stderr; same Assert-LNOuterCapture rejects despite normalized empty array" + } + ] +} diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r2/REPORT.md b/docs/internal/extensions/lifecycle-native-p0/repair-r2/REPORT.md new file mode 100644 index 00000000..cab207d1 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r2/REPORT.md @@ -0,0 +1,159 @@ +Status: CANDIDATE_COMPLETE +I found no assigned or inherited acceptance criterion unmet; coordinator acceptance is still required. + +# LIFE-NATIVE-P0-R2 outer diagnostic validation + +Worker LIFE-NATIVE-P0-R2; worktree C:/Users/poin/.codex/worktrees/eafd/RMQ; branch codex/life-native-p0-r2-outer-diagnostics; exact base 2307e3ad0739e0e1d9c3f186cdc568631086fddf; governance 7b227c49ef2ec044b702126cc41c9add847eed01. Core source freeze c3fcc2e0beb08d090382f56d16dbe9446639164a. The final implementation/test source freeze is 4d6f195b306bd1615aced8c7a7cd1db0d48a8d69. The documentation-only final package is the commit containing this report; its exact hash, report bytes and SHA-256 are recorded in the final handoff and .lake/repair-r2/FINAL_CERTIFICATION.json. A report cannot contain its own future commit/hash. Those external identities, not a moving branch name, select the final package. + +The local assignment repairs the integrity-control/certification diagnostic boundary. It preserves the supported production finally/partial-capture and normal-import provenance repairs and the finite native ownership experiment. It does not implement the consuming adapter, change a theorem/ABI or close the continuous lifecycle roadmap node. Both reviewed formal/native producers still precede that adapter; its final joint candidate precedes aggregate and fresh-blind audit; coordinator acceptance precedes separately authorized publication/integration. + +## Predicate and actual caller reach + +For a captured process C, S(C,E,e) requires completed bounded ownership, no timeout/overflow/child-error marker, retained empty launcher raw streams, actual child and launcher ordinary exits equal e, and full strict UTF-8 stdout/stderr equal the independently derived E. No trimming, blank suppression, exception-prefix allowance or successful JSON bypasses S. Read-LNExactStream decodes full bytes (including a BOM if present) with strict UTF-8; record terminators are the platform newline. Native raw byte contracts remain protected. + +The integrity caller first establishes its original inner guards: exact child raw bytes/exit, launcher state, timeout reach/cleanup, stage count, exact stage error and complete integrity error set. It then constructs E from these checked facts and the declared case, and invokes S on the same actual outer capture. The malformed FF and locked-map exception suffixes are derived from the same independently known runtime operations, not copied from an unconstrained summary. Legitimate expected-error diagnostics therefore pass; additional, missing, duplicate or wrong-stream diagnostics do not. + +The wrapper dispatch inventories exactly focused/full/integrity/dependencies/claims/checks. It compares actual captured streams/exits through Assert-LNWrapperCapture -> S. Native profiles require their exact evidence/PASS forms and positive summaries; integrity/dependency/check profiles require exact rosters/results and evidence lines. Claims independently reconstructs protected policy/source matches and consumes every stdout character as exact whole-record tokens with multiplicity and footer checks, allowing file-order variation only. The useful multiline records remain intact. + +Positive P and negative Q call the same S/Assert-LNWrapperCapture predicate on the same guarded objects. Positives and mutations differ only in the declared isolated stream/object field. Real derived-runner controls inject extra stdout/stderr after actual child 0/7 without changing production prefix/suffix or summary facts. Real wrapper controls replay a pinned legitimate producer stream through its actual capture/verdict and verify both observed streams independently before checking rejection; these are wrapper-process evidence, not additional C replays. Blank-launcher tests are real launcher processes with a synthetic inner capture object and independently established exit 0, flags and both raw streams. + +## Preservation and historical identity + +All 16 complete eight-column rows were frozen before source editing. The 14 inherited rows preserve exact UTF-8 base bytes, including historical pending cells. The verifier checks full rows, IDs/order/column shape, the initial frozen hash and every requirement cell against the separately pinned R2 prompt. Unchanged accepts; missing, duplicate, changed cell, mojibake, changed requirement, invalid UTF-8, extra column and reordered mutations reject. + +The unchanged 23 operational IDs/eight-field mapping, 65 original checks / 58 stages, 15 R1 integrity cases and 19 dependency controls remain. All protected Lean/C/lake/toolchain/public/old evidence paths retain exact filtered working bytes. Historical script pins resolve to exact immutable Git objects; current working-script hashes are separately bound, with Windows checkout filtering explicit. No old report or receipt is rewritten. + +The real old source counterexample is preserved at the coordinator's pinned 4331-byte RECEIPT SHA256 D47623CC4480AD592093871D59224ED8DB3B33B5E34D65C64F3BBD08BF7C83F7. New immutable-source reproduction returned 0 and both CONTROL PASS markers with UNEXPECTED OUTER DIAGNOSTIC on intact success and beside the expected exit 7 PROCESS failure. It took 114.287s under 300s. Those accepted historical outcomes are never relabeled rejected. The repaired actual harness rejects that failure class and corresponding stdout controls. + +## Verification ledger + +The committed RESULTS.json is a compact evidence index: complete facts plus a path/byte/SHA-256 pin for the independently checked full local pin ledger. Every raw stdout/stderr, actual exit, source artifact and result used by the collector is retained at its exact local path; the full ledger is intentionally not staged. Its versioned verifier can recheck those files. All reported profile exits are actual ordinary zero, with no timeout or output-limit flag; expected inner failures remain distinctly recorded. + +| Profile | Source-phase seconds / deadline | Outcome | +| --- | --- | --- | +| focused | 49.522 / 1200 s | One actual pop-unique case; 7 stages; integrity true | +| full | 188.136 / 1200 s | 23 ordered cases, 65 checks, 58 stages, 616 capture occurrences; integrity true | +| integrity | 533.411 / 2400 s | All 15 original controls; exact legitimate expected diagnostics and restoration | +| dependencies | 25.864 / 1200 s | All 19 original checks; 11-node normal-import inventory and restoration | +| claims | 4.680 / 7200 s | Actual protected strict scanner; complete receipt-pinned source-derived records and zero strict failures | +| checks | 22.449 / 1200 s | Contract, hygiene, native-decision, whitespace, strict whole/per-commit design, clean tree | + +The original six-profile certification is at .lake/repair-r2/source-certification-stable/PROFILES.json (c3fcc). Checks and claims were regenerated at .lake/repair-r2/corrected-certification/PROFILES.json after the 4d6f195 test/collector correction. The unchanged native/integrity/dependency source and production predicate did not require another expensive replay. The exact collector command and input pins are recorded below and in RESULTS.json. + +The eleven new harness controls ran through a 2400-second owned outer guard in 355.183s, ordinary exit 0. The immutable old two-case reproduction ran in 114.287s under its 300-second guard, ordinary exit 0, and still accepted both unexpected diagnostics. The corrected-source wrapper registry executed all 120 IDs and preserved source/fixture state; its complete raw parent capture is indexed in RESULTS.json. Focused selectors executed exactly one requested control, not a count-only listing. + +Post-package checks and claims are at .lake/repair-r2/final-certification/PROFILES.json. The final wrapper-registry and independent collector rerun are indexed by .lake/repair-r2/FINAL_CERTIFICATION.json and .lake/repair-r2/FINAL_RESULTS.json. These ignored post-commit artifacts bind the exact final package and complete report without recursive receipt commits. They re-establish full frozen-row/scope/baseline/outside-claim composition, exact-base and every new parent-to-commit design, both hygiene scans, working/range whitespace, final strict report coverage, and clean status. The final handoff is made only after these checks pass. + +The hygiene and native-decision searches expect rg exit 1 with empty output (no findings), not a fabricated successful search exit. All other final checks expect exit 0. No Lean/Lake build is repeated: all 1125 baseline sources and the existing successful build evidence are verified, with Lean/C/lakefile/toolchain protected. No aggregate gate or fresh-blind campaign audit is claimed. + +Claim coverage composes the verified historical full default-root scan with the final scan of the entire lifecycle-native-p0 subtree and both ledgers. The successor contract re-establishes every one of 2910 outside paths/bytes plus scanner/policy/rg/config identity first. This is not described as a newly executed whole-tree scan. The exact final hits/records, complete raw output and actual exit are in the final receipts. + +Source-frozen verification uses the shared host mutex and existing 120/30/8s compiler/probe/timeout limits, 1200s native and 2400s integrity bounds. Ordinary exits are recorded; killed native processes may have null ordinary exit and are never assigned successful exits. The generic helper remains protected; invocation-local retention at cleanup copies only owned redirect files and forwards actual deletion even after retention failure. Fixture restoration affects only named owned paths. + +The initial live source reproduction failed its final real-candidate check because development edits occurred concurrently; it is not passing evidence. The versioned old reproduction now uses an immutable exact-base source carrier. Earlier attempts diagnosed duplicate Path/PATH inheritance and the Windows PowerShell/Core module-path mismatch; the replay uses the same bundled pwsh as the recorded coordinator run. The first c3fcc focused source run rejected a collector file created during its baseline interval (46.567s, exit 1). After moving collector development to ignored scratch and confirming clean identity, the stable focused run passed. No unchanged timeout was retried and no healthy quiet process was stopped. + +## Explicit R1 wording correction and limits + +R1 REPORT.md calls the dependency map control a copied map fixture. dependency_controls.ps1 actually creates synthetic text measured-link-map-fixture. The zlib1.dll fixture is copied; actual generated link-map capture and final hashing are separate protected producer observations. Historical report/receipt bytes remain unchanged. + +The normal-import provenance boundary remains 11 actual local PE nodes, including the old receipt's four missing DLLs libclang-cpp.dll, libLLVM-19.dll, libc++.dll, zlib1.dll. OS/system/API-set loading, dynamic loading, compiler/PowerShell/.NET/Git correctness and transient changes between observations remain external assumptions. The already disclosed final-drain overflow branch-coverage limit stays disclosed; polling overflow evidence does not establish final-drain coverage. + +Finite requested outer-container capacity, known-root references/destructor counts, nested storage, native execution time, payload bits, proof fields and modeled ticks remain separate. Shortening an array can release elements while retaining capacity. Replacement with consuming release has distinct ownership observations; retained aliases remain live roots. No verifier pass establishes a universal native heap theorem or a production consuming ABI. + +## Digestion and downstream obligations + +Conceptually, a legitimate expected failure no longer masks unrelated output at a higher process layer. The same measured capture that supports the positive must satisfy the exact stream/exit predicate in each negative control. Raw blank lines are retained through the bottom launcher as well as the actual runner. Live assumptions remain the scoped host/runtime/file observations described above. The skeptical downstream question is whether the eventual compiled adapter retires every construction/alias root and repeatedly queries the same reviewed retained image with appropriate nested storage bounds. That adapter/formal/campaign join is explicitly deferred, not an unmet diagnostic-repair row. + +## Complete profile and registry contract + +Assert-LNWrapperCapture has exactly six supported canonical kinds. Kind is normalized once; omitted, empty and unknown kinds reject before launch. All profiles require exact actual child/launcher exit 0, empty stderr and the transport/raw-launcher guards of S. Their legitimate stdout is: + +| Kind | Complete allowed stdout, using platform CRLF terminators | +| --- | --- | +| focused | One LIFECYCLE-REPLAY evidence path inside its owned evidence root, then PASS cases=1 selfTest=False, with the successful pop-unique summary | +| full | One evidence path, then PASS cases=23 selfTest=True, with the successful exact full summary | +| integrity | Fifteen ordered CONTROL PASS records with the fixed original IDs, then the exact INTEGRITY CONTROLS evidence path; original RESULTS checks remain required | +| dependencies | One exact DEPENDENCY CONTROLS PASS evidence path; all nineteen original result IDs and predicates remain required | +| claims | Exact independent whole records, multiplicities and terminal summary; each producer expectation artifact is itself path/byte/hash pinned in its wrapper receipt | +| checks | Exact ordered CHECK PASS roster for the actual base-to-HEAD commit range, then FINAL CHECKS evidence path; each recorded check has its expected actual exit | + +HARNESS_STREAM_REGISTRY.json lists these eleven exact IDs in order: success-positive, error-positive, success-extra-stderr, error-extra-stderr, success-extra-stdout, error-extra-stdout, selector-empty, selector-unknown, selector-duplicate, launcher-blank-stdout, launcher-blank-stderr. The first six use real derived native runners through the actual integrity caller. The success positive has native/runner exits 0/0 and exact evidence plus PASS; the expected-error positive has exits 7/1 and exactly the PROCESS error. Both have successful independent integrity. The four extras preserve those inner objects and inject only the declared extra stream. Each repaired harness rejects at its exact caller-used stream predicate. The selector cases invoke the command boundary. Launcher cases produce an actual raw CRLF on exactly one bottom-launcher stream with actual launcher 0, opposite stream empty, all transport guards checked, then the same S rejects it despite the generic helper's empty normalized arrays. + +WRAPPER_STREAM_REGISTRY.json defines exactly 120 ID-to-operation mappings: + +- 108 components are the ordered product of focused/full/integrity/dependencies/claims/checks with positive, extra-stdout, extra-stderr, blank-stdout, blank-stderr, missing-output, duplicate-output, misleading-success, mixed-streams, wrong-exit, missing-ordinary-exit, timeout, output-limit, launcher-blank-stdout, launcher-blank-stderr, launcher-output, launcher-retention-error, missing-launcher-raw. Only each positive accepts; all seventeen mutations per profile reject at the exact independently derived failure surface. +- Three actual wrapper-process controls are wrapper-focused-process-positive, wrapper-focused-process-extra-stdout and wrapper-focused-process-extra-stderr. A derived wrapper changes only repository-root resolution for the relocated script and its focused producing action to replay a pinned real producer stream, while retaining the complete capture and production verdict. The real replayed child output and both streams/exits are independently verified. These are actual wrapper-process tests, not additional executions of the C experiment. +- Eight command-boundary controls reject controlids-empty-array, controlids-empty-string, controlids-whitespace, controlids-unknown, controlids-duplicate, kind-missing, kind-empty and kind-unknown. IDs use the wrapper-boundary- prefix. Complete output, exception type/message/FullyQualifiedErrorId and ordinary exit are checked; arbitrary process failure receives no credit. +- wrapper-focused-observed-mixed-holdout calls the same S on one copied capture. The declared baseline-plus-extra-stdout with empty stderr first accepts; adding exactly one unrelated stderr line then rejects. This specifically prevents an expected stdout failure from hiding another observation. + +Each registry validates exact ordered IDs, all operational columns and predicate mapping before execution. Missing/duplicate/unknown/unused cases cannot silently satisfy the registry. The one-ID corrected-source holdout is at .lake/repair-r2/wrapper-stream-controls-08e7901dbae34c148405c19813ba43f8/RESULTS.json; it executes exactly the requested ID with the same final runner/registry bytes. The earlier genuine focused-positive one-ID evidence remains at .lake/repair-r2/wrapper-stream-controls-de2a1081372d4c43a2990d24deaea671/RESULTS.json. Complete production-boundary focused/invalid-selector coverage is included in the final full registry. + +The independent source review and its findings/dispositions are retained in SOURCE_REVIEW.md. Findings include blank-launcher loss, case normalization, registry operational-field binding, full observed-stream guards and receipt-bound claim expectations. They were corrected before their respective final source runs. These are local independent reviews, not the later fresh-blind campaign audit. + +## All sixteen local acceptance dispositions + +The complete verbatim propositions are the sixteen frozen eight-column rows in ACCEPTANCE_ROWS.txt and ACCEPTANCE_MATRIX.md; the successor verifier also matches every requirement to the separately pinned commissioning prompt. The following evidence is additive and does not change any historical pending cell. Every row is locally satisfied; coordinator acceptance remains required. + +| ID | Exact object chain and closing evidence | +| --- | --- | +| LN0-01 | Unchanged pinned runtime/header/compiler and C probe -> actual full replay -> separately observed size/capacity/requested bytes/references; 23/65/58 and source/tool pins rechecked. | +| LN0-02 | Actual unique/shared pop/shrink operations -> surviving values, destructor/reference and retained-capacity projections -> same original production verdict; protected source and original registry preserved. | +| LN0-03 | Actual replacement buffers, alias roots and failure-stage pre-states -> measured cleanup/value/capacity checks; fatal allocation process outcome remains separate. Full replay preserves every original case/check/stage. | +| LN0-04 | Frozen ordered 23-case/eight-field mapping -> actual native observations -> original 65 predicates/58 stages; all original mutation/accept controls survive unchanged. | +| LN0-05 | Owned compiler/probe/runner/launcher -> complete raw streams and ordinary exits -> exact inner and new outer conjunction. Focused/full/15 integrity/11 harness/120 wrapper controls cover positives, expected errors, malformed/mixed/blank/missing/duplicate/misleading output and selector boundaries. | +| LN0-06 | Protected BOUNDARY.md and source-grounded R1/P0 evidence -> Construction.ExecState and Native.StorageImage/NativeImage transfer recommendations. Contract rechecks exact bytes; no speculative ABI is implemented. | +| INV-SEMANTIC-NONVACUITY | Existing operations drive native observations. New real child 0/7 -> checked runner 0/1 and integrity -> exact outer S changes actual harness verdict for four injected extras; process wrapper controls exercise its actual capture/verdict. | +| INV-ORACLE-INDEPENDENCE | Existing independent native input specification preserved. Exact case facts and independently reproduced decoder/lock operations derive diagnostics; protected claim policy and source matches derive claim records, never observed scanner stdout. | +| INV-CATEGORY-SEPARATION | Source/report keep payload bits, proof-only fields, model ticks, native requested capacity, nested heap, known roots and elapsed measurements separate. No new theorem or universal native-heap claim. | +| INV-MUTATION-REPRODUCIBILITY | Versioned 11/120 exact registries and runners -> same caller predicates and exact rejection surfaces -> owned restoration/candidate identity. Full raw evidence and independent collector retained. No public theorem dependency changed. | +| CHK-FINAL | Source-frozen six positives/full native/15 integrity/19 dependencies/11 harness/120 wrapper plus post-package contract, strict whole/per-commit design, hygiene, both whitespace ranges, final report claims and clean exact package receipts. | +| CHK-SCOPE | START preflight/base/clean identity -> frozen16/prompt checks -> protected3672 paths and append-only workflow ledger -> clean private commits. No push, integration, acceptance or protected-source edit. | +| NP0R1-INTEGRITY | Protected production catch/finally and immediate capture inventory -> all 15 actual changed integrity controls -> independently preserved stage errors, exact integrity error sets, timeout reach/cleanup, partial capture and restoration; actual full replay integrity true. | +| NP0R1-TOOLCHAIN | Actual 11-node local normal-import closure -> all 19 dependency checks including old bea5ce75 incompleteness/four missing DLLs -> complete/tampered/restored finalizer outcomes; actual generated binary/map pins checked separately. | +| NP0R2-STREAMS | S used by both actual callers, same complete captured objects/guards for P and Q -> six legitimate profile positives + four real harness extra-stream rejections + actual wrapper-process path + exhaustive declared 11/120 rosters. Immutable old source still accepts the exact class. | +| NP0R2-REPORT | This complete successor report, immutable historical report/receipt identities, explicit synthetic-map erratum, source/package separation, raw receipt index, limits/digestion and downstream obligations. | + +## Changed scope, identity and replay commands + +Production edits are limited to repair-r1/integrity_controls.ps1 and run_owned.ps1 plus the new focused scripts/packed_native_lifecycle_stream_check.ps1. repair-r1/final_checks.ps1 changes only its exact base and successor verifier dispatch. repair-r2 contains the row/prompt freeze, independent verifiers, exact registries and replay runners, claim expectation helper, source review, compact receipts and this report. WORKFLOW_DESIGN_DECISIONS.md contains append-only decisions R2-001/002/003. No other path changes. DESIGN_DECISIONS.md stays unchanged because no mathematical, representation, native or payload model changed. + +Source identity is core c3fcc2e0beb08d090382f56d16dbe9446639164a followed by corrected test/collector freeze 4d6f195b306bd1615aced8c7a7cd1db0d48a8d69. The final package changes documentation/evidence only. All protected source, old matrices/reports/receipts and policy/classifier/helper/PE/finally paths retain exact base identity. Historical source pins bind immutable Git objects; current file pins record actual working bytes. Neither is silently substituted for the other. + +The successful actual generated probe is 7,091,712 bytes with SHA-256 58D0451DC0A48A78E2885CFD8A2AA86100ADD46435317292F1C7BC99478129F9. .lake/repair-r2/PROBE_DEPENDENCIES.json records its twelve system import names and zero delay-import directory. The full summary and separately retained actual link map remain pinned through the native receipt. This system-import observation does not enlarge the local-tool closure into a universal loader guarantee. + +From the absolute worktree, the reusable certification orchestration is: + +```powershell +& ./docs/internal/extensions/lifecycle-native-p0/repair-r2/certify_profiles.ps1 -OutputRoot +``` + +The versioned integrity and stream-control runners accept exact focused selectors and fresh owned output roots. The actual final evidence collector invocation uses: + +```powershell +python docs/internal/extensions/lifecycle-native-p0/repair-r2/verify_results.py --profiles .lake/repair-r2/final-certification/PROFILES.json --harness .lake/repair-r2/source-harness/controls/RESULTS.json --wrapper-controls --old-reproduction .lake/repair-r2/old-reproduction-a3c583930b944c11a2b8b3e1f48c566d/actual-outer-diagnostic-9e1222ab76c34ab1b5fd39eaeb8a674c/RECEIPT.json --output .lake/repair-r2/FINAL_RESULTS.json +``` + +The exact successful commands/argv, source versions, working directories, raw files, pins, actual ordinary exits and deadlines are preserved in the indexed receipts, rather than reconstructed from the illustrative fresh-output command. .lake/repair-r2/FINAL_CERTIFICATION.json is the nonrecursive final package/report identity and verification index. + + +## Source-phase evidence pins + +All paths below are relative to C:/Users/poin/.codex/worktrees/eafd/RMQ. The receipt JSON files transitively pin the full raw streams/exits; SOURCE_RESULTS.json independently rehashes those raw files. The complete collector passed with 1938 distinct pins and 2931 pin occurrences. The full wrapper run had ordinary exit 0 and took 93.550s under 1200s. + +| Path | Bytes | SHA-256 | +| --- | ---: | --- | +| .lake/repair-r2/source-certification-stable/focused/RECEIPT.json | 3683 | A92152D571E98C88C752B009318A8439345624010370A77D1953DAE6DC8ABDC0 | +| .lake/repair-r2/source-certification-stable/full/RECEIPT.json | 3636 | CC99783460FD12ECF240F745C99218FC62BF0FE14A25BDC40F96BDDA97912B74 | +| .lake/repair-r2/source-certification-stable/integrity/RECEIPT.json | 4296 | C18DBEA18865E5D139E6796EB38D6545E2ABE27FCF8656EC061FBF60A78254B5 | +| .lake/repair-r2/source-certification-stable/dependencies/RECEIPT.json | 3718 | 2E3A098EAEFC7FA48533E47C02788B1350397E4A34E8C3127821E1DD5A6E9796 | +| .lake/repair-r2/corrected-certification/claims/RECEIPT.json | 147679 | 9528FD2D96904BC0C182768E1B869C15A9230500F76FF8B923164A5FE1004A56 | +| .lake/repair-r2/corrected-certification/checks/RECEIPT.json | 3520 | 56E13EE3A3B1A6C616EDB427F7145D8F40ED23438C01BA7CA8D381A8B2C03E98 | +| .lake/repair-r2/SOURCE_RESULTS.json | 620359 | 7F9855A6781CDD9A9CBABE6B34C4679030B46E1D07C18FC7683F884D8F4E3F95 | +| .lake/repair-r2/source-harness/controls/RESULTS.json | 95033 | B9E7FCA0C6E5797FC85E40F18954BF93EF3906D73E05883AED81720E65D30905 | +| .lake/repair-r2/source-harness/capture/CAPTURE.json | 3986 | E2675CB96181815E2A70A2606C239DCAFE935A75722425522CD6708AE5D8FF1A | +| .lake/repair-r2/wrapper-final-5b8e1eb2ebd3423db3defcbb7b703f9e/controls/RESULTS.json | 399623 | A767068C5B88F5F25783519540302D7321E4D551E632407D58C6EDBEA7484C69 | +| .lake/repair-r2/wrapper-final-5b8e1eb2ebd3423db3defcbb7b703f9e/outer/CAPTURE.json | 4627 | F56927BF8B6846B00F40C34D222F1AF2673ABC8B88900AB66C93730987973206 | +| .lake/repair-r2/old-reproduction-a3c583930b944c11a2b8b3e1f48c566d/actual-outer-diagnostic-9e1222ab76c34ab1b5fd39eaeb8a674c/RECEIPT.json | 4455 | 5A148AA0AF4FE33785D17F71A06F4C853D968036056459F7495DD907AAA018AC | +| .lake/repair-r2/PROBE_DEPENDENCIES.json | 793 | 94CB1BA6F7B675ABFC355D412DDE595DCD5086A45A11B1E02C73FB50868AB1F9 | + +The committed RESULTS.json retains the source-phase facts and the full-ledger pin. The final post-package collector output is separately pinned by FINAL_CERTIFICATION.json. Development failures are explicitly excluded from both success sets. diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r2/RESULTS.json b/docs/internal/extensions/lifecycle-native-p0/repair-r2/RESULTS.json new file mode 100644 index 00000000..07452a5a --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r2/RESULTS.json @@ -0,0 +1,1275 @@ +{ + "base": "2307e3ad0739e0e1d9c3f186cdc568631086fddf", + "head": "4d6f195b306bd1615aced8c7a7cd1db0d48a8d69", + "worktree": "C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ", + "profiles": { + "focused": { + "receipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\repair-r2\\source-certification-stable\\focused\\RECEIPT.json", + "bytes": 3683, + "sha256": "A92152D571E98C88C752B009318A8439345624010370A77D1953DAE6DC8ABDC0" + }, + "actualExit": 0, + "seconds": 49.522, + "deadlineSeconds": 1200, + "streamValidation": true, + "facts": { + "summary": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\lifecycle-native-p0\\runs\\5b2d10d020e64c24b8d81f8278eb39a7\\SUMMARY.json", + "bytes": 117086, + "sha256": "B71497497654E9544C07B73A693A411AAC20713495EBE5716CF93D8CEFEE9934" + }, + "selected": [ + "pop-unique" + ], + "checks": 2, + "stages": 7, + "capturedPins": 191, + "integritySuccess": true + } + }, + "full": { + "receipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\repair-r2\\source-certification-stable\\full\\RECEIPT.json", + "bytes": 3636, + "sha256": "CC99783460FD12ECF240F745C99218FC62BF0FE14A25BDC40F96BDDA97912B74" + }, + "actualExit": 0, + "seconds": 188.136, + "deadlineSeconds": 1200, + "streamValidation": true, + "facts": { + "summary": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\lifecycle-native-p0\\runs\\613c019061d14e24982de6651e433cd8\\SUMMARY.json", + "bytes": 330214, + "sha256": "4997E4F2A0273AB2866985FB5573C570BA1ADC8870BD8898F615A03F2E0204A7" + }, + "selected": [ + "pop-unique", + "shrink-unique", + "pop-shared", + "shrink-shared", + "pop-empty-unique", + "pop-empty-shared", + "shrink-noop", + "replace-prefix", + "replace-overlap", + "replace-tail", + "replace-empty", + "replace-alias", + "replace-element-alias", + "fail-alloc", + "fail-after-alloc", + "fail-mid-copy", + "fail-handoff", + "fail-after-consume", + "fail-alias", + "negative-shrink", + "negative-alias", + "negative-cleanup", + "negative-value" + ], + "checks": 65, + "stages": 58, + "capturedPins": 616, + "integritySuccess": true + } + }, + "integrity": { + "receipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\repair-r2\\source-certification-stable\\integrity\\RECEIPT.json", + "bytes": 4296, + "sha256": "C18DBEA18865E5D139E6796EB38D6545E2ABE27FCF8656EC061FBF60A78254B5" + }, + "actualExit": 0, + "seconds": 533.411, + "deadlineSeconds": 2400, + "streamValidation": true, + "facts": { + "results": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\repair-r1\\controls-f62ef16b877d46a0a2c4c66a469bdff5\\RESULTS.json", + "bytes": 125992, + "sha256": "773FF578752329F0EAD5A1C36AC579D90C9C5420694E37BBD267B826252AA0F1" + }, + "controls": [ + { + "id": "intact-success", + "outerExit": 0, + "nativeExit": 0, + "timeout": false, + "integritySuccess": true, + "stageFailure": null + }, + { + "id": "intact-stage-error", + "outerExit": 1, + "nativeExit": 7, + "timeout": false, + "integritySuccess": true, + "stageFailure": "PROCESS: fixture-stage actual child or launcher exit differs from 0" + }, + { + "id": "malformed-stdout-intact", + "outerExit": 1, + "nativeExit": 0, + "timeout": false, + "integritySuccess": true, + "stageFailure": "DIAGNOSTIC: invalid raw stage evidence for fixture-stage; Exception calling \"ReadAllText\" with \"2\" argument(s): \"Unable to translate bytes [FF] at index 0 from specified code page to Unicode.\"" + }, + { + "id": "stage-error-and-pin-change", + "outerExit": 1, + "nativeExit": 7, + "timeout": false, + "integritySuccess": false, + "stageFailure": "PROCESS: fixture-stage actual child or launcher exit differs from 0" + }, + { + "id": "stage-error-and-capture-error", + "outerExit": 1, + "nativeExit": 7, + "timeout": false, + "integritySuccess": false, + "stageFailure": "PROCESS: fixture-stage actual child or launcher exit differs from 0" + }, + { + "id": "success-and-pin-change", + "outerExit": 1, + "nativeExit": 0, + "timeout": false, + "integritySuccess": false, + "stageFailure": null + }, + { + "id": "mixed-diagnostic-and-pin-change", + "outerExit": 1, + "nativeExit": 0, + "timeout": false, + "integritySuccess": false, + "stageFailure": "DIAGNOSTIC: unexpected or mixed stderr for fixture-stage" + }, + { + "id": "timeout-and-pin-change", + "outerExit": 1, + "nativeExit": null, + "timeout": true, + "integritySuccess": false, + "stageFailure": "PROCESS: fixture-stage was not a completed bounded process; see retained logs" + }, + { + "id": "success-and-tracked-change", + "outerExit": 1, + "nativeExit": 0, + "timeout": false, + "integritySuccess": false, + "stageFailure": null + }, + { + "id": "success-and-index-change", + "outerExit": 1, + "nativeExit": 0, + "timeout": false, + "integritySuccess": false, + "stageFailure": null + }, + { + "id": "success-and-untracked-addition", + "outerExit": 1, + "nativeExit": 0, + "timeout": false, + "integritySuccess": false, + "stageFailure": null + }, + { + "id": "success-and-untracked-byte-change", + "outerExit": 1, + "nativeExit": 0, + "timeout": false, + "integritySuccess": false, + "stageFailure": null + }, + { + "id": "success-and-link-map-change", + "outerExit": 1, + "nativeExit": 0, + "timeout": false, + "integritySuccess": false, + "stageFailure": null + }, + { + "id": "partial-identity-and-pin-change", + "outerExit": 1, + "nativeExit": 0, + "timeout": false, + "integritySuccess": false, + "stageFailure": "IDENTITY: missing file C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\repair-r1\\controls-f62ef16b877d46a0a2c4c66a469bdff5\\partial-identity-and-pin-change\\missing-tool.exe" + }, + { + "id": "missing-baseline", + "outerExit": 1, + "nativeExit": 0, + "timeout": false, + "integritySuccess": false, + "stageFailure": null + } + ], + "fixtureRestoration": true, + "candidateUnchanged": true + } + }, + "dependencies": { + "receipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\repair-r2\\source-certification-stable\\dependencies\\RECEIPT.json", + "bytes": 3718, + "sha256": "2E3A098EAEFC7FA48533E47C02788B1350397E4A34E8C3127821E1DD5A6E9796" + }, + "actualExit": 0, + "seconds": 25.864, + "deadlineSeconds": 1200, + "streamValidation": true, + "facts": { + "results": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\repair-r1\\dependencies-991cc83249ae46c8b489ba9c165f53f2\\RESULTS.json", + "bytes": 37270, + "sha256": "6D0F7B07ECF1D467C5D0C348E6C230AA7AB34FE390C2B7E28C78FD62C66D5524" + }, + "controls": [ + "complete-inventory", + "bea5ce75-incomplete", + "omit-lean.exe", + "omit-leanc.exe", + "omit-clang.exe", + "omit-ld.lld.exe", + "omit-libleanshared.dll", + "omit-libInit_shared.dll", + "omit-libclang-cpp.dll", + "omit-libLLVM-19.dll", + "omit-libc++.dll", + "omit-zlib1.dll", + "omit-libleanshared_1.dll", + "same-name-wrong-path", + "complete-unchanged-finalizer", + "tamper-zlib1.dll", + "tamper-link.map", + "tamper-manifest-hash", + "restored-finalizer" + ], + "localNodes": 11, + "oldMissing": [ + "libc++.dll", + "libclang-cpp.dll", + "libllvm-19.dll", + "zlib1.dll" + ], + "installedToolsUnchanged": true, + "fixtureRestored": true + } + }, + "claims": { + "receipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\repair-r2\\corrected-certification\\claims\\RECEIPT.json", + "bytes": 147679, + "sha256": "9528FD2D96904BC0C182768E1B869C15A9230500F76FF8B923164A5FE1004A56" + }, + "actualExit": 0, + "seconds": 4.68, + "deadlineSeconds": 7200, + "streamValidation": true, + "facts": { + "expectation": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\repair-r2\\claim-expectation-d2a8f00f8694453ebb14dc9a252e7da6\\EXPECTATION.json", + "bytes": 196177, + "sha256": "51797DD2068ED56EFFC71CC87AC165694E0CC95183BDDA6CF40CC9F61391DBFB" + }, + "records": 268, + "hits": 387, + "strictFailures": 0, + "footer": "CLAIM-DRIFT: scan complete (387 hits, 0 strict failures)" + } + }, + "checks": { + "receipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\repair-r2\\corrected-certification\\checks\\RECEIPT.json", + "bytes": 3520, + "sha256": "56E13EE3A3B1A6C616EDB427F7145D8F40ED23438C01BA7CA8D381A8B2C03E98" + }, + "actualExit": 0, + "seconds": 22.449, + "deadlineSeconds": 1200, + "streamValidation": true, + "facts": { + "results": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\repair-r1\\final-checks-bd4375e3b52347c49a44c533aa4ffd47\\RESULTS.json", + "bytes": 7459, + "sha256": "C26981BB30695D394F7DBC813210170A51F5C5042271F9A2EFBC59A958CDFC74" + }, + "head": "4d6f195b306bd1615aced8c7a7cd1db0d48a8d69", + "checks": [ + "contract", + "hygiene", + "native-decision", + "working-whitespace", + "range-whitespace", + "design-whole", + "design-c3fcc2e0beb0", + "design-4d6f195b306b", + "clean" + ] + } + } + }, + "verifier": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\docs\\internal\\extensions\\lifecycle-native-p0\\repair-r2\\verify_results.py", + "bytes": 41462, + "sha256": "CE931FD260A5FDA818E06BEEF1C66C6152189B46984FC4510EB445376244CAD2" + }, + "harness": { + "results": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\repair-r2\\source-harness\\controls\\RESULTS.json", + "bytes": 95033, + "sha256": "B9E7FCA0C6E5797FC85E40F18954BF93EF3906D73E05883AED81720E65D30905" + }, + "controls": [ + { + "id": "success-positive", + "outcome": "accept", + "surface": "", + "predicate": "Assert-LNOuterCapture" + }, + { + "id": "error-positive", + "outcome": "accept", + "surface": "", + "predicate": "Assert-LNOuterCapture" + }, + { + "id": "success-extra-stderr", + "outcome": "reject", + "surface": "STREAM: integrity-intact-success stderr differs", + "predicate": "Assert-LNOuterCapture" + }, + { + "id": "error-extra-stderr", + "outcome": "reject", + "surface": "STREAM: integrity-intact-stage-error stderr differs", + "predicate": "Assert-LNOuterCapture" + }, + { + "id": "success-extra-stdout", + "outcome": "reject", + "surface": "STREAM: integrity-intact-success stdout differs", + "predicate": "Assert-LNOuterCapture" + }, + { + "id": "error-extra-stdout", + "outcome": "reject", + "surface": "STREAM: integrity-intact-stage-error stdout differs", + "predicate": "Assert-LNOuterCapture" + }, + { + "id": "selector-empty", + "outcome": "reject", + "surface": "STREAM-SELECTOR: empty", + "predicate": "command-selector" + }, + { + "id": "selector-unknown", + "outcome": "reject", + "surface": "STREAM-SELECTOR: unknown", + "predicate": "command-selector" + }, + { + "id": "selector-duplicate", + "outcome": "reject", + "surface": "STREAM-SELECTOR: duplicate", + "predicate": "command-selector" + }, + { + "id": "launcher-blank-stdout", + "outcome": "reject", + "surface": "STREAM: launcher-blank-stdout launcher stdout differs", + "predicate": "Assert-LNOuterCapture" + }, + { + "id": "launcher-blank-stderr", + "outcome": "reject", + "surface": "STREAM: launcher-blank-stderr launcher stderr differs", + "predicate": "Assert-LNOuterCapture" + } + ], + "completeRegistry": true + }, + "wrapperControls": { + "results": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\repair-r2\\wrapper-final-5b8e1eb2ebd3423db3defcbb7b703f9e\\controls\\RESULTS.json", + "bytes": 399623, + "sha256": "A767068C5B88F5F25783519540302D7321E4D551E632407D58C6EDBEA7484C69" + }, + "count": 120, + "completeRegistry": true, + "controls": [ + { + "id": "wrapper-focused-positive", + "mode": "component", + "expected": "accept", + "actualFailure": null + }, + { + "id": "wrapper-focused-extra-stdout", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-focused stdout differs" + }, + { + "id": "wrapper-focused-extra-stderr", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-focused stderr differs" + }, + { + "id": "wrapper-focused-blank-stdout", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-focused stdout differs" + }, + { + "id": "wrapper-focused-blank-stderr", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-focused stderr differs" + }, + { + "id": "wrapper-focused-missing-output", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-focused stdout differs" + }, + { + "id": "wrapper-focused-duplicate-output", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-focused stdout differs" + }, + { + "id": "wrapper-focused-misleading-success", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-focused stdout differs" + }, + { + "id": "wrapper-focused-mixed-streams", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-focused stderr differs" + }, + { + "id": "wrapper-focused-wrong-exit", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-focused ordinary exit differs" + }, + { + "id": "wrapper-focused-missing-ordinary-exit", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-focused ordinary exit differs" + }, + { + "id": "wrapper-focused-timeout", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-focused incomplete bounded capture" + }, + { + "id": "wrapper-focused-output-limit", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-focused incomplete bounded capture" + }, + { + "id": "wrapper-focused-launcher-blank-stdout", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-focused launcher stdout differs" + }, + { + "id": "wrapper-focused-launcher-blank-stderr", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-focused launcher stderr differs" + }, + { + "id": "wrapper-focused-launcher-output", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-focused launcher output" + }, + { + "id": "wrapper-focused-launcher-retention-error", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-focused launcher retention failed" + }, + { + "id": "wrapper-focused-missing-launcher-raw", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: raw capture missing: C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\repair-r2\\wrapper-final-5b8e1eb2ebd3423db3defcbb7b703f9e\\controls\\wrapper-focused-missing-launcher-raw\\fixture\\launcherStdout.raw" + }, + { + "id": "wrapper-full-positive", + "mode": "component", + "expected": "accept", + "actualFailure": null + }, + { + "id": "wrapper-full-extra-stdout", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-full stdout differs" + }, + { + "id": "wrapper-full-extra-stderr", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-full stderr differs" + }, + { + "id": "wrapper-full-blank-stdout", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-full stdout differs" + }, + { + "id": "wrapper-full-blank-stderr", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-full stderr differs" + }, + { + "id": "wrapper-full-missing-output", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-full stdout differs" + }, + { + "id": "wrapper-full-duplicate-output", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-full stdout differs" + }, + { + "id": "wrapper-full-misleading-success", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-full stdout differs" + }, + { + "id": "wrapper-full-mixed-streams", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-full stderr differs" + }, + { + "id": "wrapper-full-wrong-exit", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-full ordinary exit differs" + }, + { + "id": "wrapper-full-missing-ordinary-exit", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-full ordinary exit differs" + }, + { + "id": "wrapper-full-timeout", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-full incomplete bounded capture" + }, + { + "id": "wrapper-full-output-limit", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-full incomplete bounded capture" + }, + { + "id": "wrapper-full-launcher-blank-stdout", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-full launcher stdout differs" + }, + { + "id": "wrapper-full-launcher-blank-stderr", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-full launcher stderr differs" + }, + { + "id": "wrapper-full-launcher-output", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-full launcher output" + }, + { + "id": "wrapper-full-launcher-retention-error", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-full launcher retention failed" + }, + { + "id": "wrapper-full-missing-launcher-raw", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: raw capture missing: C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\repair-r2\\wrapper-final-5b8e1eb2ebd3423db3defcbb7b703f9e\\controls\\wrapper-full-missing-launcher-raw\\fixture\\launcherStdout.raw" + }, + { + "id": "wrapper-integrity-positive", + "mode": "component", + "expected": "accept", + "actualFailure": null + }, + { + "id": "wrapper-integrity-extra-stdout", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-integrity stdout differs" + }, + { + "id": "wrapper-integrity-extra-stderr", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-integrity stderr differs" + }, + { + "id": "wrapper-integrity-blank-stdout", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-integrity stdout differs" + }, + { + "id": "wrapper-integrity-blank-stderr", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-integrity stderr differs" + }, + { + "id": "wrapper-integrity-missing-output", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: evidence line missing" + }, + { + "id": "wrapper-integrity-duplicate-output", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-integrity stdout differs" + }, + { + "id": "wrapper-integrity-misleading-success", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-integrity stdout differs" + }, + { + "id": "wrapper-integrity-mixed-streams", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-integrity stderr differs" + }, + { + "id": "wrapper-integrity-wrong-exit", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-integrity ordinary exit differs" + }, + { + "id": "wrapper-integrity-missing-ordinary-exit", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-integrity ordinary exit differs" + }, + { + "id": "wrapper-integrity-timeout", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-integrity incomplete bounded capture" + }, + { + "id": "wrapper-integrity-output-limit", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-integrity incomplete bounded capture" + }, + { + "id": "wrapper-integrity-launcher-blank-stdout", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-integrity launcher stdout differs" + }, + { + "id": "wrapper-integrity-launcher-blank-stderr", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-integrity launcher stderr differs" + }, + { + "id": "wrapper-integrity-launcher-output", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-integrity launcher output" + }, + { + "id": "wrapper-integrity-launcher-retention-error", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-integrity launcher retention failed" + }, + { + "id": "wrapper-integrity-missing-launcher-raw", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: raw capture missing: C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\repair-r2\\wrapper-final-5b8e1eb2ebd3423db3defcbb7b703f9e\\controls\\wrapper-integrity-missing-launcher-raw\\fixture\\launcherStdout.raw" + }, + { + "id": "wrapper-dependencies-positive", + "mode": "component", + "expected": "accept", + "actualFailure": null + }, + { + "id": "wrapper-dependencies-extra-stdout", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-dependencies stdout differs" + }, + { + "id": "wrapper-dependencies-extra-stderr", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-dependencies stderr differs" + }, + { + "id": "wrapper-dependencies-blank-stdout", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-dependencies stdout differs" + }, + { + "id": "wrapper-dependencies-blank-stderr", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-dependencies stderr differs" + }, + { + "id": "wrapper-dependencies-missing-output", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: evidence line missing" + }, + { + "id": "wrapper-dependencies-duplicate-output", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-dependencies stdout differs" + }, + { + "id": "wrapper-dependencies-misleading-success", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-dependencies stdout differs" + }, + { + "id": "wrapper-dependencies-mixed-streams", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-dependencies stderr differs" + }, + { + "id": "wrapper-dependencies-wrong-exit", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-dependencies ordinary exit differs" + }, + { + "id": "wrapper-dependencies-missing-ordinary-exit", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-dependencies ordinary exit differs" + }, + { + "id": "wrapper-dependencies-timeout", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-dependencies incomplete bounded capture" + }, + { + "id": "wrapper-dependencies-output-limit", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-dependencies incomplete bounded capture" + }, + { + "id": "wrapper-dependencies-launcher-blank-stdout", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-dependencies launcher stdout differs" + }, + { + "id": "wrapper-dependencies-launcher-blank-stderr", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-dependencies launcher stderr differs" + }, + { + "id": "wrapper-dependencies-launcher-output", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-dependencies launcher output" + }, + { + "id": "wrapper-dependencies-launcher-retention-error", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-dependencies launcher retention failed" + }, + { + "id": "wrapper-dependencies-missing-launcher-raw", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: raw capture missing: C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\repair-r2\\wrapper-final-5b8e1eb2ebd3423db3defcbb7b703f9e\\controls\\wrapper-dependencies-missing-launcher-raw\\fixture\\launcherStdout.raw" + }, + { + "id": "wrapper-claims-positive", + "mode": "component", + "expected": "accept", + "actualFailure": null + }, + { + "id": "wrapper-claims-extra-stdout", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: claim footer differs" + }, + { + "id": "wrapper-claims-extra-stderr", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-claims stderr differs" + }, + { + "id": "wrapper-claims-blank-stdout", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: claim footer differs" + }, + { + "id": "wrapper-claims-blank-stderr", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-claims stderr differs" + }, + { + "id": "wrapper-claims-missing-output", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: claim footer differs" + }, + { + "id": "wrapper-claims-duplicate-output", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: unexpected or duplicate claim record/text at character 135616" + }, + { + "id": "wrapper-claims-misleading-success", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: claim footer differs" + }, + { + "id": "wrapper-claims-mixed-streams", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-claims stderr differs" + }, + { + "id": "wrapper-claims-wrong-exit", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-claims ordinary exit differs" + }, + { + "id": "wrapper-claims-missing-ordinary-exit", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-claims ordinary exit differs" + }, + { + "id": "wrapper-claims-timeout", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-claims incomplete bounded capture" + }, + { + "id": "wrapper-claims-output-limit", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-claims incomplete bounded capture" + }, + { + "id": "wrapper-claims-launcher-blank-stdout", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-claims launcher stdout differs" + }, + { + "id": "wrapper-claims-launcher-blank-stderr", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-claims launcher stderr differs" + }, + { + "id": "wrapper-claims-launcher-output", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-claims launcher output" + }, + { + "id": "wrapper-claims-launcher-retention-error", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-claims launcher retention failed" + }, + { + "id": "wrapper-claims-missing-launcher-raw", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: raw capture missing: C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\repair-r2\\wrapper-final-5b8e1eb2ebd3423db3defcbb7b703f9e\\controls\\wrapper-claims-missing-launcher-raw\\fixture\\launcherStdout.raw" + }, + { + "id": "wrapper-checks-positive", + "mode": "component", + "expected": "accept", + "actualFailure": null + }, + { + "id": "wrapper-checks-extra-stdout", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-checks stdout differs" + }, + { + "id": "wrapper-checks-extra-stderr", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-checks stderr differs" + }, + { + "id": "wrapper-checks-blank-stdout", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-checks stdout differs" + }, + { + "id": "wrapper-checks-blank-stderr", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-checks stderr differs" + }, + { + "id": "wrapper-checks-missing-output", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: evidence line missing" + }, + { + "id": "wrapper-checks-duplicate-output", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-checks stdout differs" + }, + { + "id": "wrapper-checks-misleading-success", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-checks stdout differs" + }, + { + "id": "wrapper-checks-mixed-streams", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-checks stderr differs" + }, + { + "id": "wrapper-checks-wrong-exit", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-checks ordinary exit differs" + }, + { + "id": "wrapper-checks-missing-ordinary-exit", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-checks ordinary exit differs" + }, + { + "id": "wrapper-checks-timeout", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-checks incomplete bounded capture" + }, + { + "id": "wrapper-checks-output-limit", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-checks incomplete bounded capture" + }, + { + "id": "wrapper-checks-launcher-blank-stdout", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-checks launcher stdout differs" + }, + { + "id": "wrapper-checks-launcher-blank-stderr", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-checks launcher stderr differs" + }, + { + "id": "wrapper-checks-launcher-output", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-checks launcher output" + }, + { + "id": "wrapper-checks-launcher-retention-error", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-checks launcher retention failed" + }, + { + "id": "wrapper-checks-missing-launcher-raw", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: raw capture missing: C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\repair-r2\\wrapper-final-5b8e1eb2ebd3423db3defcbb7b703f9e\\controls\\wrapper-checks-missing-launcher-raw\\fixture\\launcherStdout.raw" + }, + { + "id": "wrapper-focused-process-positive", + "mode": "process", + "expected": "accept", + "actualFailure": null + }, + { + "id": "wrapper-focused-process-extra-stdout", + "mode": "process", + "expected": "reject", + "actualFailure": "STREAM: wrapper-focused stdout differs" + }, + { + "id": "wrapper-focused-process-extra-stderr", + "mode": "process", + "expected": "reject", + "actualFailure": "STREAM: wrapper-focused stderr differs" + }, + { + "id": "wrapper-boundary-controlids-empty-array", + "mode": "boundary", + "expected": "reject", + "actualFailure": "WRAPPER-STREAM: empty selector", + "exceptionType": "System.Management.Automation.RuntimeException", + "fullyQualifiedErrorId": "WRAPPER-STREAM: empty selector", + "driverExit": 0 + }, + { + "id": "wrapper-boundary-controlids-empty-string", + "mode": "boundary", + "expected": "reject", + "actualFailure": "WRAPPER-STREAM: empty selector", + "exceptionType": "System.Management.Automation.RuntimeException", + "fullyQualifiedErrorId": "WRAPPER-STREAM: empty selector", + "driverExit": 0 + }, + { + "id": "wrapper-boundary-controlids-whitespace", + "mode": "boundary", + "expected": "reject", + "actualFailure": "WRAPPER-STREAM: empty selector", + "exceptionType": "System.Management.Automation.RuntimeException", + "fullyQualifiedErrorId": "WRAPPER-STREAM: empty selector", + "driverExit": 0 + }, + { + "id": "wrapper-boundary-controlids-unknown", + "mode": "boundary", + "expected": "reject", + "actualFailure": "WRAPPER-STREAM: unknown selector __unknown__", + "exceptionType": "System.Management.Automation.RuntimeException", + "fullyQualifiedErrorId": "WRAPPER-STREAM: unknown selector __unknown__", + "driverExit": 0 + }, + { + "id": "wrapper-boundary-controlids-duplicate", + "mode": "boundary", + "expected": "reject", + "actualFailure": "WRAPPER-STREAM: duplicate selector", + "exceptionType": "System.Management.Automation.RuntimeException", + "fullyQualifiedErrorId": "WRAPPER-STREAM: duplicate selector", + "driverExit": 0 + }, + { + "id": "wrapper-boundary-kind-missing", + "mode": "boundary", + "expected": "reject", + "actualFailure": "STREAM: wrapper Kind is required", + "exceptionType": "System.Management.Automation.RuntimeException", + "fullyQualifiedErrorId": "STREAM: wrapper Kind is required", + "driverExit": 0 + }, + { + "id": "wrapper-boundary-kind-empty", + "mode": "boundary", + "expected": "reject", + "actualFailure": "Cannot validate argument on parameter 'Kind'. The argument \"\" does not belong to the set \"focused,full,integrity,dependencies,claims,checks\" specified by the ValidateSet attribute. Supply an argument that is in the set and then try the command again.", + "exceptionType": "System.Management.Automation.ParameterBindingValidationException", + "fullyQualifiedErrorId": "ParameterArgumentValidationError,run_owned.ps1", + "driverExit": 0 + }, + { + "id": "wrapper-boundary-kind-unknown", + "mode": "boundary", + "expected": "reject", + "actualFailure": "Cannot validate argument on parameter 'Kind'. The argument \"__unknown__\" does not belong to the set \"focused,full,integrity,dependencies,claims,checks\" specified by the ValidateSet attribute. Supply an argument that is in the set and then try the command again.", + "exceptionType": "System.Management.Automation.ParameterBindingValidationException", + "fullyQualifiedErrorId": "ParameterArgumentValidationError,run_owned.ps1", + "driverExit": 0 + }, + { + "id": "wrapper-focused-observed-mixed-holdout", + "mode": "component", + "expected": "reject", + "actualFailure": "STREAM: wrapper-observed-focused-extra-stdout stderr differs" + } + ], + "immutableInputsUnchanged": true + }, + "oldReproduction": { + "receipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\repair-r2\\old-reproduction-a3c583930b944c11a2b8b3e1f48c566d\\actual-outer-diagnostic-9e1222ab76c34ab1b5fd39eaeb8a674c\\RECEIPT.json", + "bytes": 4455, + "sha256": "5A148AA0AF4FE33785D17F71A06F4C853D968036056459F7495DD907AAA018AC" + }, + "identity": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\repair-r2\\old-reproduction-a3c583930b944c11a2b8b3e1f48c566d\\IDENTITY.json", + "bytes": 2072, + "sha256": "BD9B60028CEFDCCE90590B98227E646A173F1890BDF369517BB3182843C01C60" + }, + "historicalReceipt": { + "path": "C:\\Users\\poin\\Documents\\RMQ\\lifecycle-implementation-20260920\\native-p0-r1-review\\actual-outer-diagnostic-68bbac4f331c4ff5b154e4c68e983681\\RECEIPT.json", + "bytes": 4331, + "sha256": "D47623CC4480AD592093871D59224ED8DB3B33B5E34D65C64F3BBD08BF7C83F7" + }, + "actualHarnessExit": 0, + "cases": [ + { + "id": "intact-success", + "nativeExit": 0, + "runnerExit": 0, + "harnessAccepted": true, + "stderr": [ + "UNEXPECTED OUTER DIAGNOSTIC" + ] + }, + { + "id": "intact-stage-error", + "nativeExit": 7, + "runnerExit": 1, + "harnessAccepted": true, + "stderr": [ + "UNEXPECTED OUTER DIAGNOSTIC", + "PROCESS: fixture-stage actual child or launcher exit differs from 0" + ] + } + ], + "meaning": "Old harness still accepted; never relabeled rejected." + }, + "success": true, + "distinctPins": 1938, + "pinOccurrences": 2931, + "seconds": 4.69, + "fixturePinBoundary": "Native successful-run captures are rehashed. Mutated/restored control summaries contribute only immutable summary/raw-stage/capture evidence, never stale fixture-source/map hashes from their capturedPins inventory.", + "status": "Local diagnostic certification evidence; coordinator acceptance, consuming adapter and campaign audit remain separate.", + "fullLedger": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\repair-r2\\SOURCE_RESULTS.json", + "bytes": 620359, + "sha256": "7F9855A6781CDD9A9CBABE6B34C4679030B46E1D07C18FC7683F884D8F4E3F95" + }, + "compactProjection": "All collector facts retained; only the top-level per-file pin array is held in the hash-bound fullLedger.", + "supplementalEvidence": { + "record": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\repair-r2\\SUPPLEMENTAL_FINAL_VERIFIED.json", + "bytes": 8411, + "sha256": "B4BDAF2773643F1D507376C9DB095F05D31AEA775A1AD09B224C83764469C352" + }, + "harnessOuter": { + "capture": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\repair-r2\\source-harness\\capture\\CAPTURE.json", + "bytes": 3986, + "sha256": "E2675CB96181815E2A70A2606C239DCAFE935A75722425522CD6708AE5D8FF1A" + }, + "actualExit": 0, + "seconds": 355.183, + "deadlineSeconds": 2400, + "exactFull11Stdout": true, + "emptyStderrAndLauncherRaw": true + }, + "generatedProbeImports": { + "record": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\repair-r2\\PROBE_DEPENDENCIES.json", + "bytes": 793, + "sha256": "94CB1BA6F7B675ABFC355D412DDE595DCD5086A45A11B1E02C73FB50868AB1F9" + }, + "binary": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\lifecycle-native-p0\\runs\\613c019061d14e24982de6651e433cd8\\lifecycle_storage_probe.exe", + "bytes": 7091712, + "sha256": "58D0451DC0A48A78E2885CFD8A2AA86100ADD46435317292F1C7BC99478129F9" + }, + "imports": [ + "ucrtbase.dll", + "KERNEL32.dll", + "icu.dll", + "bcrypt.dll", + "ADVAPI32.dll", + "WS2_32.dll", + "IPHLPAPI.DLL", + "USERENV.dll", + "USER32.dll", + "SHELL32.dll", + "ole32.dll", + "dbghelp.dll" + ], + "delayRva": 0, + "delaySize": 0, + "verification": "Actual protected Get-LNPeImports reparsed the hash-checked generated binary; twelve recorded imports and zero delay metadata matched. OS/dynamic-loading assumptions remain external." + }, + "wrapperOuter": { + "capture": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\repair-r2\\wrapper-final-5b8e1eb2ebd3423db3defcbb7b703f9e\\outer\\CAPTURE.json", + "bytes": 4627, + "sha256": "F56927BF8B6846B00F40C34D222F1AF2673ABC8B88900AB66C93730987973206" + }, + "independentWorkerVerification": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ\\.lake\\repair-r2\\wrapper-final-5b8e1eb2ebd3423db3defcbb7b703f9e\\VERIFIED.json", + "bytes": 2709, + "sha256": "3BE5539A2873C4764895AE513BD6144FE12F6F87B89FF6C0AE2624C15AA40444" + }, + "actualExit": 0, + "seconds": 93.55, + "deadlineSeconds": 1200, + "exactOrdered120PassLines": true, + "emptyStderrAndLauncherRaw": true + } + } +} diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r2/SOURCE_REVIEW.md b/docs/internal/extensions/lifecycle-native-p0/repair-r2/SOURCE_REVIEW.md new file mode 100644 index 00000000..ed9226dc --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r2/SOURCE_REVIEW.md @@ -0,0 +1,68 @@ +# R2 bounded source reviews and dispositions + +These are local read-only/helper reviews, not a fresh-blind audit or coordinator acceptance. All reviewers used the governed worktree, required rmq-proof-sprint skill and actual three-name runtime catalog; preflight passed at governance 7b227c49ef2ec044b702126cc41c9add847eed01. The initial review source was exact base 2307e3ad0739e0e1d9c3f186cdc568631086fddf. Later reviews read the current implementation before source freeze. No reviewer ran a native build or changed protected source. + +## Complete caller/profile inventory + +The profile-review agent inspected the wrapper, native producer catch/finally, integrity/dependency controls, final checks and claim scanner. Exact-base search found no tracked executable caller of run_owned; historical receipts establish its actual certification invocations. Its supported profiles are: + +| Kind/caller | Exact legitimate child output | Exit/diagnostics | +| --- | --- | --- | +| focused -> native -Cases pop-unique | One LIFECYCLE-REPLAY evidence line, then PASS cases=1 selfTest=False | Actual child and launcher exit0; empty stderr | +| full -> native -SelfTest | Evidence line, then PASS cases=23 selfTest=True | Both ordinary exits0; empty stderr | +| integrity -> all15 controls | Ordered fifteen CONTROL PASS lines, then INTEGRITY CONTROLS evidence | Child/launcher exit0; negative fixture diagnostics remain inside their raw captures | +| dependencies -> all19 controls | One DEPENDENCY CONTROLS PASS evidence line | Both exits0; empty stderr | +| claims -> protected strict scanner, complete native subtree and both ledgers | Complete exact source-grounded records, optional zero-hit text, one terminal summary | Both exits0; empty stderr; zero strict failures | +| checks -> successor final checks | Ordered CHECK PASS lines including actual parent-to-commit range, then FINAL CHECKS evidence | Both exits0; empty stderr | +| integrity harness -> derived native runner | Evidence line for every entered fixture; success marker only for intact success | Exact stage diagnostic first, then exact integrity errors; exit0 only for intact success, otherwise1 | +| byte-copy child -> owned launcher | No output on either launcher stream | Actual launcher exit equals its child's ordinary exit; no timeout, overflow or child-error marker | + +The profile reviewer confirmed both independent rosters against historical RESULTS: all15 integrity IDs and all19 dependency IDs match exactly. Cheap component calls on the historical raw capture/spec/exit objects accepted focused, full, integrity and dependencies. Those calls were source/profile compatibility evidence only, not new production-run positives. + +## Diagnostic derivation review + +Production catch emits the original stage failure. Production finally independently emits integrity errors in order, saves its summary and emits its evidence location; only successful final verdict emits PASS. The harness already establishes actual child0/7, exact native bytes, launcher silence, stage count, timeout establishment and cleanup, and the complete expected integrity error set. Those checks remain load-bearing. + +Expected stage text is fixed by the case: exit7 gives the exact PROCESS ordinary-exit mismatch; the established timeout gives the exact bounded-process failure; mixed inner stderr gives the exact DIAGNOSTIC message; partial identity gives the missing-tool path. Malformed output independently requires byte FF, then re-executes strict ReadAllText on those checked bytes to derive the exact runtime exception. The exclusive-lock capture case re-executes Get-FileHash with the same cmdlet, stop preference, owned map path and exclusive file lock. It no longer accepts an arbitrary summary suffix. The reviewer found these runtime-message derivations sound for the declared same-shell execution. + +Expected integrity errors are: changed C-source pin then changed tree for pin/partial; changed map pin for map; changed live baseline for tracked/index/untracked cases; explicit unavailable initial inventory for baseline; exact independently derived artifact-capture failure for the lock case. The outer expected stderr concatenates stage and integrity messages with the platform newline. Raw comparison preserves order, multiplicity, unrelated blank lines and both streams. + +## Findings and implementation dispositions + +1. Base integrity controls check decoded outer arrays inadequately: the generic helper removes empty lines and deletes redirect files. Disposition: use the protected production byte-copy child for actual runner capture. Preserve existing inner checks. A narrow invocation-local retention adapter copies the bottom launcher's raw redirect files at cleanup, then forwards deletion to the actual cmdlet. The global helper and process framework remain unchanged. +2. Base wrapper lacks a mandatory Kind check, allowing an omitted profile to execute an empty action. Disposition: explicit missing/empty rejection before launch. A subsequent review found that case-insensitive ValidateSet/dispatch and case-sensitive predicate disagreed on FULL. Disposition: normalize Kind once before dispatch; the supported canonical profiles stay six. +3. The current shared predicate initially still trusted normalized launcher arrays, permitting a blank-only launcher stream. Disposition: require retained raw launcher stdout/stderr to be exactly empty as well as the existing arrays. Scope-local Remove-Item interception captures only resolved invocation TempRoot redirect suffixes, forwards real cleanup even after copy failure, records retention failures and vanishes on return. The reviewer found this suitably narrow; it does not replace launch, ownership, termination or global commands. +4. The new harness registry initially froze only IDs/order, leaving kind/case/stream/outcome fields mutable. A concrete mutation could turn success-extra-stderr into a positive while retaining a reject label. Disposition: independently derive and check each operational field and actual predicate mapping from the fixed ID contract before execution. Metadata cannot select a weaker experiment. +5. The blank-launcher control initially caught the expected stream error before independently checking ordinary exit and the opposite stream. Blank output plus exit7 could conceal an unrelated failure. Disposition: before accepting rejection, require actual launcher0, no timeout/overflow/retention error, empty decoded arrays, exactly one platform newline in the target raw stream and exactly empty opposite raw stream. These are real launcher-process tests with a synthetic inner capture object; they are not native inner-stage runs. + +Main harness fixture reach was source-reviewed: one injection is inserted in the generated runner stage body before production stage assertions; complete production prefix and catch/finally/verdict suffix are retained. Expected rejection runs the existing restoration finally. A restoration failure changes the caught diagnostic and cannot satisfy the expected exact stream failure. Carrier and fixture status checks add independent restoration evidence. No live candidate or installed tool is mutated. + +## Claims helper review + +The claims-contract worker independently reconstructs all35 policy terms and the attribution pass from protected policy, rg JSON and actual source files. It never uses observed scanner stdout as expected output. It preserves scoped/allowed-path/allowed-line decisions, suppressed allowed-term hit counts, unconditional attribution emission, scanner trimming semantics, and full multiline content. The emitted roster has exact whole records including terminators, exact multiplicities and exact footer. Ripgrep file ordering may vary. Prefix-free tokenization consumes every character without blank suppression or line normalization; ambiguous record boundaries reject. + +Development used a real protected scanner run: 387 hits,268 records,135686 stdout bytes, empty stderr, actual exit0,11.37s. Independent expectation matched. Extra text, blank line, missing record, duplicate record, changed footer and changed marker rejected; reordered whole records accepted. A multiline record retained its internal blank; deleting it rejected. Prefix ambiguity rejected. A first all-pairs/token-loop implementation was slow and allowed to finish naturally; the final matcher uses ordinal-adjacent prefix checks and escaped anchored whole-record tokens with a finite regex timeout. The producing scanner was not rerun merely for the matcher optimization. Final source/report-specific evidence is separate. + +## Successor preservation verifier review + +The contract-verifier worker owns only the successor verifier and evidence collector. The row verifier compares all16 complete eight-column rows with exact initial bytes, all14 inherited base rows and every requirement in the independently pinned commissioning prompt. Missing, duplicate, changed-cell, mojibake, changed requirement, invalid UTF-8, extra-column and reordered mutations reject; unchanged rows accept. + +The development full contract checked3672 protected paths using exact Git checkout filters,1027 distinct historical pins across2066 occurrences,1125 unchanged baseline sources and2910 outside claim paths. Historical source pins resolve to exact immutable Git versions matching receipts, separately from authorized current script edits. It rechecked the old derived-driver delta, full production prefix/suffix and both accepted unexpected-stderr cases. Claim composition pins the unchanged scanner/policy/rg/config and outside bytes; the final completed-report subtree/ledger scan remains a separate mandatory action. The full development command passed in42.377s; rows-only passed in0.243s. These are development identities, not final package certification. + +## Native boundaries and report correction + +The historical dependency control copies zlib1.dll and creates synthetic text measured-link-map-fixture. It does not copy an actual generated map. The successor report must explicitly correct that wording while preserving the old report. Actual generated map capture and final hashing remain separately supported in the protected native producer and retained receipts. + +Conceptually, this repair extends the existing process/measurement/integrity conjunction with a precise predicate on the same outer captured run. It does not alter native ownership, requested-capacity semantics, Lean propositions or the production consuming boundary. Pinned shell behavior, file observations, process ownership, local normal-import interpretation and external OS/dynamic-loading assumptions remain live. The skeptical local question is whether extra, missing, duplicate or cross-stream output changes the actual caller verdict with all other objects/guards held fixed; the versioned registries and final process evidence answer that question. The later compiled consuming adapter, retained allocation proof and joint campaign audit remain explicit downstream work. + +## Final wrapper-control review + +The independent reviewer found two gaps in the newly added test harness, after the production validator source was frozen at c3fcc2e0beb08d090382f56d16dbe9446639164a. First, a real stdout-rejection control could match its expected exception before independently excluding an unrelated stderr diagnostic. Second, claims component controls loaded a named expectation artifact without requiring the precise path/byte/hash pin saved by the actual producing wrapper receipt. Neither finding changes the protected native producer or the shared production stream predicate. + +Disposition: each real wrapper fixture now independently establishes the complete observed stdout and stderr, ordinary child/launcher exits, transport flags and restoration before checking the declared wrapper rejection. A new mixed-output holdout first accepts the explicitly declared stdout change and then rejects an additional stderr line. Claims controls require the producing receipt's expectation pin, exact canonical manifest path, bytes and SHA-256; no alternate reconstruction is substituted. The exact wrapper registry grows from 119 to 120 controls. A second read-only review of the proposed runner and registry confirmed both changes address the reported gaps. Full execution follows the corrected source freeze. + +The independent collector checked all six genuine c3fcc profiles: focused 49.522s, full 188.136s, integrity 533.411s including mutex wait, dependencies 25.864s, checks 24.672s and claims 4.114s. The full native run preserves 23 ordered cases, 65 checks and 58 stages; integrity and dependency results preserve all 15 and 19 original IDs. The collector also checks the new eleven-case harness campaign, immutable old counterexample reproduction, exact raw process objects and their reachable evidence pins. Final checks/claims are regenerated after each source/report freeze because their legitimate rosters depend on the exact committed content. + +Corrected source 4d6f195b306bd1615aced8c7a7cd1db0d48a8d69 passed all 120 wrapper controls in 93.550s under a 1200s owned deadline, with ordinary exit 0, exact complete stdout, empty stderr and restored fixtures/unchanged inputs. Its three real wrapper fixtures had inner exit 0 throughout and actual wrapper exits 0/1/1 for positive/extra-stdout/extra-stderr. The independent full collector then passed in 4.690s with 1938 distinct pins across 2931 occurrences. It also rechecked the harness outer capture and reparsed the generated probe's actual import table. Compact source-phase facts and full raw-ledger pins are retained in RESULTS.json; the completed report's final committed checks/claims and resulting wrapper/collector recertification are indexed by the separate local final certification artifact. + +The final read-only report/results review found no additional acceptance or control-evidence gap. It corrected one description: a relocated derived wrapper changes both repository-root resolution and its focused producing action, while retaining complete capture/verdict code. The report now names both changes. The reviewer confirmed the reported timings, six profile outcomes, eleven/120 control counts, 1938/2931 pin counts, source/package separation, map erratum and deferred boundaries against the actual result evidence. diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r2/START.json b/docs/internal/extensions/lifecycle-native-p0/repair-r2/START.json new file mode 100644 index 00000000..6137e477 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r2/START.json @@ -0,0 +1,24 @@ +{ + "handle": "LIFE-NATIVE-P0-R2", + "worktree": "C:\\Users\\poin\\.codex\\worktrees\\eafd\\RMQ", + "base": "2307e3ad0739e0e1d9c3f186cdc568631086fddf", + "branch": "codex/life-native-p0-r2-outer-diagnostics", + "initialHead": "2307e3ad0739e0e1d9c3f186cdc568631086fddf", + "initialClean": true, + "initialCleanObservedBeforeScaffold": true, + "governance": "7b227c49ef2ec044b702126cc41c9add847eed01", + "runtimeCatalog": [ + "rmq-audit-prompt", + "rmq-coordinator", + "rmq-proof-sprint" + ], + "runtimeCatalogNote": "Coordinator and audit-prompt appear both canonically and in user skill catalog; names deduplicated.", + "requiredSkill": "rmq-proof-sprint", + "preflight": "PASS", + "frozenRowsSha256": "7dbc035076ea9cace20ac735b1aa85b099aef3d5b5b1afe514aba2c0c63e237e", + "prompt": { + "path": "C:\\Users\\poin\\Documents\\RMQ\\lifecycle-implementation-20260920\\LIFE-NATIVE-P0-R2_PROMPT.md", + "bytes": 25782, + "sha256": "7dd65657f4b6b6436fccd02a54dec2fcfdb5584663ec0ede2b56ffd35ede3db6" + } +} diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r2/WRAPPER_STREAM_REGISTRY.json b/docs/internal/extensions/lifecycle-native-p0/repair-r2/WRAPPER_STREAM_REGISTRY.json new file mode 100644 index 00000000..abbf7db1 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r2/WRAPPER_STREAM_REGISTRY.json @@ -0,0 +1,1085 @@ +{ + "schemaVersion": 1, + "controls": [ + { + "id": "wrapper-focused-positive", + "profile": "focused", + "mode": "component", + "mutation": "positive", + "expected": "accept", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-focused-extra-stdout", + "profile": "focused", + "mode": "component", + "mutation": "extra-stdout", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-focused-extra-stderr", + "profile": "focused", + "mode": "component", + "mutation": "extra-stderr", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-focused-blank-stdout", + "profile": "focused", + "mode": "component", + "mutation": "blank-stdout", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-focused-blank-stderr", + "profile": "focused", + "mode": "component", + "mutation": "blank-stderr", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-focused-missing-output", + "profile": "focused", + "mode": "component", + "mutation": "missing-output", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-focused-duplicate-output", + "profile": "focused", + "mode": "component", + "mutation": "duplicate-output", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-focused-misleading-success", + "profile": "focused", + "mode": "component", + "mutation": "misleading-success", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-focused-mixed-streams", + "profile": "focused", + "mode": "component", + "mutation": "mixed-streams", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-focused-wrong-exit", + "profile": "focused", + "mode": "component", + "mutation": "wrong-exit", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-focused-missing-ordinary-exit", + "profile": "focused", + "mode": "component", + "mutation": "missing-ordinary-exit", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-focused-timeout", + "profile": "focused", + "mode": "component", + "mutation": "timeout", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-focused-output-limit", + "profile": "focused", + "mode": "component", + "mutation": "output-limit", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-focused-launcher-blank-stdout", + "profile": "focused", + "mode": "component", + "mutation": "launcher-blank-stdout", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-focused-launcher-blank-stderr", + "profile": "focused", + "mode": "component", + "mutation": "launcher-blank-stderr", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-focused-launcher-output", + "profile": "focused", + "mode": "component", + "mutation": "launcher-output", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-focused-launcher-retention-error", + "profile": "focused", + "mode": "component", + "mutation": "launcher-retention-error", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-focused-missing-launcher-raw", + "profile": "focused", + "mode": "component", + "mutation": "missing-launcher-raw", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-full-positive", + "profile": "full", + "mode": "component", + "mutation": "positive", + "expected": "accept", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-full-extra-stdout", + "profile": "full", + "mode": "component", + "mutation": "extra-stdout", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-full-extra-stderr", + "profile": "full", + "mode": "component", + "mutation": "extra-stderr", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-full-blank-stdout", + "profile": "full", + "mode": "component", + "mutation": "blank-stdout", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-full-blank-stderr", + "profile": "full", + "mode": "component", + "mutation": "blank-stderr", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-full-missing-output", + "profile": "full", + "mode": "component", + "mutation": "missing-output", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-full-duplicate-output", + "profile": "full", + "mode": "component", + "mutation": "duplicate-output", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-full-misleading-success", + "profile": "full", + "mode": "component", + "mutation": "misleading-success", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-full-mixed-streams", + "profile": "full", + "mode": "component", + "mutation": "mixed-streams", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-full-wrong-exit", + "profile": "full", + "mode": "component", + "mutation": "wrong-exit", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-full-missing-ordinary-exit", + "profile": "full", + "mode": "component", + "mutation": "missing-ordinary-exit", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-full-timeout", + "profile": "full", + "mode": "component", + "mutation": "timeout", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-full-output-limit", + "profile": "full", + "mode": "component", + "mutation": "output-limit", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-full-launcher-blank-stdout", + "profile": "full", + "mode": "component", + "mutation": "launcher-blank-stdout", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-full-launcher-blank-stderr", + "profile": "full", + "mode": "component", + "mutation": "launcher-blank-stderr", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-full-launcher-output", + "profile": "full", + "mode": "component", + "mutation": "launcher-output", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-full-launcher-retention-error", + "profile": "full", + "mode": "component", + "mutation": "launcher-retention-error", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-full-missing-launcher-raw", + "profile": "full", + "mode": "component", + "mutation": "missing-launcher-raw", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-integrity-positive", + "profile": "integrity", + "mode": "component", + "mutation": "positive", + "expected": "accept", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-integrity-extra-stdout", + "profile": "integrity", + "mode": "component", + "mutation": "extra-stdout", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-integrity-extra-stderr", + "profile": "integrity", + "mode": "component", + "mutation": "extra-stderr", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-integrity-blank-stdout", + "profile": "integrity", + "mode": "component", + "mutation": "blank-stdout", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-integrity-blank-stderr", + "profile": "integrity", + "mode": "component", + "mutation": "blank-stderr", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-integrity-missing-output", + "profile": "integrity", + "mode": "component", + "mutation": "missing-output", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-integrity-duplicate-output", + "profile": "integrity", + "mode": "component", + "mutation": "duplicate-output", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-integrity-misleading-success", + "profile": "integrity", + "mode": "component", + "mutation": "misleading-success", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-integrity-mixed-streams", + "profile": "integrity", + "mode": "component", + "mutation": "mixed-streams", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-integrity-wrong-exit", + "profile": "integrity", + "mode": "component", + "mutation": "wrong-exit", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-integrity-missing-ordinary-exit", + "profile": "integrity", + "mode": "component", + "mutation": "missing-ordinary-exit", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-integrity-timeout", + "profile": "integrity", + "mode": "component", + "mutation": "timeout", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-integrity-output-limit", + "profile": "integrity", + "mode": "component", + "mutation": "output-limit", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-integrity-launcher-blank-stdout", + "profile": "integrity", + "mode": "component", + "mutation": "launcher-blank-stdout", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-integrity-launcher-blank-stderr", + "profile": "integrity", + "mode": "component", + "mutation": "launcher-blank-stderr", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-integrity-launcher-output", + "profile": "integrity", + "mode": "component", + "mutation": "launcher-output", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-integrity-launcher-retention-error", + "profile": "integrity", + "mode": "component", + "mutation": "launcher-retention-error", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-integrity-missing-launcher-raw", + "profile": "integrity", + "mode": "component", + "mutation": "missing-launcher-raw", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-dependencies-positive", + "profile": "dependencies", + "mode": "component", + "mutation": "positive", + "expected": "accept", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-dependencies-extra-stdout", + "profile": "dependencies", + "mode": "component", + "mutation": "extra-stdout", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-dependencies-extra-stderr", + "profile": "dependencies", + "mode": "component", + "mutation": "extra-stderr", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-dependencies-blank-stdout", + "profile": "dependencies", + "mode": "component", + "mutation": "blank-stdout", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-dependencies-blank-stderr", + "profile": "dependencies", + "mode": "component", + "mutation": "blank-stderr", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-dependencies-missing-output", + "profile": "dependencies", + "mode": "component", + "mutation": "missing-output", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-dependencies-duplicate-output", + "profile": "dependencies", + "mode": "component", + "mutation": "duplicate-output", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-dependencies-misleading-success", + "profile": "dependencies", + "mode": "component", + "mutation": "misleading-success", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-dependencies-mixed-streams", + "profile": "dependencies", + "mode": "component", + "mutation": "mixed-streams", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-dependencies-wrong-exit", + "profile": "dependencies", + "mode": "component", + "mutation": "wrong-exit", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-dependencies-missing-ordinary-exit", + "profile": "dependencies", + "mode": "component", + "mutation": "missing-ordinary-exit", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-dependencies-timeout", + "profile": "dependencies", + "mode": "component", + "mutation": "timeout", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-dependencies-output-limit", + "profile": "dependencies", + "mode": "component", + "mutation": "output-limit", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-dependencies-launcher-blank-stdout", + "profile": "dependencies", + "mode": "component", + "mutation": "launcher-blank-stdout", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-dependencies-launcher-blank-stderr", + "profile": "dependencies", + "mode": "component", + "mutation": "launcher-blank-stderr", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-dependencies-launcher-output", + "profile": "dependencies", + "mode": "component", + "mutation": "launcher-output", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-dependencies-launcher-retention-error", + "profile": "dependencies", + "mode": "component", + "mutation": "launcher-retention-error", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-dependencies-missing-launcher-raw", + "profile": "dependencies", + "mode": "component", + "mutation": "missing-launcher-raw", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-claims-positive", + "profile": "claims", + "mode": "component", + "mutation": "positive", + "expected": "accept", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-claims-extra-stdout", + "profile": "claims", + "mode": "component", + "mutation": "extra-stdout", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-claims-extra-stderr", + "profile": "claims", + "mode": "component", + "mutation": "extra-stderr", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-claims-blank-stdout", + "profile": "claims", + "mode": "component", + "mutation": "blank-stdout", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-claims-blank-stderr", + "profile": "claims", + "mode": "component", + "mutation": "blank-stderr", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-claims-missing-output", + "profile": "claims", + "mode": "component", + "mutation": "missing-output", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-claims-duplicate-output", + "profile": "claims", + "mode": "component", + "mutation": "duplicate-output", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-claims-misleading-success", + "profile": "claims", + "mode": "component", + "mutation": "misleading-success", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-claims-mixed-streams", + "profile": "claims", + "mode": "component", + "mutation": "mixed-streams", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-claims-wrong-exit", + "profile": "claims", + "mode": "component", + "mutation": "wrong-exit", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-claims-missing-ordinary-exit", + "profile": "claims", + "mode": "component", + "mutation": "missing-ordinary-exit", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-claims-timeout", + "profile": "claims", + "mode": "component", + "mutation": "timeout", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-claims-output-limit", + "profile": "claims", + "mode": "component", + "mutation": "output-limit", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-claims-launcher-blank-stdout", + "profile": "claims", + "mode": "component", + "mutation": "launcher-blank-stdout", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-claims-launcher-blank-stderr", + "profile": "claims", + "mode": "component", + "mutation": "launcher-blank-stderr", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-claims-launcher-output", + "profile": "claims", + "mode": "component", + "mutation": "launcher-output", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-claims-launcher-retention-error", + "profile": "claims", + "mode": "component", + "mutation": "launcher-retention-error", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-claims-missing-launcher-raw", + "profile": "claims", + "mode": "component", + "mutation": "missing-launcher-raw", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-checks-positive", + "profile": "checks", + "mode": "component", + "mutation": "positive", + "expected": "accept", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-checks-extra-stdout", + "profile": "checks", + "mode": "component", + "mutation": "extra-stdout", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-checks-extra-stderr", + "profile": "checks", + "mode": "component", + "mutation": "extra-stderr", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-checks-blank-stdout", + "profile": "checks", + "mode": "component", + "mutation": "blank-stdout", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-checks-blank-stderr", + "profile": "checks", + "mode": "component", + "mutation": "blank-stderr", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-checks-missing-output", + "profile": "checks", + "mode": "component", + "mutation": "missing-output", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-checks-duplicate-output", + "profile": "checks", + "mode": "component", + "mutation": "duplicate-output", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-checks-misleading-success", + "profile": "checks", + "mode": "component", + "mutation": "misleading-success", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-checks-mixed-streams", + "profile": "checks", + "mode": "component", + "mutation": "mixed-streams", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-checks-wrong-exit", + "profile": "checks", + "mode": "component", + "mutation": "wrong-exit", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-checks-missing-ordinary-exit", + "profile": "checks", + "mode": "component", + "mutation": "missing-ordinary-exit", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-checks-timeout", + "profile": "checks", + "mode": "component", + "mutation": "timeout", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-checks-output-limit", + "profile": "checks", + "mode": "component", + "mutation": "output-limit", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-checks-launcher-blank-stdout", + "profile": "checks", + "mode": "component", + "mutation": "launcher-blank-stdout", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-checks-launcher-blank-stderr", + "profile": "checks", + "mode": "component", + "mutation": "launcher-blank-stderr", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-checks-launcher-output", + "profile": "checks", + "mode": "component", + "mutation": "launcher-output", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-checks-launcher-retention-error", + "profile": "checks", + "mode": "component", + "mutation": "launcher-retention-error", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-checks-missing-launcher-raw", + "profile": "checks", + "mode": "component", + "mutation": "missing-launcher-raw", + "expected": "reject", + "predicate": "Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-focused-process-positive", + "profile": "focused", + "mode": "process", + "mutation": "positive", + "expected": "accept", + "predicate": "run_owned.ps1 -> Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-focused-process-extra-stdout", + "profile": "focused", + "mode": "process", + "mutation": "extra-stdout", + "expected": "reject", + "predicate": "run_owned.ps1 -> Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-focused-process-extra-stderr", + "profile": "focused", + "mode": "process", + "mutation": "extra-stderr", + "expected": "reject", + "predicate": "run_owned.ps1 -> Assert-LNWrapperCapture", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + }, + { + "id": "wrapper-boundary-controlids-empty-array", + "profile": "boundary", + "mode": "boundary", + "mutation": "controlids-empty-array", + "expected": "reject", + "predicate": "wrapper_stream_controls.ps1 command boundary", + "failureSurface": "Exact exception message, exception type and FullyQualifiedErrorId; no other raw output" + }, + { + "id": "wrapper-boundary-controlids-empty-string", + "profile": "boundary", + "mode": "boundary", + "mutation": "controlids-empty-string", + "expected": "reject", + "predicate": "wrapper_stream_controls.ps1 command boundary", + "failureSurface": "Exact exception message, exception type and FullyQualifiedErrorId; no other raw output" + }, + { + "id": "wrapper-boundary-controlids-whitespace", + "profile": "boundary", + "mode": "boundary", + "mutation": "controlids-whitespace", + "expected": "reject", + "predicate": "wrapper_stream_controls.ps1 command boundary", + "failureSurface": "Exact exception message, exception type and FullyQualifiedErrorId; no other raw output" + }, + { + "id": "wrapper-boundary-controlids-unknown", + "profile": "boundary", + "mode": "boundary", + "mutation": "controlids-unknown", + "expected": "reject", + "predicate": "wrapper_stream_controls.ps1 command boundary", + "failureSurface": "Exact exception message, exception type and FullyQualifiedErrorId; no other raw output" + }, + { + "id": "wrapper-boundary-controlids-duplicate", + "profile": "boundary", + "mode": "boundary", + "mutation": "controlids-duplicate", + "expected": "reject", + "predicate": "wrapper_stream_controls.ps1 command boundary", + "failureSurface": "Exact exception message, exception type and FullyQualifiedErrorId; no other raw output" + }, + { + "id": "wrapper-boundary-kind-missing", + "profile": "boundary", + "mode": "boundary", + "mutation": "kind-missing", + "expected": "reject", + "predicate": "run_owned.ps1 parameter boundary", + "failureSurface": "Exact exception message, exception type and FullyQualifiedErrorId; no other raw output" + }, + { + "id": "wrapper-boundary-kind-empty", + "profile": "boundary", + "mode": "boundary", + "mutation": "kind-empty", + "expected": "reject", + "predicate": "run_owned.ps1 parameter boundary", + "failureSurface": "Exact exception message, exception type and FullyQualifiedErrorId; no other raw output" + }, + { + "id": "wrapper-boundary-kind-unknown", + "profile": "boundary", + "mode": "boundary", + "mutation": "kind-unknown", + "expected": "reject", + "predicate": "run_owned.ps1 parameter boundary", + "failureSurface": "Exact exception message, exception type and FullyQualifiedErrorId; no other raw output" + }, + { + "id": "wrapper-focused-observed-mixed-holdout", + "profile": "focused", + "mode": "component", + "mutation": "observed-mixed-holdout", + "expected": "reject", + "predicate": "Assert-LNOuterCapture same process-observed-stream contract", + "failureSurface": "Get-ExpectedWrapperFailure exact derived string" + } + ] +} \ No newline at end of file diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r2/certify_profiles.ps1 b/docs/internal/extensions/lifecycle-native-p0/repair-r2/certify_profiles.ps1 new file mode 100644 index 00000000..a3479c56 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r2/certify_profiles.ps1 @@ -0,0 +1,33 @@ +param([string]$OutputRoot,[string[]]$Kinds=@('focused','full','integrity','dependencies','checks','claims'),[string]$ExistingManifest) +$ErrorActionPreference='Stop' +# Validate the complete selection before creating output or invoking any profile. +if($PSBoundParameters.ContainsKey('Kinds')){ + if($null -eq $Kinds -or $Kinds.Count -eq 0 -or @($Kinds|Where-Object {[string]::IsNullOrWhiteSpace($_)}).Count){throw 'CERTIFY-SELECTOR: empty'} + $known=[Collections.Generic.HashSet[string]]::new([string[]]@('focused','full','integrity','dependencies','checks','claims'),[StringComparer]::Ordinal) + $seen=[Collections.Generic.HashSet[string]]::new([StringComparer]::Ordinal) + foreach($kind in $Kinds){ + if(-not $known.Contains($kind)){throw 'CERTIFY-SELECTOR: unknown'} + if(-not $seen.Add($kind)){throw 'CERTIFY-SELECTOR: duplicate'} + } +} +$repo=[IO.Path]::GetFullPath((Join-Path $PSScriptRoot '../../../../..')) +if(-not $OutputRoot){$OutputRoot=Join-Path $repo ('.lake/repair-r2/certification-'+[Guid]::NewGuid().ToString('N'))} +[void][IO.Directory]::CreateDirectory($OutputRoot) +$encoding=[Text.UTF8Encoding]::new($false,$true) +$manifest=if($ExistingManifest){[IO.File]::ReadAllText($ExistingManifest,$encoding)|ConvertFrom-Json -AsHashtable}else{@{profiles=@{}}} +$manifestPath=Join-Path $OutputRoot 'PROFILES.json' +$shell=(Get-Process -Id $PID).Path +foreach($kind in $Kinds){ + $out=Join-Path $OutputRoot $kind + if(Test-Path -LiteralPath $out){throw 'certification profile output must be fresh'} + & $shell -NoProfile -File (Join-Path $PSScriptRoot '../repair-r1/run_owned.ps1') -Kind $kind -OutputRoot $out + $actualExit=$LASTEXITCODE + $receiptPath=Join-Path $out 'RECEIPT.json' + $receipt=[IO.File]::ReadAllText($receiptPath,$encoding)|ConvertFrom-Json + if($actualExit -ne 0 -or -not $receipt.streamValidation.validated){throw ('certification profile failed: '+$kind+'; '+$receipt.streamValidation.failure)} + $manifest.profiles[$kind]=$receiptPath + if($kind -ceq 'claims'){$manifest.claimExpectationPath=$receipt.claimExpectation.path} + $manifest.head=(& git -C $repo rev-parse HEAD).Trim() + [IO.File]::WriteAllText($manifestPath,($manifest|ConvertTo-Json -Depth 10),$encoding) + Write-Output ('PROFILE CERTIFIED '+$kind+' manifest='+$manifestPath) +} diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r2/claim_expectations.ps1 b/docs/internal/extensions/lifecycle-native-p0/repair-r2/claim_expectations.ps1 new file mode 100644 index 00000000..f7e6ea23 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r2/claim_expectations.ps1 @@ -0,0 +1,210 @@ +param([switch]$Produce,[string]$RepositoryRoot,[string]$EvidenceRoot) + +# This expectation enumerates protected policy/input facts; it never consumes +# claim_drift_scan.ps1 stdout. Only the fixed run_owned claims profile is covered. +$script:LNClaimExpectationSource=$PSCommandPath + +function Assert-LNClaimStreamExpectation([string]$Actual,[object]$Expectation) { + if($null -eq $Expectation -or $Expectation.Profile -cne 'claims-strict-subtree-ledgers' -or + $Expectation.ExpectedExit -ne 0 -or $Expectation.Stderr -cne ''){throw 'STREAM: invalid claim expectation'} + $footer=[string]$Expectation.Footer + if($footer.Length -eq 0 -or -not $Actual.EndsWith($footer,[StringComparison]::Ordinal)){ + throw 'STREAM: claim footer differs' + } + $remaining=[Collections.Generic.Dictionary[string,int]]::new([StringComparer]::Ordinal) + foreach($item in @($Expectation.Records)) { + $record=[string]$item + if(-not $record.StartsWith('CLAIM-DRIFT[',[StringComparison]::Ordinal) -or + -not $record.EndsWith([Environment]::NewLine,[StringComparison]::Ordinal)){ + throw 'STREAM: malformed expected claim record' + } + if($remaining.ContainsKey($record)){$remaining[$record]++}else{$remaining.Add($record,1)} + } + [string[]]$keys=@($remaining.Keys) + [Array]::Sort($keys,[StringComparer]::Ordinal) + # Prefix-free whole records make tokenization unique, even when source prose + # contains newlines or marker-like text. Ambiguity fails rather than allowing + # arbitrary splitting, trimming, blank suppression or substring matching. + # In ordinal order a proper-prefix pair must have adjacent representatives. + for($i=1;$i -lt $keys.Count;$i++) { + if($keys[$i].StartsWith($keys[$i-1],[StringComparison]::Ordinal)){ + throw 'STREAM: ambiguous expected claim record boundaries' + } + } + $bodyLength=$Actual.Length-$footer.Length + $offset=0 + # Every alternative is Regex.Escape of a complete known record; \G requires + # the next character, so no search can skip unexpected intervening text. + $tokens=if($keys.Count){[regex]::new('\G(?:'+(($keys|ForEach-Object {[regex]::Escape($_)})-join '|')+')', + [Text.RegularExpressions.RegexOptions]::CultureInvariant,[TimeSpan]::FromSeconds(30))}else{$null} + while($offset -lt $bodyLength) { + if($null -eq $tokens){throw 'STREAM: unexpected claim output with empty record roster'} + $match=$tokens.Match($Actual,$offset) + if(-not $match.Success -or $match.Index -ne $offset -or $match.Length -gt ($bodyLength-$offset) -or + $remaining[$match.Value] -le 0){throw ('STREAM: unexpected or duplicate claim record/text at character '+$offset)} + $remaining[$match.Value]-- + $offset+=$match.Length + } + foreach($record in $keys){if($remaining[$record] -ne 0){throw 'STREAM: missing claim record'}} +} + +function Get-LNClaimStreamExpectation([string]$RepositoryRoot) { + $root=[IO.Path]::GetFullPath($RepositoryRoot) + $out=Join-Path $root ('.lake/repair-r2/claim-expectation-'+[Guid]::NewGuid().ToString('N')) + [void][IO.Directory]::CreateDirectory($out) + . (Join-Path $root 'scripts/owned_process_tree.ps1') + . (Join-Path $root 'scripts/packed_native_lifecycle_stream_check.ps1') + $shell=(Get-Process -Id $PID).Path + # The historical scanner subtree pass took 11 s. One 1200 s owned deadline + # bounds all expectation rg children, including initialization and capture. + $capture=Invoke-LNStreamCapture $root $shell @('-NoProfile','-File',$script:LNClaimExpectationSource, + '-Produce','-RepositoryRoot',$root,'-EvidenceRoot',$out) $root (Join-Path $out 'producer') 1200 'claim-expectation' + Assert-LNOuterCapture $capture '' '' 0 'claim-expectation-producer' + $path=Join-Path $out 'EXPECTATION.json' + if(-not [IO.File]::Exists($path)){throw 'STREAM: claim expectation artifact missing'} + $expectation=Read-LNExactStream $path|ConvertFrom-Json + # Validate the expectation's own full-record grammar before caller use. + Assert-LNClaimStreamExpectation ((@($expectation.Records)-join '')+$expectation.Footer) $expectation + $expectation|Add-Member -NotePropertyName EvidencePath -NotePropertyValue $path + $expectation|Add-Member -NotePropertyName EvidenceSha256 -NotePropertyValue (Get-FileHash -LiteralPath $path).Hash + return $expectation +} + +function New-LNClaimStreamExpectation([string]$RepositoryRoot,[string]$EvidenceRoot) { + $ErrorActionPreference='Stop' + $root=[IO.Path]::GetFullPath($RepositoryRoot) + Set-Location -LiteralPath $root + $encoding=[Text.UTF8Encoding]::new($false,$true) + $newline=[Environment]::NewLine + $roots=@('docs/internal/extensions/lifecycle-native-p0','docs/internal/DESIGN_DECISIONS.md','docs/internal/WORKFLOW_DESIGN_DECISIONS.md') + foreach($path in $roots){if(-not (Test-Path -LiteralPath $path)){throw ('claim expectation root missing: '+$path)}} + $policyPath=Join-Path $root 'docs/internal/CLAIM_DRIFT_POLICY.json' + # Match the scanner's host-dependent Get-Content decoding for its policy and + # attribution pass; rg's JSON preserves complete UTF-8 source match records. + $policy=Get-Content -LiteralPath $policyPath -Raw|ConvertFrom-Json + $currentSurface=[string]$policy.currentFactSurfacePathRegex + $termIds=@($policy.terms|ForEach-Object {[string]$_.id}) + if(@($termIds|Sort-Object -Unique).Count -ne $termIds.Count){throw 'duplicate claim policy term IDs'} + foreach($term in @($policy.terms)) { + $scope=[string]$term.scope + if(-not [string]::IsNullOrWhiteSpace($scope) -and + ($scope -cne 'current-fact-surface' -or [string]::IsNullOrWhiteSpace($currentSurface))){throw 'unsupported claim policy scope'} + } + foreach($attribution in @($policy.requiredAttributions)) { + foreach($field in @('id','pathRegex','claimPattern','requiredPattern','status')) { + if([string]::IsNullOrWhiteSpace([string]$attribution.$field)){throw ('claim attribution missing '+$field)} + } + foreach($field in @('pathRegex','claimPattern','requiredPattern')){$null=[regex]::new([string]$attribution.$field)} + } + function Get-ClaimText($Value) { + if($null -ne $Value.text){return [string]$Value.text} + if($null -ne $Value.bytes){return [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String([string]$Value.bytes))} + return '' + } + function Get-ClaimPolicyPath([string]$Path) { + $comparison=if($env:OS -eq 'Windows_NT'){[StringComparison]::OrdinalIgnoreCase}else{[StringComparison]::Ordinal} + try { + $full=if([IO.Path]::IsPathRooted($Path)){[IO.Path]::GetFullPath($Path)}else{[IO.Path]::GetFullPath([IO.Path]::Combine($root,$Path))} + $prefix=$root.TrimEnd([IO.Path]::DirectorySeparatorChar,[IO.Path]::AltDirectorySeparatorChar)+[IO.Path]::DirectorySeparatorChar + if($full.StartsWith($prefix,$comparison)){return ($full.Substring($prefix.Length)-replace '\\','/')} + } catch {} + return ($Path-replace '\\','/') + } + $rg=@(Get-Command rg -CommandType Application -ErrorAction Stop) + if($rg.Count -ne 1){throw 'claim expectation requires one resolved rg executable'} + $rgPath=[string]$rg[0].Source + $runner=Join-Path $root 'scripts/packed_native_lifecycle_storage_replay.ps1' + $runnerSource=[IO.File]::ReadAllText($runner,$encoding) + $rawChildMatch=[regex]::Match($runnerSource,"(?s)\`$taskChildScript = @'\r?\n(.*?)\r?\n'@") + if(-not $rawChildMatch.Success){throw 'claim expectation raw child missing'} + $rawChild=Join-Path $EvidenceRoot 'rg-raw-child.ps1' + [IO.File]::WriteAllText($rawChild,$rawChildMatch.Groups[1].Value,$encoding) + $release=Join-Path $EvidenceRoot 'rg.release' + [IO.File]::WriteAllText($release,'released inside already owned producer',$encoding) + $records=[Collections.Generic.List[string]]::new() + $captures=[Collections.Generic.List[object]]::new() + $hits=0;$failures=0;$ordinal=0 + foreach($term in @($policy.terms)) { + $ordinal++ + $arguments=@('--json','--pcre2') + if($term.multiline -eq $true){$arguments+='--multiline'} + $arguments+=@('--glob','!**/audit_reports/**','--glob','!**/*WORKLOG.md','--',[string]$term.pattern)+$roots + $stage=Join-Path $EvidenceRoot ('rg-'+$ordinal.ToString('00')) + [void][IO.Directory]::CreateDirectory($stage) + $spec=@{file=$rgPath;arguments=$arguments;cwd=$root;environment=@{};stdout=(Join-Path $stage 'stdout.log'); + stderr=(Join-Path $stage 'stderr.log');exit=(Join-Path $stage 'exit.json');pid=(Join-Path $stage 'pid'); + error=(Join-Path $stage 'error');overflow=(Join-Path $stage 'overflow');outputLimit=16777216} + $specPath=Join-Path $stage 'spec.json' + [IO.File]::WriteAllText($specPath,($spec|ConvertTo-Json -Depth 8),$encoding) + # The producer is already inside the outer bounded job. Reuse the protected + # byte-copy child inline so all rg descendants inherit that same ownership. + & $rawChild -SpecPath $specPath -LaunchReleasePath $release + $code=$LASTEXITCODE + if([IO.File]::Exists($spec.error) -or [IO.File]::Exists($spec.overflow) -or -not [IO.File]::Exists($spec.exit)){ + throw ('claim expectation incomplete rg capture for '+$term.id) + } + $actual=[IO.File]::ReadAllText($spec.exit,$encoding)|ConvertFrom-Json + $stdout=[IO.File]::ReadAllText($spec.stdout,$encoding) + $stderr=[IO.File]::ReadAllText($spec.stderr,$encoding) + if($code -notin @(0,1) -or $actual.exitCode -ne $code -or $stderr -cne ''){throw ('claim expectation rg diagnostic/exit for '+$term.id)} + $pins=@($spec.stdout,$spec.stderr,$spec.exit,$specPath)|ForEach-Object {@{path=$_;bytes=([IO.FileInfo]$_).Length;sha256=(Get-FileHash -LiteralPath $_).Hash}} + $captures.Add(@{id=$term.id;actual=$actual;raw=@($pins)}) + # rg JSONL has one terminal LF and no blank records. Do not silently remove + # interior blank lines, malformed JSON, or unrelated output. + if(-not $stdout.EndsWith("`n",[StringComparison]::Ordinal)){throw ('claim expectation missing rg JSON terminator for '+$term.id)} + foreach($jsonLine in [regex]::Split($stdout.Substring(0,$stdout.Length-1),'\r?\n')) { + if($jsonLine.Length -eq 0){throw 'claim expectation empty rg JSON record'} + $record=$jsonLine|ConvertFrom-Json -ErrorAction Stop + if($record.type -notin @('begin','match','end','summary')){throw 'claim expectation unknown rg JSON record'} + if($record.type -ne 'match'){continue} + $file=Get-ClaimText $record.data.path + $fileNorm=Get-ClaimPolicyPath $file + $line=Get-ClaimText $record.data.lines + $policyLine=$line.TrimEnd([char[]]"`r`n") + $hits++ + $allowed=([string]$term.scope -eq 'current-fact-surface' -and $fileNorm -notmatch $currentSurface) -or + ($term.allowedPathRegex -and $fileNorm -match [string]$term.allowedPathRegex) -or + ($term.allowedLineRegex -and $policyLine -match [string]$term.allowedLineRegex) -or + ($term.allowedPathLinePathRegex -and $term.allowedPathLineRegex -and + $fileNorm -match [string]$term.allowedPathLinePathRegex -and $policyLine -match [string]$term.allowedPathLineRegex) + foreach($pair in @($term.allowedPathLinePairs)) { + if($pair.pathRegex -and $pair.lineRegex -and $fileNorm -match [string]$pair.pathRegex -and $policyLine -match [string]$pair.lineRegex){$allowed=$true;break} + } + $label=if($allowed){'allowed'}elseif($term.strict -eq $true){$failures++;'fail'}else{'review'} + if($label -cne 'allowed') { + $records.Add(('CLAIM-DRIFT[{0}][{1}][{2}] {3}:{4}: {5}' -f $term.id,$term.status,$label,$file,[string]$record.data.line_number,$line.Trim())+$newline) + } + } + } + $files=@(foreach($path in $roots){$item=Get-Item -LiteralPath $path;if($item.PSIsContainer){Get-ChildItem -LiteralPath $item.FullName -Recurse -File}else{$item}}) + $files=@($files|Where-Object {$_.FullName -notmatch '[\\/]audit_reports[\\/]' -and $_.Name -notmatch 'WORKLOG\.md$'}|Sort-Object FullName -Unique) + foreach($attribution in @($policy.requiredAttributions)) { + foreach($file in $files) { + $fileNorm=Get-ClaimPolicyPath $file.FullName + if($fileNorm -notmatch [string]$attribution.pathRegex){continue} + $content=Get-Content -LiteralPath $file.FullName -Raw + $claim=[regex]::Match($content,[string]$attribution.claimPattern) + if(-not $claim.Success){continue} + $hits++ + $present=[regex]::IsMatch($content,[string]$attribution.requiredPattern) + $label=if($present){'allowed'}elseif($attribution.strict -eq $true){$failures++;'fail'}else{'review'} + $lineNo=if($claim.Index -le 0){1}else{1+([regex]::Matches($content.Substring(0,$claim.Index),"`n")).Count} + $summary=if($present){'strong claim has its required theorem identity'}else{'strong claim is missing required theorem identity'} + $records.Add(('CLAIM-DRIFT[{0}][{1}][{2}] {3}:{4}: {5}' -f $attribution.id,$attribution.status,$label,$fileNorm,$lineNo,$summary)+$newline) + } + } + if($failures -ne 0){throw ('claim expectation strict failures: '+$failures)} + $footer=if($hits -eq 0){'CLAIM-DRIFT: no sensitive terms found'+$newline}else{''} + $footer+='CLAIM-DRIFT: scan complete ('+$hits+' hits, 0 strict failures)'+$newline + $sourcePins=@($script:LNClaimExpectationSource,(Join-Path $root 'scripts/claim_drift_scan.ps1'),$policyPath,$runner,$rgPath)|ForEach-Object {@{path=$_;bytes=([IO.FileInfo]$_).Length;sha256=(Get-FileHash -LiteralPath $_).Hash}} + return [ordered]@{Profile='claims-strict-subtree-ledgers';Records=@($records.ToArray());Footer=$footer;Stderr='';ExpectedExit=0; + Hits=$hits;StrictFailures=$failures;Roots=$roots;PolicyVersion=$policy.version;SourcePins=@($sourcePins);RipgrepConfigPath=$env:RIPGREP_CONFIG_PATH; + Captures=@($captures.ToArray());Ordering='Exact prefix-free whole-record multiset; no byte normalization within records; exact final footer.'} +} + +if($Produce) { + $ErrorActionPreference='Stop' + $value=New-LNClaimStreamExpectation $RepositoryRoot $EvidenceRoot + [IO.File]::WriteAllText((Join-Path $EvidenceRoot 'EXPECTATION.json'),($value|ConvertTo-Json -Depth 16),[Text.UTF8Encoding]::new($false,$true)) + exit 0 +} diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r2/freeze_contract.py b/docs/internal/extensions/lifecycle-native-p0/repair-r2/freeze_contract.py new file mode 100644 index 00000000..ff9aac13 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r2/freeze_contract.py @@ -0,0 +1,57 @@ +"""One-time exact-base freeze, before diagnostic implementation edits.""" +import hashlib +import json +import pathlib +import re +import subprocess + +ROOT = pathlib.Path(__file__).resolve().parents[5] +OUT = pathlib.Path(__file__).resolve().parent +BASE = '2307e3ad0739e0e1d9c3f186cdc568631086fddf' +PROMPT = pathlib.Path('C:/Users/poin/Documents/RMQ/lifecycle-implementation-20260920/LIFE-NATIVE-P0-R2_PROMPT.md') + +def git(*args): + return subprocess.check_output(['git', '-c', 'core.excludesfile=', '-C', str(ROOT), *args]) + +assert git('rev-parse', 'HEAD').decode().strip() == BASE +assert git('branch', '--show-current').decode().strip() == 'codex/life-native-p0-r2-outer-diagnostics' +assert not git('diff', '--name-only') and not git('diff', '--cached', '--name-only') +prompt = PROMPT.read_bytes() +requirements = dict(re.findall(r'^- ([A-Z0-9-]+): (.+)$', '\n'.join(prompt.decode('utf-8-sig').splitlines()), re.M)) +raw = git('show', BASE + ':docs/internal/extensions/lifecycle-native-p0/repair-r1/ACCEPTANCE_MATRIX.md') +raw.decode('utf-8', errors='strict') +rows = [r for r in raw.splitlines() if r.startswith(b'| `')] +assert len(rows) == 14 +for row in rows: + cells = row.split(b'|') + assert len(cells) == 10 + key = cells[1].strip().strip(b'`').decode() + assert cells[2].strip().decode() == requirements[key], key +for key in ('NP0R2-STREAMS', 'NP0R2-REPORT'): + rows.append(f'| `{key}` | {requirements[key]} | Narrow outer diagnostic repair | Exact production stream and exit predicates with replayable controls | Actual owned child capture -> caller-used validator -> certification verdict | Legitimate profiles plus extra, missing, duplicate, mixed and misleading output | Pending; append evidence | Open at freeze |'.encode()) +frozen = b'\n'.join(rows) + b'\n' +for name in ('ACCEPTANCE_ROWS.txt', 'ACCEPTANCE_MATRIX.md', 'START.json'): + assert not (OUT / name).exists(), name +(OUT / 'ACCEPTANCE_ROWS.txt').write_bytes(frozen) +header = b'# LIFE-NATIVE-P0-R2 frozen acceptance matrix\n\nThe fourteen inherited eight-column rows retain exact base bytes and historical pending cells. Evidence is append-only.\n\n| ID | Exact frozen requirement | Scope | Evidence needed (exact proposition/check) | Named consumer and identity/composition chain | Anti-vacuity challenge attempted and outcome | Evidence obtained | Status / residual gap |\n| --- | --- | --- | --- | --- | --- | --- | --- |\n' +plan = ''' +## Target and verification plan + +Join: reviewed native diagnostic prerequisite feeds the later consuming adapter; formal/native aggregate, blind audit and acceptance remain coordinator-owned. Hard obligation: actual outer stdout/stderr/exit objects must satisfy the same precise caller predicate used by positive and negative controls. Inner production semantics/finally/provenance are protected. No Lean/C/ABI, installed tool, old evidence or live candidate mutation is permitted. + +Development: exact base/scope/row/prompt checks; immutable old two-case reproduction (prior 60 s, 300 s guard); focused legitimate and real extra-stream cases plus component holdouts. Final-required: fifteen integrity controls (prior 467 s, 2400 s outer), full native SelfTest 23/65/58 (prior 178 s, 1200 s), nineteen dependency controls (prior 49 s, 1200 s), focused native selection, every wrapper profile positive and new exact stream registry. Serialize expensive work using Local\\RMQLifecycleImplementationHeavy20260920; preserve 120/30/8 s fixture/stage/timeout limits. Complete raw streams/exits, cleanup and fixture restoration are evidence. + +Final certification: successor contract and strict UTF-8 frozen-row mutations, hygiene/native-decision scans, working/range whitespace, exact-base and each-commit strict design, clean identity, report claim coverage. Claims may compose verified original complete coverage with a final unchanged-policy subtree/both-ledger scan only after outside bytes/scanner/policy/rg/config verification (prior subtree 11 s, 1200 s; full fallback prior 2212 s, 7200 s). Historical source hashes bind exact Git objects, current hashes bind current working bytes. Conditional build skipped if protected Lean/C/lake/toolchain and baseline evidence verify. No campaign aggregate slot. Stop only at target closure, precise obstruction, external blocker or explicit redirection. +'''.encode() +(OUT / 'ACCEPTANCE_MATRIX.md').write_bytes(header + frozen + plan) +start = dict(handle='LIFE-NATIVE-P0-R2', worktree=str(ROOT), base=BASE, + branch=git('branch', '--show-current').decode().strip(), initialHead=BASE, + initialClean=True, initialCleanObservedBeforeScaffold=True, + governance='7b227c49ef2ec044b702126cc41c9add847eed01', + runtimeCatalog=['rmq-audit-prompt', 'rmq-coordinator', 'rmq-proof-sprint'], + runtimeCatalogNote='Coordinator and audit-prompt appear both canonically and in user skill catalog; names deduplicated.', + requiredSkill='rmq-proof-sprint', preflight='PASS', + frozenRowsSha256=hashlib.sha256(frozen).hexdigest(), + prompt=dict(path=str(PROMPT), bytes=len(prompt), sha256=hashlib.sha256(prompt).hexdigest())) +(OUT / 'START.json').write_text(json.dumps(start, indent=2) + '\n', encoding='utf-8') +print('FROZEN: 16 complete rows; 14 exact-base rows; all 16 requirements match commissioning prompt') diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r2/harness_stream_controls.ps1 b/docs/internal/extensions/lifecycle-native-p0/repair-r2/harness_stream_controls.ps1 new file mode 100644 index 00000000..4bfc46e3 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r2/harness_stream_controls.ps1 @@ -0,0 +1,222 @@ +param([string]$OutputRoot,[AllowEmptyCollection()][AllowEmptyString()][string[]]$ControlIds) +$ErrorActionPreference='Stop' +Set-StrictMode -Version Latest +$repo=[IO.Path]::GetFullPath((Join-Path $PSScriptRoot '../../../../..')) +$utf8=[Text.UTF8Encoding]::new($false,$true) +$registryPath=Join-Path $PSScriptRoot 'HARNESS_STREAM_REGISTRY.json' +$registry=[IO.File]::ReadAllText($registryPath,$utf8)|ConvertFrom-Json +$expectedIds=@('success-positive','error-positive','success-extra-stderr','error-extra-stderr','success-extra-stdout','error-extra-stdout','selector-empty','selector-unknown','selector-duplicate','launcher-blank-stdout','launcher-blank-stderr') +if((@($registry.controls.id)-join ',') -cne ($expectedIds-join ',') -or @($registry.controls.id|Select-Object -Unique).Count -ne $expectedIds.Count){throw 'STREAM-REGISTRY: ordered IDs differ'} +foreach($row in $registry.controls){ + $id=[string]$row.id + $kind=if($id.StartsWith('selector-')){'selector'}elseif($id.StartsWith('launcher-')){'launcher'}else{'harness'} + $stream=if($kind -ceq 'selector'){$id.Substring(9)}elseif($id.EndsWith('stderr')){'stderr'}elseif($id.EndsWith('stdout')){'stdout'}else{'none'} + $outcome=if($id.EndsWith('-positive')){'accept'}else{'reject'} + if($row.kind -cne $kind -or $row.stream -cne $stream -or $row.outcome -cne $outcome){throw 'STREAM-REGISTRY: field mapping differs'} + if($kind -ceq 'harness'){ + $nativeCase=if($id.StartsWith('success-')){'intact-success'}else{'intact-stage-error'} + if($row.case -cne $nativeCase){throw 'STREAM-REGISTRY: fixture mapping differs'} + } + $predicate=if($kind -ceq 'selector'){'command-selector'}else{'Assert-LNOuterCapture'} + if($row.predicate -cne $predicate){throw 'STREAM-REGISTRY: predicate mapping differs'} +} +if($PSBoundParameters.ContainsKey('ControlIds')){ + if(-not $ControlIds.Count -or @($ControlIds|Where-Object {[string]::IsNullOrWhiteSpace($_)}).Count){throw 'STREAM-SELECTOR: empty'} + if(@($ControlIds|Select-Object -Unique).Count -ne $ControlIds.Count){throw 'STREAM-SELECTOR: duplicate'} + foreach($id in $ControlIds){if($id -cnotin $expectedIds){throw 'STREAM-SELECTOR: unknown'}} + $cases=@($registry.controls|Where-Object {$_.id -cin $ControlIds}) +}else{$cases=@($registry.controls)} +if(-not $OutputRoot){$OutputRoot=Join-Path $repo ('.lake/repair-r2/harness-'+[Guid]::NewGuid().ToString('N'))} +[void][IO.Directory]::CreateDirectory($OutputRoot) +# LIFE-1-R3: once OutputRoot exists, every exit path writes RESULTS.json. Every +# live source this harness reads or copies into a carrier is pinned at entry and +# re-checked in finally, and every created carrier/fixture is status-checked in +# finally; the stage error, every integrity difference and every cleanup error +# are recorded separately. +$sourcePath=Join-Path $repo 'docs/internal/extensions/lifecycle-native-p0/repair-r1/integrity_controls.ps1' +$livePaths=@('docs/internal/extensions/lifecycle-native-p0/repair-r2/HARNESS_STREAM_REGISTRY.json', + 'docs/internal/extensions/lifecycle-native-p0/repair-r1/integrity_controls.ps1', + 'scripts/packed_native_lifecycle_storage_replay.ps1','scripts/packed_native_lifecycle_integrity_check.ps1','scripts/owned_process_tree.ps1', + 'scripts/packed_native_lifecycle_stream_check.ps1','native/packed-rmq/tests/lifecycle_storage_probe.c','lean-toolchain', + 'docs/internal/extensions/lifecycle-native-p0/REGISTRY.json') +$entryPins=[ordered]@{} +$ownedRoots=[Collections.Generic.List[object]]::new() +$records=[Collections.Generic.List[object]]::new() +$mutex=$null +$held=$false +$stageError=$null;$stageRecord=$null;$completed=$false +$integrityErrors=[Collections.Generic.List[string]]::new() +$cleanupErrors=[Collections.Generic.List[string]]::new() +$pinChecks=[Collections.Generic.List[object]]::new() +$finalPins=[ordered]@{} +$ownedStatus=[Collections.Generic.List[object]]::new() +$durableFailed=$false +try { + . (Join-Path $repo 'scripts/owned_process_tree.ps1') + . (Join-Path $repo 'scripts/packed_native_lifecycle_stream_check.ps1') + . (Join-Path $repo 'scripts/packed_native_lifecycle_integrity_check.ps1') + $shell=(Get-Process -Id $PID).Path + foreach($relative in $livePaths){$entryPins[$relative]=Get-LNRawPin (Join-Path $repo $relative)} + $source=[IO.File]::ReadAllText($sourcePath,$utf8) + $mutex=[Threading.Mutex]::new($false,'Local\RMQLifecycleImplementationHeavy20260920') + try{$held=$mutex.WaitOne(600000)}catch [Threading.AbandonedMutexException]{$held=$true} + if(-not $held){throw 'host mutex unavailable'} + foreach($case in $cases){ + $out=Join-Path $OutputRoot $case.id + [void][IO.Directory]::CreateDirectory($out) + $driver=Join-Path $out 'driver.ps1' + $expectedExit=0;$expectedError='';$carrier=$null + if($case.kind -ceq 'harness'){ + # The immutable source carrier contains exact current owned source bytes; + # all operations and mutations occur in its ignored fixture directories. + $carrier=Join-Path $out 'source' + [void][IO.Directory]::CreateDirectory($carrier) + $paths=@('scripts/packed_native_lifecycle_storage_replay.ps1','scripts/packed_native_lifecycle_integrity_check.ps1','scripts/owned_process_tree.ps1','scripts/packed_native_lifecycle_stream_check.ps1','native/packed-rmq/tests/lifecycle_storage_probe.c','lean-toolchain','docs/internal/extensions/lifecycle-native-p0/REGISTRY.json') + foreach($relative in $paths){$dest=Join-Path $carrier $relative;[void][IO.Directory]::CreateDirectory((Split-Path $dest -Parent));[IO.File]::WriteAllBytes($dest,[IO.File]::ReadAllBytes((Join-Path $repo $relative)))} + [IO.File]::WriteAllText((Join-Path $carrier '.gitignore'),".lake/`n",$utf8) + & git -C $carrier init -q + & git -C $carrier config core.autocrlf false + & git -C $carrier -c core.excludesfile= add --all + & git -C $carrier -c user.name=RMQFixture -c user.email=fixture@invalid commit -qm source-carrier + if($LASTEXITCODE){throw 'carrier initialization failed'} + $ownedRoots.Add([ordered]@{carrier=$carrier;fixture=(Join-Path (Join-Path $carrier '.lake/controls') $case.case)}) + $rootLine='$repo=[IO.Path]::GetFullPath((Join-Path $PSScriptRoot ''../../../../..''))' + if([regex]::Matches($source,[regex]::Escape($rootLine)).Count -ne 1){throw 'source root anchor differs'} + $derived=$source.Replace($rootLine,('$repo='''+$carrier.Replace("'","''")+'''')) + if($case.stream -cne 'none'){ + $anchor=[regex]::Matches($derived,'(?m)^ \$mutation\r?$') + if($anchor.Count -ne 1){throw 'injection anchor differs'} + $target=if($case.stream -ceq 'stderr'){'Error'}else{'Out'} + $derived=$derived.Insert($anchor[0].Index,(" [Console]::"+$target+".WriteLine('UNEXPECTED OUTER DIAGNOSTIC')`n")) + $expectedExit=1;$expectedError='STREAM: integrity-'+$case.case+' '+$case.stream+' differs' + } + $harness=Join-Path $out 'harness-derived.ps1';[IO.File]::WriteAllText($harness,$derived,$utf8) + $controlOutput=Join-Path $carrier '.lake/controls' + $action="& '"+$harness.Replace("'","''")+"' -OutputRoot '"+$controlOutput.Replace("'","''")+"' -ControlIds '"+$case.case+"'" + }elseif($case.kind -ceq 'selector'){ + $argument=switch($case.id){'selector-empty'{"@('')"}'selector-unknown'{"@('unknown')"}'selector-duplicate'{"@('success-positive','success-positive')"}} + $action="& '"+$PSCommandPath.Replace("'","''")+"' -ControlIds "+$argument + $expectedExit=1;$expectedError='STREAM-SELECTOR: '+$case.stream + }else{ + # Execute a real release-gated launcher that emits only an unexpected blank. + $target=if($case.stream -ceq 'stdout'){'Out'}else{'Error'} + $child=Join-Path $out 'blank-launcher.ps1' + [IO.File]::WriteAllText($child,("param([string]`$LaunchReleasePath)`nwhile(-not [IO.File]::Exists(`$LaunchReleasePath)){Start-Sleep -Milliseconds 10}`n[Console]::"+$target+".WriteLine('')`nexit 0"),$utf8) + $launch=Invoke-LNRetainedLauncher -FilePath $shell -Arguments @('-NoProfile','-File',$child) -WorkingDirectory $repo -Stage $case.id -DeadlineSeconds 30 -OutputLimitBytes 8388608 -TempRoot (Join-Path $out 'launcher') -ReleaseGatedScript + if($launch.ExitCode -ne 0 -or $launch.TimedOut -or $launch.OutputLimitExceeded -or @($launch.RetentionErrors).Count -or @($launch.StandardOutput).Count -or @($launch.StandardError).Count){throw 'unexpected blank-launcher transport/exit/decoded output'} + $blankOut=if($case.stream -ceq 'stdout'){[Environment]::NewLine}else{''} + $blankErr=if($case.stream -ceq 'stderr'){[Environment]::NewLine}else{''} + Assert-LNExactStreamText (Read-LNExactStream $launch.RawStandardOutput) $blankOut 'observed blank-launcher stdout' + Assert-LNExactStreamText (Read-LNExactStream $launch.RawStandardError) $blankErr 'observed blank-launcher stderr' + $rawOut=Join-Path $out 'stdout';$rawErr=Join-Path $out 'stderr';[IO.File]::WriteAllText($rawOut,'');[IO.File]::WriteAllText($rawErr,'') + $capture=@{launcher=$launch;actual=@{exitCode=0};spec=@{stdout=$rawOut;stderr=$rawErr;error=(Join-Path $out 'absent-error');overflow=(Join-Path $out 'absent-overflow')}} + $failure=$null + try {Assert-LNOuterCapture $capture '' '' 0 $case.id}catch{$failure=$_.Exception.Message} + $wanted='STREAM: '+$case.id+' launcher '+$case.stream+' differs' + if($failure -cne $wanted){throw ('wrong launcher blank verdict: '+$failure)} + if([IO.File]::ReadAllText($(if($case.stream -ceq 'stdout'){$launch.RawStandardOutput}else{$launch.RawStandardError})) -cne [Environment]::NewLine){throw 'actual blank launcher output missing'} + $records.Add(@{id=$case.id;outcome='reject';surface=$failure;capture=$capture;predicate='Assert-LNOuterCapture';raw=@((Get-LNRawPin $launch.RawStandardOutput),(Get-LNRawPin $launch.RawStandardError))}) + Write-Output ('STREAM CONTROL PASS '+$case.id) + continue + } + [IO.File]::WriteAllText($driver,("`$ErrorActionPreference='Stop'`ntry {"+$action+"`nexit 0}catch{[Console]::Error.WriteLine(`$_.Exception.Message);exit 1}"),$utf8) + $capture=Invoke-LNStreamCapture $repo $shell @('-NoProfile','-File',$driver) $repo (Join-Path $out 'capture') 300 $case.id + $expectedStdout=if($case.kind -ceq 'harness' -and $expectedExit -eq 0){'CONTROL PASS '+$case.case+[Environment]::NewLine+'INTEGRITY CONTROLS evidence='+$controlOutput+[Environment]::NewLine}else{''} + $expectedStderr=if($expectedExit -eq 1){$expectedError+[Environment]::NewLine}else{''} + Assert-LNOuterCapture $capture $expectedStdout $expectedStderr $expectedExit ('control-'+$case.id) + $record=@{id=$case.id;outcome=$case.outcome;surface=$expectedError;capture=$capture;predicate=$case.predicate;raw=@((Get-LNRawPin $driver))} + if($null -ne $carrier){ + $fixture=Join-Path $controlOutput $case.case + $inner=Get-Content -LiteralPath (Join-Path $fixture '.lake/outer/CAPTURE.json') -Raw|ConvertFrom-Json + $summaries=@(Get-ChildItem -LiteralPath (Join-Path $fixture '.lake/lifecycle-native-p0/runs') -Filter SUMMARY.json -Recurse -File) + if($summaries.Count -ne 1){throw 'summary cardinality differs'} + $summary=Get-Content -LiteralPath $summaries[0].FullName -Raw|ConvertFrom-Json + if(-not $summary.integrity.success -or $summary.selected.Count -ne 1 -or $summary.selected[0] -cne 'pop-unique'){throw 'fixture inner guards differ'} + $wantedNative=if($case.case -ceq 'intact-success'){0}else{7};$wantedRunner=if($wantedNative -eq 0){0}else{1} + if($summary.stages[0].child.exitCode -ne $wantedNative -or $inner.actual.exitCode -ne $wantedRunner){throw 'actual inner exits differ'} + $expectedInnerOut='LIFECYCLE-REPLAY evidence='+$summary.runRoot+[Environment]::NewLine + if($wantedRunner -eq 0){$expectedInnerOut+='LIFECYCLE-REPLAY PASS cases=1 selfTest=False'+[Environment]::NewLine} + $expectedInnerErr=if($wantedRunner -eq 1){'PROCESS: fixture-stage actual child or launcher exit differs from 0'+[Environment]::NewLine}else{''} + if($case.stream -ceq 'stdout'){$expectedInnerOut='UNEXPECTED OUTER DIAGNOSTIC'+[Environment]::NewLine+$expectedInnerOut} + if($case.stream -ceq 'stderr'){$expectedInnerErr='UNEXPECTED OUTER DIAGNOSTIC'+[Environment]::NewLine+$expectedInnerErr} + Assert-LNOuterCapture $inner $expectedInnerOut $expectedInnerErr $wantedRunner ('observed-'+$case.id) + foreach($root in @($carrier,$fixture)){ + $status=@(& git -C $root -c core.excludesfile= status --porcelain=v1 --untracked-files=all) + $expectedStatus=if($root -ceq $fixture){'?? existing-untracked.txt'}else{''} + if($LASTEXITCODE -ne 0 -or ($status -join '') -cne $expectedStatus){throw 'owned fixture/carrier restoration differs'} + } + $record.inner=$inner;$record.summary=Get-LNRawPin $summaries[0].FullName + $record.fixtureRestored=$true;$record.carrierUnchanged=$true + $record.raw+=@((Get-LNRawPin $harness),(Get-LNRawPin (Join-Path $fixture 'scripts/packed_native_lifecycle_storage_replay.ps1'))) + } + $records.Add($record) + Write-Output ('STREAM CONTROL PASS '+$case.id) + } + if((@($records.ToArray().id)-join ',') -cne (@($cases.id)-join ',')){throw 'STREAM-REGISTRY: missing/unused executed control'} + $completed=$true +} catch {$stageError=$_.Exception.Message;$stageRecord=$_} +finally { + # Every created carrier and fixture, success or not, is status-checked. LIFE-1-R4: + # each git status runs through the owned-process helper with a positive + # deadline; its exit, streams and timeout are kept, and any failure is an + # integrity error, never a hang or a silent pass. + foreach($owned in $ownedRoots){ + foreach($root in @($owned.carrier,$owned.fixture)){ + if(-not [IO.Directory]::Exists($root)){continue} + $check=[ordered]@{root=$root;exitCode=$null;timedOut=$null;outputLimitExceeded=$null;stdout=@();stderr=@();durationSeconds=$null;deadlineSeconds=60;status='unchecked'} + try { + $gitPath=(Get-Command git -CommandType Application -ErrorAction Stop|Select-Object -First 1).Source + $g=Invoke-RMQOwnedBoundedProcess -FilePath $gitPath -Arguments @('-C',$root,'-c','core.excludesfile=','status','--porcelain=v1','--untracked-files=all') ` + -WorkingDirectory $repo -Stage 'stream-finalization-git-status' -DeadlineSeconds 60 -OutputLimitBytes 1048576 -TempRoot (Join-Path $OutputRoot 'finalization-git') + $check.exitCode=$g.ExitCode;$check.timedOut=$g.TimedOut;$check.outputLimitExceeded=$g.OutputLimitExceeded + $check.stdout=@($g.StandardOutput);$check.stderr=@($g.StandardError);$check.durationSeconds=$g.DurationSeconds + $expectedStatus=if($root -ceq $owned.fixture){'?? existing-untracked.txt'}else{''} + if($g.TimedOut -or $g.OutputLimitExceeded -or $g.ExitCode -ne 0 -or @($g.StandardError).Count -ne 0){ + $check.status='failed' + $integrityErrors.Add('STREAM-INTEGRITY: owned fixture/carrier status failed: '+$root+': git exit '+$g.ExitCode+'; timeout '+$g.TimedOut+'; overflow '+$g.OutputLimitExceeded+'; stderr: '+(@($g.StandardError) -join ' | ')) + } elseif((@($g.StandardOutput) -join '') -cne $expectedStatus){ + $check.status='differs' + $integrityErrors.Add('STREAM-INTEGRITY: owned fixture/carrier restoration differs: '+$root) + } else {$check.status='verified'} + } catch {$check.status='failed';$integrityErrors.Add('STREAM-INTEGRITY: owned fixture/carrier status failed: '+$root+': '+$_.Exception.Message)} + $ownedStatus.Add($check) + } + } + foreach($relative in $livePaths){ + $entry=if($entryPins.Contains($relative)){$entryPins[$relative]}else{$null} + $final=$null;$status='not-captured' + if($null -ne $entry){ + $status='verified' + try { + $final=Get-LNRawPin (Join-Path $repo $relative) + $finalPins[$relative]=$final + if($final.bytes -ne $entry.bytes -or $final.sha256 -cne $entry.sha256){$status='changed';$integrityErrors.Add('INTEGRITY: changed captured pin: '+$entry.path)} + } catch {$status='unreadable-final';$integrityErrors.Add($_.Exception.Message)} + } + $pinChecks.Add([ordered]@{path=$relative;entrySha256=$(if($null -ne $entry){$entry.sha256}else{$null});finalSha256=$(if($null -ne $final){$final.sha256}else{$null});status=$status}) + } + if($held){try{$mutex.ReleaseMutex()}catch{$cleanupErrors.Add('host mutex release: '+$_.Exception.Message)}} + if($null -ne $mutex){try{$mutex.Dispose()}catch{$cleanupErrors.Add('host mutex dispose: '+$_.Exception.Message)}} + $passed=$completed -and $null -eq $stageError -and $integrityErrors.Count -eq 0 -and $cleanupErrors.Count -eq 0 + $finalization=[ordered]@{schema='life1-r3-finalization-v1';verdict=$(if($passed){'pass'}else{'fail'});stageError=$stageError + integrityErrors=@($integrityErrors.ToArray());cleanupErrors=@($cleanupErrors.ToArray());pinChecks=@($pinChecks.ToArray()) + ownedRoots=@($ownedRoots.ToArray());ownedRootStatus=@($ownedStatus.ToArray());entryPinCount=$entryPins.Count;verifiedPinCount=@($pinChecks|Where-Object {$_.status -ceq 'verified'}).Count} + try { + # LIFE-1-R4: entry pins are labelled entry*; `registry`, `source` and + # `validator` keep their eb8e4f25 meaning, the post-run pin observed in + # finalization (null if unreadable). + $result=@{selected=@($cases.id);controls=@($records.ToArray()) + entryRegistry=$(if($entryPins.Contains($livePaths[0])){$entryPins[$livePaths[0]]}else{$null}) + entrySource=$(if($entryPins.Contains($livePaths[1])){$entryPins[$livePaths[1]]}else{$null});entryValidator=$(if($entryPins.Contains($livePaths[5])){$entryPins[$livePaths[5]]}else{$null}) + registry=$(if($finalPins.Contains($livePaths[0])){$finalPins[$livePaths[0]]}else{$null}) + source=$(if($finalPins.Contains($livePaths[1])){$finalPins[$livePaths[1]]}else{$null});validator=$(if($finalPins.Contains($livePaths[5])){$finalPins[$livePaths[5]]}else{$null}) + finalization=$finalization} + [IO.File]::WriteAllText((Join-Path $OutputRoot 'RESULTS.json'),($result|ConvertTo-Json -Depth 40),$utf8) + } catch {$durableFailed=$true;$passed=$false;[Console]::Error.WriteLine('STREAM CONTROLS: durable result write failed: '+$_.Exception.Message)} +} +if(-not $passed){ + foreach($message in @($integrityErrors)+@($cleanupErrors)){[Console]::Error.WriteLine($message)} + if($null -ne $stageRecord){throw $stageRecord} + exit 1 +} +Write-Output ('STREAM CONTROLS evidence='+$OutputRoot) diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r2/reproduce_old.py b/docs/internal/extensions/lifecycle-native-p0/repair-r2/reproduce_old.py new file mode 100644 index 00000000..3b533504 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r2/reproduce_old.py @@ -0,0 +1,41 @@ +"""Replay the immutable old diagnostic counterexample in owned ignored fixtures.""" +import hashlib +import json +import os +import pathlib +import subprocess +import uuid + +ROOT = pathlib.Path(__file__).resolve().parents[5] +BASE = '2307e3ad0739e0e1d9c3f186cdc568631086fddf' +REVIEW = pathlib.Path('C:/Users/poin/Documents/RMQ/lifecycle-implementation-20260920/native-p0-r1-review') +out = ROOT / '.lake/repair-r2' / ('old-reproduction-' + uuid.uuid4().hex) +out.mkdir(parents=True) +carrier = out / 'immutable-source' +carrier.mkdir() +paths = ['scripts/packed_native_lifecycle_storage_replay.ps1', 'scripts/packed_native_lifecycle_integrity_check.ps1', 'scripts/owned_process_tree.ps1', 'native/packed-rmq/tests/lifecycle_storage_probe.c', 'lean-toolchain', 'docs/internal/extensions/lifecycle-native-p0/REGISTRY.json'] +source_pins = [] +for name in paths: + data = subprocess.check_output(['git', '-C', str(ROOT), 'show', BASE + ':' + name]) + path = carrier / name + path.parent.mkdir(parents=True, exist_ok=True) + path.write_bytes(data) + source_pins.append(dict(path=name, bytes=len(data), sha256=hashlib.sha256(data).hexdigest())) +(carrier / '.gitignore').write_text('.lake/\n', encoding='utf-8') +for args in [('init', '-q'), ('config', 'core.autocrlf', 'false'), ('-c', 'core.excludesfile=', 'add', '--all'), ('-c', 'user.name=RMQFixture', '-c', 'user.email=fixture@invalid', 'commit', '-qm', 'immutable exact-base source carrier')]: + subprocess.check_call(['git', '-C', str(carrier), *args], env=dict(os.environ)) +old = subprocess.check_output(['git', '-C', str(ROOT), 'show', BASE + ':docs/internal/extensions/lifecycle-native-p0/repair-r1/integrity_controls.ps1']) +(out / 'old-controls.ps1').write_bytes(old) +source = (REVIEW / 'run_actual_outer_control.ps1').read_text(encoding='utf-8-sig') +source = source.replace("$repo='C:/Users/poin/.codex/worktrees/587c/RMQ'", "$repo='" + carrier.as_posix() + "'") +source = source.replace("$control=Join-Path $repo 'docs/internal/extensions/lifecycle-native-p0/repair-r1/integrity_controls.ps1'", "$control='" + (out / 'old-controls.ps1').as_posix() + "'") +source = source.replace("$held=$mutex.WaitOne(0)", "$held=$mutex.WaitOne(600000)") +source = source.replace("Write-Output 'DEFERRED_MUTEX_BUSY';exit 0", "throw 'host mutex unavailable'") +driver = out / 'replay.ps1' +driver.write_text(source, encoding='utf-8') +receipt = REVIEW / 'actual-outer-diagnostic-68bbac4f331c4ff5b154e4c68e983681/RECEIPT.json' +assert hashlib.sha256(receipt.read_bytes()).hexdigest().upper() == 'D47623CC4480AD592093871D59224ED8DB3B33B5E34D65C64F3BBD08BF7C83F7' +record = dict(base=BASE, immutableSource=str(carrier), sourcePins=source_pins, oldSource=dict(path=str(out/'old-controls.ps1'), bytes=len(old), sha256=hashlib.sha256(old).hexdigest()), historicalReceipt=str(receipt), driver=str(driver), output=str(out)) +(out/'IDENTITY.json').write_text(json.dumps(record, indent=2)+'\n', encoding='utf-8') +print(str(out), flush=True) +raise SystemExit(subprocess.call(['pwsh', '-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', str(driver)], env=dict(os.environ))) diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r2/verify_contract.py b/docs/internal/extensions/lifecycle-native-p0/repair-r2/verify_contract.py new file mode 100644 index 00000000..3bbb81aa --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r2/verify_contract.py @@ -0,0 +1,465 @@ +"""Exact R2 row/scope/history checks. This does not certify the new native runs. + +Historical source pins resolve against named immutable Git objects, never the +successor's intentionally edited working scripts. Raw artifact pins still hash +their actual files. Claim coverage remains a composition until the caller runs +the unchanged-policy scan of the complete native subtree and both ledgers. +""" +import argparse +import hashlib +import json +import os +from pathlib import Path +import re +import shutil +import subprocess +import time + +ROOT = Path(__file__).resolve().parents[5] +OUT = Path(__file__).resolve().parent +BASE = "2307e3ad0739e0e1d9c3f186cdc568631086fddf" +GOVERNANCE = "7b227c49ef2ec044b702126cc41c9add847eed01" +BRANCH = "codex/life-native-p0-r2-outer-diagnostics" +FROZEN_SHA256 = "7DBC035076EA9CACE20AC735B1AA85B099AEF3D5B5B1AFE514ABA2C0C63E237E" +PROMPT_SHA256 = "7DD65657F4B6B6436FCCD02A54DEC2FCFDB5584663EC0EDE2B56FFD35EDE3DB6" +NATIVE = "docs/internal/extensions/lifecycle-native-p0/" +R1 = NATIVE + "repair-r1/" +R2 = NATIVE + "repair-r2/" +LEDGER = "docs/internal/WORKFLOW_DESIGN_DECISIONS.md" +ORIGINAL = "bea5ce75f788c4035031ba81e69d8de36eda3f92" +ORIGINAL_FINAL = "0c873072e84be9e1d65edab1985bcff1d23abef1" +CAMPAIGN = Path("C:/Users/poin/Documents/RMQ/lifecycle-implementation-20260920") +REVIEW = CAMPAIGN / "native-p0-r1-review" +ORIGINAL_ROOT = Path("C:/Users/poin/.codex/worktrees/af4b/RMQ") +R1_ROOT = Path("C:/Users/poin/.codex/worktrees/587c/RMQ") +COUNTER = REVIEW / "actual-outer-diagnostic-68bbac4f331c4ff5b154e4c68e983681" +IDS = ["LN0-01", "LN0-02", "LN0-03", "LN0-04", "LN0-05", "LN0-06", + "INV-SEMANTIC-NONVACUITY", "INV-ORACLE-INDEPENDENCE", + "INV-CATEGORY-SEPARATION", "INV-MUTATION-REPRODUCIBILITY", + "CHK-FINAL", "CHK-SCOPE", "NP0R1-INTEGRITY", "NP0R1-TOOLCHAIN", + "NP0R2-STREAMS", "NP0R2-REPORT"] +ALLOWED = {R1 + "integrity_controls.ps1", R1 + "run_owned.ps1", + R1 + "final_checks.ps1", "scripts/packed_native_lifecycle_stream_check.ps1", + LEDGER} + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def git(*args, input=None): + result = subprocess.run(["git", "-c", "core.excludesfile=", "-C", str(ROOT), + *args], input=input, stdout=subprocess.PIPE, + stderr=subprocess.PIPE, check=False) + require(result.returncode == 0, + "git failed: " + repr(args) + ": " + result.stderr.decode(errors="replace")) + return result.stdout + + +def sha(raw): + return hashlib.sha256(raw).hexdigest().upper() + + +def readj(path): + return json.loads(Path(path).read_text(encoding="utf-8-sig")) + + +def pin(path): + path = Path(path) + digest = hashlib.sha256() + with path.open("rb") as stream: + for chunk in iter(lambda: stream.read(1024 * 1024), b""): + digest.update(chunk) + return {"path": str(path), "bytes": path.stat().st_size, + "sha256": digest.hexdigest().upper()} + + +def blob(path, ref=BASE, filtered=False): + return git("cat-file", "--filters", f"{ref}:{path}") if filtered else git("show", f"{ref}:{path}") + + +def rows(raw): + text = raw.decode("utf-8", errors="strict") + require(not any(token in text for token in ("\u00c2\u00ac", "\u00e2\u20ac", "\ufffd")), + "recognizable mojibake or replacement character") + answer = {} + for line in raw.splitlines(): + if not re.match(rb"^\| `[A-Z][A-Z0-9-]*` \|", line): + continue + cells = line.split(b"|") + require(len(cells) == 10, "eight-column row required") + key = cells[1].strip().strip(b"`").decode("utf-8") + require(key not in answer, "duplicate ID: " + key) + answer[key] = line + return answer + + +def row_context(): + start = readj(OUT / "START.json") + require(start["base"] == start["initialHead"] == BASE, "initial exact base") + require(start["governance"] == GOVERNANCE and start["branch"] == BRANCH, + "initial governance/branch") + require(start["initialClean"] is True and start["preflight"] == "PASS", + "initial clean/preflight evidence") + require(start["runtimeCatalog"] == ["rmq-audit-prompt", "rmq-coordinator", "rmq-proof-sprint"] + and start["requiredSkill"] == "rmq-proof-sprint", "runtime catalog") + prompt_pin = pin(start["prompt"]["path"]) + require(Path(start["prompt"]["path"]).resolve() == (CAMPAIGN / "LIFE-NATIVE-P0-R2_PROMPT.md").resolve(), + "commissioning prompt path changed") + require(prompt_pin["bytes"] == start["prompt"]["bytes"] and + prompt_pin["sha256"] == start["prompt"]["sha256"].upper() == PROMPT_SHA256, "prompt pin changed") + prompt = Path(start["prompt"]["path"]).read_text(encoding="utf-8-sig") + requirements = dict(re.findall(r"^- ([A-Z0-9-]+): (.+)$", "\n".join(prompt.splitlines()), re.M)) + frozen_raw = (OUT / "ACCEPTANCE_ROWS.txt").read_bytes() + require(sha(frozen_raw) == start["frozenRowsSha256"].upper() == FROZEN_SHA256, "initial frozen-row pin changed") + frozen, inherited = rows(frozen_raw), rows(blob(R1 + "ACCEPTANCE_MATRIX.md")) + require(list(frozen) == IDS and list(inherited) == IDS[:14], "initial/base exact ordered IDs") + require(all(frozen[k] == inherited[k] for k in inherited), "initial inherited row bytes changed") + for key in IDS: + require(key in requirements and frozen[key].split(b"|")[2].strip().decode() == requirements[key], + "prompt requirement changed: " + key) + return frozen, inherited, requirements, prompt_pin + + +def verify_rows(raw, context): + frozen, inherited, requirements, _ = context + current = rows(raw) + require(list(current) == IDS, "missing/extra/reordered IDs") + for key in IDS: + require(current[key] == frozen[key], "frozen row bytes changed: " + key) + require(current[key].split(b"|")[2].strip().decode() == requirements[key], + "prompt requirement changed: " + key) + if key in inherited: + require(current[key] == inherited[key], "inherited row bytes changed: " + key) + return current + + +def row_controls(raw, context): + first = context[0][IDS[0]] + require(b"Open at freeze" in raw, "changed-cell control has no mutation target") + tests = { + "missing": raw.replace(first, b"", 1), + "duplicate": raw + b"\n" + first + b"\n", + "changed-cell": raw.replace(b"Open at freeze", b"Closed at freeze", 1), + "mojibake": raw.replace(b"Implement", "\u00c2\u00acImplement".encode(), 1), + "changed-requirement": raw.replace(b"Implement a reproducible probe", b"Implement a label", 1), + "invalid-utf8": raw.replace(b"Implement", b"\xffImplement", 1), + "ninth-column": raw.replace(first, first[:-1] + b" extra |", 1), + "reordered": raw.replace(first, b"", 1) + b"\n" + first + b"\n", + } + outcomes = [] + for name, mutated in tests.items(): + require(mutated != raw, "vacuous row control: " + name) + try: + verify_rows(mutated, context) + except (ValueError, UnicodeError) as error: + outcomes.append({"id": name, "expected": "REJECT", "actual": "REJECT", + "surface": str(error)}) + else: + raise ValueError("negative accepted: " + name) + verify_rows(raw, context) + return [{"id": "unchanged", "expected": "ACCEPT", "actual": "ACCEPT"}] + outcomes + + +def tree(ref): + answer = {} + for row in git("ls-tree", "-rz", ref).split(b"\0"): + if row: + metadata, path = row.split(b"\t", 1) + mode, kind, object_id = metadata.decode().split() + answer[path.decode("utf-8")] = (mode, kind, object_id) + return answer + + +def filtered_blobs(paths): + # One Git subprocess supplies checkout-filtered bytes for all protected paths. + # Git's batch objectsize is the *unfiltered* size, even when --filters grows + # LF into CRLF. Use a fresh framing marker and fail on any collision instead + # of silently truncating filtered content at that unfiltered size. + names = [f"{BASE}:{path} {path}" for path in paths] + marker = ("RMQ_CONTRACT_FRAME_" + sha(os.urandom(32)) + " ").encode() + format_arg = "--batch=" + marker.decode() + "%(objectname) %(objecttype)" + output = git("cat-file", format_arg, "--filters", input=("\n".join(names) + "\n").encode()) + pieces = output.split(marker) + require(pieces[0] == b"" and len(pieces) == len(paths) + 1, "cat-file framing collision/missing path") + for path, piece in zip(paths, pieces[1:]): + header, content = piece.split(b"\n", 1) + require(re.fullmatch(rb"[0-9a-f]{40} blob", header) is not None and content.endswith(b"\n"), + "malformed cat-file response: " + path) + yield path, content[:-1] + + +def verify_scope(): + require(git("branch", "--show-current").decode().strip() == BRANCH, "wrong branch") + git("merge-base", "--is-ancestor", BASE, "HEAD") + git("merge-base", "--is-ancestor", GOVERNANCE, "HEAD") + base_tree, current_tree = tree(BASE), tree("HEAD") + tracked_changes = git("diff", "--name-only", "-z", BASE).decode().split("\0") + untracked = git("ls-files", "--others", "--exclude-standard", "-z").decode().split("\0") + staged = git("diff", "--cached", "--name-only", "-z", BASE).decode().split("\0") + changed = sorted(set(tracked_changes + untracked + staged) - {""}) + require(all(p in ALLOWED or p.startswith(R2) for p in changed), "outside write scope: " + repr(changed)) + protected = [p for p in base_tree if p not in ALLOWED] + for p, content in filtered_blobs(protected): + require(current_tree.get(p) == base_tree[p], "protected committed path changed: " + p) + require((ROOT / p).is_file() and (ROOT / p).read_bytes() == content, + "protected working bytes changed: " + p) + ledger_base = blob(LEDGER) + require(blob(LEDGER, "HEAD").startswith(ledger_base), "committed WDD prefix changed") + require((ROOT / LEDGER).read_bytes().startswith(blob(LEDGER, filtered=True)), "working WDD prefix changed") + def integrity_cases(raw): + blocks = re.findall(rb"(?ms)^\$cases=@\(\n(.*?)^\)\n", raw.replace(b"\r\n", b"\n")) + require(len(blocks) == 1, "unique original integrity registry block") + return blocks[0] + original_cases = integrity_cases(blob(R1 + "integrity_controls.ps1")) + require(integrity_cases((ROOT / (R1 + "integrity_controls.ps1")).read_bytes()) == original_cases, + "original fifteen integrity case definitions changed") + integrity_ids = re.findall(rb"@\{id='([^']+)'", original_cases) + require(len(integrity_ids) == len(set(integrity_ids)) == 15, "original integrity registry cardinality") + # The explicitly permitted old callers may change; all other historical + # reports, receipts, matrices, production/finally/PE/process code are above. + return {"changedPaths": changed, "protectedBasePaths": len(protected), + "workflowLedgerAppendOnly": True, "indexScopeChecked": True, + "unchangedIntegrityCaseDefinitions": [key.decode() for key in integrity_ids], + "checkoutByteRule": "Every protected base working path equals git cat-file --filters BASE:path; committed modes/blobs also equal the exact base."} + + +class HistoricalPins: + def __init__(self): + self.checked = {} + self.occurrences = 0 + self.git_sources = [] + self.source_cache = {} + + def check(self, item): + self.occurrences += 1 + path = Path(item["path"]) + require(path.is_absolute(), "historical pin is not absolute: " + str(path)) + key = str(path.resolve()).lower() + expected = (item["bytes"], item["sha256"].upper()) + if key in self.checked: + require(self.checked[key] == expected, "conflicting historical pin: " + str(path)) + return + historical = None + for root, refs in [(R1_ROOT, [BASE, "fda02922bf9e8c0707b9913013d3c16c80afe7c9", "1811eeb9e2f783cc455e44a618a99af77b0172ed"]), + (ORIGINAL_ROOT, [ORIGINAL_FINAL, ORIGINAL])]: + try: + relative = path.relative_to(root).as_posix() + except ValueError: + continue + if relative.startswith(".lake/"): + break + for ref in refs: + cache_key = (relative, ref) + if cache_key not in self.source_cache: + exists = subprocess.run(["git", "-C", str(ROOT), "cat-file", "-e", f"{ref}:{relative}"], + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL).returncode == 0 + self.source_cache[cache_key] = (blob(relative, ref), blob(relative, ref, True)) if exists else None + source = self.source_cache[cache_key] + if source: + for encoding, raw in zip(["Git blob", "Git checkout filters"], source): + if (len(raw), sha(raw)) == expected: + historical = {"path": str(path), "repositoryPath": relative, "commit": ref, + "representation": encoding, "bytes": expected[0], "sha256": expected[1]} + break + if historical: + break + # A tracked historical source must match an immutable source version. + if any(self.source_cache.get((relative, ref)) for ref in refs): + require(historical is not None, "historical Git source mismatch: " + str(path)) + break + if historical: + self.git_sources.append(historical) + else: + actual = pin(path) + require((actual["bytes"], actual["sha256"]) == expected, "raw artifact pin mismatch: " + str(path)) + self.checked[key] = expected + + def walk(self, obj): + if isinstance(obj, dict): + if all(k in obj for k in ("path", "bytes", "sha256")): + self.check(obj) + for child in obj.values(): + self.walk(child) + elif isinstance(obj, list): + for child in obj: + self.walk(child) + + +def historical_evidence(): + pins = HistoricalPins() + original_review_path = CAMPAIGN / "native-p0-review/IDENTITY_ROWS_PINS.json" + require(pin(original_review_path)["sha256"] == "EDC60E5175DBF15CE0F5AEC42612AC938BADB1A3BE1EB35C8FC5F345FB7C6375", "original reviewed pin index changed") + original_review = readj(original_review_path) + for path, expected in original_review["pins"].items(): + pins.check(dict(path=path, **expected)) + require(len(original_review["pins"]) == 251, "original historical pin inventory changed") + result = json.loads(blob(R1 + "RESULTS.json")) + final_path = R1_ROOT / ".lake/repair-r1/FINAL_CERTIFICATION.json" + require(pin(final_path)["sha256"] == "518192E33E7921CB21B2FC87457FE4F5F445D24E3B9EB37772AA49F34F284427", "R1 final certification changed") + final = readj(final_path) + pins.walk(result); pins.walk(final) + require(final["head"] == BASE, "historical certification candidate") + receipts = {} + for key in ["native", "focused", "integrityControls", "dependencyControls", "sourceChecks"]: + receipt = readj(result[key]["receipt"]["path"]); pins.walk(receipt) + require(receipt["outer"]["ExitCode"] == receipt["actual"]["exitCode"] == 0 and + not receipt["outer"]["TimedOut"] and not receipt["outer"]["OutputLimitExceeded"], + "historical ordinary receipt failure: " + key) + receipts[key] = receipt + native = readj(result["native"]["summary"]["path"]); pins.walk(native) + focused = readj(result["focused"]["summary"]["path"]); pins.walk(focused) + registry = json.loads(blob(NATIVE + "REGISTRY.json")) + original = json.loads(blob(NATIVE + "RESULTS.json")) + require(native["success"] and native["integrity"]["success"] and not native["integrity"]["errors"], "historical native success") + require(native["selected"] == [case["id"] for case in registry["cases"]] and len(native["selected"]) == 23, "historical ordered23 cases") + require([c["id"] for c in native["checks"]] == [c["id"] for c in original["checks"]] and len(native["checks"]) == 65, "historical65 native checks") + require([s["name"] for s in native["stages"]] == [s["name"] for s in result["native"]["stages"]] and len(native["stages"]) == 58, "historical58 stages") + require(len(native["capturedPins"]) == native["integrity"]["checkedPins"] == 616, "historical616 captures") + require(focused["selected"] == ["pop-unique"] and focused["success"] and focused["integrity"]["success"], "historical focused selector") + controls = readj(result["integrityControls"]["results"]["path"]); pins.walk(controls) + require(len(controls["controls"]) == 15 and controls["fixtureRestoration"] and controls["candidateUnchanged"], "historical15 integrity controls/restoration") + for control in controls["controls"]: + summary = readj(control["summary"]["path"]); pins.walk(summary) + expected_out = ["LIFECYCLE-REPLAY evidence=" + summary["runRoot"]] + if summary["success"]: + expected_out.append("LIFECYCLE-REPLAY PASS cases=1 selfTest=False") + expected_err = ([] if summary["failure"] is None else [summary["failure"]]) + summary["integrity"]["errors"] + require(control["outer"]["StandardOutput"] == expected_out and control["outer"]["StandardError"] == expected_err, + "historical recorded streams changed: " + control["id"]) + dependencies = readj(result["dependencyControls"]["results"]["path"]); pins.walk(dependencies) + require(len(dependencies["controls"]) == 19 and dependencies["installedToolsUnchanged"] and dependencies["fixtureRestored"], "historical19 dependency controls/restoration") + require(len(dependencies["closure"]["nodes"]) == 11 and len(dependencies["oldMissing"]) == 4, "historical11-node closure/four omissions") + for key in ["checks", "claims"]: + pins.walk(readj(final["finalChecks"][key]["receipt"]["path"])) + pins.walk(readj(final["finalChecks"]["exactChecks"]["path"])) + counter = verify_counterexample(pins) + return {"originalPins": 251, "distinctVerifiedPins": len(pins.checked), "pinOccurrences": pins.occurrences, + "historicalSourcePins": pins.git_sources, "nativeCases": 23, "nativeChecks": 65, + "nativeStages": 58, "nativeCaptures": 616, "integrityControls": 15, + "dependencyControls": 19, "counterexample": counter} + + +def verify_counterexample(pins): + receipt = pin(COUNTER / "RECEIPT.json") + require(receipt["bytes"] == 4331 and receipt["sha256"] == "D47623CC4480AD592093871D59224ED8DB3B33B5E34D65C64F3BBD08BF7C83F7", "named immutable negative receipt changed") + record = readj(receipt["path"]); controls = readj(COUNTER / "controls-output/RESULTS.json") + pins.walk(record); pins.walk(controls) + require(record["candidate"] == BASE and record["outer"]["ExitCode"] == record["actual"]["exitCode"] == 0 and + not record["outer"]["TimedOut"] and not record["outer"]["OutputLimitExceeded"], "old actual harness did not accept") + def receipt_source(path): + expected = next(p for p in record["pins"] if Path(p["path"]).is_relative_to(R1_ROOT) + and Path(p["path"]).relative_to(R1_ROOT).as_posix() == path) + candidates = [blob(path), blob(path, filtered=True)] + matched = [b for b in candidates if len(b) == expected["bytes"] and sha(b) == expected["sha256"].upper()] + require(bool(matched), "counterexample source representation mismatch: " + path) + return matched[0].decode("utf-8") + original = receipt_source(R1 + "integrity_controls.ps1") + rootline = "$repo=[IO.Path]::GetFullPath((Join-Path $PSScriptRoot '../../../../..'))" + require(original.count(rootline) == 1, "old driver root anchor") + derived = original.replace(rootline, "$repo='C:/Users/poin/.codex/worktrees/587c/RMQ'") + anchors = list(re.finditer(r"(?m)^ \$mutation\r?$", derived)) + require(len(anchors) == 1, "old driver body anchor") + newline = "\r\n" if "\r\n" in derived else "\n" + position = anchors[0].start() + derived = derived[:position] + " [Console]::Error.WriteLine('UNEXPECTED OUTER DIAGNOSTIC')" + newline + derived[position:] + require(derived.encode() == (COUNTER / "controls-derived.ps1").read_bytes(), "old exact driver delta") + production = receipt_source("scripts/packed_native_lifecycle_storage_replay.ps1") + start = production.index(" $LeanRoot = [IO.Path]::GetFullPath($LeanRoot)") + stop = production.rindex(" $taskSuccess = $true") + require([c["id"] for c in controls["controls"]] == ["intact-success", "intact-stage-error"], "old two-case selection") + outcomes = [] + for control in controls["controls"]: + fixture = Path(control["fixtureSource"]["path"]).read_bytes().decode("utf-8") + require(fixture.startswith(production[:start]) and fixture.endswith(production[stop:]), "old production prefix/suffix changed") + summary = readj(control["summary"]["path"]); pins.walk(summary) + require(summary["integrity"]["success"] and summary["integrity"]["errors"] == [] and len(summary["stages"]) == 1, "old counterexample integrity/stage") + code = 0 if control["id"] == "intact-success" else 7 + stage = summary["stages"][0] + require(stage["child"]["exitCode"] == stage["launcher"]["ExitCode"] == code and + stage["stdout"]["bytes"] == stage["stderr"]["bytes"] == 0, "old inner outcomes") + expected = ["UNEXPECTED OUTER DIAGNOSTIC"] + ([] if code == 0 else ["PROCESS: fixture-stage actual child or launcher exit differs from 0"]) + require(control["outer"]["StandardError"] == expected and control["actualExit"] == (0 if code == 0 else 1), "old observed outer anomaly") + outcomes.append({"id": control["id"], "nativeExit": code, "runnerExit": control["actualExit"], + "outerStderr": expected, "historicalHarnessAccepted": True}) + require(controls["fixtureRestoration"] and controls["candidateUnchanged"], "old fixture restoration") + return {"receipt": receipt, "exactOldSourceCommit": BASE, "exactDriverDelta": True, + "completeProductionPrefixSuffix": True, "actualHarnessExit": 0, "cases": outcomes, + "scope": "Reverified immutable actual-process evidence; not a new execution and never relabeled rejected."} + + +def claim_composition(): + provenance_path = ORIGINAL_ROOT / ".lake/lifecycle-native-baseline/source-provenance.json" + context_path = ORIGINAL_ROOT / ".lake/lifecycle-native-p0/checks/default-claim-context.json" + provenance, context = readj(provenance_path), readj(context_path) + actual_tree = tree("HEAD") + require(len(provenance["sources"]) == 1125, "baseline source count") + for source in provenance["sources"]: + path = source["path"] + require(path in actual_tree and actual_tree[path][2] == source["gitBlob"], "baseline Git blob changed: " + path) + require(pin(ROOT / path)["sha256"].lower() == source["sha256"].lower(), "baseline working source changed: " + path) + require(context["scanRoots"] == ["README.md", "artifact", "docs", "paper"] and + context["excludedFinalRescan"] == [NATIVE.rstrip("/"), "docs/internal/DESIGN_DECISIONS.md", LEDGER], "claim scan boundary changed") + files = [ROOT / "README.md"] + [p for directory in ["artifact", "docs", "paper"] for p in (ROOT / directory).rglob("*") if p.is_file()] + live = {p.relative_to(ROOT).as_posix(): p for p in files + if not p.relative_to(ROOT).as_posix().startswith(NATIVE) + and p.relative_to(ROOT).as_posix() not in [LEDGER, "docs/internal/DESIGN_DECISIONS.md"]} + require(set(live) == {e["path"] for e in context["files"]}, "outside claim path set changed") + for expected in context["files"]: + actual = pin(live[expected["path"]]) + require(actual["bytes"] == expected["bytes"] and actual["sha256"] == expected["sha256"], "outside claim bytes changed: " + expected["path"]) + for path, key in [("scripts/claim_drift_scan.ps1", "scannerSha256"), ("docs/internal/CLAIM_DRIFT_POLICY.json", "policySha256")]: + require(pin(ROOT / path)["sha256"] == context[key], "claim dependency changed: " + path) + resolved_rg = shutil.which("rg") + require(resolved_rg and Path(resolved_rg).resolve() == Path(context["ripgrepPath"]).resolve(), "ripgrep path changed") + require(pin(resolved_rg)["sha256"] == context["ripgrepSha256"], "ripgrep bytes changed") + require((os.environ.get("RIPGREP_CONFIG_PATH") or None) == context["ripgrepConfigPath"], "ripgrep config changed") + certification = json.loads(blob(NATIVE + "CERTIFICATION.json")) + full = certification["fullClaims"] + require(full["actualExit"] == 0 and full["strictFailures"] == 0, "historical default-root claims failed") + history = HistoricalPins(); history.walk(full) + full_receipt = readj(full["receipt"]["path"]); history.walk(full_receipt) + require(full_receipt["actualExit"] == full_receipt["result"]["ExitCode"] == 0 and + not full_receipt["result"]["TimedOut"] and not full_receipt["result"]["OutputLimitExceeded"] and + full_receipt["sourceCommit"] == ORIGINAL and full_receipt["command"] == "scripts/claim_drift_scan.ps1 -Strict", + "historical full scan actual command/exit/timeout/overflow") + raw_out = next(p for p in full["rawFiles"] if p["path"].endswith("stdout.log")) + raw_err = next(p for p in full["rawFiles"] if p["path"].endswith("stderr.log")) + require(raw_err["bytes"] == 0 and Path(raw_out["path"]).read_text(encoding="utf-8-sig").splitlines()[-1] == + "CLAIM-DRIFT: scan complete (3479 hits, 0 strict failures)", "historical full scan raw result") + return {"baselineSources": 1125, "outsideClaimPaths": len(live), + "baselineProvenance": pin(provenance_path), "defaultClaimContext": pin(context_path), + "historicalFullScan": full, "scannerPolicyRipgrepConfigUnchanged": True, + "pendingFinalRescan": [NATIVE.rstrip("/"), "docs/internal/DESIGN_DECISIONS.md", LEDGER], + "coverage": "Verified original complete default-root scan plus exact unchanged outside paths. Caller must separately supply final unchanged-policy complete subtree/ledger rescan; this verifier does not claim a new full scan."} + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--output", required=True) + parser.add_argument("--rows-only", action="store_true") + args = parser.parse_args() + started = time.monotonic() + context = row_context(); raw = (OUT / "ACCEPTANCE_MATRIX.md").read_bytes() + verify_rows(raw, context) + result = {"success": True, "mode": "rows-only" if args.rows_only else "full-contract", + "base": BASE, "head": git("rev-parse", "HEAD").decode().strip(), + "worktree": str(ROOT), "rows": IDS, "inheritedRows": IDS[:14], "changedIds": [], + "prompt": context[3], "rowControls": row_controls(raw, context), + "frozenRows": pin(OUT / "ACCEPTANCE_ROWS.txt")} + if not args.rows_only: + result["scope"] = verify_scope() + result["historicalEvidence"] = historical_evidence() + result["claimComposition"] = claim_composition() + result["currentOwnedSources"] = [pin(ROOT / p) for p in sorted(ALLOWED) if (ROOT / p).is_file()] + result["seconds"] = round(time.monotonic() - started, 3) + Path(args.output).write_text(json.dumps(result, indent=2) + "\n", encoding="utf-8") + suffix = "" if args.rows_only else (f", {result['scope']['protectedBasePaths']} protected base paths, " + f"{result['historicalEvidence']['distinctVerifiedPins']} historical pins, " + f"{result['claimComposition']['outsideClaimPaths']} unchanged outside paths") + print(f"CONTRACT PASS: 16 frozen rows, 9 row controls{suffix}") + + +if __name__ == "__main__": + main() diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r2/verify_results.py b/docs/internal/extensions/lifecycle-native-p0/repair-r2/verify_results.py new file mode 100644 index 00000000..586ca781 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r2/verify_results.py @@ -0,0 +1,589 @@ +"""Collect R2 certification facts from complete retained process evidence. + +This collector does not rerun native operations or substitute for the caller-used +PowerShell predicates. It checks their exact recorded inputs, exits, raw bytes, +registries and verdicts. Deliberately changed/restored fixture source pins are +not treated as current-file pins; immutable raw captures are checked separately. +""" +import argparse +from collections import Counter +import hashlib +import json +from pathlib import Path +import re +import subprocess +import time + +ROOT = next(p for p in Path(__file__).resolve().parents if (p / "lean-toolchain").is_file() and (p / "scripts").is_dir()) +HERE = ROOT / "docs/internal/extensions/lifecycle-native-p0/repair-r2" +BASE = "2307e3ad0739e0e1d9c3f186cdc568631086fddf" +NATIVE = "docs/internal/extensions/lifecycle-native-p0/" +PROFILES = ["focused", "full", "integrity", "dependencies", "claims", "checks"] +INTEGRITY_IDS = ["intact-success", "intact-stage-error", "malformed-stdout-intact", + "stage-error-and-pin-change", "stage-error-and-capture-error", "success-and-pin-change", + "mixed-diagnostic-and-pin-change", "timeout-and-pin-change", "success-and-tracked-change", + "success-and-index-change", "success-and-untracked-addition", "success-and-untracked-byte-change", + "success-and-link-map-change", "partial-identity-and-pin-change", "missing-baseline"] +DEPENDENCY_IDS = ["complete-inventory", "bea5ce75-incomplete", "omit-lean.exe", "omit-leanc.exe", + "omit-clang.exe", "omit-ld.lld.exe", "omit-libleanshared.dll", "omit-libInit_shared.dll", + "omit-libclang-cpp.dll", "omit-libLLVM-19.dll", "omit-libc++.dll", "omit-zlib1.dll", + "omit-libleanshared_1.dll", "same-name-wrong-path", "complete-unchanged-finalizer", + "tamper-zlib1.dll", "tamper-link.map", "tamper-manifest-hash", "restored-finalizer"] +HARNESS_IDS = ["success-positive", "error-positive", "success-extra-stderr", "error-extra-stderr", + "success-extra-stdout", "error-extra-stdout", "selector-empty", "selector-unknown", + "selector-duplicate", "launcher-blank-stdout", "launcher-blank-stderr"] +MUTATIONS = ["positive", "extra-stdout", "extra-stderr", "blank-stdout", "blank-stderr", + "missing-output", "duplicate-output", "misleading-success", "mixed-streams", "wrong-exit", + "missing-ordinary-exit", "timeout", "output-limit", "launcher-blank-stdout", + "launcher-blank-stderr", "launcher-output", "launcher-retention-error", "missing-launcher-raw"] +BOUNDARIES = ["controlids-empty-array", "controlids-empty-string", "controlids-whitespace", + "controlids-unknown", "controlids-duplicate", "kind-missing", "kind-empty", "kind-unknown"] +NL = "\r\n" # These receipts are the assigned Windows/PowerShell platform. + + +def need(value, reason): + if not value: + raise ValueError(reason) + + +def readj(path): + return json.loads(Path(path).read_bytes().decode("utf-8-sig")) + + +def raw(path): + return Path(path).read_bytes().decode("utf-8", errors="strict") + + +def git(*args): + result = subprocess.run(["git", "-c", "core.excludesfile=", "-C", str(ROOT), *args], + stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=False) + need(result.returncode == 0, "Git command failed: " + result.stderr.decode(errors="replace")) + return result.stdout + + +class Pins: + def __init__(self): + self.records = {} + self.occurrences = 0 + + def add(self, path, expected=None): + path = Path(path).resolve() + need(path.is_file(), "missing evidence: " + str(path)) + key = str(path).lower(); self.occurrences += 1 + if key not in self.records: + digest = hashlib.sha256() + with path.open("rb") as stream: + for block in iter(lambda: stream.read(1024 * 1024), b""): + digest.update(block) + self.records[key] = {"path": str(path), "bytes": path.stat().st_size, + "sha256": digest.hexdigest().upper()} + result = self.records[key] + if expected is not None: + need(result["bytes"] == expected["bytes"] and result["sha256"] == expected["sha256"].upper(), + "pin mismatch: " + str(path)) + return result + + def walk(self, obj): + # Call only on explicitly immutable evidence objects, not entire mutation + # summaries whose captured source/map hashes describe pre-restoration data. + if isinstance(obj, dict): + if all(k in obj for k in ("path", "bytes", "sha256")): + self.add(obj["path"], obj) + for value in obj.values(): + self.walk(value) + elif isinstance(obj, list): + for value in obj: + self.walk(value) + + +def roster(actual, expected, label, ordered=True): + need(len(actual) == len(set(actual)), label + " duplicate ID") + need(actual == expected if ordered else set(actual) == set(expected), label + " missing/extra/reordered ID") + + +def ordinary(launcher, actual, expected): + need(not launcher["TimedOut"] and not launcher["OutputLimitExceeded"], "incomplete bounded process") + need(actual is not None and type(actual["exitCode"]) is int and type(launcher["ExitCode"]) is int and + actual["exitCode"] == launcher["ExitCode"] == expected, + "actual ordinary exit mismatch") + need(launcher["DeadlineSeconds"] > 0 and launcher["DurationSeconds"] >= 0, "unbounded process") + + +def capture(c, pins, stdout, stderr, exit_code, allow_blank_launcher=None): + pins.walk(c.get("raw", [])) + launch, spec = c["launcher"], c["spec"] + ordinary(launch, c["actual"], exit_code) + need(not launch["StandardOutput"] and not launch["StandardError"] and not launch["RetentionErrors"], + "unexpected launcher output/retention failure") + for key in ["error", "overflow"]: + need(not Path(spec[key]).exists(), "present capture error/overflow") + for key, stream in [("RawStandardOutput", "stdout"), ("RawStandardError", "stderr")]: + pins.add(launch[key]) + need(raw(launch[key]) == (NL if allow_blank_launcher == stream else ""), "raw launcher bytes differ") + pins.add(spec["stdout"]); pins.add(spec["stderr"]) + need(raw(spec["stdout"]) == stdout and raw(spec["stderr"]) == stderr, "actual raw stream contract differs") + if "exit" in spec: + pins.add(spec["exit"]) + need(readj(spec["exit"]) == c["actual"], "ordinary exit artifact differs") + + +def evidence_path(stdout, prefix, root): + lines = stdout.split(NL) + selected = [line[len(prefix):] for line in lines if line.startswith(prefix)] + need(len(selected) == 1, "evidence line cardinality: " + prefix) + path = Path(selected[0]).resolve() + need(path.is_relative_to(root.resolve()), "evidence path escapes declared root") + return path + + +def profile_receipt(kind, path, pins): + receipt_pin = pins.add(path); receipt = readj(path) + need(receipt["kind"] == kind and receipt["streamValidation"]["validated"] is True, + "wrapper profile/production stream verdict") + validation = receipt["streamValidation"] + need(validation["profile"] == kind and validation["expectedStderr"] == "" and validation["expectedExit"] == 0, + "wrapper declared profile contract") + pins.walk(receipt["raw"]) + raw_paths = [str(Path(p["path"]).resolve()).lower() for p in receipt["raw"]] + need(len(raw_paths) == len(set(raw_paths)), "duplicate wrapper raw pin") + specs = [p for p in receipt["raw"] if Path(p["path"]).name == "spec.json"] + need(len(specs) == 1, "one pinned wrapper capture spec required") + spec = readj(specs[0]["path"]) + for p in [spec["stdout"], spec["stderr"], spec["exit"], receipt["outer"]["RawStandardOutput"], receipt["outer"]["RawStandardError"]]: + need(str(Path(p).resolve()).lower() in raw_paths, "unpinned actual capture surface") + c = dict(launcher=receipt["outer"], actual=receipt["actual"], spec=spec) + capture(c, pins, validation["expectedStdout"], "", 0) + return receipt, c, receipt_pin + + +def native_summary(kind, stdout, pins): + path = evidence_path(stdout, "LIFECYCLE-REPLAY evidence=", ROOT / ".lake/lifecycle-native-p0/runs") + summary_pin = pins.add(path / "SUMMARY.json"); s = readj(summary_pin["path"]) + need(Path(s["runRoot"]).resolve() == path and Path(s["repositoryRoot"]).resolve() == ROOT, + "native summary object identity") + need(s["success"] is True and s["failure"] is None and s["integrity"]["attempted"] is True and + s["integrity"]["success"] is True and s["integrity"]["errors"] == [], "native final integrity/verdict") + registry = readj(ROOT / (NATIVE + "REGISTRY.json")) + expected_ids = [c["id"] for c in registry["cases"]] if kind == "full" else ["pop-unique"] + roster(s["selected"], expected_ids, "native selected") + need(stdout == "LIFECYCLE-REPLAY evidence=" + s["runRoot"] + NL + + f"LIFECYCLE-REPLAY PASS cases={len(expected_ids)} selfTest={'True' if kind == 'full' else 'False'}" + NL, + "native exact output") + need(s["integrity"]["checkedPins"] == len(s["capturedPins"]) > 0, "native final captured pin count") + pins.walk(s["capturedPins"]); pins.walk(s["sources"]); pins.walk(s["identity"]) + historical = readj(ROOT / (NATIVE + "repair-r1/RESULTS.json")) + original = readj(ROOT / (NATIVE + "RESULTS.json")) + if kind == "full": + roster([c["id"] for c in s["checks"]], [c["id"] for c in original["checks"]], "native checks") + roster([c["name"] for c in s["stages"]], [c["name"] for c in historical["native"]["stages"]], "native stages") + need(len(s["selected"]) == 23 and len(s["checks"]) == 65 and len(s["stages"]) == 58, + "native23/65/58 counts") + for row in registry["cases"]: + if row["id"] not in expected_ids: + continue + stage = next(c for c in s["stages"] if c["name"] == row["id"]) + ordinary(stage["launcher"], stage["child"], row["expectedExit"]) + need(stage["stderr"]["bytes"] == 0 and not stage["childError"] and not stage["launcherError"] and + not stage["nativeOutputLimitExceeded"], "native operational case diagnostics") + return {"summary": summary_pin, "selected": s["selected"], "checks": len(s["checks"]), + "stages": len(s["stages"]), "capturedPins": len(s["capturedPins"]), "integritySuccess": True} + + +def integrity_results(stdout, pins): + path = evidence_path(stdout, "INTEGRITY CONTROLS evidence=", ROOT / ".lake/repair-r1") + result_pin = pins.add(path / "RESULTS.json"); result = readj(result_pin["path"]) + roster([c["id"] for c in result["controls"]], INTEGRITY_IDS, "integrity15") + need(result["fixtureRestoration"] and result["candidateUnchanged"], "integrity restoration") + need(stdout == "".join("CONTROL PASS " + x + NL for x in INTEGRITY_IDS) + + "INTEGRITY CONTROLS evidence=" + str(path) + NL, "integrity exact stdout") + pins.walk(result["source"]); pins.walk(result["helper"]) + facts = [] + for row in result["controls"]: + pins.walk(row["summary"]); pins.walk(row["fixtureSource"]) + s = readj(row["summary"]["path"]); contract = row["streamContract"] + wanted_integrity = row["id"] in INTEGRITY_IDS[:3] + need(row["expectedIntegrity"] == wanted_integrity and row["expectedSuccess"] == (row["id"] == "intact-success"), + "integrity original case-to-verdict mapping") + need(contract["validated"] is True and s["success"] == row["expectedSuccess"] and + s["integrity"]["success"] == row["expectedIntegrity"] and s["failure"] == row["stageFailure"], + "integrity independent stage/final verdict") + need(s["integrity"]["attempted"] is True and s["integrity"]["checkedPins"] >= 8 and row["integrity"] == s["integrity"], + "integrity attempted finalization and exact reported object") + fixture = Path(row["fixtureSource"]["path"]).parents[1] + pin_cases = ["stage-error-and-pin-change", "success-and-pin-change", "mixed-diagnostic-and-pin-change", + "timeout-and-pin-change", "partial-identity-and-pin-change"] + tree_cases = pin_cases + ["success-and-tracked-change", "success-and-index-change", "success-and-untracked-addition", "success-and-untracked-byte-change"] + errors = [] + if row["id"] in pin_cases: + errors.append("INTEGRITY: changed captured pin: " + str(fixture / "native/packed-rmq/tests/lifecycle_storage_probe.c")) + if row["id"] == "success-and-link-map-change": + errors.append("INTEGRITY: changed captured pin: " + str(Path(s["runRoot"]) / "link.map")) + if row["id"] in tree_cases: errors.append("INTEGRITY: live tracked/index/untracked baseline changed") + if row["id"] == "missing-baseline": errors.append("INTEGRITY: UNCOVERED; initial tree inventory unavailable") + if row["id"] == "stage-error-and-capture-error": + need(len(s["integrity"]["errors"]) == 1 and s["integrity"]["errors"][0].startswith( + "INTEGRITY: artifact capture failed: " + str(Path(s["runRoot"]) / "link.map") + "; "), "runtime-specific locked-map error") + else: + need(Counter(s["integrity"]["errors"]) == Counter(errors), "independent exact integrity error set") + expected_exit = 0 if row["expectedSuccess"] else 1 + expected_out = "LIFECYCLE-REPLAY evidence=" + s["runRoot"] + NL + if row["expectedSuccess"]: + expected_out += "LIFECYCLE-REPLAY PASS cases=1 selfTest=False" + NL + expected_err = ("" if s["failure"] is None else s["failure"] + NL) + "".join(e + NL for e in s["integrity"]["errors"]) + need(contract == dict(expectedStdout=expected_out, expectedStderr=expected_err, + expectedExit=expected_exit, validated=True), "integrity exact stream contract") + capture(row["capture"], pins, expected_out, expected_err, expected_exit) + need(row["actualExit"] == row["outer"]["ExitCode"] == expected_exit, "integrity outer exit") + stem = Path(s["runRoot"]) / "000-fixture-stage" + out_path, err_path = Path(str(stem) + ".stdout"), Path(str(stem) + ".stderr") + pins.add(out_path); pins.add(err_path) + malformed = row["id"] == "malformed-stdout-intact" + timeout = row["id"] == "timeout-and-pin-change" + need(out_path.read_bytes() == (b"\xff" if malformed else b""), "integrity inner stdout") + need(err_path.read_bytes() == (b"unexpected\r\n" if row["id"] == "mixed-diagnostic-and-pin-change" else b""), "integrity inner stderr") + inner_exit = None + if not timeout: + exit_path = Path(str(stem) + ".exit.json"); pins.add(exit_path) + inner_exit = 7 if row["id"] in ["intact-stage-error", "stage-error-and-pin-change", "stage-error-and-capture-error"] else 0 + need(readj(exit_path)["exitCode"] == inner_exit, "integrity real inner ordinary exit") + if not malformed: + need(len(s["stages"]) == 1, "integrity real stage cardinality") + stage = s["stages"][0]; pins.walk(stage) + need(stage["launcher"]["TimedOut"] == timeout and not stage["launcher"]["OutputLimitExceeded"] and + not stage["nativeOutputLimitExceeded"] and not stage["launcherError"] and not stage["childError"], "integrity stage guard") + if not timeout: + ordinary(stage["launcher"], stage["child"], inner_exit) + facts.append(dict(id=row["id"], outerExit=expected_exit, nativeExit=inner_exit, + timeout=timeout, integritySuccess=row["expectedIntegrity"], stageFailure=s["failure"])) + return dict(results=result_pin, controls=facts, fixtureRestoration=True, candidateUnchanged=True) + + +def dependency_results(stdout, pins): + path = evidence_path(stdout, "DEPENDENCY CONTROLS PASS evidence=", ROOT / ".lake/repair-r1") + result_pin = pins.add(path / "RESULTS.json"); r = readj(result_pin["path"]) + roster([c["id"] for c in r["controls"]], DEPENDENCY_IDS, "dependency19", False) + need(r["installedToolsUnchanged"] and r["fixtureRestored"] and len(r["closure"]["nodes"]) == 11, + "dependency closure/restoration") + need(stdout == "DEPENDENCY CONTROLS PASS evidence=" + str(path) + NL, "dependency exact stdout") + pins.walk(r.get("closure", {})); pins.walk(r.get("source", {})); pins.walk(r["pins"]); pins.walk(r["oldSummary"]) + missing = {Path(p).name.lower() for p in r["oldMissing"]} + need(missing == {"libclang-cpp.dll", "libllvm-19.dll", "libc++.dll", "zlib1.dll"}, "measured old omissions") + return dict(results=result_pin, controls=[c["id"] for c in r["controls"]], localNodes=11, + oldMissing=sorted(missing), installedToolsUnchanged=True, fixtureRestored=True) + + +def claim_records(stdout, expectation, pins): + e = readj(expectation); pins.add(expectation); pins.walk(e.get("SourcePins", [])); pins.walk(e.get("Captures", [])) + need(e["Profile"] == "claims-strict-subtree-ledgers" and e["ExpectedExit"] == 0 and + e["Stderr"] == "" and e["StrictFailures"] == 0, "claims expectation contract") + footer = e["Footer"]; need(footer and stdout.endswith(footer), "claim exact footer") + remaining = Counter(e["Records"]); keys = sorted(remaining) + need(all(r.startswith("CLAIM-DRIFT[") and r.endswith(NL) for r in keys), "claim record grammar") + need(not any(keys[i].startswith(keys[i-1]) for i in range(1, len(keys))), "ambiguous claim record prefixes") + body = stdout[:-len(footer)]; offset = 0 + while offset < len(body): + matches = [r for r in keys if body.startswith(r, offset)] + need(len(matches) == 1 and remaining[matches[0]] > 0, "unexpected/duplicate claim record") + remaining[matches[0]] -= 1; offset += len(matches[0]) + need(not any(remaining.values()), "missing claim record") + return dict(expectation=pins.add(expectation), records=len(e["Records"]), hits=e["Hits"], + strictFailures=0, footer=footer.rstrip("\r\n")) + + +def check_results(stdout, pins): + path = evidence_path(stdout, "FINAL CHECKS evidence=", ROOT / ".lake/repair-r1") + result_pin = pins.add(path / "RESULTS.json"); r = readj(result_pin["path"]) + need(r["base"] == BASE, "final checks exact base") + commits = git("rev-list", "--reverse", BASE + ".." + r["head"]).decode().splitlines() + ids = ["contract", "hygiene", "native-decision", "working-whitespace", "range-whitespace", "design-whole"] + ids += ["design-" + c[:12] for c in commits] + ["clean"] + roster([c["name"] for c in r["checks"]], ids, "final check registry") + need(all(c["exit"] == c["expected"] for c in r["checks"]), "failed final check") + need(stdout == "".join("CHECK PASS " + x + NL for x in ids) + "FINAL CHECKS evidence=" + str(path) + NL, "final checks exact stdout") + pins.walk(r.get("pins", [])) + for c in r["checks"]: + pins.add(c["log"]) + return dict(results=result_pin, head=r["head"], checks=ids) + + +def verify_harness(path, pins, complete=True): + result_pin = pins.add(path); r = readj(path); registry = readj(HERE / "HARNESS_STREAM_REGISTRY.json") + roster([c["id"] for c in registry["controls"]], HARNESS_IDS, "harness frozen registry") + ids = [c["id"] for c in r["controls"]] + roster(ids, HARNESS_IDS if complete else r["selected"], "harness executed registry") + need(r["selected"] == ids, "harness selected mapping") + for key in ["registry", "source", "validator"]: + pins.walk(r[key]) + facts = [] + for c in r["controls"]: + row = next(x for x in registry["controls"] if x["id"] == c["id"]) + need(c["outcome"] == row["outcome"] and c["predicate"] == row["predicate"], "harness registry verdict mapping") + pins.walk(c["raw"]) + if row["kind"] == "launcher": + stream = row["stream"] + need(c["surface"] == "STREAM: " + c["id"] + " launcher " + stream + " differs", "launcher exact failure") + capture(c["capture"], pins, "", "", 0, stream) + else: + positive = row["outcome"] == "accept" + expected_error = "" if positive else ("STREAM-SELECTOR: " + row["stream"] if row["kind"] == "selector" + else "STREAM: integrity-" + row["case"] + " " + row["stream"] + " differs") + need(c["surface"] == expected_error, "harness exact failure surface") + stdout = raw(c["capture"]["spec"]["stdout"]) + if positive: + control_root = Path(c["inner"]["spec"]["cwd"]).resolve().parent + need(stdout == "CONTROL PASS " + row["case"] + NL + "INTEGRITY CONTROLS evidence=" + str(control_root) + NL, + "harness exact positive output") + else: + need(stdout == "", "harness rejected stdout") + capture(c["capture"], pins, stdout, "" if positive else expected_error + NL, 0 if positive else 1) + if row["kind"] == "harness": + need(c["fixtureRestored"] and c["carrierUnchanged"], "harness fixture/carrier restoration") + pins.walk(c["summary"]); s = readj(c["summary"]["path"]) + need(s["selected"] == ["pop-unique"] and s["integrity"]["success"] and not s["integrity"]["errors"], "harness inner guards") + native_exit = 0 if row["case"] == "intact-success" else 7; runner_exit = int(native_exit != 0) + need(len(s["stages"]) == 1, "harness one real native stage") + ordinary(s["stages"][0]["launcher"], s["stages"][0]["child"], native_exit) + pins.walk(s["stages"]) + inner_out = "LIFECYCLE-REPLAY evidence=" + s["runRoot"] + NL + if not runner_exit: + inner_out += "LIFECYCLE-REPLAY PASS cases=1 selfTest=False" + NL + inner_err = "PROCESS: fixture-stage actual child or launcher exit differs from 0" + NL if runner_exit else "" + if row["stream"] == "stdout": inner_out = "UNEXPECTED OUTER DIAGNOSTIC" + NL + inner_out + if row["stream"] == "stderr": inner_err = "UNEXPECTED OUTER DIAGNOSTIC" + NL + inner_err + capture(c["inner"], pins, inner_out, inner_err, runner_exit) + facts.append(dict(id=c["id"], outcome=c["outcome"], surface=c["surface"], predicate=c["predicate"])) + return dict(results=result_pin, controls=facts, completeRegistry=complete) + + +def expected_wrapper_failure(profile, mutation, baseline_stdout, snapshot, claim): + if mutation == "positive": return None + if mutation == "observed-mixed-holdout": return "STREAM: wrapper-observed-focused-extra-stdout stderr differs" + prefix = "STREAM: wrapper-" + profile + if mutation in ["extra-stdout", "blank-stdout", "misleading-success"]: + return "STREAM: claim footer differs" if profile == "claims" else prefix + " stdout differs" + if mutation in ["extra-stderr", "blank-stderr", "mixed-streams"]: return prefix + " stderr differs" + if mutation == "missing-output": + return "STREAM: claim footer differs" if profile == "claims" else (prefix + " stdout differs" if profile in ["focused", "full"] else "STREAM: evidence line missing") + if mutation == "duplicate-output": + if profile != "claims": return prefix + " stdout differs" + if not claim["Records"]: return "STREAM: unexpected claim output with empty record roster" + # .NET reports UTF-16 character offsets. + count = len((baseline_stdout[:-len(claim["Footer"])]).encode("utf-16-le")) // 2 + return "STREAM: unexpected or duplicate claim record/text at character " + str(count) + if mutation in ["wrong-exit", "missing-ordinary-exit"]: return prefix + " ordinary exit differs" + if mutation in ["timeout", "output-limit"]: return prefix + " incomplete bounded capture" + if mutation in ["launcher-blank-stdout", "launcher-blank-stderr"]: return prefix + " launcher " + mutation.rsplit("-", 1)[1] + " differs" + if mutation == "launcher-output": return prefix + " launcher output" + if mutation == "launcher-retention-error": return prefix + " launcher retention failed" + if mutation == "missing-launcher-raw": return "STREAM: raw capture missing: " + snapshot["launcher"]["RawStandardOutput"] + raise ValueError("unmapped wrapper mutation") + + +def verify_wrapper_controls(path, manifest, baselines, pins, claim_path, complete=True): + result_pin = pins.add(path); r = readj(path); registry = readj(HERE / "WRAPPER_STREAM_REGISTRY.json") + expected = ["wrapper-" + p + "-" + m for p in PROFILES for m in MUTATIONS] + expected += ["wrapper-focused-process-" + m for m in ["positive", "extra-stdout", "extra-stderr"]] + expected += ["wrapper-boundary-" + m for m in BOUNDARIES] + expected += ["wrapper-focused-observed-mixed-holdout"] + roster([x["id"] for x in registry["controls"]], expected, "wrapper120 registry") + executed = [x["id"] for x in r["controls"]] + roster(executed, expected if complete else r["selected"], "wrapper120 executions") + need(all(key in expected for key in executed), "unknown executed wrapper control") + need(r["success"] is True and r["failure"] is None and r["registryCount"] == 120 and + r["selected"] == executed and r["immutableInputsUnchanged"], "wrapper campaign result") + need(Path(r["profileManifest"]).resolve() == Path(manifest).resolve(), "wrapper manifest identity") + pins.walk(r["sourcePins"]) + claim = readj(claim_path) if any(c["profile"] == "claims" for c in r["controls"]) else {"Records": [], "Footer": ""} + if any(c["profile"] == "claims" for c in r["controls"]): + produced_receipt_path = readj(manifest)["profiles"]["claims"] + produced = readj(produced_receipt_path)["claimExpectation"] + need(r["claimExpectationPin"] == produced and Path(r["claimExpectationSourceReceipt"]).resolve() == Path(produced_receipt_path).resolve(), + "wrapper claims language is not bound to producing receipt") + pins.walk(produced) + facts = [] + for c in r["controls"]: + row = next(item for item in registry["controls"] if item["id"] == c["id"]) + for key in ["id", "profile", "mode", "expected"]: + need(c[key] == row[key], "wrapper registry field mapping") + need(c["passed"] and c["fixtureRestored"] and c["actualFailure"] == c["expectedFailure"], "wrapper exact verdict/restoration") + if c["mode"] == "boundary": + pins.walk(c["raw"]) + specs = [p for p in c["raw"] if Path(p["path"]).name == "BOUNDARY_SPEC.json"] + errors = [p for p in c["raw"] if Path(p["path"]).name == "ERROR.json"] + need(len(specs) == len(errors) == 1, "one real boundary spec/error") + spec, error = readj(specs[0]["path"]), readj(errors[0]["path"]) + need(error == dict(message=c["actualFailure"], type=c["expectedExceptionType"], fqid=c["expectedFullyQualifiedErrorId"]), + "boundary exact observed exception") + need(spec["message"] == error["message"] and spec["type"] == error["type"] and spec["fqid"] == error["fqid"] and spec["id"] == c["id"], + "boundary producer expectation identity") + outer_root = Path(specs[0]["path"]).parent / "outer" + pins.add(outer_root / "CAPTURE.json") + outer = readj(outer_root / "CAPTURE.json") + capture(outer, pins, "BOUNDARY REJECTED " + c["id"] + NL, "", 0) + need(c["actualOuterExit"] == 0 and row["expected"] == "reject", "boundary driver/target outcome separation") + facts.append(dict(id=c["id"], mode="boundary", expected="reject", actualFailure=c["actualFailure"], + exceptionType=error["type"], fullyQualifiedErrorId=error["fqid"], driverExit=0)) + continue + need(Path(c["sourceReceipt"]).resolve() == Path(readj(manifest)["profiles"][c["profile"]]).resolve(), "wrapper baseline receipt identity") + pins.walk(c["raw"]) + baseline = baselines[c["profile"]]; mutation = row["mutation"] + if c["mode"] == "component": + snapshots = [p for p in c["raw"] if Path(p["path"]).name == "CAPTURE.json"] + need(len(snapshots) == 1, "component observed snapshot") + snapshot = readj(snapshots[0]["path"]) + expected_failure = expected_wrapper_failure(c["profile"], mutation, baseline, snapshot, claim) + need(c.get("replayExpectedFailure", c["actualFailure"]) == expected_failure, "component exact replay failure surface") + if mutation == "missing-launcher-raw": + need(not Path(snapshot["launcher"]["RawStandardOutput"]).exists(), "missing launcher mutation absent") + elif mutation == "wrong-exit": need(snapshot["actual"]["exitCode"] == snapshot["launcher"]["ExitCode"] == 99, "wrong exit mutation") + elif mutation == "missing-ordinary-exit": need(snapshot["actual"] is None, "null ordinary exit mutation") + elif mutation == "timeout": need(snapshot["launcher"]["TimedOut"], "timeout mutation") + elif mutation == "output-limit": need(snapshot["launcher"]["OutputLimitExceeded"], "output-limit mutation") + elif mutation == "launcher-retention-error": need(snapshot["launcher"]["RetentionErrors"] == ["injected isolated retention failure"], "retention mutation") + else: + observed_out, observed_err = raw(snapshot["spec"]["stdout"]), raw(snapshot["spec"]["stderr"]) + expected_out, expected_err = baseline, "" + if mutation == "extra-stdout": expected_out += "UNEXPECTED WRAPPER STDOUT" + NL + if mutation == "extra-stderr": expected_err = "UNEXPECTED WRAPPER STDERR" + NL + if mutation == "blank-stdout": expected_out += NL + if mutation == "blank-stderr": expected_err = NL + if mutation == "misleading-success": expected_out += '{"success":true,"validated":true}' + NL + if mutation == "observed-mixed-holdout": + expected_out += "UNEXPECTED WRAPPER STDOUT" + NL + expected_err = "UNRELATED SECOND STDERR DIAGNOSTIC" + NL + need(c["observedStreamContract"] == dict(expectedStdout=expected_out, expectedStderr="", expectedExit=0, + profile="wrapper-observed-focused-extra-stdout", positiveAccepted=True), "mixed holdout same P/Q contract") + if mutation == "duplicate-output": expected_out += baseline + if mutation == "mixed-streams": expected_err = baseline + if mutation == "missing-output": + cut = baseline.rfind(NL, 0, len(baseline) - len(NL)) + expected_out = "" if cut < 0 else baseline[:cut + len(NL)] + need(observed_out == expected_out and observed_err == expected_err, "component challenged byte objects differ") + if mutation.startswith("launcher-blank-"): + key = "RawStandardOutput" if mutation.endswith("stdout") else "RawStandardError" + need(raw(snapshot["launcher"][key]) == NL, "launcher blank retained bytes") + if mutation == "launcher-output": need(snapshot["launcher"]["StandardOutput"] == ["UNEXPECTED LAUNCHER OUTPUT"], "launcher output mutation") + else: + need(c["actualOuterExit"] == (0 if mutation == "positive" else 1) and c["actualInnerExit"] == 0, + "actual wrapper process verdict") + receipts = [p for p in c["raw"] if Path(p["path"]).name == "RECEIPT.json"] + need(len(receipts) == 1, "real wrapper receipt") + receipt = readj(receipts[0]["path"]) + need(receipt["streamValidation"]["validated"] == (mutation == "positive") and + receipt["streamValidation"].get("failure") == c["actualFailure"], "real production wrapper stream verdict") + ordinary(receipt["outer"], receipt["actual"], 0) + need(c["actualFailure"] == expected_wrapper_failure("focused", mutation, baseline, {}, claim), "real wrapper exact failure") + expected_out = baseline + ("UNEXPECTED WRAPPER STDOUT" + NL if mutation == "extra-stdout" else "") + expected_err = "UNEXPECTED WRAPPER STDERR" + NL if mutation == "extra-stderr" else "" + need(c["observedStreamContract"] == dict(expectedStdout=expected_out, expectedStderr=expected_err, expectedExit=0, validated=True), + "real wrapper two-sided observed-stream contract") + wrapper_root = Path(receipts[0]["path"]).parent + inner_spec = readj(wrapper_root / "spec.json") + capture(dict(launcher=receipt["outer"], actual=receipt["actual"], spec=inner_spec), pins, expected_out, expected_err, 0) + outer_root = wrapper_root.parent / "outer" + pins.add(outer_root / "CAPTURE.json"); outer = readj(outer_root / "CAPTURE.json") + capture(outer, pins, "OWNED focused exit=0 evidence=" + str(wrapper_root) + NL, "", 0 if mutation == "positive" else 1) + facts.append(dict(id=c["id"], mode=c["mode"], expected=c["expected"], actualFailure=c["actualFailure"])) + return dict(results=result_pin, count=len(facts), completeRegistry=complete, controls=facts, immutableInputsUnchanged=True) + + +def old_reproduction(path, pins): + path = Path(path).resolve() + if path.is_dir(): + candidates = list(path.rglob("RECEIPT.json")) + candidates = [p for p in candidates if readj(p).get("kind") == "ACTUAL_ADVERSARIAL_CONTROL_HARNESS"] + need(len(candidates) == 1, "one actual immutable old reproduction") + path = candidates[0] + receipt_pin = pins.add(path); r = readj(path); pins.walk(r["pins"]) + need(r["candidate"] == BASE and r["selected"] == ["intact-success", "intact-stage-error"], "old reproduction exact base/selection") + ordinary(r["outer"], r["actual"], 0) + spec = readj(path.parent / "spec.json"); pins.add(path.parent / "spec.json") + expected_out = "CONTROL PASS intact-success" + NL + "CONTROL PASS intact-stage-error" + NL + "INTEGRITY CONTROLS evidence=" + str(path.parent / "controls-output") + NL + need(raw(spec["stdout"]) == expected_out and raw(spec["stderr"]) == "" and readj(spec["exit"]) == r["actual"], "old reproduction actual accepted stdout/exit") + controls_path = path.parent / "controls-output/RESULTS.json"; pins.add(controls_path); c = readj(controls_path) + roster([x["id"] for x in c["controls"]], ["intact-success", "intact-stage-error"], "old two actual controls") + need(c["fixtureRestoration"] and c["candidateUnchanged"], "old reproduction restoration") + identity_path = next((p / "IDENTITY.json" for p in path.parents if (p / "IDENTITY.json").is_file()), None) + need(identity_path is not None, "old reproduction immutable source identity") + identity = readj(identity_path); pins.add(identity_path); pins.walk(identity["oldSource"]) + carrier = Path(identity["immutableSource"]) + for source in identity["sourcePins"]: + data = git("show", BASE + ":" + source["path"]) + need(len(data) == source["bytes"] and hashlib.sha256(data).hexdigest().upper() == source["sha256"].upper(), "old source Git object changed") + pins.add(carrier / source["path"], source) + old = git("show", BASE + ":" + NATIVE + "repair-r1/integrity_controls.ps1") + need(Path(identity["oldSource"]["path"]).read_bytes() == old, "old harness exact Git source") + source = old.decode("utf-8") + rootline = "$repo=[IO.Path]::GetFullPath((Join-Path $PSScriptRoot '../../../../..'))" + need(source.count(rootline) == 1, "old harness unique root anchor") + # The copied coordinator driver substitutes its literal $repo value. Read + # that declared value from the immutable reproduction driver, then bind it + # to the actual carrier instead of normalizing stream/source bytes. + driver_text = raw(identity["driver"]); pins.add(identity["driver"]) + roots = re.findall(r"(?m)^\$repo='([^']+)'\r?$", driver_text) + need(len(roots) == 1 and Path(roots[0]).resolve() == carrier.resolve(), "old reproduction driver source root") + derived = source.replace(rootline, "$repo='" + roots[0] + "'") + anchors = list(re.finditer(r"(?m)^ \$mutation\r?$", derived)); need(len(anchors) == 1, "old harness unique injection anchor") + newline = "\r\n" if "\r\n" in derived else "\n" + at = anchors[0].start(); derived = derived[:at] + " [Console]::Error.WriteLine('UNEXPECTED OUTER DIAGNOSTIC')" + newline + derived[at:] + need((path.parent / "controls-derived.ps1").read_bytes() == derived.encode("utf-8"), "old harness exact derived delta") + production = git("show", BASE + ":scripts/packed_native_lifecycle_storage_replay.ps1").decode("utf-8") + prefix_at = production.index(" $LeanRoot = [IO.Path]::GetFullPath($LeanRoot)") + suffix_at = production.rindex(" $taskSuccess = $true") + historical = pins.add(identity["historicalReceipt"]) + need(historical["bytes"] == 4331 and historical["sha256"] == "D47623CC4480AD592093871D59224ED8DB3B33B5E34D65C64F3BBD08BF7C83F7", "historical coordinator receipt changed") + facts = [] + for row in c["controls"]: + pins.walk(row["summary"]); pins.walk(row["fixtureSource"]) + fixture_source = raw(row["fixtureSource"]["path"]) + need(fixture_source.startswith(production[:prefix_at]) and fixture_source.endswith(production[suffix_at:]), + "old complete production prefix/suffix") + summary = readj(row["summary"]["path"]); pins.walk(summary["stages"]) + native_exit = 0 if row["id"] == "intact-success" else 7 + need(summary["integrity"]["success"] and not summary["integrity"]["errors"] and len(summary["stages"]) == 1, "old counterexample inner integrity") + ordinary(summary["stages"][0]["launcher"], summary["stages"][0]["child"], native_exit) + wanted = ["UNEXPECTED OUTER DIAGNOSTIC"] + ([] if native_exit == 0 else ["PROCESS: fixture-stage actual child or launcher exit differs from 0"]) + need(row["outer"]["StandardError"] == wanted and row["actualExit"] == int(native_exit != 0), "old actual unexpected stderr") + facts.append(dict(id=row["id"], nativeExit=native_exit, runnerExit=row["actualExit"], harnessAccepted=True, stderr=wanted)) + return dict(receipt=receipt_pin, identity=pins.add(identity_path), historicalReceipt=historical, + actualHarnessExit=0, cases=facts, meaning="Old harness still accepted; never relabeled rejected.") + + +def main(): + ap = argparse.ArgumentParser() + for name in ["profiles", "harness", "wrapper-controls", "old-reproduction", "output"]: + ap.add_argument("--" + name, required=True) + args = ap.parse_args(); started = time.monotonic(); pins = Pins() + manifest = readj(args.profiles); pins.add(args.profiles) + need(set(manifest["profiles"]) == set(PROFILES), "exact six supported profiles required") + claim_receipt = readj(manifest["profiles"]["claims"]) + need(isinstance(claim_receipt.get("claimExpectation"), dict), "producing claims receipt must pin its expectation") + pins.walk(claim_receipt["claimExpectation"]) + claim_path = claim_receipt["claimExpectation"]["path"] + if manifest.get("claimExpectationPath"): + need(Path(manifest["claimExpectationPath"]).resolve() == Path(claim_path).resolve(), "manifest claims expectation is not the producing object") + result = {"base": BASE, "head": git("rev-parse", "HEAD").decode().strip(), "worktree": str(ROOT), + "profiles": {}, "verifier": pins.add(__file__)} + baselines = {} + for kind in PROFILES: + receipt, c, receipt_pin = profile_receipt(kind, manifest["profiles"][kind], pins) + stdout = raw(c["spec"]["stdout"]); baselines[kind] = stdout + facts = (native_summary(kind, stdout, pins) if kind in ["focused", "full"] else + integrity_results(stdout, pins) if kind == "integrity" else + dependency_results(stdout, pins) if kind == "dependencies" else + claim_records(stdout, claim_path, pins) if kind == "claims" else check_results(stdout, pins)) + result["profiles"][kind] = dict(receipt=receipt_pin, actualExit=0, seconds=receipt["outer"]["DurationSeconds"], + deadlineSeconds=receipt["outer"]["DeadlineSeconds"], streamValidation=True, facts=facts) + result["harness"] = verify_harness(args.harness, pins) + result["wrapperControls"] = verify_wrapper_controls(args.wrapper_controls, args.profiles, baselines, pins, claim_path) + result["oldReproduction"] = old_reproduction(args.old_reproduction, pins) + result.update(success=True, distinctPins=len(pins.records), pinOccurrences=pins.occurrences, + pins=sorted(pins.records.values(), key=lambda p: p["path"].lower()), seconds=round(time.monotonic() - started, 3), + fixturePinBoundary="Native successful-run captures are rehashed. Mutated/restored control summaries contribute only immutable summary/raw-stage/capture evidence, never stale fixture-source/map hashes from their capturedPins inventory.", + status="Local diagnostic certification evidence; coordinator acceptance, consuming adapter and campaign audit remain separate.") + Path(args.output).write_text(json.dumps(result, indent=2) + "\n", encoding="utf-8") + print(f"RESULTS PASS: six profiles, native23/65/58, integrity15, dependency19, harness11, wrapper120; {len(pins.records)} distinct pins") + + +if __name__ == "__main__": + main() diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r2/wrapper_stream_controls.ps1 b/docs/internal/extensions/lifecycle-native-p0/repair-r2/wrapper_stream_controls.ps1 new file mode 100644 index 00000000..2590b0bb --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r2/wrapper_stream_controls.ps1 @@ -0,0 +1,376 @@ +param([string]$ProfilesPath,[AllowNull()][AllowEmptyCollection()][AllowEmptyString()][string[]]$ControlIds,[string]$OutputRoot) +$ErrorActionPreference='Stop' +$repo=[IO.Path]::GetFullPath((Join-Path $PSScriptRoot '../../../../..')) +$encoding=[Text.UTF8Encoding]::new($false,$true) +$nl=[Environment]::NewLine +$profiles=@('focused','full','integrity','dependencies','claims','checks') +$mutations=@('positive','extra-stdout','extra-stderr','blank-stdout','blank-stderr','missing-output','duplicate-output', + 'misleading-success','mixed-streams','wrong-exit','missing-ordinary-exit','timeout','output-limit', + 'launcher-blank-stdout','launcher-blank-stderr','launcher-output','launcher-retention-error','missing-launcher-raw') +$boundaryMutations=@('controlids-empty-array','controlids-empty-string','controlids-whitespace','controlids-unknown','controlids-duplicate','kind-missing','kind-empty','kind-unknown') +$registryPath=Join-Path $PSScriptRoot 'WRAPPER_STREAM_REGISTRY.json' +$registry=[IO.File]::ReadAllText($registryPath,$encoding)|ConvertFrom-Json +$expectedRows=@(foreach($profile in $profiles){foreach($mutation in $mutations){ + [ordered]@{id=('wrapper-'+$profile+'-'+$mutation);profile=$profile;mode='component';mutation=$mutation; + expected=if($mutation -ceq 'positive'){'accept'}else{'reject'};predicate='Assert-LNWrapperCapture';failureSurface='Get-ExpectedWrapperFailure exact derived string'} +}};foreach($mutation in @('positive','extra-stdout','extra-stderr')){ + [ordered]@{id=('wrapper-focused-process-'+$mutation);profile='focused';mode='process';mutation=$mutation; + expected=if($mutation -ceq 'positive'){'accept'}else{'reject'};predicate='run_owned.ps1 -> Assert-LNWrapperCapture';failureSurface='Get-ExpectedWrapperFailure exact derived string'} +};foreach($mutation in $boundaryMutations){ + [ordered]@{id=('wrapper-boundary-'+$mutation);profile='boundary';mode='boundary';mutation=$mutation;expected='reject'; + predicate=if($mutation.StartsWith('controlids-',[StringComparison]::Ordinal)){'wrapper_stream_controls.ps1 command boundary'}else{'run_owned.ps1 parameter boundary'}; + failureSurface='Exact exception message, exception type and FullyQualifiedErrorId; no other raw output'} +};[ordered]@{id='wrapper-focused-observed-mixed-holdout';profile='focused';mode='component';mutation='observed-mixed-holdout';expected='reject'; + predicate='Assert-LNOuterCapture same process-observed-stream contract';failureSurface='Get-ExpectedWrapperFailure exact derived string'}) +if($registry.schemaVersion -ne 1 -or @($registry.controls).Count -ne $expectedRows.Count){throw 'WRAPPER-STREAM: registry count/schema differs'} +for($i=0;$i -lt $expectedRows.Count;$i++) { + $row=$registry.controls[$i];$expected=$expectedRows[$i] + if((@($row.PSObject.Properties.Name|Sort-Object)-join ',') -cne (@($expected.Keys|Sort-Object)-join ',')){throw 'WRAPPER-STREAM: registry columns differ'} + foreach($key in $expected.Keys){if([string]$row.$key -cne [string]$expected[$key]){throw ('WRAPPER-STREAM: registry row differs at '+$i+' field '+$key)}} +} +$allIds=@($registry.controls.id) +if(@($allIds|Sort-Object -Unique).Count -ne $allIds.Count){throw 'WRAPPER-STREAM: duplicate registry ID'} +if($PSBoundParameters.ContainsKey('ControlIds')) { + if($null -eq $ControlIds -or $ControlIds.Count -eq 0){throw 'WRAPPER-STREAM: empty selector'} + $seen=[Collections.Generic.HashSet[string]]::new([StringComparer]::Ordinal) + foreach($id in $ControlIds){ + if([string]::IsNullOrWhiteSpace($id)){throw 'WRAPPER-STREAM: empty selector'} + if(-not $seen.Add($id)){throw 'WRAPPER-STREAM: duplicate selector'} + if(-not ($allIds -ccontains $id)){throw ('WRAPPER-STREAM: unknown selector '+$id)} + } + $selected=@($registry.controls|Where-Object {$ControlIds -ccontains $_.id}) +}else{$selected=@($registry.controls)} +if([string]::IsNullOrWhiteSpace($ProfilesPath)){throw 'WRAPPER-STREAM: ProfilesPath required'} +$manifest=[IO.File]::ReadAllText([IO.Path]::GetFullPath($ProfilesPath),$encoding)|ConvertFrom-Json +if((@($manifest.profiles.PSObject.Properties.Name|Sort-Object)-join ',') -cne (@($profiles|Sort-Object)-join ',')){ + throw 'WRAPPER-STREAM: exact six-profile manifest required' +} +if(-not $OutputRoot){$OutputRoot=Join-Path $repo ('.lake/repair-r2/wrapper-stream-controls-'+[Guid]::NewGuid().ToString('N'))} +$OutputRoot=[IO.Path]::GetFullPath($OutputRoot) +if(Test-Path -LiteralPath $OutputRoot){throw 'WRAPPER-STREAM: output root must be fresh'} +[void][IO.Directory]::CreateDirectory($OutputRoot) +. (Join-Path $repo 'scripts/owned_process_tree.ps1') +. (Join-Path $repo 'scripts/packed_native_lifecycle_stream_check.ps1') +. (Join-Path $PSScriptRoot 'claim_expectations.ps1') +$shell=(Get-Process -Id $PID).Path +$protectedPins=[Collections.Generic.Dictionary[string,object]]::new([StringComparer]::OrdinalIgnoreCase) +$controls=[Collections.Generic.List[object]]::new() +$baselines=@{} +$claimExpectation=$null +$claimExpectationPin=$null +$claimExpectationSourceReceipt=$null +$failure=$null +$unchanged=$false + +function Pin-WrapperInput([string]$Path) { + $full=[IO.Path]::GetFullPath($Path) + if(-not [IO.File]::Exists($full)){throw ('WRAPPER-STREAM: immutable input missing '+$full)} + $pin=@{path=$full;bytes=([IO.FileInfo]$full).Length;sha256=(Get-FileHash -LiteralPath $full).Hash} + if($protectedPins.ContainsKey($full)){ + $prior=$protectedPins[$full] + if($prior.bytes -ne $pin.bytes -or $prior.sha256 -cne $pin.sha256){throw ('WRAPPER-STREAM: input changed '+$full)} + }else{$protectedPins.Add($full,$pin)} + return $pin +} +function Get-WrapperPins([string[]]$Paths) { + return @(foreach($path in $Paths){if([IO.File]::Exists($path)){ + @{path=$path;bytes=([IO.FileInfo]$path).Length;sha256=(Get-FileHash -LiteralPath $path).Hash} + }}) +} +function Copy-WrapperObject($Value){return ($Value|ConvertTo-Json -Depth 30|ConvertFrom-Json)} +function Get-ExpectedWrapperFailure([string]$Profile,[string]$Mutation,[string]$Stdout,[object]$Capture) { + switch -CaseSensitive ($Mutation) { + 'positive' {return $null} + {$_ -in @('extra-stdout','blank-stdout','misleading-success')} { + if($Profile -ceq 'claims'){return 'STREAM: claim footer differs'} + return ('STREAM: wrapper-'+$Profile+' stdout differs') + } + {$_ -in @('extra-stderr','blank-stderr','mixed-streams')} {return ('STREAM: wrapper-'+$Profile+' stderr differs')} + 'missing-output' { + if($Profile -ceq 'claims'){return 'STREAM: claim footer differs'} + if($Profile -in @('focused','full')){return ('STREAM: wrapper-'+$Profile+' stdout differs')} + return 'STREAM: evidence line missing' + } + 'duplicate-output' { + if($Profile -ceq 'claims'){ + if(@($claimExpectation.Records).Count -eq 0){return 'STREAM: unexpected claim output with empty record roster'} + return ('STREAM: unexpected or duplicate claim record/text at character '+($Stdout.Length-$claimExpectation.Footer.Length)) + } + return ('STREAM: wrapper-'+$Profile+' stdout differs') + } + {$_ -in @('wrong-exit','missing-ordinary-exit')} {return ('STREAM: wrapper-'+$Profile+' ordinary exit differs')} + {$_ -in @('timeout','output-limit')} {return ('STREAM: wrapper-'+$Profile+' incomplete bounded capture')} + 'launcher-blank-stdout' {return ('STREAM: wrapper-'+$Profile+' launcher stdout differs')} + 'launcher-blank-stderr' {return ('STREAM: wrapper-'+$Profile+' launcher stderr differs')} + 'launcher-output' {return ('STREAM: wrapper-'+$Profile+' launcher output')} + 'launcher-retention-error' {return ('STREAM: wrapper-'+$Profile+' launcher retention failed')} + 'missing-launcher-raw' {return ('STREAM: raw capture missing: '+$Capture.launcher.RawStandardOutput)} + 'observed-mixed-holdout' {return 'STREAM: wrapper-observed-focused-extra-stdout stderr differs'} + default {throw 'WRAPPER-STREAM: unmapped mutation'} + } +} +function Load-WrapperBaseline([string]$Profile) { + $receiptPath=[IO.Path]::GetFullPath([string]$manifest.profiles.$Profile) + $null=Pin-WrapperInput $receiptPath + $receipt=Read-LNExactStream $receiptPath|ConvertFrom-Json + if($receipt.kind -cne $Profile -or -not $receipt.streamValidation.validated){throw ('WRAPPER-STREAM: positive receipt invalid '+$Profile)} + if($Profile -ceq 'claims') { + # The expectation is part of the actual producing wrapper's predicate. + # Equal concatenated text is insufficient: a different tokenization can + # recognize a different language. Require that exact produced artifact. + $producedPin=$receipt.claimExpectation + if($null -eq $producedPin -or [string]::IsNullOrWhiteSpace([string]$producedPin.path) -or + [string]::IsNullOrWhiteSpace([string]$producedPin.sha256)){throw 'WRAPPER-STREAM: producing claims expectation pin missing'} + $producedPath=[IO.Path]::GetFullPath([string]$producedPin.path) + if($manifest.claimExpectationPath -and -not [string]::Equals( + [IO.Path]::GetFullPath([string]$manifest.claimExpectationPath),$producedPath,[StringComparison]::OrdinalIgnoreCase)){ + throw 'WRAPPER-STREAM: manifest claims expectation differs from producing receipt' + } + $actualExpectationPin=Pin-WrapperInput $producedPath + if($actualExpectationPin.bytes -ne $producedPin.bytes -or $actualExpectationPin.sha256 -cne $producedPin.sha256){ + throw 'WRAPPER-STREAM: producing claims expectation bytes/hash differ' + } + $script:claimExpectation=Read-LNExactStream $producedPath|ConvertFrom-Json + Assert-LNClaimStreamExpectation ((@($script:claimExpectation.Records)-join '')+$script:claimExpectation.Footer) $script:claimExpectation + $script:claimExpectationPin=$actualExpectationPin + $script:claimExpectationSourceReceipt=$receiptPath + } + $rawSeen=[Collections.Generic.HashSet[string]]::new([StringComparer]::OrdinalIgnoreCase) + foreach($pin in @($receipt.raw)) { + if(-not $rawSeen.Add([IO.Path]::GetFullPath($pin.path))){throw 'WRAPPER-STREAM: duplicate receipt raw pin'} + $actual=Pin-WrapperInput $pin.path + if($actual.bytes -ne $pin.bytes -or $actual.sha256 -cne $pin.sha256){throw ('WRAPPER-STREAM: raw pin differs '+$pin.path)} + } + $specPath=Join-Path (Split-Path -Parent $receiptPath) 'spec.json' + if(-not $rawSeen.Contains($specPath)){throw 'WRAPPER-STREAM: unpinned capture spec'} + $spec=Read-LNExactStream $specPath|ConvertFrom-Json + foreach($path in @($spec.stdout,$spec.stderr,$spec.exit,$receipt.outer.RawStandardOutput,$receipt.outer.RawStandardError)) { + if([string]::IsNullOrEmpty($path) -or -not $rawSeen.Contains([IO.Path]::GetFullPath($path))){throw 'WRAPPER-STREAM: missing current raw stream pin; historical capture uncovered'} + } + $actual=Read-LNExactStream $spec.exit|ConvertFrom-Json + if(($actual|ConvertTo-Json -Compress) -cne ($receipt.actual|ConvertTo-Json -Compress)){throw 'WRAPPER-STREAM: actual exit receipt differs'} + $capture=@{launcher=$receipt.outer;actual=$actual;spec=$spec} + $positive=Assert-LNWrapperCapture $capture $Profile $repo $claimExpectation + $stdout=Read-LNExactStream $spec.stdout + # Bind the independently checked producing summary/result consumed by the + # real predicate, including claims expectation when that profile is selected. + switch -CaseSensitive ($Profile) { + {$_ -in @('focused','full')} { + $path=Get-LNStreamEvidencePath $stdout 'LIFECYCLE-REPLAY evidence=' (Join-Path $repo '.lake/lifecycle-native-p0/runs') + $null=Pin-WrapperInput (Join-Path $path 'SUMMARY.json') + } + 'integrity' {$line=@($stdout.Split(@($nl),[StringSplitOptions]::None)|Where-Object {$_.StartsWith('INTEGRITY CONTROLS evidence=',[StringComparison]::Ordinal)})[0];$null=Pin-WrapperInput (Join-Path $line.Substring('INTEGRITY CONTROLS evidence='.Length) 'RESULTS.json')} + 'dependencies' {$path=Get-LNStreamEvidencePath $stdout 'DEPENDENCY CONTROLS PASS evidence=' (Join-Path $repo '.lake/repair-r1');$null=Pin-WrapperInput (Join-Path $path 'RESULTS.json')} + 'checks' {$line=@($stdout.Split(@($nl),[StringSplitOptions]::None)|Where-Object {$_.StartsWith('FINAL CHECKS evidence=',[StringComparison]::Ordinal)})[0];$null=Pin-WrapperInput (Join-Path $line.Substring('FINAL CHECKS evidence='.Length) 'RESULTS.json')} + } + return @{receipt=$receiptPath;capture=$capture;positive=$positive;stdout=$stdout;stderr=(Read-LNExactStream $spec.stderr)} +} +function Invoke-WrapperComponent($Row,$Baseline,[string]$CaseRoot) { + $fixture=Join-Path $CaseRoot 'fixture';$observed=Join-Path $CaseRoot 'observed' + [void][IO.Directory]::CreateDirectory($fixture);[void][IO.Directory]::CreateDirectory($observed) + $capture=Copy-WrapperObject $Baseline.capture + $paths=@{stdout=$capture.spec.stdout;stderr=$capture.spec.stderr;exit=$capture.spec.exit; + launcherStdout=$capture.launcher.RawStandardOutput;launcherStderr=$capture.launcher.RawStandardError} + $restore=@{} + foreach($name in $paths.Keys){$target=Join-Path $fixture ($name+'.raw');$restore[$target]=[IO.File]::ReadAllBytes($paths[$name]);[IO.File]::WriteAllBytes($target,$restore[$target])} + $capture.spec.stdout=Join-Path $fixture 'stdout.raw';$capture.spec.stderr=Join-Path $fixture 'stderr.raw';$capture.spec.exit=Join-Path $fixture 'exit.raw' + $capture.spec.error=Join-Path $fixture 'error';$capture.spec.overflow=Join-Path $fixture 'overflow' + $capture.launcher.RawStandardOutput=Join-Path $fixture 'launcherStdout.raw';$capture.launcher.RawStandardError=Join-Path $fixture 'launcherStderr.raw' + $baselineCapture=Copy-WrapperObject $capture + $expectedFailure=Get-ExpectedWrapperFailure $Row.profile $Row.mutation $Baseline.stdout $capture + $actualFailure=$null;$restored=$false;$pins=@();$snapshotPath=Join-Path $observed 'CAPTURE.json' + $observedContract=$null + try { + switch -CaseSensitive ($Row.mutation) { + 'positive' {} + 'extra-stdout' {[IO.File]::WriteAllText($capture.spec.stdout,($Baseline.stdout+'UNEXPECTED WRAPPER STDOUT'+$nl),$encoding)} + 'extra-stderr' {[IO.File]::WriteAllText($capture.spec.stderr,($Baseline.stderr+'UNEXPECTED WRAPPER STDERR'+$nl),$encoding)} + 'blank-stdout' {[IO.File]::WriteAllText($capture.spec.stdout,($Baseline.stdout+$nl),$encoding)} + 'blank-stderr' {[IO.File]::WriteAllText($capture.spec.stderr,($Baseline.stderr+$nl),$encoding)} + 'missing-output' { + $cut=$Baseline.stdout.LastIndexOf($nl,$Baseline.stdout.Length-$nl.Length-1,[StringComparison]::Ordinal) + $value=if($cut -lt 0){''}else{$Baseline.stdout.Substring(0,$cut+$nl.Length)} + [IO.File]::WriteAllText($capture.spec.stdout,$value,$encoding) + } + 'duplicate-output' {[IO.File]::WriteAllText($capture.spec.stdout,($Baseline.stdout+$Baseline.stdout),$encoding)} + 'misleading-success' {[IO.File]::WriteAllText($capture.spec.stdout,($Baseline.stdout+'{"success":true,"validated":true}'+$nl),$encoding)} + 'mixed-streams' {[IO.File]::WriteAllText($capture.spec.stderr,($Baseline.stdout+$Baseline.stderr),$encoding)} + 'wrong-exit' {$capture.actual.exitCode=99;$capture.launcher.ExitCode=99;[IO.File]::WriteAllText($capture.spec.exit,($capture.actual|ConvertTo-Json),$encoding)} + 'missing-ordinary-exit' {$capture.actual=$null;[IO.File]::WriteAllText($capture.spec.exit,'null',$encoding)} + 'timeout' {$capture.launcher.TimedOut=$true} + 'output-limit' {$capture.launcher.OutputLimitExceeded=$true} + 'launcher-blank-stdout' {[IO.File]::WriteAllText($capture.launcher.RawStandardOutput,$nl,$encoding)} + 'launcher-blank-stderr' {[IO.File]::WriteAllText($capture.launcher.RawStandardError,$nl,$encoding)} + 'launcher-output' {$capture.launcher.StandardOutput=@('UNEXPECTED LAUNCHER OUTPUT');[IO.File]::WriteAllText($capture.launcher.RawStandardOutput,('UNEXPECTED LAUNCHER OUTPUT'+$nl),$encoding)} + 'launcher-retention-error' {$capture.launcher.RetentionErrors=@('injected isolated retention failure')} + 'missing-launcher-raw' {Remove-Item -LiteralPath $capture.launcher.RawStandardOutput} + 'observed-mixed-holdout' { + # Same observed-stream contract used by the real extra-stdout process + # control: the declared stdout addition is legitimate fixture data. + $observedContract=@{expectedStdout=($Baseline.stdout+'UNEXPECTED WRAPPER STDOUT'+$nl);expectedStderr=$Baseline.stderr;expectedExit=0;profile='wrapper-observed-focused-extra-stdout'} + [IO.File]::WriteAllText($capture.spec.stdout,$observedContract.expectedStdout,$encoding) + Assert-LNOuterCapture $capture $observedContract.expectedStdout $observedContract.expectedStderr 0 $observedContract.profile + $observedContract.positiveAccepted=$true + # This second unregistered diagnostic must not hide behind the known + # stdout rejection produced by the wrapper itself. + [IO.File]::WriteAllText($capture.spec.stderr,($Baseline.stderr+'UNRELATED SECOND STDERR DIAGNOSTIC'+$nl),$encoding) + } + default {throw 'WRAPPER-STREAM: unexecuted component mutation'} + } + try { + if($null -ne $observedContract){Assert-LNOuterCapture $capture $observedContract.expectedStdout $observedContract.expectedStderr 0 $observedContract.profile} + else{$null=Assert-LNWrapperCapture $capture $Row.profile $repo $claimExpectation} + }catch{$actualFailure=$_.Exception.Message} + # Preserve the complete challenged objects/bytes before fixture restoration. + $snapshot=Copy-WrapperObject $capture + foreach($name in $paths.Keys){$from=Join-Path $fixture ($name+'.raw');$to=Join-Path $observed ($name+'.raw');if([IO.File]::Exists($from)){[IO.File]::Copy($from,$to,$false)}} + $snapshot.spec.stdout=Join-Path $observed 'stdout.raw';$snapshot.spec.stderr=Join-Path $observed 'stderr.raw';$snapshot.spec.exit=Join-Path $observed 'exit.raw' + $snapshot.launcher.RawStandardOutput=Join-Path $observed 'launcherStdout.raw';$snapshot.launcher.RawStandardError=Join-Path $observed 'launcherStderr.raw' + [IO.File]::WriteAllText($snapshotPath,($snapshot|ConvertTo-Json -Depth 25),$encoding) + $pins=Get-WrapperPins @($snapshotPath,(Join-Path $observed 'stdout.raw'),(Join-Path $observed 'stderr.raw'),(Join-Path $observed 'exit.raw'),(Join-Path $observed 'launcherStdout.raw'),(Join-Path $observed 'launcherStderr.raw')) + if($actualFailure -cne $expectedFailure){throw ('WRAPPER-STREAM: '+$Row.id+' expected ['+$expectedFailure+'] got ['+$actualFailure+']')} + } finally { + foreach($path in $restore.Keys){[IO.File]::WriteAllBytes($path,$restore[$path]);if([Convert]::ToBase64String([IO.File]::ReadAllBytes($path)) -cne [Convert]::ToBase64String($restore[$path])){throw 'WRAPPER-STREAM: fixture bytes not restored'}} + [IO.File]::WriteAllText((Join-Path $fixture 'RESTORED_CAPTURE.json'),($baselineCapture|ConvertTo-Json -Depth 25),$encoding) + $restored=$true + } + return @{id=$Row.id;profile=$Row.profile;mode=$Row.mode;expected=$Row.expected;expectedFailure=$expectedFailure;actualFailure=$actualFailure; + replayExpectedFailure=if($Row.mutation -ceq 'missing-launcher-raw'){'STREAM: raw capture missing: '+(Join-Path $observed 'launcherStdout.raw')}else{$expectedFailure}; + replayCapture=$snapshotPath;observedStreamContract=$observedContract;passed=$true;fixtureRestored=$restored;sourceReceipt=$Baseline.receipt;raw=$pins} +} +function Invoke-WrapperProcess($Row,$Baseline,[string]$CaseRoot) { + [void][IO.Directory]::CreateDirectory($CaseRoot) + $wrapperPath=Join-Path $repo 'docs/internal/extensions/lifecycle-native-p0/repair-r1/run_owned.ps1' + $source=[IO.File]::ReadAllText($wrapperPath,$encoding) + $rootNeedle='$repo=[IO.Path]::GetFullPath((Join-Path $PSScriptRoot ''../../../../..''))' + $rootReplacement='$repo='''+$repo.Replace("'","''")+'''' + $innerNeedle='$inner=Join-Path $OutputRoot ''inner.ps1''' + if(([regex]::Matches($source,[regex]::Escape($rootNeedle))).Count -ne 1 -or + ([regex]::Matches($source,[regex]::Escape($innerNeedle))).Count -ne 1){throw 'WRAPPER-STREAM: production wrapper fixture anchors differ'} + $savedOut=Join-Path $CaseRoot 'positive.stdout';$savedErr=Join-Path $CaseRoot 'positive.stderr' + [IO.File]::Copy($Baseline.capture.spec.stdout,$savedOut,$false);[IO.File]::Copy($Baseline.capture.spec.stderr,$savedErr,$false) + $action="[Console]::Out.Write([IO.File]::ReadAllText('"+$savedOut.Replace("'","''")+"',[Text.UTF8Encoding]::new(`$false,`$true)))`n"+ + "[Console]::Error.Write([IO.File]::ReadAllText('"+$savedErr.Replace("'","''")+"',[Text.UTF8Encoding]::new(`$false,`$true)))`n" + if($Row.mutation -ceq 'extra-stdout'){$action+="[Console]::Out.Write('UNEXPECTED WRAPPER STDOUT'+[Environment]::NewLine)`n"} + if($Row.mutation -ceq 'extra-stderr'){$action+="[Console]::Error.Write('UNEXPECTED WRAPPER STDERR'+[Environment]::NewLine)`n"} + $action+="exit 0`n" + $insertion="`$action = @'`n"+$action+"'@`n"+$innerNeedle + $derived=$source.Replace($rootNeedle,$rootReplacement).Replace($innerNeedle,$insertion) + if($derived.Replace($insertion,$innerNeedle).Replace($rootReplacement,$rootNeedle) -cne $source){throw 'WRAPPER-STREAM: copied wrapper delta not exact'} + $driver=Join-Path $CaseRoot 'run_owned.derived.ps1' + [IO.File]::WriteAllText($driver,$derived,$encoding) + $wrapperOutput=Join-Path $CaseRoot 'wrapper-output' + $capture=Invoke-LNStreamCapture $repo $shell @('-NoProfile','-File',$driver,'-Kind','focused','-OutputRoot',$wrapperOutput) $repo (Join-Path $CaseRoot 'outer') 300 ('wrapper-process-'+$Row.mutation) + $expectedExit=if($Row.mutation -ceq 'positive'){0}else{1} + Assert-LNOuterCapture $capture ('OWNED focused exit=0 evidence='+$wrapperOutput+$nl) '' $expectedExit ('wrapper-process-'+$Row.mutation) + $receiptPath=Join-Path $wrapperOutput 'RECEIPT.json' + $receipt=Read-LNExactStream $receiptPath|ConvertFrom-Json + # Establish the declared two-sided observation before interpreting the + # expected production rejection. A stdout failure cannot conceal an + # unrelated stderr anomaly (or vice versa) in the control's own verdict. + $innerSpec=Read-LNExactStream (Join-Path $wrapperOutput 'spec.json')|ConvertFrom-Json + $innerCapture=@{launcher=$receipt.outer;actual=$receipt.actual;spec=$innerSpec} + $expectedInnerStdout=$Baseline.stdout + $expectedInnerStderr=$Baseline.stderr + if($Row.mutation -ceq 'extra-stdout'){$expectedInnerStdout+='UNEXPECTED WRAPPER STDOUT'+$nl} + if($Row.mutation -ceq 'extra-stderr'){$expectedInnerStderr+='UNEXPECTED WRAPPER STDERR'+$nl} + Assert-LNOuterCapture $innerCapture $expectedInnerStdout $expectedInnerStderr 0 ('wrapper-observed-focused-'+$Row.mutation) + $expectedFailure=Get-ExpectedWrapperFailure 'focused' $Row.mutation $Baseline.stdout $null + if($receipt.actual.exitCode -ne 0 -or $receipt.outer.ExitCode -ne 0 -or + [bool]$receipt.streamValidation.validated -ne ($Row.mutation -ceq 'positive') -or + $receipt.streamValidation.failure -cne $expectedFailure){throw ('WRAPPER-STREAM: actual production verdict differs '+$Row.id)} + $pins=@($capture.raw)+@(Get-WrapperPins @($receiptPath,$driver,$savedOut,$savedErr)) + $pins+=@($receipt.raw) + return @{id=$Row.id;profile=$Row.profile;mode=$Row.mode;expected=$Row.expected;expectedFailure=$expectedFailure;actualFailure=$receipt.streamValidation.failure; + passed=$true;fixtureRestored=$true;sourceReceipt=$Baseline.receipt;sourceWrapperSha256=(Get-FileHash -LiteralPath $wrapperPath).Hash; + exactDerivedDelta='Only repository root resolution and action override immediately before original inner creation; original switch/capture/verdict retained.'; + replayMeaning='Real wrapper process and capture/verdict; saved positive native output replay, not a new native runtime experiment.'; + observedStreamContract=@{expectedStdout=$expectedInnerStdout;expectedStderr=$expectedInnerStderr;expectedExit=0;validated=$true}; + actualOuterExit=$capture.actual.exitCode;actualInnerExit=$receipt.actual.exitCode;deadlineSeconds=300;raw=$pins} +} +function Invoke-WrapperBoundary($Row,[string]$CaseRoot) { + [void][IO.Directory]::CreateDirectory($CaseRoot) + $isSelector=$Row.mutation.StartsWith('controlids-',[StringComparison]::Ordinal) + $target=if($isSelector){Join-Path $PSScriptRoot 'wrapper_stream_controls.ps1'}else{Join-Path $repo 'docs/internal/extensions/lifecycle-native-p0/repair-r1/run_owned.ps1'} + $arguments=@{} + $message='';$type='System.Management.Automation.RuntimeException';$fqid='' + switch -CaseSensitive ($Row.mutation) { + 'controlids-empty-array' {$arguments=@{ControlIds=@()};$message='WRAPPER-STREAM: empty selector'} + 'controlids-empty-string' {$arguments=@{ControlIds=@('')};$message='WRAPPER-STREAM: empty selector'} + 'controlids-whitespace' {$arguments=@{ControlIds=@(' ')};$message='WRAPPER-STREAM: empty selector'} + 'controlids-unknown' {$arguments=@{ControlIds=@('__unknown__')};$message='WRAPPER-STREAM: unknown selector __unknown__'} + 'controlids-duplicate' {$arguments=@{ControlIds=@('wrapper-focused-positive','wrapper-focused-positive')};$message='WRAPPER-STREAM: duplicate selector'} + 'kind-missing' {$message='STREAM: wrapper Kind is required'} + {$_ -in @('kind-empty','kind-unknown')} { + $value=if($_ -ceq 'kind-empty'){''}else{'__unknown__'} + $arguments=@{Kind=$value} + $message="Cannot validate argument on parameter 'Kind'. The argument `""+$value+"`" does not belong to the set `"focused,full,integrity,dependencies,claims,checks`" specified by the ValidateSet attribute. Supply an argument that is in the set and then try the command again." + $type='System.Management.Automation.ParameterBindingValidationException' + $fqid='ParameterArgumentValidationError,run_owned.ps1' + } + default {throw 'WRAPPER-STREAM: unmapped boundary mutation'} + } + if($fqid -ceq ''){$fqid=$message} + $testSpec=@{id=$Row.id;target=$target;arguments=$arguments;message=$message;type=$type;fqid=$fqid;errorArtifact=(Join-Path $CaseRoot 'ERROR.json')} + $testSpecPath=Join-Path $CaseRoot 'BOUNDARY_SPEC.json' + [IO.File]::WriteAllText($testSpecPath,($testSpec|ConvertTo-Json -Depth 8),$encoding) + $driver=Join-Path $CaseRoot 'boundary.ps1' + [IO.File]::WriteAllText($driver,@' +param([string]$SpecPath) +$ErrorActionPreference='Stop' +$utf8=[Text.UTF8Encoding]::new($false,$true) +$spec=[IO.File]::ReadAllText($SpecPath,$utf8)|ConvertFrom-Json +$arguments=@{} +foreach($property in $spec.arguments.PSObject.Properties){$arguments[$property.Name]=$property.Value} +$failure=$null +try { & $spec.target @arguments } catch { + $failure=@{message=$_.Exception.Message;type=$_.Exception.GetType().FullName;fqid=$_.FullyQualifiedErrorId} + [IO.File]::WriteAllText($spec.errorArtifact,($failure|ConvertTo-Json),$utf8) +} +if($null -eq $failure -or $failure.message -cne $spec.message -or $failure.type -cne $spec.type -or $failure.fqid -cne $spec.fqid){throw 'boundary exception differs'} +[Console]::Out.Write('BOUNDARY REJECTED '+$spec.id+[Environment]::NewLine) +exit 0 +'@,$encoding) + $capture=Invoke-LNStreamCapture $repo $shell @('-NoProfile','-File',$driver,'-SpecPath',$testSpecPath) $repo (Join-Path $CaseRoot 'outer') 300 $Row.id + Assert-LNOuterCapture $capture ('BOUNDARY REJECTED '+$Row.id+$nl) '' 0 $Row.id + return @{id=$Row.id;profile=$Row.profile;mode=$Row.mode;expected=$Row.expected;expectedFailure=$message;actualFailure=$message; + expectedExceptionType=$type;expectedFullyQualifiedErrorId=$fqid;passed=$true;fixtureRestored=$true;actualOuterExit=$capture.actual.exitCode; + targetBoundary='Actual script parameter/selector invocation in a caught child scope; target exception is not a target ordinary process exit.'; + raw=(@($capture.raw)+@(Get-WrapperPins @($driver,$testSpecPath,$testSpec.errorArtifact)))} +} +try { + foreach($path in @($ProfilesPath,$registryPath,$PSCommandPath,(Join-Path $repo 'scripts/packed_native_lifecycle_stream_check.ps1'), + (Join-Path $repo 'scripts/owned_process_tree.ps1'),(Join-Path $repo 'scripts/packed_native_lifecycle_storage_replay.ps1'), + (Join-Path $repo 'docs/internal/extensions/lifecycle-native-p0/repair-r1/run_owned.ps1'),(Join-Path $PSScriptRoot 'claim_expectations.ps1'))){$null=Pin-WrapperInput $path} + + foreach($profile in @($selected|Where-Object {$_.mode -cne 'boundary'}|ForEach-Object {$_.profile}|Select-Object -Unique)){$baselines[$profile]=Load-WrapperBaseline $profile} + foreach($row in $selected) { + $caseRoot=Join-Path $OutputRoot $row.id + $watch=[Diagnostics.Stopwatch]::StartNew() + $result=switch -CaseSensitive ($row.mode) { + 'component' {Invoke-WrapperComponent $row $baselines[$row.profile] $caseRoot} + 'process' {Invoke-WrapperProcess $row $baselines[$row.profile] $caseRoot} + 'boundary' {Invoke-WrapperBoundary $row $caseRoot} + default {throw 'WRAPPER-STREAM: unknown registry mode'} + } + $watch.Stop();$result.seconds=$watch.Elapsed.TotalSeconds + $controls.Add($result) + Write-Output ('WRAPPER CONTROL PASS '+$row.id) + } + if((@($controls.id)-join ',') -cne (@($selected.id)-join ',')){throw 'WRAPPER-STREAM: executed registry differs'} +} catch {$failure=$_.Exception.Message} finally { + try { + foreach($pin in @($protectedPins.Values)){ + if(-not [IO.File]::Exists($pin.path) -or ([IO.FileInfo]$pin.path).Length -ne $pin.bytes -or + (Get-FileHash -LiteralPath $pin.path).Hash -cne $pin.sha256){throw ('WRAPPER-STREAM: immutable input changed '+$pin.path)} + } + $unchanged=$true + }catch{if($null -eq $failure){$failure=$_.Exception.Message}else{$failure+=' | '+$_.Exception.Message}} + $report=@{success=($null -eq $failure);failure=$failure;registryCount=$allIds.Count;selected=@($selected.id);controls=@($controls.ToArray()); + immutableInputsUnchanged=$unchanged;sourcePins=@($protectedPins.Values);profileManifest=[IO.Path]::GetFullPath($ProfilesPath); + claimExpectationPin=$claimExpectationPin;claimExpectationSourceReceipt=$claimExpectationSourceReceipt; + fixtureBoundary='Only owned copies are mutated/restored; original raw captures and producer summaries remain pinned and unchanged.'} + [IO.File]::WriteAllText((Join-Path $OutputRoot 'RESULTS.json'),($report|ConvertTo-Json -Depth 30),$encoding) +} +if($null -ne $failure){throw $failure} +Write-Output ('WRAPPER STREAM CONTROLS PASS evidence='+$OutputRoot) diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r3/ACCEPTANCE_MATRIX.md b/docs/internal/extensions/lifecycle-native-p0/repair-r3/ACCEPTANCE_MATRIX.md new file mode 100644 index 00000000..bb0e1811 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r3/ACCEPTANCE_MATRIX.md @@ -0,0 +1,64 @@ +# LIFE-NATIVE-P0-R3 frozen acceptance matrix + +Sixteen complete inherited rows retain exact base bytes and historical pending cells. All eighteen rows are frozen; append evidence separately. + +| ID | Exact frozen requirement | Scope | Evidence needed (exact proposition/check) | Named consumer and identity/composition chain | Anti-vacuity challenge attempted and outcome | Evidence obtained | Status / residual gap | +| --- | --- | --- | --- | --- | --- | --- | --- | +| `LN0-01` | Implement a reproducible probe of the pinned Lean 4.22 runtime array ownership operations, without altering the production RMQ ABI. Record logical size, retained capacity, requested container bytes and live element references as distinct quantities. Inspect actual runtime definitions and record compiler/runtime/header identity; do not infer capacity from Array.size. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-02` | Exercise unique and shared owners with destructor-counted elements. Demonstrate the actual effects of pop/shrink on surviving values, tail element references and retained backing capacity, without accessing freed objects. Distinguish release of one owner from reclamation when another alias remains live. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-03` | Exercise a consuming replacement-buffer route: copy surviving output values into a newly allocated bounded-capacity buffer, release the old owner, and measure which old allocations/elements remain reachable. Include success, empty output, overlap-relevant source positions, alias-retained and deterministically injected handoff/allocation-stage failure cleanup. Do not assume actual Lean allocator failure is recoverable; a fatal process outcome is reported separately. Treat observed allocator/requested capacity separately from a universal native heap theorem. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-04` | Commit an exact replay registry and positive/negative controls for logical shrink falsely labeled reclamation, retained alias falsely labeled exclusive consumption, and an omitted cleanup action. Validation executes the actual pinned runtime operations and the owned measurement/verdict path; predecessor RMQ replay is regression evidence only. The verdict must depend on observed value/ownership/capacity projections, not labels or a prewritten expected log; use the same positive predicate or a checked/explicit measured implication. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-05` | Use bounded owned compiler/probe processes, preserve full stdout/stderr and actual exits, reject unexpected or mixed diagnostics, validate focused/unknown/empty selector behavior, and exercise cleanup. A platform/toolchain inability is uncovered, not success. No credit purchase, package installation or persistent service is needed as an assumed prerequisite. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-06` | Deliver a source-grounded consuming-boundary recommendation mapping Construction.ExecState resources and Native.StorageImage/NativeImage ownership to later transfer obligations. Specify success/failure ownership, aliases, retained observations and capacity. Do not implement a speculative production BuilderOwner-to-QueryOwner ABI before the formal lifecycle interface is reviewed. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-SEMANTIC-NONVACUITY` | semantic coverage, liveness, ownership, and refinement predicates are derived from the operational construction they describe. A predicate defined to be `True`, an enumeration restated as membership, or a separately hand-written consumer label does not establish operational liveness by itself; | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-ORACLE-INDEPENDENCE` | executable fixtures and edge-case expected values come from an independent specification or a theorem already connected to it, never from the implementation result being tested; | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-CATEGORY-SEPARATION` | payload bits, proof fields, model ticks, machine state, Lean runtime, and measured performance remain distinct. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-MUTATION-REPRODUCIBILITY` | when acceptance relies on an exhaustive, production, or public-dependency mutation campaign, the candidate contains a versioned runner or fixtures that replay every claimed case, check the exact expected failure/acceptance surface, restore tracked state, and leave the tree clean. Report prose, copied terminal output, and dangling Git objects are not replayable evidence. A public theorem additionally has a checked exact-type consumer that fails when the advertised dependency is removed; `#print axioms` over the theorem's current type is not such a consumer. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `CHK-FINAL` | Run the final-required checks on the final submitted content, with exact identities, complete outcomes and declared platform limits. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `CHK-SCOPE` | Keep the assigned write scope, clean committed tree, exact base, full frozen row integrity and truthful local-versus-campaign status. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `NP0R1-INTEGRITY` | Every entered native replay verification lifecycle records and enforces an independent final integrity outcome in finally, including prior compiler/probe errors, unexpected diagnostics, timeout and partially initialized identity inventories. Verify every captured source/tool/generated-artifact pin and the declared live tracked/index/untracked baseline; absence of required final verification is failure or explicitly uncovered, never success. Preserve the original stage error separately from integrity errors. Detect unexpected changes without silently overwriting unrelated user data. Commit positive and changed-pin/tree controls through the actual production verifier/finalization path, including failure plus integrity failure, success plus integrity failure, and an ordinary failed stage with intact inputs. All owned fixture mutations are restored in their own finally and leave the real candidate unchanged. Keep existing owned-process cleanup and exact diagnostics/exits. | Local verification repair | Production finalizer and exact dependency checks | Captured run inputs -> final verification -> success/receipt | Isolated unchanged, tampered, failed-stage and incomplete inventories | Pending; append evidence | Open at freeze | +| `NP0R1-TOOLCHAIN` | Bind the substantive local implementation dependencies of the actually invoked pinned compiler/runtime to the replay receipt and final identity verification. In particular include clang's normal-import libclang-cpp.dll, libLLVM-19.dll and libc++.dll and inspect the invoked tools' remaining local non-system dependency closure; state the external OS/system-library and dynamic-loading boundary honestly. Include the generated link map in final available-artifact integrity checks. Commit a completeness/tamper control using actual dependency inventory and isolated manifest/file fixtures, without modifying installed tools. The original bea5ce75 runner/receipt must fail the new completeness predicate for the independently measured missing dependencies while a complete unchanged inventory passes. No installation, runtime upgrade, tool replacement or claim of universal loader/compiler verification. | Local verification repair | Production finalizer and exact dependency checks | Captured run inputs -> final verification -> success/receipt | Isolated unchanged, tampered, failed-stage and incomplete inventories | Pending; append evidence | Open at freeze | +| `NP0R2-STREAMS` | The actual native integrity-control harness and certification wrapper reject unexpected or mixed outer process stdout/stderr as well as preserving the existing inner native/launcher stream, summary, integrity and ordinary-exit checks. Define one precise stream contract for each actual caller/profile and use its production predicate in real positive/negative controls. Legitimate expected-error output must pass only with the exact expected diagnostics; extra, missing, duplicate or unrelated lines, misleading success output and mixed streams cannot be hidden by an expected exception, successful JSON or expected exit. Preserve complete raw output and actual exits, bounded ownership, cleanup and finally integrity. Reproduce the exact 2307e3ad counterexample on immutable old source/evidence and show the repaired production verdict rejects that same failure class, including actual outer stderr on successful and expected-failure cases and corresponding stdout controls. Keep all fourteen inherited rows, original operational IDs/predicates, fifteen integrity controls and nineteen dependency controls. Use isolated fixtures and restore only owned fixture state; never mutate installed tools or the live candidate. All supported wrapper profiles have a checked legitimate positive; no blanket empty-stderr rule that rejects legitimate negative-control diagnostics. | Narrow outer diagnostic repair | Exact production stream and exit predicates with replayable controls | Actual owned child capture -> caller-used validator -> certification verdict | Legitimate profiles plus extra, missing, duplicate, mixed and misleading output | Pending; append evidence | Open at freeze | +| `NP0R2-REPORT` | Deliver a complete successor report distinguishing the repaired control/certification boundary from the already-supported production finally/provenance and unchanged finite native ownership experiment. Explicitly correct the historical R1 copied-map wording: dependency_controls.ps1 creates a synthetic text map fixture; actual generated link-map capture and final hashing are separate verified observations. Preserve all historical report/receipt bytes and accurately state source-freeze, final-package, actual command results and remaining native-adapter/formal/campaign obligations. | Narrow outer diagnostic repair | Exact production stream and exit predicates with replayable controls | Actual owned child capture -> caller-used validator -> certification verdict | Legitimate profiles plus extra, missing, duplicate, mixed and misleading output | Pending; append evidence | Open at freeze | +| `NP0R3-LITERAL` | The actual common stream predicate uses literal equality after strict UTF-8 decoding (or equivalent byte comparison), preserving every admitted character and newline without culture-sensitive equivalence, BOM stripping, trimming, normalization or silent suppression. Exact legitimate success and expected-error streams pass; unequal additions including U+FEFF, U+0000 and U+00AD reject at the same production predicate with all actual transport/ordinary-exit guards intact. Retain exact old9519 accepted counterexamples and show the repaired actual caller rejects them. Distinguish prefix-specific rejection, actual emitted child captures, copied-capture profile tests and synthetic launcher components. Preserve the six supported profile meanings, expected legitimate diagnostics, claim whole-record multiplicities, complete raw evidence, finally/ownership and inherited operational predicates. No new outer wrapper layer is required. | Narrow local verifier repair | Strict decoded literal equality and direct nonempty selector controls | Actual capture -> common production predicate; actual certify_profiles boundary -> run_owned | Exact positives, unequal Unicode/transport holdouts, rejected empty selectors and one actual focused run | Pending; append evidence | Open at freeze | +| `NP0R3-SELECTOR` | The actual certify_profiles.ps1 parameter boundary distinguishes omission (the declared six-profile default) from an explicitly bound null, empty array, empty string or whitespace; rejects those, unknown and duplicate profile selections before starting work; and executes one explicitly selected valid profile exactly once. Use direct actual-boundary controls, an exact frozen control registry and an actual valid focused invocation. Preserve six-profile final manifest completeness and existing run_owned behavior. A no-work ordinary return is not successful verification. The outermost convenience launcher's own terminal text remains outside the named captured-child stream contract; do not add an unbounded wrapper hierarchy to change that scope. | Narrow local verifier repair | Strict decoded literal equality and direct nonempty selector controls | Actual capture -> common production predicate; actual certify_profiles boundary -> run_owned | Exact positives, unequal Unicode/transport holdouts, rejected empty selectors and one actual focused run | Pending; append evidence | Open at freeze | + +## Target and verification coverage plan + +The join is the reviewed native prerequisite plus reviewed formal producer, then consuming adapter and final campaign certification. This local task closes literal comparison and explicit nonempty selection only. No Lean/C/ABI or public-source edits. No weakened predicate, normalization, parallel test comparator, live candidate mutation, policy expansion, historical relabeling or new outer wrapper hierarchy. + +Development-loop: exact identity/scope and all eighteen complete row bytes against exact-base rows and independently pinned prompt; literal references, actual emitted Unicode stdout/stderr, retained root/leaf counterexamples, ASCII and newline/normalization/invalid UTF-8 holdouts; upfront direct selector controls. Controls consume the production predicate with the same expected strings, transport flags and ordinary exits. + +Final-required: complete new frozen registry; one actual focused native invocation through certify_profiles (1200 s outer, prior 49.522 s); source-derived integrity caller preserving native 0/7 and runner 0/1; six historical legitimate captures and fifteen integrity diagnostic captures revalidated with historical source/producing-root expectations; fresh checks and claims at current HEAD. Tiny children use 60 s and control groups 300 s (root four captures prior 10.106 s). Use unchanged bounded helper and Local\RMQLifecycleImplementationHeavy20260920, preserve all streams/exits, cleanup and finally identities. Synthetic launcher components and copied-capture profile tests remain separate from actual emitted children. + +Final package: eighteen-row successor contract/negative mutations/protected sources, hygiene/native-decision scans, working and exact-base committed whitespace, production strict design against base and each new commit parent, clean final HEAD and complete-report claims. Reuse 23/65/58, fifteen/nineteen and eleven/120 historical registries plus baseline build only after exact source/registry/raw-pin verification; literal change cannot by itself invalidate unchanged native operations. Re-establish whole-root historical claim coverage with unchanged outside paths/scanner/policy/rg/config and fresh entire native subtree/both-ledger scan, else one 7200 s full scan. No duplicate native campaign or Lake build solely to rename evidence. Adapter, final joint aggregate, fresh-blind audit and acceptance remain deferred to coordinator. Stop only on completed local rows, precise obstruction, external blocker or redirection. + + +## Appended R3 evidence and local dispositions + +All eighteen frozen rows above remain unchanged. The complete successor REPORT.md explains the production predicates, ordinary-exit/transport guards, source/package distinction, raw paths, preserved failures, map-fixture erratum and live limitations. RESULTS.json is the compact source index; the external .lake/repair-r3/FINAL_CERTIFICATION.json binds the clean final package and complete report after current checks/claims and final retained revalidation. + +P(c,o,e,x) is the actual Assert-LNOuterCapture conjunction: present launcher; no timeout/output limit/error/overflow/retention error; empty launcher arrays and literally empty strict-decoded launcher streams; actual ordinary child and launcher exits x; and strict-decoded child streams ordinal-equal to independently prescribed o,e. The negative Q uses this same production predicate and guards on independently prescribed unequal output bytes. The 25 emitted cases establish exact raw byte production before the observed production accept/reject verdict. Malformed UTF-8 rejects in decoding, with its actual exit artifact checked separately. Ten invalid direct selector invocations establish the exact rejection and absence of work, one real focused invocation selects pop-unique exactly once, and one integrity pair preserves native/runner 0/0 and 7/1 plus independent final integrity. + +Source commit 6bcd1fc50020482ab441723a1964eec0232d223f passed the exact 37-control roster in five bounded groups. Forty retained cases preserve actual emitted root/leaf witnesses, copied captures and synthetic launcher components as separate evidence tiers. The 21 historical legitimate contracts preserve six profile meanings and fifteen integrity diagnostics; old/current P/Q use identical retained capture objects, expected strings and exits. The source contract reconstructs 23/65/58, fifteen/nineteen and eleven/120 historical registries, protected sources and complete raw pins. The final collector requires those same tested sources, exact current checks commands and a current claims producer bound to every scanned input before/after. No report flag or manifest-head substitution closes a row. + +| ID | Evidence conclusion and local disposition | +| --- | --- | +| LN0-01 | Preserved exact C/runtime/header/compiler identity and finite size/capacity/requested-container/reference observations; baseline and full raw evidence rehashed. Satisfied by preservation. | +| LN0-02 | Preserved unique/shared owner operations, destructor observations and alias-retained capacity distinctions. Satisfied by preservation. | +| LN0-03 | Preserved replacement success/empty/overlap/alias/staged-failure cases and cleanup predicates; fatal handler remains separate from recoverable allocation failure. Satisfied by preservation. | +| LN0-04 | Exact 23/65/58 operational IDs, predicates and replay evidence retained; actual new focused case and independent controls remain nonvacuous. Satisfied. | +| LN0-05 | Literal complete streams plus actual transport/exits now enforced; explicit invalid selection rejects before work; real focused invocation and cleanup pass. Satisfied. | +| LN0-06 | Protected `BOUNDARY.md` recommendation still maps formal/runtime resources to later success/failure/alias/capacity obligations. No speculative ABI added. Satisfied by preservation. | +| INV-SEMANTIC-NONVACUITY | Existing operational measurements unchanged; direct selector negatives and one real selected native case prevent no-work success. Satisfied. | +| INV-ORACLE-INDEPENDENCE | New emitted bytes are frozen before observation; historical errors/profile contracts are reconstructed from pinned source and producing objects; fresh claims derive from source/policy inputs. Satisfied. | +| INV-CATEGORY-SEPARATION | Formal model, finite requested capacity, aliases, native measurements, byte captures and process components remain distinct. Satisfied. | +| INV-MUTATION-REPRODUCIBILITY | Versioned 37/40 registries and actual-production runners preserve exact predicates, surfaces, positives, negative bytes and finally integrity; prior complete registries remain preserved. Satisfied. | +| CHK-FINAL | Source evidence plus post-package exact current checks/claims, final retained pass and complete collector are bound in FINAL_CERTIFICATION.json. Satisfied at handoff. | +| CHK-SCOPE | Exact base/branch, 18 complete frozen rows, protected byte/mode checks, narrow historical deltas, append-only ledger and clean private final package. Satisfied. | +| NP0R1-INTEGRITY | Production independent finally and complete fifteen-control evidence remain intact; new success/error caller pair preserves ordinary exits and separate errors. Satisfied. | +| NP0R1-TOOLCHAIN | Exact eleven-node dependency machinery, nineteen controls, original omitted-DLL finding and actual generated-link-map final hashing remain preserved. Satisfied within the declared loader boundary. | +| NP0R2-STREAMS | Existing caller contracts, complete eleven/120 evidence and expected-error diagnostics retained; current common relation now rejects the Unicode inequality class. Satisfied. | +| NP0R2-REPORT | Historical reports remain unchanged; this report separates old/source/final evidence and corrects the map wording below. Satisfied. | +| NP0R3-LITERAL | Ordinal equality after strict decoding on the actual common path; 25 actual emitted cases plus retained old/current witnesses and all legitimate historical contracts pass their exact expected verdicts. Satisfied. | +| NP0R3-SELECTOR | Actual bound null/empty/whitespace/unknown/duplicate selections reject before work; ordinal unknown-name holdouts reject; focused selection runs once; default/composed six-profile coverage preserved. Satisfied. | diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r3/ACCEPTANCE_ROWS.txt b/docs/internal/extensions/lifecycle-native-p0/repair-r3/ACCEPTANCE_ROWS.txt new file mode 100644 index 00000000..57979fcf --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r3/ACCEPTANCE_ROWS.txt @@ -0,0 +1,18 @@ +| `LN0-01` | Implement a reproducible probe of the pinned Lean 4.22 runtime array ownership operations, without altering the production RMQ ABI. Record logical size, retained capacity, requested container bytes and live element references as distinct quantities. Inspect actual runtime definitions and record compiler/runtime/header identity; do not infer capacity from Array.size. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-02` | Exercise unique and shared owners with destructor-counted elements. Demonstrate the actual effects of pop/shrink on surviving values, tail element references and retained backing capacity, without accessing freed objects. Distinguish release of one owner from reclamation when another alias remains live. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-03` | Exercise a consuming replacement-buffer route: copy surviving output values into a newly allocated bounded-capacity buffer, release the old owner, and measure which old allocations/elements remain reachable. Include success, empty output, overlap-relevant source positions, alias-retained and deterministically injected handoff/allocation-stage failure cleanup. Do not assume actual Lean allocator failure is recoverable; a fatal process outcome is reported separately. Treat observed allocator/requested capacity separately from a universal native heap theorem. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-04` | Commit an exact replay registry and positive/negative controls for logical shrink falsely labeled reclamation, retained alias falsely labeled exclusive consumption, and an omitted cleanup action. Validation executes the actual pinned runtime operations and the owned measurement/verdict path; predecessor RMQ replay is regression evidence only. The verdict must depend on observed value/ownership/capacity projections, not labels or a prewritten expected log; use the same positive predicate or a checked/explicit measured implication. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-05` | Use bounded owned compiler/probe processes, preserve full stdout/stderr and actual exits, reject unexpected or mixed diagnostics, validate focused/unknown/empty selector behavior, and exercise cleanup. A platform/toolchain inability is uncovered, not success. No credit purchase, package installation or persistent service is needed as an assumed prerequisite. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `LN0-06` | Deliver a source-grounded consuming-boundary recommendation mapping Construction.ExecState resources and Native.StorageImage/NativeImage ownership to later transfer obligations. Specify success/failure ownership, aliases, retained observations and capacity. Do not implement a speculative production BuilderOwner-to-QueryOwner ABI before the formal lifecycle interface is reviewed. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-SEMANTIC-NONVACUITY` | semantic coverage, liveness, ownership, and refinement predicates are derived from the operational construction they describe. A predicate defined to be `True`, an enumeration restated as membership, or a separately hand-written consumer label does not establish operational liveness by itself; | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-ORACLE-INDEPENDENCE` | executable fixtures and edge-case expected values come from an independent specification or a theorem already connected to it, never from the implementation result being tested; | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-CATEGORY-SEPARATION` | payload bits, proof fields, model ticks, machine state, Lean runtime, and measured performance remain distinct. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `INV-MUTATION-REPRODUCIBILITY` | when acceptance relies on an exhaustive, production, or public-dependency mutation campaign, the candidate contains a versioned runner or fixtures that replay every claimed case, check the exact expected failure/acceptance surface, restore tracked state, and leave the tree clean. Report prose, copied terminal output, and dangling Git objects are not replayable evidence. A public theorem additionally has a checked exact-type consumer that fails when the advertised dependency is removed; `#print axioms` over the theorem's current type is not such a consumer. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `CHK-FINAL` | Run the final-required checks on the final submitted content, with exact identities, complete outcomes and declared platform limits. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `CHK-SCOPE` | Keep the assigned write scope, clean committed tree, exact base, full frozen row integrity and truthful local-versus-campaign status. | Local native prerequisite | Operational observations and exact checks; see append-only evidence | Owned runtime probe -> measured verdict -> reviewed future adapter | Positive controls plus challenged value, ownership, capacity or cleanup projection | Pending; append evidence below without changing this row | Open at freeze; disposition in appended evidence | +| `NP0R1-INTEGRITY` | Every entered native replay verification lifecycle records and enforces an independent final integrity outcome in finally, including prior compiler/probe errors, unexpected diagnostics, timeout and partially initialized identity inventories. Verify every captured source/tool/generated-artifact pin and the declared live tracked/index/untracked baseline; absence of required final verification is failure or explicitly uncovered, never success. Preserve the original stage error separately from integrity errors. Detect unexpected changes without silently overwriting unrelated user data. Commit positive and changed-pin/tree controls through the actual production verifier/finalization path, including failure plus integrity failure, success plus integrity failure, and an ordinary failed stage with intact inputs. All owned fixture mutations are restored in their own finally and leave the real candidate unchanged. Keep existing owned-process cleanup and exact diagnostics/exits. | Local verification repair | Production finalizer and exact dependency checks | Captured run inputs -> final verification -> success/receipt | Isolated unchanged, tampered, failed-stage and incomplete inventories | Pending; append evidence | Open at freeze | +| `NP0R1-TOOLCHAIN` | Bind the substantive local implementation dependencies of the actually invoked pinned compiler/runtime to the replay receipt and final identity verification. In particular include clang's normal-import libclang-cpp.dll, libLLVM-19.dll and libc++.dll and inspect the invoked tools' remaining local non-system dependency closure; state the external OS/system-library and dynamic-loading boundary honestly. Include the generated link map in final available-artifact integrity checks. Commit a completeness/tamper control using actual dependency inventory and isolated manifest/file fixtures, without modifying installed tools. The original bea5ce75 runner/receipt must fail the new completeness predicate for the independently measured missing dependencies while a complete unchanged inventory passes. No installation, runtime upgrade, tool replacement or claim of universal loader/compiler verification. | Local verification repair | Production finalizer and exact dependency checks | Captured run inputs -> final verification -> success/receipt | Isolated unchanged, tampered, failed-stage and incomplete inventories | Pending; append evidence | Open at freeze | +| `NP0R2-STREAMS` | The actual native integrity-control harness and certification wrapper reject unexpected or mixed outer process stdout/stderr as well as preserving the existing inner native/launcher stream, summary, integrity and ordinary-exit checks. Define one precise stream contract for each actual caller/profile and use its production predicate in real positive/negative controls. Legitimate expected-error output must pass only with the exact expected diagnostics; extra, missing, duplicate or unrelated lines, misleading success output and mixed streams cannot be hidden by an expected exception, successful JSON or expected exit. Preserve complete raw output and actual exits, bounded ownership, cleanup and finally integrity. Reproduce the exact 2307e3ad counterexample on immutable old source/evidence and show the repaired production verdict rejects that same failure class, including actual outer stderr on successful and expected-failure cases and corresponding stdout controls. Keep all fourteen inherited rows, original operational IDs/predicates, fifteen integrity controls and nineteen dependency controls. Use isolated fixtures and restore only owned fixture state; never mutate installed tools or the live candidate. All supported wrapper profiles have a checked legitimate positive; no blanket empty-stderr rule that rejects legitimate negative-control diagnostics. | Narrow outer diagnostic repair | Exact production stream and exit predicates with replayable controls | Actual owned child capture -> caller-used validator -> certification verdict | Legitimate profiles plus extra, missing, duplicate, mixed and misleading output | Pending; append evidence | Open at freeze | +| `NP0R2-REPORT` | Deliver a complete successor report distinguishing the repaired control/certification boundary from the already-supported production finally/provenance and unchanged finite native ownership experiment. Explicitly correct the historical R1 copied-map wording: dependency_controls.ps1 creates a synthetic text map fixture; actual generated link-map capture and final hashing are separate verified observations. Preserve all historical report/receipt bytes and accurately state source-freeze, final-package, actual command results and remaining native-adapter/formal/campaign obligations. | Narrow outer diagnostic repair | Exact production stream and exit predicates with replayable controls | Actual owned child capture -> caller-used validator -> certification verdict | Legitimate profiles plus extra, missing, duplicate, mixed and misleading output | Pending; append evidence | Open at freeze | +| `NP0R3-LITERAL` | The actual common stream predicate uses literal equality after strict UTF-8 decoding (or equivalent byte comparison), preserving every admitted character and newline without culture-sensitive equivalence, BOM stripping, trimming, normalization or silent suppression. Exact legitimate success and expected-error streams pass; unequal additions including U+FEFF, U+0000 and U+00AD reject at the same production predicate with all actual transport/ordinary-exit guards intact. Retain exact old9519 accepted counterexamples and show the repaired actual caller rejects them. Distinguish prefix-specific rejection, actual emitted child captures, copied-capture profile tests and synthetic launcher components. Preserve the six supported profile meanings, expected legitimate diagnostics, claim whole-record multiplicities, complete raw evidence, finally/ownership and inherited operational predicates. No new outer wrapper layer is required. | Narrow local verifier repair | Strict decoded literal equality and direct nonempty selector controls | Actual capture -> common production predicate; actual certify_profiles boundary -> run_owned | Exact positives, unequal Unicode/transport holdouts, rejected empty selectors and one actual focused run | Pending; append evidence | Open at freeze | +| `NP0R3-SELECTOR` | The actual certify_profiles.ps1 parameter boundary distinguishes omission (the declared six-profile default) from an explicitly bound null, empty array, empty string or whitespace; rejects those, unknown and duplicate profile selections before starting work; and executes one explicitly selected valid profile exactly once. Use direct actual-boundary controls, an exact frozen control registry and an actual valid focused invocation. Preserve six-profile final manifest completeness and existing run_owned behavior. A no-work ordinary return is not successful verification. The outermost convenience launcher's own terminal text remains outside the named captured-child stream contract; do not add an unbounded wrapper hierarchy to change that scope. | Narrow local verifier repair | Strict decoded literal equality and direct nonempty selector controls | Actual capture -> common production predicate; actual certify_profiles boundary -> run_owned | Exact positives, unequal Unicode/transport holdouts, rejected empty selectors and one actual focused run | Pending; append evidence | Open at freeze | diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r3/CONTROL_REGISTRY.json b/docs/internal/extensions/lifecycle-native-p0/repair-r3/CONTROL_REGISTRY.json new file mode 100644 index 00000000..af6ac29e --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r3/CONTROL_REGISTRY.json @@ -0,0 +1,442 @@ +{ + "version": 1, + "defaultProfiles": [ + "focused", + "full", + "integrity", + "dependencies", + "checks", + "claims" + ], + "controls": [ + { + "id": "literal-success-exact", + "mode": "literal", + "predicate": "Assert-LNOuterCapture", + "tier": "actual emitted child", + "stdout": "RVhQRUNURUQgU1VDQ0VTUw0K", + "stderr": "", + "expectedStdout": "RVhQRUNURUQgU1VDQ0VTUw0K", + "expectedStderr": "", + "exit": 0, + "verdict": "accept", + "failure": "" + }, + { + "id": "literal-success-bom-stdout", + "mode": "literal", + "predicate": "Assert-LNOuterCapture", + "tier": "actual emitted child", + "stdout": "RVhQRUNURUQgU1VDQ0VTUw0K77u/", + "stderr": "", + "expectedStdout": "RVhQRUNURUQgU1VDQ0VTUw0K", + "expectedStderr": "", + "exit": 0, + "verdict": "reject", + "failure": "STREAM: literal-success-bom-stdout stdout differs" + }, + { + "id": "literal-success-bom-stderr", + "mode": "literal", + "predicate": "Assert-LNOuterCapture", + "tier": "actual emitted child", + "stdout": "RVhQRUNURUQgU1VDQ0VTUw0K", + "stderr": "77u/", + "expectedStdout": "RVhQRUNURUQgU1VDQ0VTUw0K", + "expectedStderr": "", + "exit": 0, + "verdict": "reject", + "failure": "STREAM: literal-success-bom-stderr stderr differs" + }, + { + "id": "literal-success-nul-stdout", + "mode": "literal", + "predicate": "Assert-LNOuterCapture", + "tier": "actual emitted child", + "stdout": "RVhQRUNURUQgU1VDQ0VTUw0KAA==", + "stderr": "", + "expectedStdout": "RVhQRUNURUQgU1VDQ0VTUw0K", + "expectedStderr": "", + "exit": 0, + "verdict": "reject", + "failure": "STREAM: literal-success-nul-stdout stdout differs" + }, + { + "id": "literal-success-nul-stderr", + "mode": "literal", + "predicate": "Assert-LNOuterCapture", + "tier": "actual emitted child", + "stdout": "RVhQRUNURUQgU1VDQ0VTUw0K", + "stderr": "AA==", + "expectedStdout": "RVhQRUNURUQgU1VDQ0VTUw0K", + "expectedStderr": "", + "exit": 0, + "verdict": "reject", + "failure": "STREAM: literal-success-nul-stderr stderr differs" + }, + { + "id": "literal-success-shy-stdout", + "mode": "literal", + "predicate": "Assert-LNOuterCapture", + "tier": "actual emitted child", + "stdout": "RVhQRUNURUQgU1VDQ0VTUw0Kwq0=", + "stderr": "", + "expectedStdout": "RVhQRUNURUQgU1VDQ0VTUw0K", + "expectedStderr": "", + "exit": 0, + "verdict": "reject", + "failure": "STREAM: literal-success-shy-stdout stdout differs" + }, + { + "id": "literal-success-shy-stderr", + "mode": "literal", + "predicate": "Assert-LNOuterCapture", + "tier": "actual emitted child", + "stdout": "RVhQRUNURUQgU1VDQ0VTUw0K", + "stderr": "wq0=", + "expectedStdout": "RVhQRUNURUQgU1VDQ0VTUw0K", + "expectedStderr": "", + "exit": 0, + "verdict": "reject", + "failure": "STREAM: literal-success-shy-stderr stderr differs" + }, + { + "id": "literal-success-ascii-stdout", + "mode": "literal", + "predicate": "Assert-LNOuterCapture", + "tier": "actual emitted child", + "stdout": "RVhQRUNURUQgU1VDQ0VTUw0KRVhUUkENCg==", + "stderr": "", + "expectedStdout": "RVhQRUNURUQgU1VDQ0VTUw0K", + "expectedStderr": "", + "exit": 0, + "verdict": "reject", + "failure": "STREAM: literal-success-ascii-stdout stdout differs" + }, + { + "id": "literal-success-ascii-stderr", + "mode": "literal", + "predicate": "Assert-LNOuterCapture", + "tier": "actual emitted child", + "stdout": "RVhQRUNURUQgU1VDQ0VTUw0K", + "stderr": "RVhUUkENCg==", + "expectedStdout": "RVhQRUNURUQgU1VDQ0VTUw0K", + "expectedStderr": "", + "exit": 0, + "verdict": "reject", + "failure": "STREAM: literal-success-ascii-stderr stderr differs" + }, + { + "id": "literal-error-exact", + "mode": "literal", + "predicate": "Assert-LNOuterCapture", + "tier": "actual emitted child", + "stdout": "RVhQRUNURUQgQ09OVEVYVA0K", + "stderr": "UFJPQ0VTUzogZXhwZWN0ZWQgZmFpbHVyZQ0K", + "expectedStdout": "RVhQRUNURUQgQ09OVEVYVA0K", + "expectedStderr": "UFJPQ0VTUzogZXhwZWN0ZWQgZmFpbHVyZQ0K", + "exit": 7, + "verdict": "accept", + "failure": "" + }, + { + "id": "literal-error-bom-stdout", + "mode": "literal", + "predicate": "Assert-LNOuterCapture", + "tier": "actual emitted child", + "stdout": "RVhQRUNURUQgQ09OVEVYVA0K77u/", + "stderr": "UFJPQ0VTUzogZXhwZWN0ZWQgZmFpbHVyZQ0K", + "expectedStdout": "RVhQRUNURUQgQ09OVEVYVA0K", + "expectedStderr": "UFJPQ0VTUzogZXhwZWN0ZWQgZmFpbHVyZQ0K", + "exit": 7, + "verdict": "reject", + "failure": "STREAM: literal-error-bom-stdout stdout differs" + }, + { + "id": "literal-error-bom-stderr", + "mode": "literal", + "predicate": "Assert-LNOuterCapture", + "tier": "actual emitted child", + "stdout": "RVhQRUNURUQgQ09OVEVYVA0K", + "stderr": "UFJPQ0VTUzogZXhwZWN0ZWQgZmFpbHVyZQ0K77u/", + "expectedStdout": "RVhQRUNURUQgQ09OVEVYVA0K", + "expectedStderr": "UFJPQ0VTUzogZXhwZWN0ZWQgZmFpbHVyZQ0K", + "exit": 7, + "verdict": "reject", + "failure": "STREAM: literal-error-bom-stderr stderr differs" + }, + { + "id": "literal-error-nul-stdout", + "mode": "literal", + "predicate": "Assert-LNOuterCapture", + "tier": "actual emitted child", + "stdout": "RVhQRUNURUQgQ09OVEVYVA0KAA==", + "stderr": "UFJPQ0VTUzogZXhwZWN0ZWQgZmFpbHVyZQ0K", + "expectedStdout": "RVhQRUNURUQgQ09OVEVYVA0K", + "expectedStderr": "UFJPQ0VTUzogZXhwZWN0ZWQgZmFpbHVyZQ0K", + "exit": 7, + "verdict": "reject", + "failure": "STREAM: literal-error-nul-stdout stdout differs" + }, + { + "id": "literal-error-nul-stderr", + "mode": "literal", + "predicate": "Assert-LNOuterCapture", + "tier": "actual emitted child", + "stdout": "RVhQRUNURUQgQ09OVEVYVA0K", + "stderr": "UFJPQ0VTUzogZXhwZWN0ZWQgZmFpbHVyZQ0KAA==", + "expectedStdout": "RVhQRUNURUQgQ09OVEVYVA0K", + "expectedStderr": "UFJPQ0VTUzogZXhwZWN0ZWQgZmFpbHVyZQ0K", + "exit": 7, + "verdict": "reject", + "failure": "STREAM: literal-error-nul-stderr stderr differs" + }, + { + "id": "literal-error-shy-stdout", + "mode": "literal", + "predicate": "Assert-LNOuterCapture", + "tier": "actual emitted child", + "stdout": "RVhQRUNURUQgQ09OVEVYVA0Kwq0=", + "stderr": "UFJPQ0VTUzogZXhwZWN0ZWQgZmFpbHVyZQ0K", + "expectedStdout": "RVhQRUNURUQgQ09OVEVYVA0K", + "expectedStderr": "UFJPQ0VTUzogZXhwZWN0ZWQgZmFpbHVyZQ0K", + "exit": 7, + "verdict": "reject", + "failure": "STREAM: literal-error-shy-stdout stdout differs" + }, + { + "id": "literal-error-shy-stderr", + "mode": "literal", + "predicate": "Assert-LNOuterCapture", + "tier": "actual emitted child", + "stdout": "RVhQRUNURUQgQ09OVEVYVA0K", + "stderr": "UFJPQ0VTUzogZXhwZWN0ZWQgZmFpbHVyZQ0Kwq0=", + "expectedStdout": "RVhQRUNURUQgQ09OVEVYVA0K", + "expectedStderr": "UFJPQ0VTUzogZXhwZWN0ZWQgZmFpbHVyZQ0K", + "exit": 7, + "verdict": "reject", + "failure": "STREAM: literal-error-shy-stderr stderr differs" + }, + { + "id": "literal-error-ascii-stdout", + "mode": "literal", + "predicate": "Assert-LNOuterCapture", + "tier": "actual emitted child", + "stdout": "RVhQRUNURUQgQ09OVEVYVA0KRVhUUkENCg==", + "stderr": "UFJPQ0VTUzogZXhwZWN0ZWQgZmFpbHVyZQ0K", + "expectedStdout": "RVhQRUNURUQgQ09OVEVYVA0K", + "expectedStderr": "UFJPQ0VTUzogZXhwZWN0ZWQgZmFpbHVyZQ0K", + "exit": 7, + "verdict": "reject", + "failure": "STREAM: literal-error-ascii-stdout stdout differs" + }, + { + "id": "literal-error-ascii-stderr", + "mode": "literal", + "predicate": "Assert-LNOuterCapture", + "tier": "actual emitted child", + "stdout": "RVhQRUNURUQgQ09OVEVYVA0K", + "stderr": "UFJPQ0VTUzogZXhwZWN0ZWQgZmFpbHVyZQ0KRVhUUkENCg==", + "expectedStdout": "RVhQRUNURUQgQ09OVEVYVA0K", + "expectedStderr": "UFJPQ0VTUzogZXhwZWN0ZWQgZmFpbHVyZQ0K", + "exit": 7, + "verdict": "reject", + "failure": "STREAM: literal-error-ascii-stderr stderr differs" + }, + { + "id": "holdout-lf-crlf", + "mode": "literal", + "predicate": "Assert-LNOuterCapture", + "tier": "actual emitted child", + "stdout": "bGluZQo=", + "stderr": "", + "expectedStdout": "bGluZQ0K", + "expectedStderr": "", + "exit": 0, + "verdict": "reject", + "failure": "STREAM: holdout-lf-crlf stdout differs" + }, + { + "id": "holdout-normalization", + "mode": "literal", + "predicate": "Assert-LNOuterCapture", + "tier": "actual emitted child", + "stdout": "Y2FmZcyBDQo=", + "stderr": "", + "expectedStdout": "Y2Fmw6kNCg==", + "expectedStderr": "", + "exit": 0, + "verdict": "reject", + "failure": "STREAM: holdout-normalization stdout differs" + }, + { + "id": "holdout-zero-width", + "mode": "literal", + "predicate": "Assert-LNOuterCapture", + "tier": "actual emitted child", + "stdout": "bGluZeKAiw0K", + "stderr": "", + "expectedStdout": "bGluZQ0K", + "expectedStderr": "", + "exit": 0, + "verdict": "reject", + "failure": "STREAM: holdout-zero-width stdout differs" + }, + { + "id": "holdout-nonbreaking-space", + "mode": "literal", + "predicate": "Assert-LNOuterCapture", + "tier": "actual emitted child", + "stdout": "YcKgYg0K", + "stderr": "", + "expectedStdout": "YSBiDQo=", + "expectedStderr": "", + "exit": 0, + "verdict": "reject", + "failure": "STREAM: holdout-nonbreaking-space stdout differs" + }, + { + "id": "holdout-invalid-utf8", + "mode": "literal", + "predicate": "Assert-LNOuterCapture", + "tier": "actual emitted child", + "stdout": "/w==", + "stderr": "", + "expectedStdout": "", + "expectedStderr": "", + "exit": 0, + "verdict": "reject", + "failure": "invalid-utf8" + }, + { + "id": "holdout-overlong-utf8", + "mode": "literal", + "predicate": "Assert-LNOuterCapture", + "tier": "actual emitted child", + "stdout": "wIA=", + "stderr": "", + "expectedStdout": "", + "expectedStderr": "", + "exit": 0, + "verdict": "reject", + "failure": "invalid-utf8" + }, + { + "id": "holdout-literal-codepoints", + "mode": "literal", + "predicate": "Assert-LNOuterCapture", + "tier": "actual emitted child", + "stdout": "77u/AMKtDQo=", + "stderr": "", + "expectedStdout": "77u/AMKtDQo=", + "expectedStderr": "", + "exit": 0, + "verdict": "accept", + "failure": "" + }, + { + "id": "selector-null", + "mode": "selector", + "predicate": "certify_profiles parameter boundary", + "tier": "actual script boundary in captured child", + "expression": "$null", + "verdict": "reject", + "failure": "CERTIFY-SELECTOR: empty" + }, + { + "id": "selector-empty-array", + "mode": "selector", + "predicate": "certify_profiles parameter boundary", + "tier": "actual script boundary in captured child", + "expression": "@()", + "verdict": "reject", + "failure": "CERTIFY-SELECTOR: empty" + }, + { + "id": "selector-empty-string", + "mode": "selector", + "predicate": "certify_profiles parameter boundary", + "tier": "actual script boundary in captured child", + "expression": "@('')", + "verdict": "reject", + "failure": "CERTIFY-SELECTOR: empty" + }, + { + "id": "selector-whitespace", + "mode": "selector", + "predicate": "certify_profiles parameter boundary", + "tier": "actual script boundary in captured child", + "expression": "@(' ')", + "verdict": "reject", + "failure": "CERTIFY-SELECTOR: empty" + }, + { + "id": "selector-unknown", + "mode": "selector", + "predicate": "certify_profiles parameter boundary", + "tier": "actual script boundary in captured child", + "expression": "@('unknown')", + "verdict": "reject", + "failure": "CERTIFY-SELECTOR: unknown" + }, + { + "id": "selector-duplicate", + "mode": "selector", + "predicate": "certify_profiles parameter boundary", + "tier": "actual script boundary in captured child", + "expression": "@('focused','focused')", + "verdict": "reject", + "failure": "CERTIFY-SELECTOR: duplicate" + }, + { + "id": "selector-late-empty", + "mode": "selector", + "predicate": "certify_profiles parameter boundary", + "tier": "actual script boundary in captured child", + "expression": "@('focused','')", + "verdict": "reject", + "failure": "CERTIFY-SELECTOR: empty" + }, + { + "id": "selector-late-unknown", + "mode": "selector", + "predicate": "certify_profiles parameter boundary", + "tier": "actual script boundary in captured child", + "expression": "@('focused','unknown')", + "verdict": "reject", + "failure": "CERTIFY-SELECTOR: unknown" + }, + { + "id": "selector-unknown-bom", + "mode": "selector", + "predicate": "certify_profiles parameter boundary", + "tier": "actual script boundary in captured child", + "expression": "@(('focused'+[char]0xFEFF))", + "verdict": "reject", + "failure": "CERTIFY-SELECTOR: unknown" + }, + { + "id": "selector-unknown-nul", + "mode": "selector", + "predicate": "certify_profiles parameter boundary", + "tier": "actual script boundary in captured child", + "expression": "@(('focused'+[char]0))", + "verdict": "reject", + "failure": "CERTIFY-SELECTOR: unknown" + }, + { + "id": "selector-focused", + "mode": "focused", + "predicate": "certify_profiles -> run_owned -> Assert-LNWrapperCapture", + "tier": "actual focused native run", + "verdict": "accept" + }, + { + "id": "integrity-caller-pair", + "mode": "integrity", + "predicate": "unchanged harness_stream_controls -> integrity_controls -> Assert-LNOuterCapture", + "tier": "source-derived integrity callers, native 0/7, runner 0/1", + "verdict": "accept" + } + ] +} diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r3/FREEZE.json b/docs/internal/extensions/lifecycle-native-p0/repair-r3/FREEZE.json new file mode 100644 index 00000000..eb128030 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r3/FREEZE.json @@ -0,0 +1,31 @@ +{ + "base": "9519b2c1af5e2cf59536b311db5e8dc81376a32f", + "ids": [ + "LN0-01", + "LN0-02", + "LN0-03", + "LN0-04", + "LN0-05", + "LN0-06", + "INV-SEMANTIC-NONVACUITY", + "INV-ORACLE-INDEPENDENCE", + "INV-CATEGORY-SEPARATION", + "INV-MUTATION-REPRODUCIBILITY", + "CHK-FINAL", + "CHK-SCOPE", + "NP0R1-INTEGRITY", + "NP0R1-TOOLCHAIN", + "NP0R2-STREAMS", + "NP0R2-REPORT", + "NP0R3-LITERAL", + "NP0R3-SELECTOR" + ], + "inherited": 16, + "rowsSha256": "d567ff2b9f861a6a910cc94a9e7abb44d2d559893cbbc7293cefbe798ce01abf", + "prompt": { + "path": "C:\\Users\\poin\\Documents\\RMQ\\lifecycle-implementation-20260920\\LIFE-NATIVE-P0-R3_PROMPT.md", + "bytes": 28741, + "sha256": "901e5559c45a711b92bd686482934596d7259d0d21d7fa628b7c1851969c4172" + }, + "template": "docs/internal/templates/PROOF_ACCEPTANCE_MATRIX.md" +} diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r3/REPORT.md b/docs/internal/extensions/lifecycle-native-p0/repair-r3/REPORT.md new file mode 100644 index 00000000..d3ab6bac --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r3/REPORT.md @@ -0,0 +1,143 @@ +Status: CANDIDATE_COMPLETE +I found no assigned or inherited acceptance criterion unmet; coordinator acceptance is still required. + +# LIFE-NATIVE-P0-R3: literal diagnostic streams and nonempty profile selection + +This candidate repairs the common diagnostic equality operation and the actual certification selector. It preserves the finite native ownership experiment, R1 finally/provenance repair, R2 caller boundaries, historical reports, and historical accepted counterexamples. It does not implement the consuming adapter or close the lifecycle roadmap node. + +## Exact identity and source/package boundary + +Worktree: `C:/Users/poin/.codex/worktrees/367c/RMQ`. +Branch: `codex/life-native-p0-r3-literal-streams`. +Exact base: `9519b2c1af5e2cf59536b311db5e8dc81376a32f`. +Governance: `7b227c49ef2ec044b702126cc41c9add847eed01`. +Source freeze tested by all 37 new controls: `6bcd1fc50020482ab441723a1964eec0232d223f`. + +`START.json` records the initially clean exact worktree, actual three-role runtime inventory, required `rmq-proof-sprint`, and complete successful preflight. The app-provided detached checkout already had the required base; only this worktree was switched to the requested private branch. No fetch, push, integration, primary-checkout edit or destructive retirement occurred. + +The exact final package commit, report bytes/SHA256, current checks, current claims, final retained revalidation and full pin inventory are recorded after packaging in `C:/Users/poin/.codex/worktrees/367c/RMQ/.lake/repair-r3/FINAL_CERTIFICATION.json`. Its `finalPackageCommit` and `cleanHead` name the final commit; `report` pins this complete file. The terminal handoff repeats those exact identities. This acyclic source/package convention avoids embedding a report's future containing commit or its own hash inside itself. Source-phase evidence below remains attributed to its actual source commit. + +## Frozen requirements and write scope + +[ACCEPTANCE_MATRIX.md](ACCEPTANCE_MATRIX.md) uses the canonical eight-column template and includes the completed local row dispositions. All sixteen complete inherited rows were copied as strict UTF-8 bytes from the exact base, retaining every historical pending cell. Two complete rows were added before implementation. `ACCEPTANCE_ROWS.txt` freezes all eighteen ordered rows, SHA256 `D567FF2B9F861A6A910CC94A9E7ABB44D2D559893CBBC7293CEFBE798CE01ABF`. Every requirement cell is independently compared with the commissioning prompt: 28,741 bytes, SHA256 `901E5559C45A711B92BD686482934596D7259D0D21D7FA628B7C1851969C4172`. Evidence is appended separately; old rows and matrices were not rewritten. + +Production changes are confined to: + +- `scripts/packed_native_lifecycle_stream_check.ps1`: one ordinal equality operation and the checks profile's exact 9519 base. +- `repair-r2/certify_profiles.ps1`: complete upfront validation of explicitly bound selections. +- `repair-r1/final_checks.ps1`: the same exact base and R3 contract-verifier dispatch. + +The other additions are local R3 registries, evidence adapters, this report, its compact index and appended workflow decisions. The unchanged production classifier checks this internal workflow scope. No Lean, C, lakefile, toolchain, ABI, global process helper, integrity/dependency driver, R2 control/parser, policy, skill, template, attribute or public-source change occurred. No mathematical design decision required a `DESIGN_DECISIONS.md` edit. Current public wording, public comments and theorem migration inventories are not applicable. + +## Actual predicates and caller composition + +`Read-LNExactStream` still calls `UTF8Encoding(false,true).GetString(ReadAllBytes(path))`. It rejects missing files and malformed UTF-8; it does not strip a BOM. The old comparison `$Actual -cne $Expected` is replaced by `[string]::Equals($Actual,$Expected,[StringComparison]::Ordinal)`. The decoder and equality operation have distinct roles: strict decoding does not itself make a culture comparison literal. + +For one capture `c`, expected strings `o,e`, ordinary exit `x` and profile label, the production predicate is the conjunction of: + +1. A present launcher; no timeout or output limit; absent raw-child error/overflow markers. +2. Empty launcher output arrays and retention-error array. +3. Strictly decoded retained launcher stdout and stderr both ordinal-equal to the empty string. +4. A present actual child exit and both actual child and launcher ordinary exits equal to `x`. +5. Strictly decoded child stdout ordinal-equal to `o`, and child stderr ordinal-equal to `e`. + +These are the unchanged guards of `Assert-LNOuterCapture`, with only its common string relation repaired. No successful receipt flag, expected exception prefix or copied comparator replaces them. The native integrity harness still calls this function after checking its actual inner stage, raw bytes, independent finally outcome and separately derived stage/integrity diagnostics. `run_owned` still calls `Assert-LNWrapperCapture`, which performs the declared profile-specific checks and then calls the common predicate. + +Positive P and negative Q use that same current predicate on the same kind of capture/expected-string/exit object; the negative changes only the independently prescribed output bytes. Each live control first establishes the complete emitted bytes and actual transport/exits before crediting its exact rejection surface. The malformed UTF-8 controls explicitly retain and check both streams and the ordinary exit artifact even though decoding must reject. The independent collector also checks that exit artifact before handling the decoder rejection. + +The historical P/Q comparison loads the exact unchanged 9519 helper and current helper in separate function scopes and applies both actual callers to identical retained captures, strings and ordinary exits. It does not substitute a stronger test-only equality. On the named root captures, old P accepts trailing EF-BB-BF after the expected error and EF-BB-BF-only stderr; current Q rejects both. Exact expected error passes both, and ordinary extra ASCII rejects both. + +All six profile meanings remain: focused/full native summary and independent integrity, fifteen integrity diagnostics, nineteen dependency controls, current exact checks roster, and source-derived claims. Claims retain their ordinal whole-record multiset with exact multiplicities and footer; whole-record ordering is an admitted profile variation. Its expected text is passed to the common transport check only after that independent complete-record matcher. No blanket empty-stderr rule is imposed on legitimate expected-error callers. + +## Actual selector boundary + +The original six-profile default remains in the actual parameter declaration. If `Kinds` is explicitly bound, null/zero-length selections and any null/empty/whitespace item reject immediately. An ordinal supported-name set rejects unknown names; an ordinal seen-name set rejects duplicates. Validation of the entire list precedes repository/output setup and every child invocation. A valid leading profile cannot execute before a later invalid item is discovered. + +The direct boundary controls cover null, empty array, empty string, whitespace, unknown, duplicate, valid-plus-empty, valid-plus-unknown, and unknown names with trailing U+FEFF or U+0000. Each actual script call throws the exact declared selector error, produces the expected caught-boundary marker and no unrelated output, and creates no target output directory or profile child. The source ordering establishes that no work precedes the guard. The same ordinal discipline is used by the new control-ID selector. + +The real focused invocation calls actual `certify_profiles -Kinds @('focused')`, then unchanged `run_owned` and the current complete wrapper predicate. Its manifest contains exactly one profile and its native summary selects exactly `pop-unique`. The unchanged focused runner also performs its common setup and explicit fatal-handler observation: the recorded focused result has two checks and seven stages, including fatal handler exit 1 labeled as neither actual exhaustion nor recoverable allocation failure. One selected profile/case does not mean only one administrative process. + +Omission is checked against the actual script AST's exact six-name default, composed with all six preserved legitimate profiles and the final six-profile manifest. No redundant full native campaign was run merely to exercise default parameter binding. The outermost convenience launcher's own terminal text remains outside the named captured-child production contract. + +## Versioned controls and observed source results + +`CONTROL_REGISTRY.json` contains 37 exact ordered cases, including ID-to-object, predicate, tier, expected bytes and verdict. Its canonical LF file is 14,326 bytes, SHA256 `16E26C5B131BBE258B3813BCDB252414E8BED454EF6286EB2ED7F7EF3496261D`. The runner pins those complete bytes; the contract adapter independently checks the ordered roster. `make_registry.py` prescribes the bytes before execution and writes canonical bytes rather than depending on Windows text newline translation. + +The 37 cases consist of 25 actual emitted-child controls, ten direct invalid-selector boundaries, one real focused native profile and one source-derived integrity caller pair. The emitted cases cover legitimate success and expected-error streams; additions of U+FEFF, U+0000, U+00AD and ASCII on both stdout/stderr; LF versus CRLF; canonically equivalent but unequal Unicode sequences; zero-width and nonbreaking-space differences; malformed and overlong UTF-8; and an exact positive containing the three named codepoints. Thus those characters are preserved when declared and rejected when added, rather than suppressed. + +All five successful groups are from the same clean source freeze. Full raw stdout/stderr, actual exits, source pins, driver identity, selection, outcomes and final tree/pin checks are at these paths below `.lake/repair-r3/`: + +| Source group | Controls | Outer elapsed seconds | Deadline seconds | Actual child/launcher exits | +| --- | ---: | ---: | ---: | --- | +| source-tiny-success | 9 | 46.279 | 300 | 0/0 | +| source-tiny-error | 9 | 110.817 | 300 | 0/0 | +| source-tiny-holdouts-selectors | 17 | 73.394 | 300 | 0/0 | +| source-focused | 1 | 55.622 | 1200 | 0/0 | +| source-integrity | 1 pair | 83.205 | 300 | 0/0 | + +Each directory contains `LAUNCH.json`, the complete parent capture, and `controls/RESULTS.json`. These five selections concatenate to the exact 37-case registry once. The focused inner wrapper took 34.712 seconds and consumed native summary `C:/Users/poin/.codex/worktrees/367c/RMQ/.lake/lifecycle-native-p0/runs/fe16a6c6c836478a90e17b6e68f4174f/SUMMARY.json`. + +The integrity pair invokes the protected R2 harness for `success-positive,error-positive`, which derives the current actual integrity caller while preserving its full production prefix/suffix, stage guards, catch/finally/verdict and fixture restoration. Actual native/runner exits are respectively 0/0 and 7/1, with intact independent integrity in both. Expected PROCESS stderr passes only with its exact prescribed diagnostic. This is a real source-derived caller regression using tiny stage fixtures, not a new C ownership experiment. + +`retained_registry.json` separately freezes 40 exact cases. Twenty-one reapply the repaired common predicate to six historical legitimate profiles and all fifteen integrity diagnostic captures, with independently reconstructed old source/producing-root contracts. The remaining nineteen compare the exact old/current actual predicate: four named root emitted captures, four leaf emitted captures, five historically copied focused captures and six explicitly synthetic launcher Unicode components. Old P accepts fifteen and rejects four of those nineteen; current Q accepts three legitimate references and rejects sixteen negatives. The four preexisting rejections include ordinary ASCII additions and the leading-BOM evidence-prefix case. A leading BOM can already fail ordinal prefix parsing; this candidate does not invent a universal placement claim. + +The source retained pass is `.lake/repair-r3/source-retained/RESULTS.json`: 40/40, 342 final pins, intact final tree, child/launcher 0/0, 31.47 seconds under 300 seconds. It is a retained component pass, not fresh native execution. Original raw addresses and paths are not rebased, normalized or rewritten. Historical checks use their own 2307-to-9519 roster; they do not certify the current HEAD. Final packaging repeats the cheap retained component pass against the final contract and source pins. + +## Preserved evidence and final certification + +The fresh source contract at `.lake/repair-r3/SOURCE_CONTRACT.json` passed through actual owned capture and the repaired common predicate: child/launcher 0/0, 49.48 seconds under 300 seconds. It verifies 18 frozen rows and 11 row controls; 3,689 protected base paths; 1,027 R1 historical pins; the independently reviewed 3,016-file R2 inventory; 1,125 baseline sources; and 2,910 unchanged outside claim paths. Row controls accept the original and reject missing, duplicate, reordered, non-requirement-cell, requirement, mojibake, invalid-UTF8 and extra-column mutations, including separate mutations of both new requirements. + +The unchanged R2 parsers reconstruct the complete original native 23-case/65-check/58-stage evidence, fifteen integrity controls, nineteen dependency controls, eleven harness controls and 120 wrapper controls. The latter remain an explicitly mixed component/process/boundary campaign, not 120 native executions. The original 2307 accepted-extra-diagnostic counterexample and all old reports/receipts remain immutable. Exact historical tracked source uses its pinned raw bytes plus the named Git blob/checkout-clean relation; raw process captures always use their actual bytes. This explicit distinction handles historical CRLF source without normalizing diagnostics. + +The final certificate composes three retained historical profiles (full, integrity, dependencies) with the actual new focused profile and fresh checks/claims. The checks profile and final dispatch both use exact base 9519. Final checks execute the successor 18-row contract, hygiene and native-decision scans, working and committed-range whitespace, strict design against the base and each new commit's parent, and clean HEAD. Both rg no-match exits are correctly 1 with empty output; they are not reported as exit 0. + +Fresh claims run the unchanged strict scanner on the entire native-p0 subtree and both design ledgers, including this complete report and the new evidence scripts. The final evidence invocation records the clean producing HEAD, actual commands/captures and exact scanned-input bytes before and after; the collector compares those inputs with the final tree. This prevents a stale same-worktree claims receipt from being substituted merely by editing a manifest head. Its expected complete records are independently produced from unchanged policy/source/rg inputs and matched with actual multiplicities. Coverage composes with the verified historical full scan only after re-establishing outside paths, scanner, policy, rg and configuration identity; it is not a new full-root scan or a proof of all prose. + +No duplicate Lake build, full native campaign or full dependency campaign was justified: the protected Lean/C/lake/toolchain/build-input relation and baseline evidence passed, and the comparison/selector change does not alter native ownership operations. The final campaign aggregate and fresh-blind audit remain coordinator-owned. Final current verification and the completed-report pin are in the external final certificate rather than a recursive report-hash commit. + +## Failed attempts retained as failures + +The original combined tiny run, `.lake/repair-r3/source-tiny/LAUNCH.json`, reached its 300-second bound after partial progress. Owned capture elapsed times were roughly 2.4–3.5 seconds, with long pre-capture gaps consistent with shared-mutex waiting; mutex wait duration was not separately instrumented. The helper reports timeout and sentinel launcher exit -1; the enclosing killed script has no actual ordinary exit. No ordinary exit was fabricated and no partial group was credited. Cleanup and source identity were checked before replaying smaller selections under the same 300-second bound. `.lake/repair-r3/source-tiny/TIMEOUT_REVIEW.json` records that a prior captured pwsh PID 25608 (actual exit 0) had been reused by a later `sleep` process with a later creation time; that unrelated process was not killed. All successful replacement groups have completed finally checks. + +The first retained convenience driver expected a forward-slash output path while the actual adapter correctly printed its canonical Windows path. The adapter itself completed 40 cases with child/launcher 0/0; the convenience driver then exited 1. Its original bytes and failed `source-retained-outer/LAUNCH.json` remain preserved. `REVALIDATED_LAUNCH.json` checks the same unchanged capture against the source-derived canonical expected line without relabeling that failed convenience invocation. The final run uses a separate corrected canonical-path driver and final source identity. + +The first post-package current-profile invocation at `a7b8566a44f9ff6d3e9c294f822937eaa76c3754` failed the existing contract's ripgrep path-identity guard. The elevated shell resolved the separately installed WinGet ripgrep before the pinned Codex binary, whereas the source-phase environment had resolved the pinned binary. `.lake/repair-r3/final-current-outer/LAUNCH.json` retains child/launcher exit 1/1, and `final-current/RESULTS.json` records intact before/after source integrity. No final profile from that attempt is credited. A separate convenience driver checks the original claim-context hash and pinned binary hash, then prepends that existing binary's directory to PATH only in its disposable process and children. No installed tool, persistent environment, source predicate or policy changed. The subsequent final run uses a fresh output directory and the complete updated report package. + +The next invocation at `9a15563f4231e79bb143ddbd885f6171811f94d2` passed all ten final source checks, but the protected claim-expectation producer rejected multiple discoverable ripgrep executables. Merely prepending the pinned directory retained duplicate entries and another installed binary. The failed actual producer capture remains under `.lake/repair-r2/claim-expectation-601656b494b34fe1ad49851c83eac203/producer/`; `final-current-pinned-tools-outer/LAUNCH.json` and its `RESULTS.json` retain the enclosing failure and intact finally outcome. A narrow diagnostic then removed ripgrep-containing directories and duplicate PATH entries only in the disposable process, inserted the one hash-checked pinned directory, required exactly one resolved application, and reran only the actual expectation producer. It passed at `.lake/repair-r2/claim-expectation-042b2d5a1b6b4cb4a26681d312fa2cd3/EXPECTATION.json`. This component pass diagnoses tool discovery; fresh checks/claims on the final updated report remain the credited final evidence. No installed executable or persistent PATH was edited. + +Two development preservation checks rejected accidental edited-line newline changes; those were restored before the source freeze. A source review caught culture-sensitive membership in the first draft of the new selector and control-ID validation; both were corrected to ordinal sets before any credited run. A later evidence review strengthened the collector's malformed-byte exit check, actual driver/capture identity and final claims source binding. Those are evidence-consumer changes; the already-tested production and control sources remain byte-identical. + +## All eighteen local dispositions + +The appended evidence section of the frozen matrix supplies the row-to-artifact map. The following dispositions concern the assigned local rung only. + +| ID | Evidence conclusion and local disposition | +| --- | --- | +| LN0-01 | Preserved exact C/runtime/header/compiler identity and finite size/capacity/requested-container/reference observations; baseline and full raw evidence rehashed. Satisfied by preservation. | +| LN0-02 | Preserved unique/shared owner operations, destructor observations and alias-retained capacity distinctions. Satisfied by preservation. | +| LN0-03 | Preserved replacement success/empty/overlap/alias/staged-failure cases and cleanup predicates; fatal handler remains separate from recoverable allocation failure. Satisfied by preservation. | +| LN0-04 | Exact 23/65/58 operational IDs, predicates and replay evidence retained; actual new focused case and independent controls remain nonvacuous. Satisfied. | +| LN0-05 | Literal complete streams plus actual transport/exits now enforced; explicit invalid selection rejects before work; real focused invocation and cleanup pass. Satisfied. | +| LN0-06 | Protected `BOUNDARY.md` recommendation still maps formal/runtime resources to later success/failure/alias/capacity obligations. No speculative ABI added. Satisfied by preservation. | +| INV-SEMANTIC-NONVACUITY | Existing operational measurements unchanged; direct selector negatives and one real selected native case prevent no-work success. Satisfied. | +| INV-ORACLE-INDEPENDENCE | New emitted bytes are frozen before observation; historical errors/profile contracts are reconstructed from pinned source and producing objects; fresh claims derive from source/policy inputs. Satisfied. | +| INV-CATEGORY-SEPARATION | Formal model, finite requested capacity, aliases, native measurements, byte captures and process components remain distinct. Satisfied. | +| INV-MUTATION-REPRODUCIBILITY | Versioned 37/40 registries and actual-production runners preserve exact predicates, surfaces, positives, negative bytes and finally integrity; prior complete registries remain preserved. Satisfied. | +| CHK-FINAL | Source evidence plus post-package exact current checks/claims, final retained pass and complete collector are bound in FINAL_CERTIFICATION.json. Satisfied at handoff. | +| CHK-SCOPE | Exact base/branch, 18 complete frozen rows, protected byte/mode checks, narrow historical deltas, append-only ledger and clean private final package. Satisfied. | +| NP0R1-INTEGRITY | Production independent finally and complete fifteen-control evidence remain intact; new success/error caller pair preserves ordinary exits and separate errors. Satisfied. | +| NP0R1-TOOLCHAIN | Exact eleven-node dependency machinery, nineteen controls, original omitted-DLL finding and actual generated-link-map final hashing remain preserved. Satisfied within the declared loader boundary. | +| NP0R2-STREAMS | Existing caller contracts, complete eleven/120 evidence and expected-error diagnostics retained; current common relation now rejects the Unicode inequality class. Satisfied. | +| NP0R2-REPORT | Historical reports remain unchanged; this report separates old/source/final evidence and corrects the map wording below. Satisfied. | +| NP0R3-LITERAL | Ordinal equality after strict decoding on the actual common path; 25 actual emitted cases plus retained old/current witnesses and all legitimate historical contracts pass their exact expected verdicts. Satisfied. | +| NP0R3-SELECTOR | Actual bound null/empty/whitespace/unknown/duplicate selections reject before work; ordinal unknown-name holdouts reject; focused selection runs once; default/composed six-profile coverage preserved. Satisfied. | + +## Digestion, assumptions and downstream obligations + +Conceptually, the repair makes the implementation's equality relation agree with the declared literal stream contract. In plain English, an unexpected invisible character is still unexpected output, while an explicitly declared invisible character is preserved. The selector now rejects an explicit request to verify nothing and validates the complete request before acting. + +The R1 wording correction remains explicit: `dependency_controls.ps1` creates a synthetic text map fixture. Capturing an actual compiler-generated link map and hashing it in production finalization are separate verified observations; the synthetic fixture is not a copied generated map. + +Live assumptions include the pinned PowerShell/.NET strict decoder and ordinal comparison implementations, unchanged owned-process/byte-copy helpers, the Windows job/OS boundary, protected source-derived expectations, and the declared normal-import compiler/runtime dependency closure. OS/system libraries and dynamic loading remain external boundaries. The finite suite is regression evidence and source-level contract justification, not a formally verified implementation of PowerShell/.NET. The inherited final-drain overflow coverage limit remains. Finite requested container capacity is neither an RSS measurement nor a universal native heap theorem; known-root alias observations do not quantify over arbitrary foreign references. + +A skeptical reviewer should reconstruct the same captures/strings/ordinary exits at the actual caller, inspect the historical versus current checks rosters, and verify the final scanned report/input pins. Those obligations are served by the versioned adapters and raw records, not deferred as prose risk. The genuinely later work is the reviewed formal/native consuming adapter, a serialized complete joint aggregate, a fresh-blind exact-candidate audit and coordinator acceptance. LIFE-1-R1's interface remains its owner's responsibility. No adapter, integration, push, campaign closure or acceptance is claimed here. diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r3/RESULTS.json b/docs/internal/extensions/lifecycle-native-p0/repair-r3/RESULTS.json new file mode 100644 index 00000000..724d20cb --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r3/RESULTS.json @@ -0,0 +1,250 @@ +{ + "status": "SOURCE_EVIDENCE_COMPLETE", + "base": "9519b2c1af5e2cf59536b311db5e8dc81376a32f", + "sourceCommit": "6bcd1fc50020482ab441723a1964eec0232d223f", + "worktree": "C:\\Users\\poin\\.codex\\worktrees\\367c\\RMQ", + "controls": 37, + "groups": [ + { + "launch": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\367c\\RMQ\\.lake\\repair-r3\\source-tiny-success\\LAUNCH.json", + "bytes": 5696, + "sha256": "E071D623BDF29FDA98A63C0A3FDF2929D97586EF07FF613548FDC7802B9596D2" + }, + "results": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\367c\\RMQ\\.lake\\repair-r3\\source-tiny-success\\controls\\RESULTS.json", + "bytes": 53796, + "sha256": "D75E0A6889A0B6C077A86EABE965285DD01CEB9613FB1CD90B4445554BF10DE6" + }, + "selected": [ + "literal-success-exact", + "literal-success-bom-stdout", + "literal-success-bom-stderr", + "literal-success-nul-stdout", + "literal-success-nul-stderr", + "literal-success-shy-stdout", + "literal-success-shy-stderr", + "literal-success-ascii-stdout", + "literal-success-ascii-stderr" + ], + "actual": { + "pid": 30884, + "exitCode": 0, + "durationSeconds": 44.5340132 + }, + "launcherExit": 0 + }, + { + "launch": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\367c\\RMQ\\.lake\\repair-r3\\source-tiny-error\\LAUNCH.json", + "bytes": 5622, + "sha256": "9BF265EFE0806657446BED269333BEAA0DAC8C3F1FCECDA9D5B06B4FB4988B35" + }, + "results": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\367c\\RMQ\\.lake\\repair-r3\\source-tiny-error\\controls\\RESULTS.json", + "bytes": 53087, + "sha256": "7FCEB6DBB40F7576DDF8C6824B84D2385EEAC27858945100202E0FE87D586A56" + }, + "selected": [ + "literal-error-exact", + "literal-error-bom-stdout", + "literal-error-bom-stderr", + "literal-error-nul-stdout", + "literal-error-nul-stderr", + "literal-error-shy-stdout", + "literal-error-shy-stderr", + "literal-error-ascii-stdout", + "literal-error-ascii-stderr" + ], + "actual": { + "pid": 24700, + "exitCode": 0, + "durationSeconds": 108.0620985 + }, + "launcherExit": 0 + }, + { + "launch": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\367c\\RMQ\\.lake\\repair-r3\\source-tiny-holdouts-selectors\\LAUNCH.json", + "bytes": 6348, + "sha256": "CBFC83F25A7DF0F52D0A023BBC590FA2B6B4738BEDF4DE917B6579A7F0DC9278" + }, + "results": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\367c\\RMQ\\.lake\\repair-r3\\source-tiny-holdouts-selectors\\controls\\RESULTS.json", + "bytes": 100723, + "sha256": "7AD29972239280B7D1C5A78DFBB6909118D6FA4F59A2B35B33340E536372B278" + }, + "selected": [ + "holdout-lf-crlf", + "holdout-normalization", + "holdout-zero-width", + "holdout-nonbreaking-space", + "holdout-invalid-utf8", + "holdout-overlong-utf8", + "holdout-literal-codepoints", + "selector-null", + "selector-empty-array", + "selector-empty-string", + "selector-whitespace", + "selector-unknown", + "selector-duplicate", + "selector-late-empty", + "selector-late-unknown", + "selector-unknown-bom", + "selector-unknown-nul" + ], + "actual": { + "pid": 27496, + "exitCode": 0, + "durationSeconds": 71.6867527 + }, + "launcherExit": 0 + }, + { + "launch": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\367c\\RMQ\\.lake\\repair-r3\\source-focused\\LAUNCH.json", + "bytes": 4937, + "sha256": "E8EEFAB4F1CC953CD95679543DEDF272214A8015CFD05F066441131B73927998" + }, + "results": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\367c\\RMQ\\.lake\\repair-r3\\source-focused\\controls\\RESULTS.json", + "bytes": 9368, + "sha256": "BF514EAE811963A25383557608CB627A6E80FCC2CF766BE385D5BAD8EDAEE9E3" + }, + "selected": [ + "selector-focused" + ], + "actual": { + "pid": 25052, + "exitCode": 0, + "durationSeconds": 54.4175713 + }, + "launcherExit": 0 + }, + { + "launch": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\367c\\RMQ\\.lake\\repair-r3\\source-integrity\\LAUNCH.json", + "bytes": 4990, + "sha256": "5EAB4B90B2DAA02E5250288390AFC7433AEC3D5AB278963A7D37DDCB543F99BC" + }, + "results": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\367c\\RMQ\\.lake\\repair-r3\\source-integrity\\controls\\RESULTS.json", + "bytes": 8598, + "sha256": "1ADB67CC95D96D462A3C1934C6E6E55D2D404EE613823C552349B09D5F921C50" + }, + "selected": [ + "integrity-caller-pair" + ], + "actual": { + "pid": 31016, + "exitCode": 0, + "durationSeconds": 81.9114243 + }, + "launcherExit": 0 + } + ], + "registry": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\367c\\RMQ\\docs\\internal\\extensions\\lifecycle-native-p0\\repair-r3\\CONTROL_REGISTRY.json", + "bytes": 14326, + "sha256": "16E26C5B131BBE258B3813BCDB252414E8BED454EF6286EB2ED7F7EF3496261D" + }, + "sourceContract": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\367c\\RMQ\\.lake\\repair-r3\\SOURCE_CONTRACT.json", + "bytes": 479159, + "sha256": "CAA7444A0A6121E2A19F24DEA2805B7EC887DBD34BDCF89032E292771DD709D7" + }, + "sourceContractCapture": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\367c\\RMQ\\.lake\\repair-r3\\source-contract-capture\\CAPTURE.json", + "bytes": 3843, + "sha256": "EBAAE6FBDBD19A9AF3ABD9154F73EF393C6D62FC4A84F7CD6507534B210A9D15" + }, + "retained": { + "cases": 40, + "registry": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\367c\\RMQ\\docs\\internal\\extensions\\lifecycle-native-p0\\repair-r3\\retained_registry.json", + "bytes": 3340, + "sha256": "521BFA0CD6DEE84383AB41F8B7D6CC0F226EEFABFC96113EF5EBE835A48A20EB" + }, + "results": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\367c\\RMQ\\.lake\\repair-r3\\source-retained\\RESULTS.json", + "bytes": 461957, + "sha256": "41487CC705A7E67CAFD7885EEC2DD387DCCA6F501EED7830325A4E6EC6DC261D" + }, + "correctedSameCaptureValidation": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\367c\\RMQ\\.lake\\repair-r3\\source-retained-outer\\REVALIDATED_LAUNCH.json", + "bytes": 5983, + "sha256": "EA7E781829E2331359729C4CA277D9129163BAF4119586626A223E286FD7F428" + } + }, + "excludedFailedAttempts": [ + { + "reason": "300-second timeout; partial controls not credited; no actual ordinary enclosing-child exit", + "launch": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\367c\\RMQ\\.lake\\repair-r3\\source-tiny\\LAUNCH.json", + "bytes": 7155, + "sha256": "3ADCC447FD979CE2DF050836C61DE7934A223CDA738ED6803DCD264DD4A903A8" + }, + "review": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\367c\\RMQ\\.lake\\repair-r3\\source-tiny\\TIMEOUT_REVIEW.json", + "bytes": 6775, + "sha256": "82886A69F4184A4897EE804A46CBDC2539F96FD4DF6FAA4BC83F629BF25BCEC9" + } + }, + { + "reason": "Convenience driver expected noncanonical path; its failure remains preserved", + "launch": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\367c\\RMQ\\.lake\\repair-r3\\source-retained-outer\\LAUNCH.json", + "bytes": 4887, + "sha256": "25F627B18017038793BB1B98A287378B50DF5B66EB5D0377DA11CDE963062983" + } + }, + { + "reason": "Elevated PATH resolved WinGet ripgrep before the exact pinned Codex ripgrep; existing identity guard rejected, final tree integrity intact", + "packageCommit": "a7b8566a44f9ff6d3e9c294f822937eaa76c3754", + "launch": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\367c\\RMQ\\.lake\\repair-r3\\final-current-outer\\LAUNCH.json", + "bytes": 5871, + "sha256": "E6B91DF1D690EB26C7B9D1A66DFB21F3D0A104B8D431ACF2CFBBCE5A50C2848A" + }, + "finalIntegrity": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\367c\\RMQ\\.lake\\repair-r3\\final-current\\RESULTS.json", + "bytes": 2668559, + "sha256": "51D68E61435A088069AF64BD706FA7472A6E04F8CC017FA0A35B4B0CDFCEE97A" + } + }, + { + "reason": "Checks passed but unchanged claim producer rejected duplicate/multiple discoverable rg applications; no final claims receipt", + "packageCommit": "9a15563f4231e79bb143ddbd885f6171811f94d2", + "launch": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\367c\\RMQ\\.lake\\repair-r3\\final-current-pinned-tools-outer\\LAUNCH.json", + "bytes": 6810, + "sha256": "46CA3C19F7B33A1DF7AAA44149C6C700A99CFCA970B24A596146489F012BD0E3" + }, + "finalIntegrity": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\367c\\RMQ\\.lake\\repair-r3\\final-current-pinned-tools\\RESULTS.json", + "bytes": 2668950, + "sha256": "4ECAF6ECDA19633A41993FD7F70DBAF3986258782C99409687BF0235E225ABE7" + }, + "producer": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\367c\\RMQ\\.lake\\repair-r2\\claim-expectation-601656b494b34fe1ad49851c83eac203\\producer\\CAPTURE.json", + "bytes": 4692, + "sha256": "8B6B36D188F1AF85699081E187B75A1780C6EDD6F1831EE7D9334B5FD97F951F" + } + } + ], + "finalCertification": "C:\\Users\\poin\\.codex\\worktrees\\367c\\RMQ\\.lake\\repair-r3\\FINAL_CERTIFICATION.json", + "boundary": "Source evidence only. Final certificate records the clean package commit, report pin, fresh checks/claims, final retained pass and all six composed profiles. No coordinator acceptance or campaign closure.", + "toolDiscoveryDiagnostic": { + "scope": "Actual expectation producer only; final package checks/claims remain separate", + "result": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\367c\\RMQ\\.lake\\repair-r3\\CLAIM_PRODUCER_DIAGNOSTIC.json", + "bytes": 196427, + "sha256": "9ACED0E8B6E374658AFF32C28179FE7F28ACB1B5134A1D712ADA33CB83021CBE" + }, + "producer": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\367c\\RMQ\\.lake\\repair-r2\\claim-expectation-042b2d5a1b6b4cb4a26681d312fa2cd3\\producer\\CAPTURE.json", + "bytes": 4690, + "sha256": "6A047D7560EEB836B820F77FF946C2F7789569FA6C7ED4157F2C963A578F3A7F" + } + } +} diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r3/START.json b/docs/internal/extensions/lifecycle-native-p0/repair-r3/START.json new file mode 100644 index 00000000..dec3323f --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r3/START.json @@ -0,0 +1,34 @@ +{ + "handle": "LIFE-NATIVE-P0-R3", + "title": "(LIFE-NATIVE-P0-R3) Make stream equality literal", + "worktree": "C:\\Users\\poin\\.codex\\worktrees\\367c\\RMQ", + "base": "9519b2c1af5e2cf59536b311db5e8dc81376a32f", + "head": "9519b2c1af5e2cf59536b311db5e8dc81376a32f", + "branch": "codex/life-native-p0-r3-literal-streams", + "initialClean": true, + "initialStatus": "", + "governance": "7b227c49ef2ec044b702126cc41c9add847eed01", + "runtimeProjectSkills": [ + "rmq-audit-prompt", + "rmq-coordinator", + "rmq-proof-sprint" + ], + "requiredSkills": [ + "rmq-proof-sprint" + ], + "preflightExit": 0, + "preflightOutput": [ + "warning: unable to access 'C:\\Users\\poin/.config/git/ignore': Permission denied", + "warning: unable to access 'C:\\Users\\poin/.config/git/ignore': Permission denied", + "warning: unable to access 'C:\\Users\\poin/.config/git/ignore': Permission denied", + "SKILL-PREFLIGHT: governance=7b227c49ef2ec044b702126cc41c9add847eed01", + "SKILL-PREFLIGHT: checkout=9519b2c1af5e2cf59536b311db5e8dc81376a32f", + "SKILL-PREFLIGHT: expected=rmq-audit-prompt,rmq-coordinator,rmq-proof-sprint", + "SKILL-PREFLIGHT: checkout_skills=rmq-audit-prompt,rmq-coordinator,rmq-proof-sprint", + "SKILL-PREFLIGHT: working_skills=rmq-audit-prompt,rmq-coordinator,rmq-proof-sprint", + "SKILL-PREFLIGHT: runtime_skills=rmq-audit-prompt,rmq-coordinator,rmq-proof-sprint", + "SKILL-PREFLIGHT: required=rmq-proof-sprint", + "SKILL-PREFLIGHT: required_mode=role-skills", + "SKILL-PREFLIGHT: PASS" + ] +} \ No newline at end of file diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r3/certify_current.ps1 b/docs/internal/extensions/lifecycle-native-p0/repair-r3/certify_current.ps1 new file mode 100644 index 00000000..1d641237 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r3/certify_current.ps1 @@ -0,0 +1,58 @@ +param([Parameter(Mandatory)][string]$OutputRoot,[Parameter(Mandatory)][string]$FocusedManifest,[Parameter(Mandatory)][string]$HistoricalContract) +$ErrorActionPreference='Stop' +Set-StrictMode -Version Latest +$repo=[IO.Path]::GetFullPath((Join-Path $PSScriptRoot '../../../../..')) +$utf8=[Text.UTF8Encoding]::new($false,$true) +$base='9519b2c1af5e2cf59536b311db5e8dc81376a32f' +$OutputRoot=[IO.Path]::GetFullPath($OutputRoot);$FocusedManifest=[IO.Path]::GetFullPath($FocusedManifest);$HistoricalContract=[IO.Path]::GetFullPath($HistoricalContract) +$allowed=[IO.Path]::GetFullPath((Join-Path $repo '.lake/repair-r3')).TrimEnd('\','/')+[IO.Path]::DirectorySeparatorChar +if(-not $OutputRoot.StartsWith($allowed,[StringComparison]::OrdinalIgnoreCase) -or (Test-Path -LiteralPath $OutputRoot)){throw 'fresh owned final output required'} +[void][IO.Directory]::CreateDirectory($OutputRoot) +. (Join-Path $repo 'scripts/owned_process_tree.ps1') +. (Join-Path $repo 'scripts/packed_native_lifecycle_integrity_check.ps1') +$before=$null;$after=$null;$scanBefore=$null;$scanAfter=$null;$head=$null;$failure=$null;$initialStatus=$null;$finalStatus=$null +$sourcePins=@();$focusedPin=$null;$historyPin=$null;$seedPin=$null;$profilesPin=$null +$errors=[Collections.Generic.List[string]]::new() +$selector=Join-Path $PSScriptRoot '../repair-r2/certify_profiles.ps1' +$profiles=Join-Path $OutputRoot 'profiles/PROFILES.json' +function Scan-Inputs { + $paths=@(Get-ChildItem -LiteralPath (Join-Path $repo 'docs/internal/extensions/lifecycle-native-p0') -Recurse -File -Force|ForEach-Object {$_.FullName}) + $paths+=@((Join-Path $repo 'docs/internal/DESIGN_DECISIONS.md'),(Join-Path $repo 'docs/internal/WORKFLOW_DESIGN_DECISIONS.md')) + @($paths|Sort-Object|ForEach-Object {Get-LNRawPin $_}) +} +function Same($a,$b,[string]$name){if(-not [string]::Equals(($a|ConvertTo-Json -Depth 15 -Compress),($b|ConvertTo-Json -Depth 15 -Compress),[StringComparison]::Ordinal)){throw ($name+' changed')}} +try { + $before=Get-LNTreeSnapshot $repo (Join-Path $OutputRoot 'before');$head=$before.head + $initialStatus=@(& git -C $repo -c core.excludesfile= status --porcelain=v1 --untracked-files=all) + if($LASTEXITCODE -ne 0 -or $initialStatus.Count){throw 'initial final candidate is not clean'} + $scanBefore=@(Scan-Inputs) + $sourcePaths=@($PSCommandPath,$selector,(Join-Path $PSScriptRoot '../repair-r1/run_owned.ps1'),(Join-Path $PSScriptRoot '../repair-r1/final_checks.ps1'),(Join-Path $PSScriptRoot '../repair-r2/claim_expectations.ps1'),(Join-Path $repo 'scripts/owned_process_tree.ps1'),(Join-Path $repo 'scripts/packed_native_lifecycle_stream_check.ps1'),(Join-Path $repo 'scripts/packed_native_lifecycle_integrity_check.ps1')) + $sourcePins=@($sourcePaths|ForEach-Object {Get-LNRawPin $_});$focusedPin=Get-LNRawPin $FocusedManifest;$historyPin=Get-LNRawPin $HistoricalContract + $focused=[IO.File]::ReadAllText($FocusedManifest,$utf8)|ConvertFrom-Json -AsHashtable + $history=[IO.File]::ReadAllText($HistoricalContract,$utf8)|ConvertFrom-Json -AsHashtable + if($focused.profiles.Count -ne 1 -or -not $focused.profiles.ContainsKey('focused')){throw 'focused manifest must contain exactly focused'} + if(-not $history.success -or $history.mode -cne 'full-contract' -or $history.base -cne $base -or $history.historicalR2.packageCommit -cne $base -or [IO.Path]::GetFullPath($history.worktree) -cne $repo){throw 'historical preservation contract identity differs'} + $seed=@{head=$head;profiles=@{focused=$focused.profiles.focused}} + foreach($kind in @('full','integrity','dependencies')){$seed.profiles[$kind]=$history.historicalR2.profiles[$kind].receipt.path} + $seedPath=Join-Path $OutputRoot 'SEED.json';[IO.File]::WriteAllText($seedPath,($seed|ConvertTo-Json -Depth 12),$utf8);$seedPin=Get-LNRawPin $seedPath + & $selector -Kinds @('checks','claims') -ExistingManifest $seedPath -OutputRoot (Join-Path $OutputRoot 'profiles') + if($LASTEXITCODE -ne 0){throw 'current certification did not return ordinary zero'} + $manifest=[IO.File]::ReadAllText($profiles,$utf8)|ConvertFrom-Json -AsHashtable + if($manifest.head -cne $head -or $manifest.profiles.Count -ne 6){throw 'final six-profile manifest identity differs'} + foreach($kind in @('focused','full','integrity','dependencies','checks','claims')){if(-not $manifest.profiles.ContainsKey($kind)){throw 'final profile missing'}} +}catch{$failure=$_.Exception.Message} +finally { + foreach($pin in @(@($sourcePins)+@($focusedPin,$historyPin,$seedPin)|Where-Object {$null -ne $_})){ + try{Same (Get-LNRawPin $pin.path) $pin 'final captured source/input pin'}catch{$errors.Add($_.Exception.Message)} + } + try{if($null -eq $before){throw 'initial final snapshot unavailable'};$after=Get-LNTreeSnapshot $repo (Join-Path $OutputRoot 'after');Same $after $before 'final tracked/index/untracked tree'}catch{$errors.Add($_.Exception.Message)} + try{if($null -eq $scanBefore){throw 'initial scan input inventory unavailable'};$scanAfter=@(Scan-Inputs);Same $scanAfter $scanBefore 'entire subtree/both-ledger input bytes'}catch{$errors.Add($_.Exception.Message)} + try{$finalStatus=@(& git -C $repo -c core.excludesfile= status --porcelain=v1 --untracked-files=all);if($LASTEXITCODE -ne 0 -or $finalStatus.Count){throw 'final candidate is not clean'}}catch{$errors.Add($_.Exception.Message)} + try{if([IO.File]::Exists($profiles)){$profilesPin=Get-LNRawPin $profiles}}catch{$errors.Add($_.Exception.Message)} + $result=[ordered]@{success=($null -eq $failure -and $errors.Count -eq 0);base=$base;head=$head;worktree=$repo;before=$before;after=$after;initialStatus=$initialStatus;finalStatus=$finalStatus; + scanInputsBefore=$scanBefore;scanInputsAfter=$scanAfter;sourcePins=$sourcePins;focusedManifest=$focusedPin;historicalContract=$historyPin;seed=$seedPin;profiles=$profilesPin;failure=$failure; + finalIntegrity=@{attempted=$true;success=($errors.Count -eq 0);errors=@($errors.ToArray())}} + [IO.File]::WriteAllText((Join-Path $OutputRoot 'RESULTS.json'),($result|ConvertTo-Json -Depth 35),$utf8) +} +if(-not $result.success){throw ('current profile certification failed: '+$failure+'; integrity='+($errors -join '; '))} +Write-Output ('CURRENT PROFILES PASS evidence='+$OutputRoot) diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r3/freeze_contract.py b/docs/internal/extensions/lifecycle-native-p0/repair-r3/freeze_contract.py new file mode 100644 index 00000000..d71d10df --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r3/freeze_contract.py @@ -0,0 +1,59 @@ +"""One-time strict-byte acceptance freeze before production edits.""" +import hashlib +import json +import pathlib +import re +import subprocess + +ROOT = pathlib.Path(__file__).resolve().parents[5] +OUT = pathlib.Path(__file__).resolve().parent +BASE = '9519b2c1af5e2cf59536b311db5e8dc81376a32f' +PROMPT = pathlib.Path('C:/Users/poin/Documents/RMQ/lifecycle-implementation-20260920/LIFE-NATIVE-P0-R3_PROMPT.md') +IDS = ['LN0-01', 'LN0-02', 'LN0-03', 'LN0-04', 'LN0-05', 'LN0-06', + 'INV-SEMANTIC-NONVACUITY', 'INV-ORACLE-INDEPENDENCE', + 'INV-CATEGORY-SEPARATION', 'INV-MUTATION-REPRODUCIBILITY', + 'CHK-FINAL', 'CHK-SCOPE', 'NP0R1-INTEGRITY', 'NP0R1-TOOLCHAIN', + 'NP0R2-STREAMS', 'NP0R2-REPORT', 'NP0R3-LITERAL', 'NP0R3-SELECTOR'] + +def git(*args): + return subprocess.check_output(['git', '-c', 'core.excludesfile=', '-C', str(ROOT), *args]) + +assert git('rev-parse', 'HEAD').decode().strip() == BASE +assert git('branch', '--show-current').decode().strip() == 'codex/life-native-p0-r3-literal-streams' +assert not git('diff', '--name-only') and not git('diff', '--cached', '--name-only') +prompt = PROMPT.read_bytes() +requirements = dict(re.findall(r'^- ([A-Z0-9-]+): (.+)$', prompt.decode('utf-8').replace('\r\n', '\n'), re.M)) +raw = git('show', BASE + ':docs/internal/extensions/lifecycle-native-p0/repair-r2/ACCEPTANCE_MATRIX.md') +raw.decode('utf-8', errors='strict') +rows = [r for r in raw.splitlines() if r.startswith(b'| `')] +assert len(rows) == 16 +for key, row in zip(IDS, rows): + cells = row.split(b'|') + assert len(cells) == 10 + assert cells[1].strip().strip(b'`').decode('utf-8') == key + assert cells[2].strip().decode('utf-8') == requirements[key], key +for key in IDS[16:]: + rows.append(f'| `{key}` | {requirements[key]} | Narrow local verifier repair | Strict decoded literal equality and direct nonempty selector controls | Actual capture -> common production predicate; actual certify_profiles boundary -> run_owned | Exact positives, unequal Unicode/transport holdouts, rejected empty selectors and one actual focused run | Pending; append evidence | Open at freeze |'.encode('utf-8')) +frozen = b'\n'.join(rows) + b'\n' +for name in ('ACCEPTANCE_ROWS.txt', 'ACCEPTANCE_MATRIX.md', 'FREEZE.json'): + assert not (OUT / name).exists(), name +header = b'# LIFE-NATIVE-P0-R3 frozen acceptance matrix\n\nSixteen complete inherited rows retain exact base bytes and historical pending cells. All eighteen rows are frozen; append evidence separately.\n\n| ID | Exact frozen requirement | Scope | Evidence needed (exact proposition/check) | Named consumer and identity/composition chain | Anti-vacuity challenge attempted and outcome | Evidence obtained | Status / residual gap |\n| --- | --- | --- | --- | --- | --- | --- | --- |\n' +plan = ''' +## Target and verification coverage plan + +The join is the reviewed native prerequisite plus reviewed formal producer, then consuming adapter and final campaign certification. This local task closes literal comparison and explicit nonempty selection only. No Lean/C/ABI or public-source edits. No weakened predicate, normalization, parallel test comparator, live candidate mutation, policy expansion, historical relabeling or new outer wrapper hierarchy. + +Development-loop: exact identity/scope and all eighteen complete row bytes against exact-base rows and independently pinned prompt; literal references, actual emitted Unicode stdout/stderr, retained root/leaf counterexamples, ASCII and newline/normalization/invalid UTF-8 holdouts; upfront direct selector controls. Controls consume the production predicate with the same expected strings, transport flags and ordinary exits. + +Final-required: complete new frozen registry; one actual focused native invocation through certify_profiles (1200 s outer, prior 49.522 s); source-derived integrity caller preserving native 0/7 and runner 0/1; six historical legitimate captures and fifteen integrity diagnostic captures revalidated with historical source/producing-root expectations; fresh checks and claims at current HEAD. Tiny children use 60 s and control groups 300 s (root four captures prior 10.106 s). Use unchanged bounded helper and Local\\RMQLifecycleImplementationHeavy20260920, preserve all streams/exits, cleanup and finally identities. Synthetic launcher components and copied-capture profile tests remain separate from actual emitted children. + +Final package: eighteen-row successor contract/negative mutations/protected sources, hygiene/native-decision scans, working and exact-base committed whitespace, production strict design against base and each new commit parent, clean final HEAD and complete-report claims. Reuse 23/65/58, fifteen/nineteen and eleven/120 historical registries plus baseline build only after exact source/registry/raw-pin verification; literal change cannot by itself invalidate unchanged native operations. Re-establish whole-root historical claim coverage with unchanged outside paths/scanner/policy/rg/config and fresh entire native subtree/both-ledger scan, else one 7200 s full scan. No duplicate native campaign or Lake build solely to rename evidence. Adapter, final joint aggregate, fresh-blind audit and acceptance remain deferred to coordinator. Stop only on completed local rows, precise obstruction, external blocker or redirection. +'''.encode('utf-8') +(OUT / 'ACCEPTANCE_ROWS.txt').write_bytes(frozen) +(OUT / 'ACCEPTANCE_MATRIX.md').write_bytes(header + frozen + plan) +record = dict(base=BASE, ids=IDS, inherited=16, + rowsSha256=hashlib.sha256(frozen).hexdigest(), + prompt=dict(path=str(PROMPT), bytes=len(prompt), sha256=hashlib.sha256(prompt).hexdigest()), + template='docs/internal/templates/PROOF_ACCEPTANCE_MATRIX.md') +(OUT / 'FREEZE.json').write_text(json.dumps(record, indent=2) + '\n', encoding='utf-8') +print('FROZEN: 18 complete rows; 16 exact-base rows; all 18 requirements match commissioning prompt') diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r3/literal_selector_controls.ps1 b/docs/internal/extensions/lifecycle-native-p0/repair-r3/literal_selector_controls.ps1 new file mode 100644 index 00000000..a5272f81 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r3/literal_selector_controls.ps1 @@ -0,0 +1,134 @@ +param([string]$OutputRoot,[AllowNull()][AllowEmptyCollection()][AllowEmptyString()][string[]]$ControlIds) +$ErrorActionPreference='Stop' +Set-StrictMode -Version Latest +$repo=[IO.Path]::GetFullPath((Join-Path $PSScriptRoot '../../../../..')) +$utf8=[Text.UTF8Encoding]::new($false,$true) +$registryPath=Join-Path $PSScriptRoot 'CONTROL_REGISTRY.json' +$registry=[IO.File]::ReadAllText($registryPath,$utf8)|ConvertFrom-Json +# The registry is committed expected data, pinned independently before execution. +if((Get-FileHash $registryPath).Hash -cne '16E26C5B131BBE258B3813BCDB252414E8BED454EF6286EB2ED7F7EF3496261D'){throw 'R3 registry byte identity differs'} +$ids=@($registry.controls.id) +$knownIds=[Collections.Generic.HashSet[string]]::new([string[]]$ids,[StringComparer]::Ordinal) +if($knownIds.Count -ne $ids.Count){throw 'R3 registry duplicate'} +if($PSBoundParameters.ContainsKey('ControlIds')){ + if($null -eq $ControlIds -or -not $ControlIds.Count -or @($ControlIds|Where-Object {[string]::IsNullOrWhiteSpace($_)}).Count){throw 'R3 selector empty'} + $selectedIds=[Collections.Generic.HashSet[string]]::new([StringComparer]::Ordinal) + foreach($id in $ControlIds){ + if(-not $knownIds.Contains($id)){throw 'R3 selector unknown'} + if(-not $selectedIds.Add($id)){throw 'R3 selector duplicate'} + } + $cases=@($registry.controls|Where-Object {$selectedIds.Contains($_.id)}) +}else{$cases=@($registry.controls)} +if(-not $OutputRoot){$OutputRoot=Join-Path $repo ('.lake/repair-r3/controls-'+[Guid]::NewGuid().ToString('N'))} +if(Test-Path -LiteralPath $OutputRoot){throw 'R3 output must be fresh'} +[void][IO.Directory]::CreateDirectory($OutputRoot) +. (Join-Path $repo 'scripts/owned_process_tree.ps1') +. (Join-Path $repo 'scripts/packed_native_lifecycle_stream_check.ps1') +. (Join-Path $repo 'scripts/packed_native_lifecycle_integrity_check.ps1') +$shell=(Get-Process -Id $PID).Path +$selector=Join-Path $PSScriptRoot '../repair-r2/certify_profiles.ps1' +$selectorSource=[IO.File]::ReadAllText($selector,$utf8) +$tokens=$null;$parseErrors=$null +$ast=[Management.Automation.Language.Parser]::ParseInput($selectorSource,[ref]$tokens,[ref]$parseErrors) +if($parseErrors.Count){throw 'selector parse failed'} +$param=@($ast.ParamBlock.Parameters|Where-Object {$_.Name.VariablePath.UserPath -ceq 'Kinds'}) +if($param.Count -ne 1 -or $param[0].DefaultValue.Extent.Text -cne "@('focused','full','integrity','dependencies','checks','claims')"){throw 'omitted default roster differs'} +$before=Get-LNTreeSnapshot $repo (Join-Path $OutputRoot 'candidate-before') +$sourcePaths=@($PSCommandPath,$registryPath,$selector,(Join-Path $repo 'scripts/packed_native_lifecycle_stream_check.ps1'),(Join-Path $repo 'scripts/owned_process_tree.ps1'),(Join-Path $repo 'scripts/packed_native_lifecycle_storage_replay.ps1'),(Join-Path $PSScriptRoot '../repair-r1/run_owned.ps1'),(Join-Path $PSScriptRoot '../repair-r1/integrity_controls.ps1'),(Join-Path $PSScriptRoot '../repair-r2/harness_stream_controls.ps1')) +$pins=@($sourcePaths|ForEach-Object {Get-LNRawPin $_}) +$records=[Collections.Generic.List[object]]::new() +$failure=$null;$integrityFailure=$null +$watch=[Diagnostics.Stopwatch]::StartNew() +function Assert-Bytes([string]$Path,[string]$Base64) { + if(-not [string]::Equals([Convert]::ToBase64String([IO.File]::ReadAllBytes($Path)),$Base64,[StringComparison]::Ordinal)){throw ('R3 emitted bytes differ: '+$Path)} +} +try { + foreach($case in $cases){ + $out=Join-Path $OutputRoot $case.id + [void][IO.Directory]::CreateDirectory($out) + $driver=Join-Path $out 'driver.ps1' + $record=@{id=$case.id;mode=$case.mode;predicate=$case.predicate;tier=$case.tier;verdict=$case.verdict} + if($case.mode -ceq 'literal'){ + $body="`$o=[Convert]::FromBase64String('"+$case.stdout+"');`$e=[Convert]::FromBase64String('"+$case.stderr+"');`$s=[Console]::OpenStandardOutput();`$s.Write(`$o,0,`$o.Length);`$s.Flush();`$s=[Console]::OpenStandardError();`$s.Write(`$e,0,`$e.Length);`$s.Flush();exit "+$case.exit + [IO.File]::WriteAllText($driver,$body,$utf8) + $mutex=[Threading.Mutex]::new($false,'Local\RMQLifecycleImplementationHeavy20260920');$held=$false + try { + try{$held=$mutex.WaitOne(600000)}catch [Threading.AbandonedMutexException]{$held=$true} + if(-not $held){throw 'R3 shared mutex unavailable'} + $capture=Invoke-LNStreamCapture $repo $shell @('-NoProfile','-File',$driver) $repo (Join-Path $out 'capture') 60 $case.id + }finally{if($held){$mutex.ReleaseMutex()};$mutex.Dispose()} + Assert-Bytes $capture.spec.stdout $case.stdout + Assert-Bytes $capture.spec.stderr $case.stderr + Assert-Bytes $capture.launcher.RawStandardOutput '' + Assert-Bytes $capture.launcher.RawStandardError '' + # Guard observations precede intended rejection, including malformed bytes. + if($capture.launcher.TimedOut -or $capture.launcher.OutputLimitExceeded -or @($capture.launcher.RetentionErrors).Count -or @($capture.launcher.StandardOutput).Count -or @($capture.launcher.StandardError).Count -or [IO.File]::Exists($capture.spec.error) -or [IO.File]::Exists($capture.spec.overflow) -or $null -eq $capture.actual -or $capture.actual.exitCode -ne $case.exit -or $capture.launcher.ExitCode -ne $case.exit){throw 'R3 actual transport/ordinary exit differs'} + $actualExit=[IO.File]::ReadAllText($capture.spec.exit,$utf8)|ConvertFrom-Json + if($actualExit.exitCode -ne $case.exit){throw 'R3 ordinary exit artifact differs'} + if($case.failure -cne 'invalid-utf8'){ + Assert-LNOuterCapture $capture ($utf8.GetString([Convert]::FromBase64String($case.stdout))) ($utf8.GetString([Convert]::FromBase64String($case.stderr))) $case.exit ('observed-'+$case.id) + } + $rejection=$null + try {Assert-LNOuterCapture $capture ($utf8.GetString([Convert]::FromBase64String($case.expectedStdout))) ($utf8.GetString([Convert]::FromBase64String($case.expectedStderr))) $case.exit $case.id}catch{$rejection=$_.Exception.Message} + $wanted=if($case.failure -ceq 'invalid-utf8'){'STREAM: invalid UTF-8 capture: '+$capture.spec.stdout}elseif($case.verdict -ceq 'reject'){$case.failure}else{$null} + if(-not [string]::Equals($rejection,$wanted,[StringComparison]::Ordinal)){throw ('R3 wrong verdict '+$case.id+': '+$rejection)} + $childPid=[int][IO.File]::ReadAllText($capture.spec.pid) + if(Get-Process -Id $childPid -ErrorAction SilentlyContinue){throw 'R3 emitted child survived'} + $record.capture=$capture;$record.failure=$rejection;$record.childAbsent=$true + }elseif($case.mode -ceq 'selector'){ + $targetOutput=Join-Path $out 'must-not-exist' + $body="`$ErrorActionPreference='Stop';try { & '"+$selector.Replace("'","''")+"' -OutputRoot '"+$targetOutput.Replace("'","''")+"' -Kinds "+$case.expression+";throw 'UNEXPECTED NORMAL RETURN' }catch{ if(`$_.Exception.Message -cne '"+$case.failure+"'){throw};if(Test-Path -LiteralPath '"+$targetOutput.Replace("'","''")+"'){throw 'selector started work'};[Console]::Out.WriteLine('BOUNDARY REJECTED "+$case.id+"');exit 0}" + [IO.File]::WriteAllText($driver,$body,$utf8) + $capture=Invoke-LNStreamCapture $repo $shell @('-NoProfile','-File',$driver) $repo (Join-Path $out 'capture') 60 $case.id + Assert-LNOuterCapture $capture ('BOUNDARY REJECTED '+$case.id+[Environment]::NewLine) '' 0 $case.id + if(Test-Path -LiteralPath $targetOutput){throw 'R3 rejected selector created output'} + $record.capture=$capture;$record.failure=$case.failure;$record.noWorkBeforeRejection=$true + }elseif($case.mode -ceq 'focused'){ + $targetOutput=Join-Path $out 'certification' + $body="`$ErrorActionPreference='Stop'; & '"+$selector.Replace("'","''")+"' -OutputRoot '"+$targetOutput.Replace("'","''")+"' -Kinds @('focused')" + [IO.File]::WriteAllText($driver,$body,$utf8) + $capture=Invoke-LNStreamCapture $repo $shell @('-NoProfile','-File',$driver) $repo (Join-Path $out 'capture') 1200 $case.id + $manifestPath=Join-Path $targetOutput 'PROFILES.json' + $expected='OWNED focused exit=0 evidence='+(Join-Path $targetOutput 'focused')+[Environment]::NewLine+'PROFILE CERTIFIED focused manifest='+$manifestPath+[Environment]::NewLine + Assert-LNOuterCapture $capture $expected '' 0 $case.id + $manifest=[IO.File]::ReadAllText($manifestPath,$utf8)|ConvertFrom-Json -AsHashtable + if($manifest.profiles.Count -ne 1 -or -not $manifest.profiles.ContainsKey('focused')){throw 'R3 focused manifest not exactly one profile'} + $receipt=[IO.File]::ReadAllText($manifest.profiles.focused,$utf8)|ConvertFrom-Json + $spec=[IO.File]::ReadAllText((Join-Path $targetOutput 'focused/spec.json'),$utf8)|ConvertFrom-Json + $inner=@{launcher=$receipt.outer;actual=$receipt.actual;spec=$spec} + $validation=Assert-LNWrapperCapture $inner 'focused' $repo + $evidence=Get-LNStreamEvidencePath $validation.expectedStdout 'LIFECYCLE-REPLAY evidence=' (Join-Path $repo '.lake/lifecycle-native-p0/runs') + $summary=[IO.File]::ReadAllText((Join-Path $evidence 'SUMMARY.json'),$utf8)|ConvertFrom-Json + if(@($summary.selected).Count -ne 1 -or $summary.selected[0] -cne 'pop-unique'){throw 'R3 focused native selection differs'} + $record.capture=$capture;$record.manifest=Get-LNRawPin $manifestPath;$record.receipt=Get-LNRawPin $manifest.profiles.focused;$record.summary=Get-LNRawPin (Join-Path $evidence 'SUMMARY.json');$record.validation=$validation + }elseif($case.mode -ceq 'integrity'){ + $harness=Join-Path $PSScriptRoot '../repair-r2/harness_stream_controls.ps1' + $targetOutput=Join-Path $out 'harness' + $body="`$ErrorActionPreference='Stop'; & '"+$harness.Replace("'","''")+"' -OutputRoot '"+$targetOutput.Replace("'","''")+"' -ControlIds @('success-positive','error-positive')" + [IO.File]::WriteAllText($driver,$body,$utf8) + $capture=Invoke-LNStreamCapture $repo $shell @('-NoProfile','-File',$driver) $repo (Join-Path $out 'capture') 300 $case.id + $expected='STREAM CONTROL PASS success-positive'+[Environment]::NewLine+'STREAM CONTROL PASS error-positive'+[Environment]::NewLine+'STREAM CONTROLS evidence='+$targetOutput+[Environment]::NewLine + Assert-LNOuterCapture $capture $expected '' 0 $case.id + $resultPath=Join-Path $targetOutput 'RESULTS.json' + $result=[IO.File]::ReadAllText($resultPath,$utf8)|ConvertFrom-Json + if((@($result.selected)-join ',') -cne 'success-positive,error-positive'){throw 'R3 integrity pair selection differs'} + $record.capture=$capture;$record.results=Get-LNRawPin $resultPath + }else{throw 'R3 unsupported registry mode'} + $record.driver=Get-LNRawPin $driver + $records.Add($record) + Write-Output ('R3 CONTROL PASS '+$case.id) + } + if(-not [string]::Equals((@($records.ToArray().id)-join ','),(@($cases.id)-join ','),[StringComparison]::Ordinal)){throw 'R3 missing/unused control'} +}catch{$failure=$_.Exception.Message} +finally{ + try { + foreach($pin in $pins){if((Get-FileHash -LiteralPath $pin.path).Hash -cne $pin.sha256 -or ([IO.FileInfo]$pin.path).Length -ne $pin.bytes){throw ('R3 source changed: '+$pin.path)}} + $after=Get-LNTreeSnapshot $repo (Join-Path $OutputRoot 'candidate-after') + if(-not [string]::Equals(($before|ConvertTo-Json -Depth 12 -Compress),($after|ConvertTo-Json -Depth 12 -Compress),[StringComparison]::Ordinal)){throw 'R3 live candidate changed'} + }catch{$integrityFailure=$_.Exception.Message} + $watch.Stop() + $result=@{head=(& git -C $repo rev-parse HEAD).Trim();selected=@($cases.id);controls=@($records.ToArray());failure=$failure;integrityFailure=$integrityFailure;candidateUnchanged=($null -eq $integrityFailure);seconds=$watch.Elapsed.TotalSeconds;sourcePins=$pins;omittedDefaultProfiles=@($registry.defaultProfiles);defaultEvidence='actual AST default; composed six historical profiles separately revalidated'} + [IO.File]::WriteAllText((Join-Path $OutputRoot 'RESULTS.json'),($result|ConvertTo-Json -Depth 45),$utf8) +} +if($null -ne $failure -or $null -ne $integrityFailure){throw ('R3 controls failed: '+$failure+'; integrity: '+$integrityFailure)} +Write-Output ('R3 CONTROLS evidence='+$OutputRoot) diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r3/make_registry.py b/docs/internal/extensions/lifecycle-native-p0/repair-r3/make_registry.py new file mode 100644 index 00000000..33d142a5 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r3/make_registry.py @@ -0,0 +1,55 @@ +"""Freeze explicit expected bytes before executing any regression.""" +import base64 +import json +from pathlib import Path + +out = Path(__file__).resolve().parent / 'CONTROL_REGISTRY.json' +assert not out.exists() +b64 = lambda b: base64.b64encode(b).decode('ascii') +rows = [] +for context, code, stdout, stderr in [ + ('success', 0, b'EXPECTED SUCCESS\r\n', b''), + ('error', 7, b'EXPECTED CONTEXT\r\n', b'PROCESS: expected failure\r\n')]: + variants = [('exact', 'none', b'')] + variants += [(name + '-' + stream, stream, extra) + for name, extra in [('bom', b'\xef\xbb\xbf'), ('nul', b'\0'), + ('shy', b'\xc2\xad'), ('ascii', b'EXTRA\r\n')] + for stream in ['stdout', 'stderr']] + for name, stream, extra in variants: + rows.append(dict(id=f'literal-{context}-{name}', mode='literal', + predicate='Assert-LNOuterCapture', tier='actual emitted child', + stdout=b64(stdout + (extra if stream == 'stdout' else b'')), + stderr=b64(stderr + (extra if stream == 'stderr' else b'')), + expectedStdout=b64(stdout), expectedStderr=b64(stderr), + exit=code, verdict='accept' if stream == 'none' else 'reject', + failure='' if stream == 'none' else f'STREAM: literal-{context}-{name} {stream} differs')) +for name, emitted, expected, failure in [ + ('lf-crlf', b'line\n', b'line\r\n', 'differs'), + ('normalization', 'caf\u0065\u0301\r\n'.encode(), 'caf\u00e9\r\n'.encode(), 'differs'), + ('zero-width', 'line\u200b\r\n'.encode(), b'line\r\n', 'differs'), + ('nonbreaking-space', 'a\u00a0b\r\n'.encode(), b'a b\r\n', 'differs'), + ('invalid-utf8', b'\xff', b'', 'invalid-utf8'), + ('overlong-utf8', b'\xc0\x80', b'', 'invalid-utf8'), + ('literal-codepoints', '\ufeff\x00\u00ad\r\n'.encode(), '\ufeff\x00\u00ad\r\n'.encode(), '')]: + rows.append(dict(id='holdout-'+name, mode='literal', predicate='Assert-LNOuterCapture', + tier='actual emitted child', stdout=b64(emitted), stderr='', + expectedStdout=b64(expected), expectedStderr='', exit=0, + verdict='accept' if not failure else 'reject', + failure=('STREAM: holdout-'+name+' stdout differs') if failure == 'differs' else failure)) +for name, expression, category in [ + ('null', '$null', 'empty'), ('empty-array', '@()', 'empty'), + ('empty-string', "@('')", 'empty'), ('whitespace', "@(' ')", 'empty'), + ('unknown', "@('unknown')", 'unknown'), ('duplicate', "@('focused','focused')", 'duplicate'), + ('late-empty', "@('focused','')", 'empty'), + ('late-unknown', "@('focused','unknown')", 'unknown'), + ('unknown-bom', "@(('focused'+[char]0xFEFF))", 'unknown'), + ('unknown-nul', "@(('focused'+[char]0))", 'unknown')]: + rows.append(dict(id='selector-'+name, mode='selector', predicate='certify_profiles parameter boundary', + tier='actual script boundary in captured child', expression=expression, + verdict='reject', failure='CERTIFY-SELECTOR: '+category)) +rows += [dict(id='selector-focused', mode='focused', predicate='certify_profiles -> run_owned -> Assert-LNWrapperCapture', + tier='actual focused native run', verdict='accept'), + dict(id='integrity-caller-pair', mode='integrity', predicate='unchanged harness_stream_controls -> integrity_controls -> Assert-LNOuterCapture', + tier='source-derived integrity callers, native 0/7, runner 0/1', verdict='accept')] +out.write_bytes((json.dumps(dict(version=1, defaultProfiles=['focused','full','integrity','dependencies','checks','claims'], controls=rows), indent=2) + '\n').encode('utf-8')) +print(f'FROZEN: {len(rows)} exact controls') diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r3/retained_registry.json b/docs/internal/extensions/lifecycle-native-p0/repair-r3/retained_registry.json new file mode 100644 index 00000000..e92c8369 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r3/retained_registry.json @@ -0,0 +1,34 @@ +{ + "version": 1, + "oldHead": "9519b2c1af5e2cf59536b311db5e8dc81376a32f", + "historicalRoot": "C:/Users/poin/.codex/worktrees/eafd/RMQ", + "profiles": ["focused", "full", "integrity", "dependencies", "claims", "checks"], + "integrity": ["intact-success", "intact-stage-error", "malformed-stdout-intact", "stage-error-and-pin-change", "stage-error-and-capture-error", "success-and-pin-change", "mixed-diagnostic-and-pin-change", "timeout-and-pin-change", "success-and-tracked-change", "success-and-index-change", "success-and-untracked-addition", "success-and-untracked-byte-change", "success-and-link-map-change", "partial-identity-and-pin-change", "missing-baseline"], + "root": [ + {"id": "expected-error", "oldAccept": true, "currentAccept": true, "failure": null}, + {"id": "error-plus-ascii", "oldAccept": false, "currentAccept": false, "failure": "STREAM: error-plus-ascii stderr differs"}, + {"id": "error-plus-bom", "oldAccept": true, "currentAccept": false, "failure": "STREAM: error-plus-bom stderr differs"}, + {"id": "otherwise-empty-bom", "oldAccept": true, "currentAccept": false, "failure": "STREAM: otherwise-empty-bom stderr differs"} + ], + "leaf": [ + {"id": "intact-expected-error", "oldAccept": true, "currentAccept": true, "failure": null}, + {"id": "nul-stdout", "oldAccept": true, "currentAccept": false, "failure": "STREAM: process-component stdout differs"}, + {"id": "bom-stdout", "oldAccept": true, "currentAccept": false, "failure": "STREAM: process-component stdout differs"}, + {"id": "extra-error-words", "oldAccept": false, "currentAccept": false, "failure": "STREAM: process-component stderr differs"} + ], + "copiedFocused": [ + {"id": "intact", "oldAccept": true, "currentAccept": true, "failure": null}, + {"id": "trailing-nul-stdout", "oldAccept": true, "currentAccept": false, "failure": "STREAM: wrapper-focused stdout differs"}, + {"id": "nul-only-stderr", "oldAccept": true, "currentAccept": false, "failure": "STREAM: wrapper-focused stderr differs"}, + {"id": "extra-error-words", "oldAccept": false, "currentAccept": false, "failure": "STREAM: wrapper-focused stderr differs"}, + {"id": "leading-bom-stdout", "oldAccept": false, "currentAccept": false, "failure": "STREAM: evidence line missing"} + ], + "syntheticLauncher": [ + {"id": "bom-stdout", "channel": "stdout", "codepoint": 65279, "oldAccept": true, "currentAccept": false, "failure": "STREAM: wrapper-focused launcher stdout differs"}, + {"id": "bom-stderr", "channel": "stderr", "codepoint": 65279, "oldAccept": true, "currentAccept": false, "failure": "STREAM: wrapper-focused launcher stderr differs"}, + {"id": "nul-stdout", "channel": "stdout", "codepoint": 0, "oldAccept": true, "currentAccept": false, "failure": "STREAM: wrapper-focused launcher stdout differs"}, + {"id": "nul-stderr", "channel": "stderr", "codepoint": 0, "oldAccept": true, "currentAccept": false, "failure": "STREAM: wrapper-focused launcher stderr differs"}, + {"id": "soft-hyphen-stdout", "channel": "stdout", "codepoint": 173, "oldAccept": true, "currentAccept": false, "failure": "STREAM: wrapper-focused launcher stdout differs"}, + {"id": "soft-hyphen-stderr", "channel": "stderr", "codepoint": 173, "oldAccept": true, "currentAccept": false, "failure": "STREAM: wrapper-focused launcher stderr differs"} + ] +} diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r3/revalidate_retained.ps1 b/docs/internal/extensions/lifecycle-native-p0/repair-r3/revalidate_retained.ps1 new file mode 100644 index 00000000..6726c867 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r3/revalidate_retained.ps1 @@ -0,0 +1,219 @@ +param([Parameter(Mandatory)][string]$ContractPath,[string]$OutputRoot) +$ErrorActionPreference='Stop' +Set-StrictMode -Version Latest +$repo=[IO.Path]::GetFullPath((Join-Path $PSScriptRoot '../../../../..')) +$utf8=[Text.UTF8Encoding]::new($false,$true) +$nl="`r`n" # Original Windows producing runtime; never rebase historical text. +$base='9519b2c1af5e2cf59536b311db5e8dc81376a32f' +$oldRoot='C:\Users\poin\.codex\worktrees\eafd\RMQ' +$review='C:\Users\poin\Documents\RMQ\lifecycle-implementation-20260920\native-p0-r2-review' +$currentHelper=Join-Path $repo 'scripts/packed_native_lifecycle_stream_check.ps1' +$oldHelper=Join-Path $oldRoot 'scripts/packed_native_lifecycle_stream_check.ps1' +if(-not $OutputRoot){$OutputRoot=Join-Path $repo ('.lake/repair-r3/retained-'+[Guid]::NewGuid().ToString('N'))} +$OutputRoot=[IO.Path]::GetFullPath($OutputRoot) +$allowed=[IO.Path]::GetFullPath((Join-Path $repo '.lake/repair-r3')).TrimEnd('\','/')+[IO.Path]::DirectorySeparatorChar +if(-not $OutputRoot.StartsWith($allowed,[StringComparison]::OrdinalIgnoreCase) -or (Test-Path -LiteralPath $OutputRoot)){ + throw 'R3-RETAINED: output must be a fresh directory inside this checkout .lake/repair-r3' +} +[void][IO.Directory]::CreateDirectory($OutputRoot) +. (Join-Path $repo 'scripts/owned_process_tree.ps1') +. (Join-Path $repo 'scripts/packed_native_lifecycle_integrity_check.ps1') +$pins=[Collections.Generic.Dictionary[string,object]]::new([StringComparer]::OrdinalIgnoreCase) +$rows=[Collections.Generic.List[object]]::new() +$failure=$null;$finalErrors=[Collections.Generic.List[string]]::new();$before=$null + +function Add-Pin([string]$Path,[object]$Expected=$null) { + $pin=Get-LNRawPin $Path + if($null -ne $Expected -and ($pin.bytes -ne $Expected.bytes -or + -not [string]::Equals($pin.sha256,[string]$Expected.sha256,[StringComparison]::OrdinalIgnoreCase))){throw ('R3-RETAINED: pin differs '+$Path)} + if($pins.ContainsKey($pin.path)){ + $prior=$pins[$pin.path] + if($pin.bytes -ne $prior.bytes -or $pin.sha256 -cne $prior.sha256){throw ('R3-RETAINED: conflicting pin '+$Path)} + }else{$pins.Add($pin.path,$pin)} + return $pin +} +function Read-PinnedJson([string]$Path,[long]$Bytes,[string]$Hash) { + $null=Add-Pin $Path @{bytes=$Bytes;sha256=$Hash} + return $utf8.GetString([IO.File]::ReadAllBytes($Path))|ConvertFrom-Json +} +function Same([object]$Actual,[object]$Expected,[string]$Surface) { + if(-not [string]::Equals([string]$Actual,[string]$Expected,[StringComparison]::Ordinal)){throw ('R3-RETAINED: '+$Surface+' differs')} +} +function Check-Roster($Actual,$Expected,[string]$Surface) { + if(@($Actual).Count -ne @($Expected).Count){throw ('R3-RETAINED: '+$Surface+' count differs')} + for($i=0;$i -lt @($Expected).Count;$i++){Same $Actual[$i] $Expected[$i] ($Surface+' order')} +} +function Pin-Capture($Capture) { + foreach($pin in @($Capture.raw)){$null=Add-Pin $pin.path $pin} + foreach($path in @($Capture.spec.stdout,$Capture.spec.stderr,$Capture.launcher.RawStandardOutput,$Capture.launcher.RawStandardError)){ + $null=Add-Pin $path + } + $hasExit=if($Capture.spec -is [Collections.IDictionary]){$Capture.spec.Contains('exit')}else{$null -ne $Capture.spec.PSObject.Properties['exit']} + if($hasExit){ + $null=Add-Pin $Capture.spec.exit + $actual=$utf8.GetString([IO.File]::ReadAllBytes($Capture.spec.exit))|ConvertFrom-Json + Same $actual.exitCode $Capture.actual.exitCode 'ordinary exit artifact' + } +} +function Observe([string]$Helper,$Capture,[string]$Out,[string]$Err,[int]$Exit,[string]$Profile,[switch]$Wrapper) { + # Each function definition is scoped to this call. P and Q use the actual + # historical/current caller with the identical object, expected strings and + # ordinary-exit/transport guards. No copied comparison implements either one. + . $Helper + try { + if($Wrapper){$null=Assert-LNWrapperCapture $Capture 'focused' $oldRoot} + else{Assert-LNOuterCapture $Capture $Out $Err $Exit $Profile} + return @{accepted=$true;failure=$null} + }catch{return @{accepted=$false;failure=$_.Exception.Message}} +} +function Compare-Case($Definition,$Capture,[string]$Out,[string]$Err,[int]$Exit,[string]$Profile,[string]$Tier,[switch]$Wrapper) { + Pin-Capture $Capture + $p=Observe $oldHelper $Capture $Out $Err $Exit $Profile -Wrapper:$Wrapper + $q=Observe $currentHelper $Capture $Out $Err $Exit $Profile -Wrapper:$Wrapper + if($p.accepted -ne $Definition.oldAccept -or $q.accepted -ne $Definition.currentAccept){throw ('R3-RETAINED: unexpected P/Q verdict '+$Definition.id)} + Same $q.failure $Definition.failure ($Definition.id+' current failure') + if(-not $Definition.oldAccept){Same $p.failure $Definition.failure ($Definition.id+' historical failure')} + $rows.Add([ordered]@{id=$Tier+'/'+$Definition.id;tier=$Tier;predicate=$(if($Wrapper){'Assert-LNWrapperCapture focused -> Assert-LNOuterCapture'}else{'Assert-LNOuterCapture'}); + profile=$Profile;expectedStdout=$Out;expectedStderr=$Err;expectedExit=$Exit;capture=$Capture;P=$p;Q=$q}) +} + +try { + $before=Get-LNTreeSnapshot $repo (Join-Path $OutputRoot 'before') + foreach($path in @($PSCommandPath,$currentHelper,(Join-Path $repo 'scripts/owned_process_tree.ps1'), + (Join-Path $repo 'scripts/packed_native_lifecycle_integrity_check.ps1'),$ContractPath)){$null=Add-Pin $path} + $registryPath=Join-Path $PSScriptRoot 'retained_registry.json' + $null=Add-Pin $registryPath @{bytes=3340;sha256='521BFA0CD6DEE84383AB41F8B7D6CC0F226EEFABFC96113EF5EBE835A48A20EB'} + $registry=$utf8.GetString([IO.File]::ReadAllBytes($registryPath))|ConvertFrom-Json + Same $registry.oldHead $base 'registry historical head' + Same ([IO.Path]::GetFullPath($registry.historicalRoot)) $oldRoot 'registry historical root' + $null=Add-Pin $oldHelper @{bytes=11037;sha256='5CACC1BFE9C9B9E7AB2044E2B28E8BE5F447B75AB863264A463FB2089B073347'} + $oldBlob=(& git -C $repo rev-parse ($base+':scripts/packed_native_lifecycle_stream_check.ps1')).Trim() + if($LASTEXITCODE){throw 'R3-RETAINED: old Git source unavailable'} + $workingBlob=(& git -C $repo hash-object --path=scripts/packed_native_lifecycle_stream_check.ps1 $oldHelper).Trim() + if($LASTEXITCODE){throw 'R3-RETAINED: old working source identity unavailable'} + Same $workingBlob $oldBlob 'historical Git/check-out source identity' + + # The successor preservation verifier reconstructs these contracts with the + # unchanged R2 semantic parsers and the exact producing root. Historical + # checks use 2307..9519, and the claims matcher consumes its independently + # source-derived expectation. Nothing below treats old checks as current. + $contracts=$utf8.GetString([IO.File]::ReadAllBytes($ContractPath))|ConvertFrom-Json + if(-not $contracts.success){throw 'R3-RETAINED: preservation verifier did not pass'} + Same $contracts.mode 'full-contract' 'preservation verifier mode' + Same $contracts.base $base 'preservation verifier base' + Same ([IO.Path]::GetFullPath($contracts.worktree)) $repo 'preservation verifier worktree' + Same $contracts.historicalR2.packageCommit $base 'historical package identity' + Same $contracts.historicalR2.historicalBase '2307e3ad0739e0e1d9c3f186cdc568631086fddf' 'historical check base' + foreach($pin in @($contracts.currentOwnedSources)){$null=Add-Pin $pin.path $pin} + $retained=@($contracts.retainedContracts) + $expectedIds=@($registry.profiles|ForEach-Object {'profile-'+$_})+@($registry.integrity|ForEach-Object {'integrity-'+$_}) + Check-Roster @($retained.id) $expectedIds 'retained contracts' + foreach($contract in $retained){ + Same ([IO.Path]::GetFullPath($contract.producingRoot)) $oldRoot 'contract producing root' + foreach($pin in @($contract.sourcePins)){$null=Add-Pin $pin.path $pin} + foreach($pin in @($contract.rawPins)){$null=Add-Pin $pin.path $pin} + Pin-Capture $contract.capture + $q=Observe $currentHelper $contract.capture $contract.expectedStdout $contract.expectedStderr $contract.expectedExit $contract.id + if(-not $q.accepted){throw ('R3-RETAINED: historical legitimate rejected '+$contract.id+'; '+$q.failure)} + $rows.Add([ordered]@{id=$contract.id;tier='retained-historical-capture';predicate='Assert-LNOuterCapture'; + expectedStdout=$contract.expectedStdout;expectedStderr=$contract.expectedStderr;expectedExit=$contract.expectedExit; + producingRoot=$contract.producingRoot;capture=$contract.capture;Q=$q}) + } + + $rootManifest=Read-PinnedJson (Join-Path $review 'ROOT_COUNTEREXAMPLE_PINS.json') 11921 '082365E5E6DAB0E92D23C4D2D35B89DB238090058585D6F6885D6204D9127622' + if(@($rootManifest).Count -ne 41){throw 'R3-RETAINED: root manifest roster differs'} + foreach($pin in $rootManifest){$null=Add-Pin $pin.path $pin} + $root=Read-PinnedJson (Join-Path $review 'ordinal-capture-647ce95dae85469e85586548d4ed9496/RESULT.json') 14113 '7CB4B0F64197973D37CC640C43AEFBB59FC61515CC58E360A19E844FB1BEE4A9' + Check-Roster @($root.cases.id) @($registry.root.id) 'root named cases' + for($i=0;$i -lt $registry.root.Count;$i++){ + $definition=$registry.root[$i];$record=$root.cases[$i] + $capture=$utf8.GetString([IO.File]::ReadAllBytes($record.capture))|ConvertFrom-Json + $out='';$err=if($definition.id -ceq 'otherwise-empty-bom'){''}else{'PROCESS: expected failure'+$nl} + $exit=if($definition.id -ceq 'otherwise-empty-bom'){0}else{7} + $actualErr=switch -CaseSensitive ($definition.id){ + 'expected-error' {$err} + 'error-plus-ascii' {$err+'UNEXPECTED OUTER DIAGNOSTIC'+$nl} + 'error-plus-bom' {$err+[char]0xFEFF} + 'otherwise-empty-bom' {[string][char]0xFEFF} + } + Same ($utf8.GetString([IO.File]::ReadAllBytes($capture.spec.stdout))) $out 'prescribed root emitted stdout' + Same ($utf8.GetString([IO.File]::ReadAllBytes($capture.spec.stderr))) $actualErr 'prescribed root emitted stderr' + Compare-Case $definition $capture $out $err $exit $definition.id 'historical-actual-root-child' + } + + $leaf=Read-PinnedJson (Join-Path $review 'stream-process-f023afa2f19b43cda8980f8f59f724a3/RESULT.json') 26231 'A53216543CFE84C830861332912C4D57A525381E33019AE7AAE17F438ADA9361' + Check-Roster @($leaf.records.id) @($registry.leaf.id) 'leaf emitted cases' + for($i=0;$i -lt $registry.leaf.Count;$i++){ + $definition=$registry.leaf[$i];$record=$leaf.records[$i] + $null=Add-Pin $record.child.path $record.child + $out='component evidence'+$nl;$err='PROCESS: declared component failure'+$nl + $actualOut=switch -CaseSensitive ($definition.id){'nul-stdout' {$out+[char]0};'bom-stdout' {([string][char]0xFEFF)+$out};default {$out}} + $actualErr=if($definition.id -ceq 'extra-error-words'){$err+'UNEXPECTED OUTER DIAGNOSTIC'+$nl}else{$err} + Same ($utf8.GetString([IO.File]::ReadAllBytes($record.capture.spec.stdout))) $actualOut 'prescribed leaf emitted stdout' + Same ($utf8.GetString([IO.File]::ReadAllBytes($record.capture.spec.stderr))) $actualErr 'prescribed leaf emitted stderr' + Compare-Case $definition $record.capture $out $err 1 'process-component' 'historical-actual-leaf-child' + } + + $wrapper=Read-PinnedJson (Join-Path $review 'stream-wrapper-16987dad0e7f455cbd45e64b6fb6e11b/RESULT.json') 7598 'BA143B9F0A4D100115A90F82507DD3647E9F089821A2F10BB328D798679EFA21' + Check-Roster @($wrapper.records.id) @($registry.copiedFocused.id) 'copied focused cases' + $null=Add-Pin $wrapper.baseline.path $wrapper.baseline + $baseline=$utf8.GetString([IO.File]::ReadAllBytes($wrapper.baseline.path))|ConvertFrom-Json + foreach($pin in $baseline.raw){$null=Add-Pin $pin.path $pin} + $nativeRoot=[IO.Path]::GetFullPath((Join-Path $oldRoot '.lake/lifecycle-native-p0/runs/5b2d10d020e64c24b8d81f8278eb39a7')) + $null=Add-Pin (Join-Path $nativeRoot 'SUMMARY.json') @{bytes=117086;sha256='B71497497654E9544C07B73A693A411AAC20713495EBE5716CF93D8CEFEE9934'} + $out='LIFECYCLE-REPLAY evidence='+$nativeRoot+$nl+'LIFECYCLE-REPLAY PASS cases=1 selfTest=False'+$nl + for($i=0;$i -lt $registry.copiedFocused.Count;$i++){ + $definition=$registry.copiedFocused[$i];$record=$wrapper.records[$i] + foreach($pin in $record.raw){$null=Add-Pin $pin.path $pin} + $dir=Split-Path $record.raw[0].path -Parent + $launcher=$baseline.outer|ConvertTo-Json -Depth 20|ConvertFrom-Json + $launcher.RawStandardOutput=Join-Path $dir 'launcher.stdout.raw';$launcher.RawStandardError=Join-Path $dir 'launcher.stderr.raw' + $capture=@{launcher=$launcher;actual=$baseline.actual;raw=$record.raw; + spec=@{stdout=(Join-Path $dir 'stdout.raw');stderr=(Join-Path $dir 'stderr.raw');error=(Join-Path $dir 'child-error');overflow=(Join-Path $dir 'overflow')}} + $actualOut=switch -CaseSensitive ($definition.id){'trailing-nul-stdout' {$out+[char]0};'leading-bom-stdout' {([string][char]0xFEFF)+$out};default {$out}} + $actualErr=switch -CaseSensitive ($definition.id){'nul-only-stderr' {[string][char]0};'extra-error-words' {'UNEXPECTED OUTER DIAGNOSTIC'+$nl};default {''}} + Same ($utf8.GetString([IO.File]::ReadAllBytes($capture.spec.stdout))) $actualOut 'prescribed copied stdout' + Same ($utf8.GetString([IO.File]::ReadAllBytes($capture.spec.stderr))) $actualErr 'prescribed copied stderr' + Compare-Case $definition $capture $out '' 0 'wrapper-focused' 'historical-copied-focused' -Wrapper + } + # These six launcher components are freshly written copies. They are not + # actual launcher emissions; child transport/ordinary exits still come from + # the immutable positive receipt, and the complete focused predicate is used. + foreach($definition in $registry.syntheticLauncher){ + $dir=Join-Path $OutputRoot ('synthetic-launcher/'+$definition.id) + [void][IO.Directory]::CreateDirectory($dir) + $baselineDir=Split-Path $wrapper.baseline.path -Parent + $launcher=$baseline.outer|ConvertTo-Json -Depth 20|ConvertFrom-Json + $launcher.RawStandardOutput=Join-Path $dir 'launcher.stdout.raw';$launcher.RawStandardError=Join-Path $dir 'launcher.stderr.raw' + $spec=@{stdout=(Join-Path $dir 'stdout.raw');stderr=(Join-Path $dir 'stderr.raw');error=(Join-Path $dir 'child-error');overflow=(Join-Path $dir 'overflow')} + [IO.File]::WriteAllBytes($spec.stdout,[IO.File]::ReadAllBytes((Join-Path $baselineDir 'stdout.log'))) + [IO.File]::WriteAllBytes($spec.stderr,[IO.File]::ReadAllBytes((Join-Path $baselineDir 'stderr.log'))) + [IO.File]::WriteAllBytes($launcher.RawStandardOutput,[IO.File]::ReadAllBytes($baseline.outer.RawStandardOutput)) + [IO.File]::WriteAllBytes($launcher.RawStandardError,[IO.File]::ReadAllBytes($baseline.outer.RawStandardError)) + $target=if($definition.channel -ceq 'stdout'){$launcher.RawStandardOutput}else{$launcher.RawStandardError} + [IO.File]::WriteAllBytes($target,$utf8.GetBytes([string][char]$definition.codepoint)) + $raw=@($spec.stdout,$spec.stderr,$launcher.RawStandardOutput,$launcher.RawStandardError)|ForEach-Object {Get-LNRawPin $_} + $capture=@{launcher=$launcher;actual=$baseline.actual;raw=$raw;spec=$spec} + Compare-Case $definition $capture $out '' 0 'wrapper-focused' 'synthetic-launcher-component' -Wrapper + } + if($rows.Count -ne 40){throw 'R3-RETAINED: complete 21/4/4/5/6 registry did not execute'} +}catch{$failure=$_.Exception.Message} +finally { + foreach($pin in @($pins.Values)){ + try{$now=Get-LNRawPin $pin.path;if($now.bytes -ne $pin.bytes -or $now.sha256 -cne $pin.sha256){throw ('changed pin '+$pin.path)}} + catch{$finalErrors.Add($_.Exception.Message)} + } + try{ + if($null -eq $before){throw 'initial candidate snapshot unavailable'} + $after=Get-LNTreeSnapshot $repo (Join-Path $OutputRoot 'after') + Same ($after|ConvertTo-Json -Depth 8 -Compress) ($before|ConvertTo-Json -Depth 8 -Compress) 'live candidate finally' + }catch{$finalErrors.Add($_.Exception.Message)} + $result=[ordered]@{success=($null -eq $failure -and $finalErrors.Count -eq 0);failure=$failure;finalIntegrity=@{attempted=$true;success=($finalErrors.Count -eq 0);errors=@($finalErrors.ToArray());checkedPins=$pins.Count;restorationWrites=0}; + oldHead=$base;historicalRoot=$oldRoot;currentHead=$(if($null -ne $before){$before.head}else{$null}); + runtime=@{shell=(Get-Process -Id $PID).Path;PowerShell=$PSVersionTable.PSVersion.ToString();DotNet=[Environment]::Version.ToString()}; + sourceGitWorkingRelation='Old helper exact raw hash plus Git check-out filter identity; raw captures never normalized.'; + registry=@($rows.ToArray());pins=@($pins.Values|Sort-Object path);scope='Retained capture components only. No new native run; historical checks do not certify current HEAD. Actual-child and copied-focused evidence tiers remain separate.'} + [IO.File]::WriteAllText((Join-Path $OutputRoot 'RESULTS.json'),($result|ConvertTo-Json -Depth 30),$utf8) +} +if(-not $result.success){throw ('R3-RETAINED: '+$failure+'; finally='+($finalErrors -join '; '))} +Write-Output ('R3 RETAINED PASS cases='+$rows.Count+' evidence='+$OutputRoot) diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r3/verify_contract.py b/docs/internal/extensions/lifecycle-native-p0/repair-r3/verify_contract.py new file mode 100644 index 00000000..59e676b3 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r3/verify_contract.py @@ -0,0 +1,480 @@ +"""R3 contract adapter: new rows/scope, explicitly historical R2 evidence. + +The protected R2 parsers remain unchanged. Their historical root/base describe +the runs they inspect, not this checkout. The emitted retainedContracts are +inputs for a separate call of the current PowerShell Assert-LNOuterCapture; +Python reconstruction alone does not establish that production verdict. +""" +import argparse +import importlib.util +import json +from pathlib import Path +import re +import sys +import time + +sys.dont_write_bytecode = True +ROOT = Path(__file__).resolve().parents[5] +HERE = Path(__file__).resolve().parent +NATIVE = "docs/internal/extensions/lifecycle-native-p0/" +R3 = NATIVE + "repair-r3/" +BASE = "9519b2c1af5e2cf59536b311db5e8dc81376a32f" +GOVERNANCE = "7b227c49ef2ec044b702126cc41c9add847eed01" +BRANCH = "codex/life-native-p0-r3-literal-streams" +LEDGER = "docs/internal/WORKFLOW_DESIGN_DECISIONS.md" +ALLOWED = {"scripts/packed_native_lifecycle_stream_check.ps1", + NATIVE + "repair-r2/certify_profiles.ps1", + NATIVE + "repair-r1/final_checks.ps1", LEDGER} +CAMPAIGN = Path("C:/Users/poin/Documents/RMQ/lifecycle-implementation-20260920") +R2_ROOT = Path("C:/Users/poin/.codex/worktrees/eafd/RMQ") +R2_BASE = "2307e3ad0739e0e1d9c3f186cdc568631086fddf" +PROMPT_SHA = "901E5559C45A711B92BD686482934596D7259D0D21D7FA628B7C1851969C4172" +FROZEN_SHA = "D567FF2B9F861A6A910CC94A9E7ABB44D2D559893CBBC7293CEFBE798CE01ABF" +MANIFEST_SHA = "5C41CAB7E65E07E14763E2977E66AB06073901E0A9E70252C130E0F9A5E23E15" +FINAL_SHA = "7AA1748F86B6BE85C9DC40602D1B78DFD0AC73AD57BF848010E98B3BE989BF03" +PROFILE_SHA = "FA532B198B5EF6D627F61EF645FE3B030B640B28A1E489C2E1DCC950EFC63ACF" + + +def load(name, filename, expected_sha): + path = ROOT / (NATIVE + "repair-r2/" + filename) + import hashlib + if hashlib.sha256(path.read_bytes()).hexdigest().upper() != expected_sha: + raise ValueError("protected R2 parser identity: " + filename) + spec = importlib.util.spec_from_file_location(name, path) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +C = load("r3_inherited_contract", "verify_contract.py", + "6F1CFB871656215513FA91F617EA563BC9B2EE4EBFBE04D77A7F2E7C30A69871") +V = load("r3_historical_results", "verify_results.py", + "CE931FD260A5FDA818E06BEEF1C66C6152189B46984FC4510EB445376244CAD2") +# Explicitly configure only the historical result parser's producing root. +# Its base remains 2307; current scope and final dispatch use 9519 separately. +V.ROOT = R2_ROOT +# Git plumbing only asks for immutable object/history data shared by these +# worktrees. Use the governed current checkout, without changing a safe.directory +# setting or pretending that the captures were produced in the current root. +V.git = C.git +IDS = C.IDS + ["NP0R3-LITERAL", "NP0R3-SELECTOR"] +need, git, pin = C.require, C.git, C.pin + + +def row_context(): + start, freeze = C.readj(HERE / "START.json"), C.readj(HERE / "FREEZE.json") + need(start["base"] == start["head"] == BASE and start["branch"] == BRANCH, + "initial exact base/branch") + need(Path(start["worktree"]).resolve() == ROOT and start["initialClean"] is True + and start["initialStatus"] == "", "initial clean exact worktree") + need(start["governance"] == GOVERNANCE and start["preflightExit"] == 0 + and start["runtimeProjectSkills"] == ["rmq-audit-prompt", "rmq-coordinator", "rmq-proof-sprint"] + and start["requiredSkills"] == ["rmq-proof-sprint"], "preflight role inventory") + expected_preflight = ["governance=" + GOVERNANCE, "checkout=" + BASE] + expected_preflight += [key + "=rmq-audit-prompt,rmq-coordinator,rmq-proof-sprint" + for key in ["expected", "checkout_skills", "working_skills", "runtime_skills"]] + expected_preflight += ["required=rmq-proof-sprint", "required_mode=role-skills", "PASS"] + need([line for line in start["preflightOutput"] if line.startswith("SKILL-PREFLIGHT: ")] + == ["SKILL-PREFLIGHT: " + line for line in expected_preflight], "complete preflight outcome") + prompt_path = CAMPAIGN / "LIFE-NATIVE-P0-R3_PROMPT.md" + prompt = pin(prompt_path) + need(prompt["bytes"] == 28741 and prompt["sha256"] == PROMPT_SHA, + "independently pinned commissioning prompt") + need(Path(freeze["prompt"]["path"]).resolve() == prompt_path.resolve() + and freeze["prompt"]["bytes"] == 28741 + and freeze["prompt"]["sha256"].upper() == PROMPT_SHA, "freeze prompt identity") + raw = (HERE / "ACCEPTANCE_ROWS.txt").read_bytes() + need(C.sha(raw) == FROZEN_SHA == freeze["rowsSha256"].upper(), "initial full row bytes") + need(freeze["base"] == BASE and freeze["ids"] == IDS and freeze["inherited"] == 16, + "freeze exact ordered contract") + requirements = dict(re.findall(r"^- ([A-Z0-9-]+): (.+)$", + "\n".join(prompt_path.read_bytes().decode("utf-8-sig", errors="strict").splitlines()), re.M)) + frozen = C.rows(raw) + inherited = C.rows(C.blob(NATIVE + "repair-r2/ACCEPTANCE_MATRIX.md", BASE)) + need(list(frozen) == IDS and list(inherited) == IDS[:16], "initial ordered inherited IDs") + for key in IDS: + need(frozen[key].split(b"|")[2].strip().decode("utf-8") == requirements[key], + "pinned prompt requirement: " + key) + if key in inherited: + need(frozen[key] == inherited[key], "exact inherited full row: " + key) + return frozen, inherited, requirements, prompt + + +def verify_rows(raw, context): + frozen, inherited, requirements, _ = context + current = C.rows(raw) + need(list(current) == IDS, "missing/extra/reordered IDs") + for key in IDS: + need(current[key] == frozen[key], "frozen full row changed: " + key) + need(current[key].split(b"|")[2].strip().decode("utf-8") == requirements[key], + "pinned prompt requirement changed: " + key) + if key in inherited: + need(current[key] == inherited[key], "inherited full row changed: " + key) + + +def row_controls(raw, context): + first = context[0][IDS[0]] + tests = { + "missing": raw.replace(first, b"", 1), + "duplicate": raw + b"\n" + first + b"\n", + "changed-cell": raw.replace(b"Open at freeze", b"Closed at freeze", 1), + "mojibake": raw.replace(b"Implement", "\u00c2\u00acImplement".encode(), 1), + "changed-requirement": raw.replace(b"Implement a reproducible probe", b"Implement a label", 1), + "invalid-utf8": raw.replace(b"Implement", b"\xffImplement", 1), + "ninth-column": raw.replace(first, first[:-1] + b" extra |", 1), + "reordered": raw.replace(first, b"", 1) + b"\n" + first + b"\n", + "literal-requirement": raw.replace(b"literal equality after strict", b"cultural equality after strict", 1), + "selector-requirement": raw.replace(b"explicitly bound null", b"implicitly bound null", 1), + } + results = [{"id": "unchanged", "expected": "ACCEPT", "actual": "ACCEPT"}] + verify_rows(raw, context) + for key, mutant in tests.items(): + need(mutant != raw, "vacuous row mutation: " + key) + try: + verify_rows(mutant, context) + except (ValueError, UnicodeError) as error: + results.append(dict(id=key, expected="REJECT", actual="REJECT", surface=str(error))) + else: + raise ValueError("row mutation accepted: " + key) + return results + + +def verify_scope(): + need(git("branch", "--show-current").decode().strip() == BRANCH, "current exact branch") + need(Path(git("rev-parse", "--show-toplevel").decode().strip()).resolve() == ROOT, "current exact root") + for ref in [BASE, GOVERNANCE]: + git("merge-base", "--is-ancestor", ref, "HEAD") + base_tree, current_tree = C.tree(BASE), C.tree("HEAD") + changed = set() + for args in [("diff", "--name-only", "-z", BASE), + ("diff", "--cached", "--name-only", "-z", BASE), + ("ls-files", "--others", "--exclude-standard", "-z")]: + changed.update(git(*args).decode("utf-8").split("\0")) + changed.discard("") + need(all(path in ALLOWED or path.startswith(R3) for path in changed), + "outside R3 write scope: " + repr(sorted(changed))) + protected = [path for path in base_tree if path not in ALLOWED] + # filtered_blobs takes its ref from the inherited module's BASE variable. + # Limit this temporary binding to this helper, then restore its historical + # base before any historical source or baseline composition is evaluated. + old_base = C.BASE + try: + C.BASE = BASE + for path, raw in C.filtered_blobs(protected): + need(current_tree.get(path) == base_tree[path], "protected committed mode/blob: " + path) + need((ROOT / path).is_file() and (ROOT / path).read_bytes() == raw, + "protected checkout-filtered bytes: " + path) + finally: + C.BASE = old_base + need(C.blob(LEDGER, "HEAD").startswith(C.blob(LEDGER, BASE)), "committed WDD prefix changed") + need((ROOT / LEDGER).read_bytes().startswith(C.blob(LEDGER, BASE, True)), "working WDD prefix changed") + return dict(changedPaths=sorted(changed), protectedBasePaths=len(protected), + workflowLedgerAppendOnly=True, indexScopeChecked=True, + narrowHistoricalEdits=narrow_historical_edits(), + checkoutByteRule="Committed mode/blob and actual git cat-file --filters 9519 bytes both checked.") + + +def narrow_historical_edits(): + """Exact anchored transformations bind all other inherited caller bytes.""" + guard = "\n".join([ + "# Validate the complete selection before creating output or invoking any profile.", + "if($PSBoundParameters.ContainsKey('Kinds')){", + " if($null -eq $Kinds -or $Kinds.Count -eq 0 -or @($Kinds|Where-Object {[string]::IsNullOrWhiteSpace($_)}).Count){throw 'CERTIFY-SELECTOR: empty'}", + " $known=[Collections.Generic.HashSet[string]]::new([string[]]@('focused','full','integrity','dependencies','checks','claims'),[StringComparer]::Ordinal)", + " $seen=[Collections.Generic.HashSet[string]]::new([StringComparer]::Ordinal)", + " foreach($kind in $Kinds){", + " if(-not $known.Contains($kind)){throw 'CERTIFY-SELECTOR: unknown'}", + " if(-not $seen.Add($kind)){throw 'CERTIFY-SELECTOR: duplicate'}", + " }", "}", ""]) + facts = [] + for path in sorted(ALLOWED - {LEDGER}): + candidates = [] + for filtered in [False, True]: + source = C.blob(path, BASE, filtered).decode("utf-8", errors="strict") + newline = "\r\n" if "\r\n" in source else "\n" + def replace(old, new): + nonlocal source + need(source.count(old) == 1, "unique inherited syntax anchor: " + path) + source = source.replace(old, new) + if path.endswith("packed_native_lifecycle_stream_check.ps1"): + replace("if($Actual -cne $Expected)", + "if(-not [string]::Equals($Actual,$Expected,[StringComparison]::Ordinal))") + replace("rev-list --reverse '" + R2_BASE + "..HEAD'", + "rev-list --reverse '" + BASE + "..HEAD'") + elif path.endswith("final_checks.ps1"): + replace("$base='" + R2_BASE + "'", "$base='" + BASE + "'") + replace("'../repair-r2/verify_contract.py'", "'../repair-r3/verify_contract.py'") + else: + anchor = "$ErrorActionPreference='Stop'" + newline + replace(anchor, anchor + guard.replace("\n", newline)) + replace(" if($kind -cnotin @('focused','full','integrity','dependencies','checks','claims')){throw 'unsupported certification profile'}" + newline, "") + candidates.append(source.encode("utf-8")) + need((ROOT / path).read_bytes() in candidates, "historical caller delta exceeds exact authorized repair: " + path) + facts.append(dict(path=path, allOtherInheritedBytesPreserved=True, + representation="exact Git blob or exact checkout-filtered bytes, then only prescribed anchored edit")) + return facts + + +class HistoricalPins(V.Pins): + """Tracked historical sources use exact Git identities; raw artifacts use files.""" + def __init__(self): + super().__init__() + self.git_sources = [] + self.blobs = {} + self.trees = {} + + def add(self, path, expected=None): + path = Path(path).resolve() + key = str(path).lower() + if expected is None or key in self.records: + return super().add(path, expected) + contexts = [(R2_ROOT, [BASE, "4d6f195b306bd1615aced8c7a7cd1db0d48a8d69", + "c3fcc2e0beb08d090382f56d16dbe9446639164a"]), + (C.R1_ROOT, [R2_BASE, "fda02922bf9e8c0707b9913013d3c16c80afe7c9", + "1811eeb9e2f783cc455e44a618a99af77b0172ed"]), + (C.ORIGINAL_ROOT, [C.ORIGINAL_FINAL, C.ORIGINAL])] + for root, refs in contexts: + if not path.is_relative_to(root): + continue + relative = path.relative_to(root).as_posix() + if relative.startswith(".lake/"): + break + found_source = False + for ref in refs: + cache_key = (ref, relative) + if cache_key not in self.blobs: + if ref not in self.trees: + self.trees[ref] = C.tree(ref) + if relative not in self.trees[ref]: + self.blobs[cache_key] = None + else: + self.blobs[cache_key] = [(kind, C.blob(relative, ref, filtered)) + for kind, filtered in [("Git blob", False), ("Git checkout filters", True)]] + for representation, raw in self.blobs[cache_key] or []: + found_source = True + if len(raw) == expected["bytes"] and C.sha(raw) == expected["sha256"].upper(): + item = dict(path=str(path), bytes=len(raw), sha256=C.sha(raw)) + self.records[key] = item + self.occurrences += 1 + self.git_sources.append(dict(**item, repositoryPath=relative, commit=ref, + representation=representation)) + return item + if found_source: + # Some preserved Windows working sources were written with CRLF + # although their exact Git blobs and today's smudge result use + # LF. Check their actual raw pin first; only the source-to-Git + # relation uses the unchanged repository's clean filter. Raw + # stdout/stderr never enter this tracked-source branch. + actual = C.pin(path) + need(actual["bytes"] == expected["bytes"] and actual["sha256"] == expected["sha256"].upper(), + "retained historical source raw pin: " + str(path)) + object_id = git("hash-object", "--path=" + relative, "--stdin", input=path.read_bytes()).decode().strip() + matches = [ref for ref in refs if self.trees[ref].get(relative, (None, None, None))[2] == object_id] + need(bool(matches), "historical tracked clean-filter identity: " + str(path)) + self.records[key] = actual + self.occurrences += 1 + self.git_sources.append(dict(**actual, repositoryPath=relative, commit=matches[0], + gitBlob=object_id, representation="Exact retained raw source pin plus Git clean-filter blob identity")) + return actual + need(not found_source, "historical tracked Git identity mismatch: " + str(path)) + break + return super().add(path, expected) + + +def integrity_contracts(result): + """Reconstruct fixed case diagnostics, preserving the old Windows runtime text. + + Lock and decoder wording below is the pinned historical platform contract, + derived there by the source's independent lock/decode operations. It is not + asserted as a portable .NET wording or inferred from current capture text. + """ + contracts = [] + for row in result["controls"]: + key = row["id"] + summary = V.readj(row["summary"]["path"]) + run = Path(summary["runRoot"]) + fixture = Path(row["fixtureSource"]["path"]).parents[1] + errors = [] + pin_cases = ["stage-error-and-pin-change", "success-and-pin-change", + "mixed-diagnostic-and-pin-change", "timeout-and-pin-change", "partial-identity-and-pin-change"] + if key in pin_cases: + errors.append("INTEGRITY: changed captured pin: " + str(fixture / "native/packed-rmq/tests/lifecycle_storage_probe.c")) + if key == "success-and-link-map-change": + errors.append("INTEGRITY: changed captured pin: " + str(run / "link.map")) + if key in pin_cases + ["success-and-tracked-change", "success-and-index-change", + "success-and-untracked-addition", "success-and-untracked-byte-change"]: + errors.append("INTEGRITY: live tracked/index/untracked baseline changed") + if key == "missing-baseline": + errors.append("INTEGRITY: UNCOVERED; initial tree inventory unavailable") + if key == "stage-error-and-capture-error": + path = str(run / "link.map") + errors.append("INTEGRITY: artifact capture failed: " + path + "; The process cannot access the file '" + + path + "' because it is being used by another process.") + failure = None + if key in ["intact-stage-error", "stage-error-and-pin-change", "stage-error-and-capture-error"]: + failure = "PROCESS: fixture-stage actual child or launcher exit differs from 0" + elif key == "timeout-and-pin-change": + failure = "PROCESS: fixture-stage was not a completed bounded process; see retained logs" + elif key == "mixed-diagnostic-and-pin-change": + failure = "DIAGNOSTIC: unexpected or mixed stderr for fixture-stage" + elif key == "partial-identity-and-pin-change": + failure = "IDENTITY: missing file " + str(fixture / "missing-tool.exe") + elif key == "malformed-stdout-intact": + failure = ('DIAGNOSTIC: invalid raw stage evidence for fixture-stage; Exception calling "ReadAllText" ' + 'with "2" argument(s): "Unable to translate bytes [FF] at index 0 from specified code page to Unicode."') + need(summary["failure"] == failure and summary["integrity"]["errors"] == errors, + "source-derived complete historical diagnostic order: " + key) + stdout = "LIFECYCLE-REPLAY evidence=" + str(run) + V.NL + if key == "intact-success": + stdout += "LIFECYCLE-REPLAY PASS cases=1 selfTest=False" + V.NL + stderr = "".join(message + V.NL for message in ([failure] if failure else []) + errors) + expected = dict(expectedStdout=stdout, expectedStderr=stderr, + expectedExit=0 if key == "intact-success" else 1, validated=True) + need(row["streamContract"] == expected, "independently reconstructed historical stream contract: " + key) + contracts.append(dict(id="integrity-" + key, profile="integrity-" + key, + producingRoot=str(R2_ROOT), capture=row["capture"], + sourcePins=[row["fixtureSource"]], rawPins=[row["summary"]] + row["capture"]["raw"], + **expected)) + return contracts + + +def historical_r2(): + pins = HistoricalPins() + review_manifest = CAMPAIGN / "native-p0-r2-review/EVIDENCE_PIN_MANIFEST.json" + need(pin(review_manifest)["sha256"] == MANIFEST_SHA, "independent R2 review pin inventory") + inventory = V.readj(review_manifest) + need(inventory["count"] == len(inventory["entries"]) == 3016 and inventory["occurrences"] == 4498, + "reviewed R2 inventory cardinality") + for item in inventory["entries"]: + pins.add(item["path"], item) + final_path = R2_ROOT / ".lake/repair-r2/FINAL_CERTIFICATION.json" + need(pin(final_path)["sha256"] == FINAL_SHA, "R2 exact final certificate") + final = V.readj(final_path) + need(final["base"] == R2_BASE and final["finalPackageCommit"] == BASE, + "historical final package/base identity") + profiles_path = Path(final["finalProfileManifest"]["path"]) + need(pin(profiles_path)["sha256"] == PROFILE_SHA, "R2 final manifest identity") + manifest = V.readj(profiles_path) + need(manifest["head"] == BASE and set(manifest["profiles"]) == set(V.PROFILES), + "R2 historical six-profile final manifest") + claim_receipt = V.readj(manifest["profiles"]["claims"]) + claim_path = claim_receipt["claimExpectation"]["path"] + need(Path(manifest["claimExpectationPath"]).resolve() == Path(claim_path).resolve(), + "historical claims producing expectation identity") + facts, baselines, contracts = {}, {}, [] + for kind in V.PROFILES: + receipt, capture, receipt_pin = V.profile_receipt(kind, manifest["profiles"][kind], pins) + capture["raw"] = receipt["raw"] + stdout = V.raw(capture["spec"]["stdout"]) + baselines[kind] = stdout + fact = (V.native_summary(kind, stdout, pins) if kind in ["focused", "full"] else + V.integrity_results(stdout, pins) if kind == "integrity" else + V.dependency_results(stdout, pins) if kind == "dependencies" else + V.claim_records(stdout, claim_path, pins) if kind == "claims" else + V.check_results(stdout, pins)) + facts[kind] = dict(receipt=receipt_pin, facts=fact) + # Each parser above independently checks the whole source-derived + # language. Claims admits any ordering of its exact record multiset. + contracts.append(dict(id="profile-" + kind, profile="wrapper-" + kind, + producingRoot=str(R2_ROOT), capture=capture, + sourcePins=[], rawPins=[receipt_pin] + receipt["raw"], + expectedStdout=stdout, expectedStderr="", expectedExit=0, validated=True)) + need(facts["checks"]["facts"]["head"] == BASE, "historical final checks head") + ledger = V.readj(final["finalLedger"]["record"]["path"]) + harness = V.verify_harness(ledger["harness"]["results"]["path"], pins) + wrapper = V.verify_wrapper_controls(ledger["wrapperControls"]["results"]["path"], + profiles_path, baselines, pins, claim_path) + old = V.old_reproduction(ledger["oldReproduction"]["receipt"]["path"], pins) + controls = V.readj(facts["integrity"]["facts"]["results"]["path"]) + contracts += integrity_contracts(controls) + source_paths = ["scripts/packed_native_lifecycle_stream_check.ps1", + "scripts/packed_native_lifecycle_storage_replay.ps1", + "scripts/owned_process_tree.ps1", + NATIVE + "repair-r1/run_owned.ps1", NATIVE + "repair-r1/integrity_controls.ps1", + NATIVE + "repair-r1/final_checks.ps1", NATIVE + "repair-r2/claim_expectations.ps1"] + source_pins = [] + for path in source_paths: + historical = R2_ROOT / path + need(historical.read_bytes() in [C.blob(path, BASE), C.blob(path, BASE, True)], + "producing historical caller bytes: " + path) + source_pins.append(dict(**pins.add(historical), repositoryPath=path, commit=BASE)) + for contract in contracts: + contract["sourcePins"] += source_pins + need(len(contracts) == 21 and len({c["id"] for c in contracts}) == 21, + "six historical profiles plus fifteen integrity contracts") + return dict(producingRoot=str(R2_ROOT), historicalBase=R2_BASE, packageCommit=BASE, + independentReviewManifest=pin(review_manifest), verifiedManifestEntries=3016, + finalCertificate=pin(final_path), profiles=facts, harness=harness, + wrapperControls=wrapper, oldReproduction=old, distinctPins=len(pins.records), + pinOccurrences=pins.occurrences, historicalGitSources=pins.git_sources, + meaning="Preserved finite historical executions and exact raw bytes; not new native runs or a current-head checks roster."), contracts + + +def current_registries(): + literal_path, retained_path = HERE / "CONTROL_REGISTRY.json", HERE / "retained_registry.json" + need(pin(literal_path)["sha256"] == "16E26C5B131BBE258B3813BCDB252414E8BED454EF6286EB2ED7F7EF3496261D", + "frozen new literal/selector registry complete bytes") + need(pin(retained_path)["sha256"] == "521BFA0CD6DEE84383AB41F8B7D6CC0F226EEFABFC96113EF5EBE835A48A20EB", + "frozen retained registry complete bytes") + literal, retained = V.readj(literal_path), V.readj(retained_path) + expected = [] + for stage in ["success", "error"]: + expected.append("literal-" + stage + "-exact") + expected += ["literal-" + stage + "-" + mutation + "-" + channel + for mutation in ["bom", "nul", "shy", "ascii"] for channel in ["stdout", "stderr"]] + expected += ["holdout-" + key for key in ["lf-crlf", "normalization", "zero-width", "nonbreaking-space", + "invalid-utf8", "overlong-utf8", "literal-codepoints"]] + expected += ["selector-" + key for key in ["null", "empty-array", "empty-string", "whitespace", "unknown", + "duplicate", "late-empty", "late-unknown", "unknown-bom", "unknown-nul", "focused"]] + expected += ["integrity-caller-pair"] + V.roster([row["id"] for row in literal["controls"]], expected, "new37 registry") + need(literal["defaultProfiles"] == ["focused", "full", "integrity", "dependencies", "checks", "claims"], + "actual default profile roster") + need(retained["oldHead"] == BASE and Path(retained["historicalRoot"]).resolve() == R2_ROOT + and retained["profiles"] == V.PROFILES and retained["integrity"] == V.INTEGRITY_IDS, + "retained historical source/roster identity") + retained_ids = ["profile-" + key for key in V.PROFILES] + ["integrity-" + key for key in V.INTEGRITY_IDS] + for category in ["root", "leaf", "copiedFocused", "syntheticLauncher"]: + keys = [row["id"] for row in retained[category]] + need(len(keys) == len(set(keys)), "duplicate retained category ID") + retained_ids += [category + "-" + key for key in keys] + need(len(retained_ids) == len(set(retained_ids)) == 40, "retained40 exact ordered unique roster") + return dict(literal=pin(literal_path), literalIds=expected, retained=pin(retained_path), + retainedIds=retained_ids, + boundary="Exact whole registry bytes bind IDs, case objects, predicates, evidence tiers and expected verdicts; execution remains a separate production check.") + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--output", required=True) + parser.add_argument("--rows-only", action="store_true") + args = parser.parse_args() + started = time.monotonic() + context = row_context() + raw = (HERE / "ACCEPTANCE_MATRIX.md").read_bytes() + verify_rows(raw, context) + result = dict(success=True, mode="rows-only" if args.rows_only else "full-contract", + base=BASE, head=git("rev-parse", "HEAD").decode().strip(), worktree=str(ROOT), + historicalHead=BASE, historicalRoot=str(R2_ROOT), verifier=pin(__file__), + rows=IDS, inheritedRows=IDS[:16], changedIds=[], prompt=context[3], + frozenRows=pin(HERE / "ACCEPTANCE_ROWS.txt"), rowControls=row_controls(raw, context)) + if not args.rows_only: + result["scope"] = verify_scope() + result["currentRegistries"] = current_registries() + result["historicalR1"] = C.historical_evidence() + result["historicalR2"], result["retainedContracts"] = historical_r2() + result["claimComposition"] = C.claim_composition() + result["currentOwnedSources"] = [pin(ROOT / p) for p in sorted(ALLOWED)] + result["pendingProductionChecks"] = [ + "Current Assert-LNOuterCapture on all 21 retainedContracts, with original paths unchanged", + "Complete new literal/selector registry and actual focused certify_profiles invocation", + "Current-head final checks and fresh entire native subtree/both-ledger strict claims"] + result["seconds"] = round(time.monotonic() - started, 3) + Path(args.output).write_text(json.dumps(result, indent=2) + "\n", encoding="utf-8") + suffix = "" if args.rows_only else (f", {result['scope']['protectedBasePaths']} protected paths, " + "R2 native23/65/58 integrity15 dependency19 harness11 wrapper120 retained, 21 historical contracts") + print(f"CONTRACT PASS: 18 frozen rows, {len(result['rowControls'])} row controls{suffix}") + + +if __name__ == "__main__": + main() diff --git a/docs/internal/extensions/lifecycle-native-p0/repair-r3/verify_results.py b/docs/internal/extensions/lifecycle-native-p0/repair-r3/verify_results.py new file mode 100644 index 00000000..fb2b6138 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native-p0/repair-r3/verify_results.py @@ -0,0 +1,485 @@ +"""Compose R3 evidence using the protected R2 receipt parsers. + +This collector reads retained facts; the recorded PowerShell predicates remain +the production verdicts. Historical profiles remain historical executions. +""" +import argparse +import base64 +import hashlib +import importlib.util +import json +from pathlib import Path +import sys +import time + +sys.dont_write_bytecode = True +ROOT = next(p for p in Path(__file__).resolve().parents + if (p / "lean-toolchain").is_file() and (p / "scripts").is_dir()) +NATIVE = ROOT / "docs/internal/extensions/lifecycle-native-p0" +HERE = NATIVE / "repair-r3" +BASE = "9519b2c1af5e2cf59536b311db5e8dc81376a32f" +REGISTRY_SHA = "16E26C5B131BBE258B3813BCDB252414E8BED454EF6286EB2ED7F7EF3496261D" +RETAINED_SHA = "521BFA0CD6DEE84383AB41F8B7D6CC0F226EEFABFC96113EF5EBE835A48A20EB" +PARSER = NATIVE / "repair-r2/verify_results.py" +if hashlib.sha256(PARSER.read_bytes()).hexdigest().upper() != "CE931FD260A5FDA818E06BEEF1C66C6152189B46984FC4510EB445376244CAD2": + raise ValueError("protected R2 receipt parser byte identity") +spec = importlib.util.spec_from_file_location("r3_reused_r2_results", PARSER) +V = importlib.util.module_from_spec(spec) +spec.loader.exec_module(V) +# Only the explicit current-source consumers use this parser instance. Its +# registry directory remains repair-r2; no historical parser file is changed. +V.ROOT, V.BASE = ROOT, BASE +need, readj, NL = V.need, V.readj, V.NL + + +def same_path(a, b): + return Path(a).resolve() == Path(b).resolve() + + +def frozen(path, digest, pins): + pin = pins.add(path) + need(pin["sha256"] == digest, "frozen registry byte identity: " + str(path)) + return readj(path) + + +def artifact_capture(capture, pins): + """Bind a row to its actually retained CAPTURE.json when one exists.""" + path = Path(capture["spec"]["stdout"]).parent / "CAPTURE.json" + need(path.is_file(), "actual emitted capture record missing") + pins.add(path) + need(readj(path) == capture, "recorded capture object differs from raw capture record") + + +def captured_driver(capture, driver): + args = capture["spec"]["arguments"] + need(len(args) == 3 and args[:2] == ["-NoProfile", "-File"] and same_path(args[2], driver["path"]) and + same_path(capture["spec"]["cwd"], ROOT), "actual captured driver/working-directory identity") + + +def groups(paths, registry, pins, head): + all_rows, facts, source_heads = [], [], [] + for path in paths: + launch = readj(path); launch_pin = pins.add(path) + group, selected = launch["group"], launch["selected"] + need(group in ["tiny", "focused", "integrity"] and launch["failure"] is None, "group identity/failure") + allowed = [r["id"] for r in registry["controls"] + if (r["mode"] in ["literal", "selector"] if group == "tiny" else r["mode"] == group)] + need(selected and all(key in allowed for key in selected), "group requested mode/IDs") + V.roster(selected, [key for key in allowed if key in selected], "group requested ordered subset") + result_path = Path(launch["results"]); result = readj(result_path); pins.add(result_path) + expected = "".join("R3 CONTROL PASS " + x + NL for x in selected) + expected += "R3 CONTROLS evidence=" + str(result_path.parent) + NL + need((launch["expectedStdout"], launch["expectedStderr"], launch["expectedExit"]) == + (expected, "", 0), "group declared full stream contract") + V.capture(launch["capture"], pins, expected, "", 0) + artifact_capture(launch["capture"], pins) + need(launch["capture"]["launcher"]["DeadlineSeconds"] == (1200 if group == "focused" else 300), + "group deadline contract") + for key in ["driver", "launcherScript"]: + pins.walk(launch[key]) + captured_driver(launch["capture"], launch["driver"]) + need(result["head"] == launch["head"] and result["failure"] is None and + result["integrityFailure"] is None and result["candidateUnchanged"] is True, + "group source head/final integrity") + V.git("merge-base", "--is-ancestor", result["head"], head) + source_heads.append(result["head"]) + pins.walk(result["sourcePins"]) + required_sources = [HERE / "literal_selector_controls.ps1", HERE / "CONTROL_REGISTRY.json", + NATIVE / "repair-r2/certify_profiles.ps1", ROOT / "scripts/packed_native_lifecycle_stream_check.ps1", + ROOT / "scripts/owned_process_tree.ps1", ROOT / "scripts/packed_native_lifecycle_storage_replay.ps1", + NATIVE / "repair-r1/run_owned.ps1", NATIVE / "repair-r1/integrity_controls.ps1", + NATIVE / "repair-r2/harness_stream_controls.ps1"] + V.roster([str(Path(p["path"]).resolve()) for p in result["sourcePins"]], + [str(p.resolve()) for p in required_sources], "group exact source pins") + need(result["omittedDefaultProfiles"] == registry["defaultProfiles"], "omitted selector default roster") + V.roster(result["selected"], selected, "group executed selection") + V.roster([r["id"] for r in result["controls"]], selected, "group complete records") + for record in result["controls"]: + row = next(r for r in registry["controls"] if r["id"] == record["id"]) + for key in ["id", "mode", "predicate", "tier", "verdict"]: + need(record[key] == row[key], "new registry object/predicate/verdict mapping") + pins.walk(record["driver"]) + c = record["capture"]; artifact_capture(c, pins) + captured_driver(c, record["driver"]) + if row["mode"] == "literal": + emitted = [base64.b64decode(row[key], validate=True) for key in ["stdout", "stderr"]] + for key, expected_bytes in zip(["stdout", "stderr"], emitted): + need(Path(c["spec"][key]).read_bytes() == expected_bytes, "actual prescribed emitted bytes") + if row["failure"] == "invalid-utf8": + pins.add(c["spec"]["exit"]) + need(readj(c["spec"]["exit"]) == c["actual"], "malformed case actual ordinary exit artifact") + # R2.capture checks all transport/ordinary-exit guards before + # decoding. Its strict decoder must reject these known bytes. + try: + V.capture(c, pins, "", "", row["exit"]) + except UnicodeDecodeError: + pass + else: + raise ValueError("malformed UTF-8 was decoded") + wanted = "STREAM: invalid UTF-8 capture: " + c["spec"]["stdout"] + else: + V.capture(c, pins, emitted[0].decode("utf-8"), emitted[1].decode("utf-8"), row["exit"]) + prescribed = [base64.b64decode(row[key], validate=True) + for key in ["expectedStdout", "expectedStderr"]] + need((emitted == prescribed) == (row["verdict"] == "accept"), "literal independent byte verdict") + wanted = None if row["verdict"] == "accept" else row["failure"] + need(record["failure"] == wanted and record["childAbsent"] is True, + "literal actual production rejection/cleanup") + need(c["launcher"]["DeadlineSeconds"] == 60, "tiny child deadline") + elif row["mode"] == "selector": + V.capture(c, pins, "BOUNDARY REJECTED " + row["id"] + NL, "", 0) + need(record["failure"] == row["failure"] and record["noWorkBeforeRejection"] is True, + "direct selector verdict/no-work marker") + need(not (Path(record["driver"]["path"]).parent / "must-not-exist").exists(), + "rejected selector created output") + driver = V.raw(record["driver"]["path"]) + need("-Kinds " + row["expression"] + ";throw 'UNEXPECTED NORMAL RETURN'" in driver, + "actual selector expression/normal-return trap") + elif row["mode"] == "focused": + pins.walk(record["manifest"]); pins.walk(record["receipt"]); pins.walk(record["summary"]) + manifest = readj(record["manifest"]["path"]) + need(set(manifest["profiles"]) == {"focused"} and manifest["head"] == result["head"] and + same_path(manifest["profiles"]["focused"], record["receipt"]["path"]), + "actual focused manifest is exactly one executed profile") + output = Path(record["manifest"]["path"]).parent + expected = "OWNED focused exit=0 evidence=" + str(output / "focused") + NL + expected += "PROFILE CERTIFIED focused manifest=" + record["manifest"]["path"] + NL + V.capture(c, pins, expected, "", 0) + receipt, inner, _ = V.profile_receipt("focused", record["receipt"]["path"], pins) + need(record["validation"] == receipt["streamValidation"], "focused same full production predicate") + native = V.native_summary("focused", V.raw(inner["spec"]["stdout"]), pins) + need(native["summary"] == record["summary"] and native["selected"] == ["pop-unique"], + "focused same actual native object") + else: + need(row["mode"] == "integrity", "unsupported new control mode") + pins.walk(record["results"]) + target = Path(record["results"]["path"]).parent + expected = "STREAM CONTROL PASS success-positive" + NL + "STREAM CONTROL PASS error-positive" + NL + expected += "STREAM CONTROLS evidence=" + str(target) + NL + V.capture(c, pins, expected, "", 0) + harness = readj(record["results"]["path"]) + V.roster(harness["selected"], ["success-positive", "error-positive"], "actual integrity pair") + V.verify_harness(record["results"]["path"], pins, complete=False) + all_rows.append(record) + facts.append(dict(group=group, launch=launch_pin, results=pins.add(result_path), selected=selected)) + need(len(set(source_heads)) == 1, "groups did not test one source freeze") + V.roster([r["id"] for r in all_rows], [r["id"] for r in registry["controls"]], "all37 actual new controls") + return facts, all_rows, source_heads[0] + + +def retained(path, contract, registry, pins, head, contract_path): + r = readj(path); result_pin = pins.add(path); pins.walk(r["pins"]) + root = Path(path).resolve().parent + launch_path = Path(str(root) + "-outer") / "LAUNCH.json" + pins.add(launch_path); launch = readj(launch_path) + need(launch["head"] == head and launch["failure"] is None and same_path(launch["results"], path), + "actual final retained launch/result identity") + expected = "R3 RETAINED PASS cases=40 evidence=" + str(root) + NL + need((launch["expectedStdout"], launch["expectedStderr"], launch["expectedExit"]) == (expected, "", 0), + "final retained declared complete output") + c = launch["capture"]; V.capture(c, pins, expected, "", 0); artifact_capture(c, pins) + args = c["spec"]["arguments"] + need(len(args) == 7 and args[:2] == ["-NoProfile", "-File"] and + same_path(args[2], HERE / "revalidate_retained.ps1") and args[3] == "-ContractPath" and + same_path(args[4], contract_path) and args[5] == "-OutputRoot" and same_path(args[6], root) and + same_path(c["spec"]["cwd"], ROOT) and c["launcher"]["DeadlineSeconds"] == 300, + "actual retained exact command/deadline") + pins.walk(launch["driver"]); pins.walk(launch["launcherScript"]) + need(same_path(launch["driver"]["path"], HERE / "revalidate_retained.ps1"), "retained actual driver pin") + need(r["success"] is True and r["failure"] is None and r["currentHead"] == head and + r["oldHead"] == BASE and same_path(r["historicalRoot"], registry["historicalRoot"]), + "final retained candidate/historical identities") + integrity = r["finalIntegrity"] + need(integrity["attempted"] is True and integrity["success"] is True and integrity["errors"] == [] and + integrity["restorationWrites"] == 0 and integrity["checkedPins"] == len(r["pins"]), + "retained independent final pin/tree outcome") + contracts = contract["retainedContracts"] + ids = ["profile-" + key for key in registry["profiles"]] + ["integrity-" + key for key in registry["integrity"]] + V.roster([c["id"] for c in contracts], ids, "retained independent21 contracts") + tiers = [("root", "historical-actual-root-child"), ("leaf", "historical-actual-leaf-child"), + ("copiedFocused", "historical-copied-focused"), ("syntheticLauncher", "synthetic-launcher-component")] + ids += [tier + "/" + row["id"] for category, tier in tiers for row in registry[category]] + V.roster([row["id"] for row in r["registry"]], ids, "retained40 exact ordered cases") + for row, declared in zip(r["registry"][:21], contracts): + for key in ["capture", "expectedStdout", "expectedStderr", "expectedExit", "producingRoot"]: + need(row[key] == declared[key], "retained contract object/expected string identity") + need(row["tier"] == "retained-historical-capture" and row["predicate"] == "Assert-LNOuterCapture" and + row["Q"] == dict(accepted=True, failure=None), "retained21 literal production acceptance") + V.capture(row["capture"], pins, row["expectedStdout"], row["expectedStderr"], row["expectedExit"]) + pins.walk(declared["sourcePins"]); pins.walk(declared["rawPins"]) + index = 21 + for category, tier in tiers: + for definition in registry[category]: + row = r["registry"][index]; index += 1 + need(row["tier"] == tier and row["Q"] == dict(accepted=definition["currentAccept"], failure=definition["failure"]), + "retained exact current verdict/tier") + need(row["P"] == dict(accepted=definition["oldAccept"], failure=None if definition["oldAccept"] else definition["failure"]), + "retained exact old accepted/rejected verdict") + c, name = row["capture"], definition["id"] + out, err = row["expectedStdout"], row["expectedStderr"] + if category == "root": + expected_err = "" if name == "otherwise-empty-bom" else "PROCESS: expected failure" + NL + need((out, err, row["expectedExit"], row["profile"]) == + ("", expected_err, 0 if name == "otherwise-empty-bom" else 7, name), "root prescribed contract") + if name == "error-plus-ascii": err += "UNEXPECTED OUTER DIAGNOSTIC" + NL + if name in ["error-plus-bom", "otherwise-empty-bom"]: err += "\ufeff" + elif category == "leaf": + need((out, err, row["expectedExit"], row["profile"]) == + ("component evidence" + NL, "PROCESS: declared component failure" + NL, 1, "process-component"), + "leaf prescribed contract") + if name == "nul-stdout": out += "\0" + if name == "bom-stdout": out = "\ufeff" + out + if name == "extra-error-words": err += "UNEXPECTED OUTER DIAGNOSTIC" + NL + else: + focused = contract["retainedContracts"][0] + need(focused["id"] == "profile-focused" and (out, err, row["expectedExit"], row["profile"]) == + (focused["expectedStdout"], "", 0, "wrapper-focused"), "copied focused independent baseline contract") + if name == "trailing-nul-stdout": out += "\0" + if name == "leading-bom-stdout": out = "\ufeff" + out + if name == "nul-only-stderr": err = "\0" + if name == "extra-error-words": err = "UNEXPECTED OUTER DIAGNOSTIC" + NL + expected_predicate = "Assert-LNWrapperCapture focused -> Assert-LNOuterCapture" if category in ["copiedFocused", "syntheticLauncher"] else "Assert-LNOuterCapture" + need(row["predicate"] == expected_predicate, "retained production predicate mapping") + if category != "syntheticLauncher": + V.capture(c, pins, out, err, row["expectedExit"]) + else: + # The R2 helper supports blank-launcher mutations only. Inspect + # this explicitly synthetic Unicode component, retaining its + # original ordinary exits/transport and exact child bytes. + pins.walk(c["raw"]); launch, spec = c["launcher"], c["spec"] + V.ordinary(launch, c["actual"], 0) + need(not launch["StandardOutput"] and not launch["StandardError"] and not launch["RetentionErrors"] and + not Path(spec["error"]).exists() and not Path(spec["overflow"]).exists(), "synthetic retained transport guards") + need(V.raw(spec["stdout"]) == out and V.raw(spec["stderr"]) == err, "synthetic unchanged child streams") + for channel, key in [("stdout", "RawStandardOutput"), ("stderr", "RawStandardError")]: + need(V.raw(launch[key]) == (chr(definition["codepoint"]) if definition["channel"] == channel else ""), + "synthetic prescribed launcher component") + return dict(results=result_pin, launch=pins.add(launch_path), cases=ids, finalIntegrity=integrity, + tiers={"retainedHistorical": 21, "actualRoot": 4, "actualLeaf": 4, "copiedFocused": 5, "syntheticLauncher": 6}) + + +def current_run(path, profiles_path, rows, contract, pins, head): + launch = readj(path); launch_pin = pins.add(path) + result_path = Path(launch["results"]); root = result_path.resolve().parent + result = readj(result_path); pins.add(result_path) + need(launch["head"] == result["head"] == head and launch["failure"] is None and result["success"] is True and + result["failure"] is None and result["base"] == BASE and same_path(result["worktree"], ROOT), + "actual final current invocation identity/outcome") + integrity = result["finalIntegrity"] + need(integrity == dict(attempted=True, success=True, errors=[]), "current final independent integrity") + expected = "" + for kind in ["checks", "claims"]: + expected += "OWNED " + kind + " exit=0 evidence=" + str(root / "profiles" / kind) + NL + expected += "PROFILE CERTIFIED " + kind + " manifest=" + str(root / "profiles/PROFILES.json") + NL + expected += "CURRENT PROFILES PASS evidence=" + str(root) + NL + need((launch["expectedStdout"], launch["expectedStderr"], launch["expectedExit"]) == (expected, "", 0), + "current entire actual outer stream contract") + c = launch["capture"]; V.capture(c, pins, expected, "", 0); artifact_capture(c, pins) + args = c["spec"]["arguments"] + need(len(args) == 9 and args[:2] == ["-NoProfile", "-File"] and same_path(args[2], HERE / "certify_current.ps1") and + args[3] == "-OutputRoot" and same_path(args[4], root) and args[5] == "-FocusedManifest" and + same_path(args[6], result["focusedManifest"]["path"]) and args[7] == "-HistoricalContract" and + same_path(args[8], result["historicalContract"]["path"]) and same_path(c["spec"]["cwd"], ROOT) and + c["launcher"]["DeadlineSeconds"] == launch["deadlineSeconds"] == 1200, + "actual final current exact arguments/working-directory/deadline") + pins.walk(launch["driver"]); pins.walk(launch["launcherScript"]) + need(same_path(launch["driver"]["path"], HERE / "certify_current.ps1"), "current actual versioned driver pin") + for key in ["sourcePins", "focusedManifest", "historicalContract", "seed", "profiles"]: + pins.walk(result[key]) + required = [HERE / "certify_current.ps1", NATIVE / "repair-r2/certify_profiles.ps1", NATIVE / "repair-r1/run_owned.ps1", + NATIVE / "repair-r1/final_checks.ps1", NATIVE / "repair-r2/claim_expectations.ps1", + ROOT / "scripts/owned_process_tree.ps1", ROOT / "scripts/packed_native_lifecycle_stream_check.ps1", + ROOT / "scripts/packed_native_lifecycle_integrity_check.ps1"] + V.roster([str(Path(p["path"]).resolve()) for p in result["sourcePins"]], [str(p.resolve()) for p in required], + "final invocation exact source pins") + focused = next(row for row in rows if row["id"] == "selector-focused") + need(result["focusedManifest"] == focused["manifest"], "final invocation actual focused input identity") + history = readj(result["historicalContract"]["path"]) + need(history["success"] is True and history["mode"] == "full-contract" and history["base"] == BASE and + history["historicalR2"] == contract["historicalR2"], "seed same reviewed historical facts") + seed = readj(result["seed"]["path"]) + expected_seed = {kind: contract["historicalR2"]["profiles"][kind]["receipt"]["path"] + for kind in ["full", "integrity", "dependencies"]} + expected_seed["focused"] = focused["receipt"]["path"] + need(seed == dict(head=head, profiles=expected_seed), "final exact four-profile seed") + need(same_path(result["profiles"]["path"], profiles_path) and + same_path(profiles_path, root / "profiles/PROFILES.json"), "actual final composed manifest identity") + manifest = readj(profiles_path) + for kind in ["checks", "claims"]: + need(same_path(manifest["profiles"][kind], root / "profiles" / kind / "RECEIPT.json"), "actual fresh profile receipt join") + before, after = result["before"], result["after"] + need(before == after and before["head"] == head and result["initialStatus"] == result["finalStatus"] == [], + "current actual clean identical before/after source snapshots") + need(before["index"] == V.git("ls-files", "--stage", "-z").decode("utf-8"), "current semantic index equals producing snapshot") + paths = set(V.git("ls-files", "--cached", "--others", "--exclude-standard", "-z").decode("utf-8").split("\0")) - {""} + V.roster([p["path"] for p in before["files"]], sorted(paths), "current tracked/untracked exact snapshot roster", ordered=False) + for pin in before["files"]: + need("missing" not in pin, "missing producing source file") + pins.add(ROOT / pin["path"], pin) + need(result["scanInputsBefore"] == result["scanInputsAfter"], "current all scanned bytes unchanged around actual invocation") + scan_paths = {str(p.resolve()) for p in NATIVE.rglob("*") if p.is_file()} + scan_paths.update(str((ROOT / p).resolve()) for p in ["docs/internal/DESIGN_DECISIONS.md", "docs/internal/WORKFLOW_DESIGN_DECISIONS.md"]) + V.roster([str(Path(p["path"]).resolve()) for p in result["scanInputsBefore"]], sorted(scan_paths), "complete actual scan input byte inventory", ordered=False) + pins.walk(result["scanInputsBefore"]) + return dict(launch=launch_pin, results=pins.add(result_path), head=head, scanInputCount=len(scan_paths), finalIntegrity=integrity) + + +def final_checks(stdout, capture, pins, head, contract_path): + facts = V.check_results(stdout, pins); result = readj(facts["results"]["path"]) + need(result["head"] == head, "fresh final checks must certify current HEAD") + checks = {row["name"]: row for row in result["checks"]} + check_root = Path(facts["results"]["path"]).parent + commands = { + "hygiene": ("rg", ["-n", r"\b(sorry|admit|axiom|unsafe|opaque|implemented_by|partial|extern|noncomputable)\b|import Mathlib", "RMQ", "lakefile.toml"], 1), + "native-decision": ("rg", ["-n", r"native_decide|Lean\.ofReduceBool", "RMQ"], 1), + "working-whitespace": ("git", ["diff", "--check"], 0), + "range-whitespace": ("git", ["diff", "--check", BASE + "..HEAD"], 0), + "clean": ("git", ["-c", "core.excludesfile=", "status", "--porcelain=v1", "--untracked-files=all"], 0)} + for name, (file, arguments, expected) in commands.items(): + c = checks[name] + need((c["file"], c["arguments"], c["expected"], c["exit"]) == (file, arguments, expected, expected), + "final exact command/ordinary exit: " + name) + need(Path(c["log"]).read_bytes() == b"", "final required empty command output: " + name) + c = checks["contract"] + need(c["file"] == "python" and same_path(c["arguments"][0], HERE / "verify_contract.py") and + c["arguments"][1] == "--output" and same_path(c["arguments"][2], check_root / "CONTRACT.json") and + len(c["arguments"]) == 3 and c["expected"] == c["exit"] == 0, "successor contract exact dispatch") + actual_contract = check_root / "CONTRACT.json"; pins.add(actual_contract) + need(actual_contract.read_bytes() == Path(contract_path).read_bytes(), "supplied final contract must be final-check generated exact artifact") + shell = capture["spec"]["file"] + expected_design = {"design-whole": ["-NoProfile", "-File", "scripts/design_decision_check.ps1", "-Strict", "-Base", BASE]} + for commit in V.git("rev-list", "--reverse", BASE + ".." + head).decode().splitlines(): + parent = V.git("rev-parse", commit + "^").decode().strip() + expected_design["design-" + commit[:12]] = ["-NoProfile", "-File", "scripts/design_decision_check.ps1", "-Strict", "-Base", parent, "-Head", commit] + for name, arguments in expected_design.items(): + c = checks[name] + need(same_path(c["file"], shell) and c["arguments"] == arguments and c["exit"] == c["expected"] == 0, + "whole-range/each-parent strict design command") + return facts + + +def claim_inputs(path, pins): + """Check retained producing commands/exits, without duplicating the classifier.""" + expectation = readj(path) + roots = ["docs/internal/extensions/lifecycle-native-p0", "docs/internal/DESIGN_DECISIONS.md", + "docs/internal/WORKFLOW_DESIGN_DECISIONS.md"] + need(expectation["Roots"] == roots, "claims complete source roots") + producer_path = Path(path).parent / "producer/CAPTURE.json" + pins.add(producer_path); producer = readj(producer_path) + V.capture(producer, pins, "", "", 0) + need(same_path(producer["spec"]["cwd"], ROOT) and producer["launcher"]["DeadlineSeconds"] == 1200, + "actual bounded claims expectation producer") + args = producer["spec"]["arguments"] + need(len(args) == 8 and args[:2] == ["-NoProfile", "-File"] and + same_path(args[2], NATIVE / "repair-r2/claim_expectations.ps1") and + args[3:5] == ["-Produce", "-RepositoryRoot"] and same_path(args[5], ROOT) and + args[6] == "-EvidenceRoot" and same_path(args[7], Path(path).parent), "actual expectation producer command") + policy = readj(ROOT / "docs/internal/CLAIM_DRIFT_POLICY.json") + V.roster([c["id"] for c in expectation["Captures"]], [t["id"] for t in policy["terms"]], "claims actual rg term roster") + rg_paths = [p["path"] for p in expectation["SourcePins"] if Path(p["path"]).name.lower() in ["rg.exe", "rg"]] + need(len(rg_paths) == 1, "one pinned claim rg executable") + for observed, term in zip(expectation["Captures"], policy["terms"]): + pins.walk(observed["raw"]) + specs = [p for p in observed["raw"] if Path(p["path"]).name == "spec.json"] + need(len(specs) == 1, "one actual claim rg spec") + s = readj(specs[0]["path"]) + arguments = ["--json", "--pcre2"] + (["--multiline"] if term.get("multiline") else []) + arguments += ["--glob", "!**/audit_reports/**", "--glob", "!**/*WORKLOG.md", "--", term["pattern"]] + roots + need(same_path(s["file"], rg_paths[0]) and same_path(s["cwd"], ROOT) and s["arguments"] == arguments, + "claim actual exact rg command") + need(not Path(s["error"]).exists() and not Path(s["overflow"]).exists() and + Path(s["stderr"]).read_bytes() == b"", "claim rg completed raw capture") + actual = readj(s["exit"]) + need(actual == observed["actual"] and type(actual["exitCode"]) is int and actual["exitCode"] in [0, 1], + "claim actual ordinary rg0/1 artifact") + raw = V.raw(s["stdout"]) + need(raw.endswith("\n"), "claim rg JSONL terminator") + records = [json.loads(line) for line in raw[:-1].split("\n")] + need(records and records[-1]["type"] == "summary" and + all(r["type"] in ["begin", "match", "end", "summary"] for r in records), "claim complete rg JSON records") + need(actual["exitCode"] == (0 if any(r["type"] == "match" for r in records) else 1), + "claim actual rg exit agrees with retained match/no-match records") + return dict(producer=pins.add(producer_path), termCaptures=len(expectation["Captures"])) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--groups", nargs="+", required=True, metavar="LAUNCH") + for name in ["retained", "contract", "profiles", "current-run", "output"]: + parser.add_argument("--" + name, required=True) + args = parser.parse_args(); started = time.monotonic(); pins = V.Pins() + verifier_pin = pins.add(__file__); pins.add(PARSER) + head = V.git("rev-parse", "HEAD").decode().strip() + need(V.git("status", "--porcelain=v1", "--untracked-files=all") == b"", "final candidate must be clean") + registry = frozen(HERE / "CONTROL_REGISTRY.json", REGISTRY_SHA, pins) + retained_registry = frozen(HERE / "retained_registry.json", RETAINED_SHA, pins) + contract = readj(args.contract); contract_pin = pins.add(args.contract) + need(contract["success"] is True and contract["mode"] == "full-contract" and contract["base"] == BASE and + contract["head"] == head and same_path(contract["worktree"], ROOT) and len(contract["rows"]) == 18 and + contract["changedIds"] == [], "final full18 contract identity") + pins.walk(contract["verifier"]); pins.walk(contract["currentOwnedSources"]) + need(same_path(contract["verifier"]["path"], HERE / "verify_contract.py"), "actual successor contract verifier") + need(contract["historicalR2"]["packageCommit"] == BASE and + contract["historicalR2"]["historicalBase"] == "2307e3ad0739e0e1d9c3f186cdc568631086fddf", "historical source identity") + need(contract["currentRegistries"]["literal"]["sha256"] == REGISTRY_SHA and + contract["currentRegistries"]["retained"]["sha256"] == RETAINED_SHA, "contract same frozen registries") + group_facts, rows, source_head = groups(args.groups, registry, pins, head) + retained_facts = retained(args.retained, contract, retained_registry, pins, head, args.contract) + manifest = readj(args.profiles); manifest_pin = pins.add(args.profiles) + need(manifest["head"] == head and set(manifest["profiles"]) == set(V.PROFILES), "final exact six-profile manifest/current head") + current_facts = current_run(args.current_run, args.profiles, rows, contract, pins, head) + profile_facts = {} + for kind in V.PROFILES: + path = manifest["profiles"][kind] + if kind in ["full", "integrity", "dependencies"]: + historical = contract["historicalR2"]["profiles"][kind] + need(same_path(path, historical["receipt"]["path"]), "historical profile receipt identity") + pins.add(path, historical["receipt"]) + profile_facts[kind] = dict(reusedHistorical=True, **historical) + continue + need(Path(path).resolve().is_relative_to((ROOT / ".lake").resolve()), "current profile receipt belongs to current checkout") + receipt, c, receipt_pin = V.profile_receipt(kind, path, pins) + need(same_path(c["spec"]["cwd"], ROOT), "current profile actual working directory") + stdout = V.raw(c["spec"]["stdout"]) + if kind == "focused": + actual = next(r for r in rows if r["id"] == "selector-focused") + need(same_path(path, actual["receipt"]["path"]), "manifest actual focused invocation identity") + facts = V.native_summary(kind, stdout, pins) + elif kind == "checks": + facts = final_checks(stdout, c, pins, head, args.contract) + else: + pins.walk(receipt["claimExpectation"]) + need(same_path(manifest["claimExpectationPath"], receipt["claimExpectation"]["path"]), "claims source-derived producing expectation identity") + facts = V.claim_records(stdout, receipt["claimExpectation"]["path"], pins) + expectation = readj(receipt["claimExpectation"]["path"]) + # Whole actual records are parsed above; require the actual scanner + # driver to name the complete subtree plus both ledgers. + command = receipt["command"] + need("-Strict -Path @('docs/internal/extensions/lifecycle-native-p0','docs/internal/DESIGN_DECISIONS.md','docs/internal/WORKFLOW_DESIGN_DECISIONS.md')" in command, + "fresh entire native subtree/both-ledger claim invocation") + need(expectation["SourcePins"], "claims current source pins missing") + facts["producingInputs"] = claim_inputs(receipt["claimExpectation"]["path"], pins) + profile_facts[kind] = dict(receipt=receipt_pin, reusedHistorical=False, facts=facts) + report = HERE / "REPORT.md"; report_pin = pins.add(report) + need(report.read_bytes().decode("utf-8").startswith("Status: CANDIDATE_COMPLETE\nI found no assigned or inherited acceptance criterion unmet; coordinator acceptance is still required.") or + report.read_bytes().decode("utf-8").startswith("Status: CANDIDATE_COMPLETE\r\nI found no assigned or inherited acceptance criterion unmet; coordinator acceptance is still required."), + "complete report candidate declaration") + need(V.git("rev-parse", "HEAD").decode().strip() == head and + V.git("status", "--porcelain=v1", "--untracked-files=all") == b"", "final collector clean same HEAD") + # Rehash after all reads; a cached pin inventory alone is not final integrity. + for pin in pins.records.values(): + data = Path(pin["path"]).read_bytes() + need(len(data) == pin["bytes"] and hashlib.sha256(data).hexdigest().upper() == pin["sha256"], "collector final pin changed") + result = dict(success=True, base=BASE, sourceCommit=source_head, finalPackageCommit=head, worktree=str(ROOT), + report=report_pin, contract=contract_pin, groups=group_facts, retained=retained_facts, + profiles=profile_facts, currentRun=current_facts, finalProfileManifest=manifest_pin, verifier=verifier_pin, + claimComposition=contract["claimComposition"], distinctPins=len(pins.records), + pinOccurrences=pins.occurrences, pins=sorted(pins.records.values(), key=lambda p: p["path"].lower()), + seconds=round(time.monotonic() - started, 3), cleanHead=head, + scope="Local literal/selector evidence composition. Historical full/integrity/dependencies remain retained runs; retained40 are components, not new native execution. Coordinator acceptance, adapter and campaign audit remain separate.") + Path(args.output).write_text(json.dumps(result, indent=2) + "\n", encoding="utf-8") + print(f"R3 RESULTS PASS: 37 controls, 40 retained cases, six composed profiles; {len(pins.records)} distinct pins") + + +if __name__ == "__main__": + main() diff --git a/docs/internal/extensions/lifecycle-native1-r1/ACCEPTANCE_MATRIX.md b/docs/internal/extensions/lifecycle-native1-r1/ACCEPTANCE_MATRIX.md new file mode 100644 index 00000000..14175aa7 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native1-r1/ACCEPTANCE_MATRIX.md @@ -0,0 +1,1011 @@ +# LIFE-NATIVE-1-R1 acceptance evidence + +Status: CANDIDATE_COMPLETE; final committed identity requires the external delivery receipt. + +All55 original ordered requirements remain binding. Their complete frozen rows and source bytes remain immutable in ../lifecycle-native1/CONTRACT_REQUIREMENTS.json and ACCEPTANCE_MATRIX.frozen.md. Each requirement below is quoted verbatim from that source. Historical proposition/composition text is quoted from the original immutable evidence matrix, whose execution references remain historical. R1 supplements its evidence and supersedes the three rejected harness guarantees; it does not rewrite the original certification. Exact current receipts and hashes are indexed by COMMANDS.md and the external R1 delivery receipt. + +Evidence keys: **F** = unchanged exact formal propositions/consumers in PROOF_EVIDENCE.md and the original matrix; fresh four-root/default builds plus REUSE_APPLICABILITY export34/axiom21. **N** = unchanged compiled/ownership source and fresh DLL/client/startup/fixture26/ABI23/client10/native48 execution, with unchanged expectations approved externally. **H** = actual R1 registry74/setup2/closure7 plus original caller/recipe/stream controls and fresh owned descendant3. **S** = exact3930-file scope, original55rows, append-only ledger, complete14-file roster, final scope/design at both bases/whole original-base claims/hygiene/whitespace/clean HEAD. Original Rust17 applies only through the explicit source/tool/capture bridge. No old full-tree certificate certifies edited scripts. + +## N1-01 + +Prove a small export-facing Lean result for the actual word and comparison lifecycle runners: on the declared InputDomain and represented endpoints, build-and-first-query produces the actual Ownership.owner, correct halted optionNatPacket answer, canonical produced memory, empty key banks, fixed numeric bank and the same complete modeled retained-capacity bound. Derive these facts from the existing capstone/refinement; do not accept final-memory or answer equality as a hypothesis. Native admission limits are separately labeled and do not weaken the all-size Lean theorem. + +Original complete frozen row SHA256: 7dc306bcecba40f0b533b93b03d92daa9f19b7fdf969f22aa6223774709be3d6. + +Unchanged exact proposition/check (original evidence): + +Under D: B=Ownership.owner, B.toState=cr.final, Ready(B), halted(packet), pointwise memory=mem/exact extent, empty keys/keyRegs, regs.size8273 and C(B)*w≤2n+rho. No output equality premise. + +Unchanged named consumer and object-composition chain (original evidence): + +P E01–E11/E13,U02/U03: buildFirst_eq→Ownership.refinement/ready/halted/capacity_bound→export_contract; independent expanded READY/capacity at actual B. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 39f39dd0de5b9f6bacc5a15d7afc9285cb1ac9d08af1154b2b4dde2e0686b4b8. + +## N1-02 + +The compiled production path executes Lifecycle runOwner from Executable.initialOwner and uses Executable.queryOwner or a proved definitionally/extensionally equal cached-program adapter thereafter. First inspect emitted C and bounded execution for suspected reference-count-driven copies. If actual measurements justify an observation-erasing loop, it may delegate the unchanged executeArray and must prove equality to runOwner for every program/state/fuel, including stopped/fault/missing-fetch cases; it may not replace any primitive evaluator or weaken the admitted domain. It must not call the old Native/LimbMachine query interpreter as a substitute, rebuild buildMemory/canonicalImage/buildPayload, invoke a reference RMQ answer, or reconstruct state from a reference trace. The actual returned C/Rust result must come from this runner's status. + +Original complete frozen row SHA256: cb04c35c4e2dc4d6df6d48aa168b111e5f89c88e3ad74e9c3a1a1e8de3933263. + +Unchanged exact proposition/check (original evidence): + +∀program owner fuel, runThin=runOwner including stopped/fault/missing fetch; query=Executable.queryOwner via equal cache; returned packet derives actual status. + +Unchanged named consumer and object-composition chain (original evidence): + +P T01–T07/B11–B18; G nativeInitial→initialOwner→thin loop→unchanged executeArray→Owner.status→nativePacket→C/Rust. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 26ac01f502465feedee1384fdbe4a2f16fb426844a24f8f078f6fe3d51067337. + +## N1-03 + +Define and prove the successful admission/representation bridge used by the exports, including exact signed Int encoding for word input, arbitrary signed finite integers for comparison input, canonical endpoint words and model selection. Word InputFits failures and host format/resource limits reject explicitly; no silent fallback to comparison input or narrower u64/u128 arithmetic. Carry the actual count and query-independent word profile, and derive READY n/M from produced metadata rather than trusted caller duplicates. + +Original complete frozen row SHA256: 027f9814c470fc21949c72d19c33214d058aa7970289271b5aceebc05d12e58a. + +Unchanged exact proposition/check (original evidence): + +nativeAdmit success⇒actual decoded n, signed xs, canonical endpoints, InputDomain and host limits. READY cell0=n/cell7=memory.size; Word InputFits explicit, comparison Int arbitrary. + +Unchanged named consumer and object-composition chain (original evidence): + +P B01–B18: nativeAdmit_source→nativeBuildFirst_correct/packet; nativeQueryAdmit_iff→nativeQuery_correct/packet; same model/xs/endpoints and produced metadata. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 382f821dfa8778be87e83b209b06abb7ed0119412e54b64622d8fb4198c2ca9b. + +## N1-04 + +Separate malformed/native-domain rejection, represented invalid RMQ range with ordinary None answer, model fault and exhausted fuel. Empty, reversed and out-of-bounds represented ranges retain the correct formal guard throughout combined fields. A represented invalid first or later query still returns a reusable canonical owner when the formal route does. Unrepresentable requests are rejected before consuming a healthy owner; temporary parsing/admission allocations and Lean codec calls are allowed before transfer if cleaned on failure. No rejection is silently reported as successful execution. + +Original complete frozen row SHA256: 1aeb3a09fa4b1e28952ece08ade2a0605e3069994a52a9db692d28ca3555186d. + +Unchanged exact proposition/check (original evidence): + +D/QD invalid represented range⇒halted0 and READY. Native malformed/domain, fault and fuel statuses distinct; pre-take reject preserves old owner. + +Unchanged named consumer and object-composition chain (original evidence): + +P E13/Q11/B consumers→C prevalidate/take/actual-status classifier→Rust state table; matching represented guards throughout. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 3f2b3c4eec2460f3bf4e62d0718e1a280e774a18ba67f718c0fada889ff0a6a9. + +## N1-05 + +Prove exact export/owner projection and value-preserving array repacking interfaces sufficient for the actual native boundary. Expose a single coherent small public export contract and an independent expected-type Lean consumer in RMQ/Validation/LifecycleNativeContract.lean that uses each mandatory projection at the fixed objects/domain. Attempt deletion/weakening/sibling substitution of load-bearing facts and replay the intended client rejection only after successful producer compilation. C/runtime implementation correctness remains an explicit trust boundary supported by actual controls, not falsely kernel-proved. + +Original complete frozen row SHA256: 3399b17e70784cc7da421c57162e4e6f0aead31ec825cc3a9e532d6888b65881. + +Unchanged exact proposition/check (original evidence): + +B.toState=cr.final; Q.toState=qr.final. Four ArrayCopy size+entry relations plus pc/status imply target=source, equal state/status/capacity, READY iff and future query equality. + +Unchanged named consumer and object-composition chain (original evidence): + +P E01–E13/Q01–Q11 fixed independent consumer; E12 universal repack transport. Actual C copying validates equality; C correctness is not kernel-proved. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 421a80876472e9f2a06d02b09b7adde749f0421ed0252ccbd32539cc5a53d51b. + +## N1-06 + +Repeated native calls continue on the same produced canonical allocation through the existing four charged request/control boundary events and finite setup. Here allocation equality means the actual produced modeled contents/extents, transported through a proved value-preserving native repacking boundary before publication; it is not a theorem of unchanged native pointer address. Measure physical identity/capacity separately and disclose any further native replacement. The uninterrupted first query does not prepend the four external re-entry events. Prove the export continuation inherits Ready.query, answer correctness, preserved memory and the 160257 model-step upper bound. Do not reset halted state, registers or metadata for free, and do not retain the original input to recreate the owner per request. + +Original complete frozen row SHA256: 833bf29aaa3a510d219648e90bb5b8758df23d0f050fa86f661be3ad48eb245b. + +Unchanged exact proposition/check (original evidence): + +QD⇒READY(Q),halted(packet),Q.memory=owner.memory,qr.steps=4+4+8271+compactQueryRun.steps≤160257,C(Q)*w≤2n+rho. Repack is logical value, not pointer equality. + +Unchanged named consumer and object-composition chain (original evidence): + +E12+continuation→Q01–Q11→Ready.query/query_owner_refinement/query_correct; Q07 two requestAdmission+two controlEntry; first run no external re-entry prefix. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is a22ea76842b7d0b6bdcd9682046d307083789d893fd715b55ce2cca3cefba414. + +## N1-07 + +Production owners contain only the finite operational arrays/scalars and explicit native handle metadata. Drop temporary parsed input/list roots, old owner roots, comparison keys/registers, old arena containers and result-wrapper references at the documented transfer point. Validation histories/read receipts are optional separately owned artifacts and must not be retained in the production owner, input closure, Rust cache or query result. Establish actual compiled closure/root identity, not only logical fields. + +Original complete frozen row SHA256: 1fd177ece96a2e8383fdbf23f18a85a277770f1b2e6df4b3523c8f1f5275bd1f. + +Unchanged exact proposition/check (original evidence): + +Owner only regs/memory/keys/keyRegs/pc/status; native metadata/results/observations separately inventoried. Parsed xs/list/old owner/backing/wrapper roots released; no production xs/history. + +Unchanged named consumer and object-composition chain (original evidence): + +G exact emitted Entry/Run/ThinRun/Observations fields/callees/decrements→C take/repack/publish/cleanup; recordBefore releases prestate before primitive; observations separate. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 67e419d0149aca7ece26a344f28859249cff05bd5057e53aa2834b840df8d34f. + +## N1-08 + +Replace excess-capacity backing arrays at native READY publication after the first query using the reviewed consume/replacement route and preserve all logical entries. Every subsequently published reusable state must retain the same declared capacity guarantees; extra native replacement work is separately accounted. Measure actual initialized size, capacity and requested outer-container storage for every retained array, including zero-sized key banks, plus reachable boxed/scalar representation and shared fixed code separately. Operationally release old backing roots. Array.pop/size, zero logical extents, destructor counters alone, or generic P0 observations do not prove this production capacity claim. Do not equate requested bytes with allocator usable bytes or RSS. + +Original complete frozen row SHA256: 4701818ed03e2f59c019735d7f75355b0c9facb0967b853a23ac0f5a0e1e73cb. + +Unchanged exact proposition/check (original evidence): + +Published size=capacity=[8273,M,0,0],requested outer bytes24+8*capacity,entries equal source,operational containers exclusive; repack transports READY. + +Unchanged named consumer and object-composition chain (original evidence): + +P E12→actual C copying/strict_info; N each array and separately shared code/scalars; retired backing containers decremented. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is c47e5082a6e4c2baafbee9ae1c0d638843a9e0ea2f5d2709bcb1979dde783d52. + +## N1-09 + +Make ownership transfer explicit in the C contract and enforceable safe Rust types: no safe clone/raw-alias escape, borrowed result data cannot outlive its owner, destruction exactly once on the initializing thread, and a mutation requires unique handle access. Identify trusted foreign-caller preconditions precisely; finite alias tests cannot quantify over arbitrary C misuse. Deliberate extra-root controls must not earn the strict exclusive-transfer conclusion, and no test may dereference freed objects. Shared immutable scalar values and fixed program objects need not have reference count one; distinguish these permitted references from extra operational owner/input/arena roots. + +Original complete frozen row SHA256: 0cd0473856fe9b8fde996dddfd711f8c55d20ec24f9bbbd9362952f37b6569f3. + +Unchanged exact proposition/check (original evidence): + +Rust unique mutation/no Clone/private raw/borrowed result/runtime-bound !Send/!Sync; C live unique same-runtime initializing-thread handles. Immutable scalar/program sharing permitted. + +Unchanged named consumer and object-composition chain (original evidence): + +GUIDE/N/R table→Rust lifetimes/PhantomData→same C ABI; strict_info checks operational containers, not scalar RC1. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 177db4b9f9e2e329811321b733129cf37f7ed6da2466515b82bcb1705eff4240. + +## N1-10 + +Specify and implement the complete state table for validation-before-consumption failures, controlled failures during allocation/copy/transfer, successful transfer and destruction. Keep a valid old owner when rejected before consumption; after an irrevocable take, either return exactly one valid replacement or return an explicit empty/poisoned handle with all initialized temporary resources released. Exercise both sides and partial-copy boundaries on actual production helpers. Ordinary Lean allocation failure may be fatal under the pinned runtime; do not present it as recoverable injected failure. + +Original complete frozen row SHA256: d1151e59dbd15076c1a8f83f9263ac4a1cfa2a54f2f42f515b1b4b55e70539cf. + +Unchanged exact proposition/check (original evidence): + +Before take reject preserves exact owner; after take one strict replacement or empty outputs/all initialized temporaries released; exactly-once handle destruction. + +Unchanged named consumer and object-composition chain (original evidence): + +GUIDE state table→C allocate/copy/take/strict/publish/cleanup; P repack only after actual equality; generation-local balances supplement inspection. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 0921e483576cca2fdcccdf64c241895759eb2391792100d6b3f643108c03f214. + +## N1-11 + +Compile actual Lean source with the pinned Lean 4.22 toolchain and bind generated symbols, prototypes, object/library hashes, transitive source closure and compiler/runtime identity to the tested DLL. Verify cache provenance includes relevant source and tool/compiler identities before reuse. Inspect generated initialization and calls so proofs, whole trace witnesses or large proof-only reference payloads are not evaluated at import/startup. An import or linker list naming a module is not proof the returned route executes it. + +Original complete frozen row SHA256: 77dcebda6d049fc69cce0c19fbc3d716ad16a237b7c69eeeb0576c1ecf301096. + +Unchanged exact proposition/check (original evidence): + +Tested DLL binds Lean4.22/tool/runtime/transitive sources/exact generated symbols/prototypes/objects. Startup excludes evaluated proof-only reference payload; cache rechecks relevant identities. + +Unchanged named consumer and object-composition chain (original evidence): + +L→DLL5stages→clients8stages→F/A/CL staged binaries; G initializers/callees. Approved five macro_inline annotations preserve names/types/bodies/propositions. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 6ef2b77bd14667bcb09654f9054ddc5a9c88d8b979ed8e3a41f14dda6338e57c. + +## N1-12 + +Reuse one checked fixed program representation per input model through the native lifecycle without input-specialized code or reconstructing the program list/array per query. If an additive cached-array adapter is needed, prove it equals Layout.program.toArray and prove the resulting run equals the accepted runner. Account for shared code and native representation explicitly; code constants are not free hidden payload and modeled encoded words are not native heap bytes. + +Original complete frozen row SHA256: 4ed69bccea9214b328c088cf3ad5ccc10cc70cdc9231d06fe9d2c7adb4885382. + +Unchanged exact proposition/check (original evidence): + +cachedProgram model=Layout.program.toArray; any cached run equals accepted runner; only two model-fixed programs; C(owner) includes encodedProgram.length. + +Unchanged named consumer and object-composition chain (original evidence): + +P E01/cached_run/T→actual build/query; G persistent globals→instruction fetch→executeArray; no xs-specialized/per-query code reconstruction. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 17d14d9d44aa6226be8d0bd8b30a17bf76ecce3886cd72aab46dfec90b5e5c3c. + +## N1-13 + +Keep modeled construction/finalization/re-entry work, host admission/conversion, native repacking, fixed-code initialization, optional observation cost and native timings separate. Preserve original linear modeled construction and complete READY 2n+rho conclusions at the proved owner. State any host resource ceiling and its admitted domain precisely. No generic all-input practical speed or native 2n+o(n)-heap claim follows from the interpreter theorem. + +Original complete frozen row SHA256: 1928232f59494cbf4eb0f43537e5e1fdb5a7fe9c8449af3ff06faca72b99f78d. + +Unchanged exact proposition/check (original evidence): + +Inherited modeled construction bound and C(B)*w≤2n+rho are separate from host admission, initialization, native copies, observations, runtime heap and time. + +Unchanged named consumer and object-composition chain (original evidence): + +Capstone ConstructionChain/ExecutedOwner/uniform→P exact B/Q projections; N per-size M/first-steps/code/global/latency tables; GUIDE native ceilings. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 8e8c1598db8777578c700208216d6bb8a8b87f45f65ae02f09907633bd737464. + +## N1-14 + +Implement runtime initialization, cross-thread restrictions, handle lifetimes, C result access and Rust RAII around the real ABI. Rust owner/runtime types must encode !Send/!Sync or an equally explicit checked restriction; document foreign callers' matching obligations. Reuse the existing crate-level runtime-claim guard so only one chosen Lean runtime is initialized per process; incompatible old/new runtime acquisition must reject, including after initialization failure. Coexistence of old and new runtime owners is not required. Inspect actual DLL/runtime linkage rather than assuming two imported bridges share runtime state. Include compile-time misuse controls for safe Rust plus real normal/error/drop paths, and avoid undefined-behavior tests as purported safety evidence. + +Original complete frozen row SHA256: 255961ab7af74aa8bac3ff9e5675c3ffe9a0d2d7a88261a934471f6b51ee214c. + +Unchanged exact proposition/check (original evidence): + +One crate runtime claim/process; !Send/!Sync Runtime/Owner/Observation/Natural/QueryResult; failed init retains incompatible-runtime claim. Foreign thread/lifetime/uniqueness obligations explicit. + +Unchanged named consumer and object-composition chain (original evidence): + +R type restrictions→actual ABI; CL conflict/error/drop; A initializing/secondary thread; N PE/runtime linkage and predecessor reuse provenance. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 995e632ae895eef27f437d9ad61b62203511047bb48092c5c2d82d65341ba622. + +## N1-15 + +Return canonical arbitrary-width answer/status representations through the C ABI and Rust facade, with no lossy host-sized intermediate. Endpoint and input conversions use tested/proved codecs with exact lengths/sign/magnitude/overflow rules. Values wider than128bits and negative comparison keys must reach actual construction. Host-sized indices/counts may be used only under explicit checked bounds and a proven conversion relation. + +Original complete frozen row SHA256: 3ff75d70c71f9db9ba42a94824676016eed092c9620ec8da7c6bf0f854bbc662. + +Unchanged exact proposition/check (original evidence): + +READY+halted(packet) derives packet<2^w; nativePacket=encodeEndpoint w packet,canonical bytes,decodeMagnitude=packet. Exact signed input/endpoint lengths; bounded host sizes separate. + +Unchanged named consumer and object-composition chain (original evidence): + +P B01–B18: bytes→actual xs/count/model→runner status→canonical bytes; Rust Natural retains arbitrary-width bytes, no u64/u128 answer conversion. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 5d8e901dd5a9e91cf45d9273a2b9908c1e43372ea791eb668eb0efc15128dfc5. + +## N1-16 + +Supply real C, safe Rust and C++ clients of the same generated DLL, including construction, at least two later queries and destruction. The C++ example uses the actual C ABI and its errors, not a second implementation. Keep existing NativeImage ABI and its regression route intact; old query evidence is background and cannot substitute for new lifecycle-client execution. + +Original complete frozen row SHA256: 09bec19daf6e6b5590485762325c0bf8ceb282fb9f14fd80581c0c13aec8aaf2. + +Unchanged exact proposition/check (original evidence): + +Actual C/safe Rust/C++ use same generated ABI for construction,≥2later queries and destruction. Existing NativeImage remains separate regression route. + +Unchanged named consumer and object-composition chain (original evidence): + +DLL/client build→CL ordered10 current-DLL processes; F actual C replay; C++ invokes C ABI ownership/errors, no second RMQ implementation. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 3b6dcd4c4e82a674bac06e90759cd117673d0ff2cac40cf05f9b7de50f917e04. + +## N1-17 + +Freeze meaningful exact fixture IDs and independent expected answers before the final run. Cover both models; empty/singleton/two elements; duplicates/leftmost ties; negative and wider-than128bit values under the proper domains; representative sizes24/83; actual same-block, different-block/fringe/interior/crossing-cell query paths when reachable; represented invalid/reversed/out-of-bounds endpoints; malformed/unrepresentable input; and repeated valid queries after admitted invalid ones. Record actual route coverage or a precise absence, not guessed labels. Expected values come from the independent reference semantics, not the executed answer. + +Original complete frozen row SHA256: 211a6d089272470c78899f255ae68e34035e812a4dd3cb697912e8147616b163. + +Unchanged exact proposition/check (original evidence): + +Frozen13 independent expected fixtures cover models,n0/1/2/4/24/83,ties,negative/wide,invalid and valid-after-invalid; route labels require source-signature/actual-read joins. + +Unchanged named consumer and object-composition chain (original evidence): + +F registry/reference oracle→mode pairs; RC unique comparison signatures→block/interior conditions plus actual ordered payload addresses/replies. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is c0969fcc5e6c41c70658293f1273bdd8a967c37b5a9f0ad2dba22109a79ed475. + +## N1-18 + +Compare optional observed runs with production using a proved same-final-owner bridge, preserving actual ordered read/reply occurrences and charged categories across construction, retirement and repeated queries. Use actual producing prestates; global observations concatenate segments and only the query suffix equals query-only evidence. Prove each advertised counter/category fold-to-trace projection separately: the existing counted_owner final-state equality alone does not prove those counters. Avoid constructing a huge retained trace merely to count steps. At native test points confirm observed and unobserved modes return identical answers/canonical memory while only the explicit observation object retains diagnostics. + +Original complete frozen row SHA256: 1c143b8e13dec8853d499c8a200feb49a14d71e89085ed3aee0dff2218b09428. + +Unchanged exact proposition/check (original evidence): + +Observed final owner=production; counter15=steps,each0–14=its category fold,routes0–12=countP actual marker,ordered reads=model reads; indexed occurrence has actual prestate/primitive; session=first++queries. + +Unchanged named consumer and object-composition chain (original evidence): + +P T/Stats bridges→O01–O11; O09 runOwner prefix+stepArray; O10 same indexed query transition→query_array_refinement→backed mem reply; O11 exact segment order. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is b08d224f1c9281b3e57d01b3681690b3817a1794f5841e75a6402ce1460e8835. + +## N1-19 + +Production ownership/capacity controls must challenge skipped replacement, retained old arena/input/key/history roots, wrong copied value/offset, extra alias, partial-copy cleanup, failed admission before transfer, post-take failure and repeated-query memory preservation using the same acceptance predicates as successful controls. Demonstrate changed answers or actual state/resource differences where that is the claim; a changed log alone is insufficient. A correct reference oracle may agree on every answer, so forbidden oracle substitution is checked by actual evaluator dependence/compiled route evidence and a valid route challenge, not an invented guaranteed answer divergence. Define and measure new fixture challenges before assigning their exact expected rejection; preserve the frozen property while disclosing a challenge that does not distinguish it. Name each mutation kind and exact oracle; do not label a synthetic helper component an actual end-to-end native failure. + +Original complete frozen row SHA256: d3662b96e2309e5880cf3033edfdefc8871282a5cba7c8e3c9b09b2e6c1d3570. + +Unchanged exact proposition/check (original evidence): + +Healthy and mutated actual helpers use same strict_info/value/capacity/cleanup predicates; claimed failures require measured state/resource difference, not changed log. + +Unchanged named consumer and object-composition chain (original evidence): + +NC actual helper→nativeJSON→ordered48mapping/projections→independent review→frozen NATIVE_EXPECTATIONS→final Replay; P repack identifies logical copy predicate. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: N + H. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 3cb35d41b551e7f3c7afbe2ecfd222e283681ad9455bd7016078b4bb1d57a149. + +## N1-20 + +New replay verification must preserve the actual ordinary exit, timeout/overflow, complete captured stdout/stderr and exact intended diagnostic. Reject expected plus unrelated diagnostics on either stream. If claiming literal UTF-8 output, decode strictly and compare ordinally without stripping BOM/NUL/newlines or culture normalization, using actual caller-level holdouts. State any inherited returned-line loss limit explicitly. Source/tool/artifact integrity and disposable cleanup run independently in finally even after partial setup or earlier stage failure. + +Original complete frozen row SHA256: 7342923ca43a357d8162787bde799aa0bc5f36c439e2442ba2ecc7671637801d. + +Unchanged exact proposition/check (original evidence): + +Preserve ordinary exit,timeout/overflow,bounded raw streams; strictUTF8 ordinal equality rejects unrelated text,BOM/NUL/newline/invalidUTF8. Finally integrity/cleanup independent after partial setup. + +Unchanged named consumer and object-composition chain (original evidence): + +SC/CC/EC/EXC/RS real binders/capture; ODC production finally; F/CL/A/R/NC actual raw captures, not reconstructed returned lines. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: H + N + S. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 3bdf63bb827534e7d903efc12a6cab077964cddce90845931167588772f65964. + +## N1-21 + +Replay selectors validate the full request before any semantic child or output mutation. Omission may select the declared full registry; explicitly empty/null/whitespace/unknown/duplicate selectors reject. A focused request executes exactly its one named case. Check ordered ID-to-handler/verdict mappings and complete counts, not pass totals. Commit reproducible controls for omitted/duplicated middle IDs, known/unknown selectors and real parameter-binding boundaries. + +Original complete frozen row SHA256: 7a3e8595ed812e197f00c747792383b495079de6e7de5c6bec50e85366f15d2d. + +Unchanged exact proposition/check (original evidence): + +Actual omission may select full; bound null/empty/whitespace/unknown/duplicate rejects before semantic child/output mutation; knownfocus exactly1; full ordered ID/handler/verdict mapping checked. + +Unchanged named consumer and object-composition chain (original evidence): + +SC33 fixture/CC13 client/EC18 native-control/EXC15 export/RS15 Rust real caller Plan/Validate→frozen mappings. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: H + N + S. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 1cfe108036e1afbc3ec07672f9c53b6d46ded15d09717892ffcc4c03a8af1022. + +## N1-22 + +Use positive evidence-based deadlines and the existing owned-process facility for every external build/compiler/native stage; preserve failures and terminate only the owned tree. Exercise one cheap established descendant termination control on the platform actually certified. Use Local\RMQLifecycleImplementationHeavy20260920 for expensive work; one heavy runner per cache, one full aggregate owner. Unsupported platforms/timeouts are uncovered. No quiet-run restart, unchanged duplicate full build/replay, broad global helper rewrite or weakened timeout verdict. + +Original complete frozen row SHA256: 545ab1da9b8e2c4659a6587751e7ffc185815764e0a148a77f756b320f8eae95. + +Unchanged exact proposition/check (original evidence): + +Positive evidence-based deadlines/owned process capture; timeout failure/only owned tree killed; one heavy owner Local\RMQLifecycleImplementationHeavy20260920 and one aggregate owner. + +Unchanged named consumer and object-composition chain (original evidence): + +ODC Windows helper/tree barriers; runner identities/finally restore; root serializes heavy Lean/DLL/native/compiler work. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: H + N + S. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is f0431d61dd7b993f27adffec31998da5c37838388652efdfb9589c03c455327f. + +## N1-23 + +Preserve all predecessor frozen rows, source/probe/registry/history bytes and producer identities. The private join creates new current ledger identities; do not run a historical producer's whole-checkout pin as though it described this new branch, rewrite old captures, or silently rebase old source paths. Establish reused source/evidence applicability explicitly. New final execution evidence binds its actual source; final report-sensitive checks bind final report/ledger/claim input bytes without recursive self-hashes. + +Original complete frozen row SHA256: b807fbdccd78d15d385c6d20c3227ed2b31cedd082aa040cd7b4e0d67f86d628. + +Unchanged exact proposition/check (original evidence): + +Preserve predecessor raw/Git rows/history/identities; current joins mint new ledgers. Reuse exact applicable sourcepins or disclose historical binary provenance. Final report inputs separately pinned without recursive self-hash. + +Unchanged named consumer and object-composition chain (original evidence): + +Frozen contract/matrix→scope_check exact base inventory; user-approved exact five annotations exception; CC retained review/PREDECESSOR_DLL_REUSE; F/CL/A current DLL. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 9006031cfdf95ee5be9bbb5a7af81094ed9bcda3ae74081dbfc803eff1f26c0d. + +## N1-24 + +Deliver a compact worked guide explaining input admission, actual builder/finalizer, READY transfer/repacking, one subsequent request and cleanup, with theorem names/types and ABI ownership diagrams or tables where useful. Add narrowly truthful family/digestion/native docs and DD/WDD decisions. Separate kernel facts, generated-code/FFI assumptions, measured native controls and unproved native performance. Complete the entire production consumer and its controls before candidate declaration; a route-ready probe is not the assigned endpoint. + +Original complete frozen row SHA256: 0d089f49663a3003edd6b93ae4289f74fb40fd7034b865a95b2bb1a09ada21b9. + +Unchanged exact proposition/check (original evidence): + +Worked guide covers admission→builder/finalizer→READY replace/take→next request→cleanup,typed contracts/state table; claims separate kernel/FFI/compiler/measurements/performance. + +Unchanged named consumer and object-composition chain (original evidence): + +GUIDE/P/G/N/RC/NC/R→ledger→root REPORT; DD/WDD LIFE-NATIVE1 decisions/evidence order/thin route; all controls precede candidate declaration. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is b5e6467c691553facb60624ee82ecb621d5b75224c366cd9fffe39bb3282dcc9. + +## INV-STORE-IDENTITY + +the exact payload/store executed is the payload/store + counted by the public space theorem; a theorem about a sibling payload is + insufficient; + +Original complete frozen row SHA256: 1d34956c7732672c40f9a3dc37be9e6cf22ecd43a8aa2c435ec04b69c10bc702. + +Unchanged exact proposition/check (original evidence): + +B=Ownership.owner,B.toState=cr.final,B.memory entries/extent=mem; C(B) counts that same memory/regs/code/metadata; Q preserves incoming memory; Repacked gives exact owner equality. + +Unchanged named consumer and object-composition chain (original evidence): + +P E02/E03/E06/E09/E12,Q01/Q05/Q10; Capstone ExecutedOwner uses identical owner for refinement,READY,capacity. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is d49b435de47d0a0db302d3f60692d64f1dd439dafc348417483c178608fa02c6. + +## INV-VALUE-DEPENDENCY + +returned values and routing decisions depend on + actual charged reads, not a semantic answer computed before the reads. When + the requirement concerns the returned answer or route, evidence must constrain + that value, state, or route; inequality of an enclosing trace record can be + satisfied by its log alone and is insufficient; + +Original complete frozen row SHA256: a1dc2e5f22c6b389f548bf24e6dae3194323bd9429f9ce28f4fdb969e9fcf10e. + +Unchanged exact proposition/check (original evidence): + +Returned packet comes from actual executeArray/runThin status; charged loads update registers used by routing/answer. Matched dynamic-read agreement constrains status/categories,not log alone. + +Unchanged named consumer and object-composition chain (original evidence): + +G returned-calculation callgraph+P universal thin equality; inherited lifecycle_store_determinism: initial State.Agree and DynamicReadsAgree at same program/fuel⇒run Agree,equal status/orderedreads/allcategorycounts. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 06ba69ae73c05434a75447eb6ca18ea083acfa74932efea460d8fe156ac94041. + +## INV-SEMANTIC-NONVACUITY + +semantic coverage, liveness, ownership, and + refinement predicates are derived from the operational construction they + describe. A predicate defined to be `True`, an enumeration restated as + membership, or a separately hand-written consumer label does not establish + operational liveness by itself; + +Original complete frozen row SHA256: 2385833d4c26d9c319161c261d5196fcb331c6d80ae17a27d6ce9c9701be1da7. + +Unchanged exact proposition/check (original evidence): + +ExpectedReady expands canonical memory/extent,zero keys/keyRegs/extents,register bound/Fits and8273bank; actual halted packet/capacity derived from B,not assumed/True. + +Unchanged named consumer and object-composition chain (original evidence): + +P E04 independent expanded ExpectedCanonical/ExpectedReady,E05/E09,Q03/Q04/Q10; export only D/query only QD. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 1d6c3a25573c01243c2da2cdd3f84e8c22379951ff259870798f9aea590aeb3b. + +## INV-TRACE-EXECUTION + +traces and footprints are derived from the execution + they describe; + +Original complete frozen row SHA256: 1d327d8bb97c5aa71a9df97ddf268bf0215554eb74485aa9c3fb3134fb74a474. + +Unchanged exact proposition/check (original evidence): + +Ownership.observations.toRun=cr;queryArray.toRun=qr; native reads/categories fold actual transitions; indexed occurrence actual runprefix prestate+stepArray. + +Unchanged named consumer and object-composition chain (original evidence): + +P E11/Q06/O01–O11 via runAcc/recordBefore/thin equality; Capstone construction/PhysicalRun shares continuousRun. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is f6534d1bcf3dac39b12c62c614cd0511b70817f063fc80bc10007e5d52e5f1fa. + +## INV-STORE-AGREEMENT + +supplied-store agreement determines result, cost, and + the relevant trace; + +Original complete frozen row SHA256: 5ea77efbb58f7c902292aa589733cfffe86c6c7c4c5d1837c076ff83d45ed714. + +Unchanged exact proposition/check (original evidence): + +∀model fuel s t,State.Agree s t→DynamicReadsAgree(Layout.program model)fuel s t→run Agree,equal final.status,equal ordered reads,∀category equal categoryCount. + +Unchanged named consumer and object-composition chain (original evidence): + +Capstone lifecycle_store_determinism→run_agree_of_dynamic_reads same program/fuel; P B/Q projection+thin equality preserves actual exported run identity. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 33d5cf1080becaf9b25067da5c88ea6f61510adc671dfb8c48e54954d0e31c3b. + +## INV-READ-BACKING + +every successful read is backed positionally by the + counted store; + +Original complete frozen row SHA256: c6ea85cde80be6989c08bbda07824a09b59dcdd00b9e2a494c79d93c25a56dca. + +Unchanged exact proposition/check (original evidence): + +Indexed query read address<2^w,reply=mem[address]?,present value<2^w. Construction read uses its actual indexed producing prestate/Physical.lookup/checkedAddress with boundedphysical address. + +Unchanged named consumer and object-composition chain (original evidence): + +P O09/O10 via actual query_array_refinement/Reusable.query_read_occurrence; Capstone PhysicalRun full continuous prefixes; E06/Q05 identifies counted query store. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 86fa434c37939f423c9837cc8197275a696e47af0e2ef90358043156392b5a4a. + +## INV-WORD-WIDTH + +stored and returned words fit one declared modeled + machine word; + +Original complete frozen row SHA256: 322e190d234dfc0434609e25826bed5830315f399bc7764497c3a259808b4396. + +Unchanged exact proposition/check (original evidence): + +One w=wordWidth n bounds numeric store/register/result/packet; canonical byte length from w. Comparison arbitrary Int keys are separately counted. + +Unchanged named consumer and object-composition chain (original evidence): + +P ExpectedCanonical.Fits/Bpacket/Q-O10; Capstone safety/PhysicalRun same w; actual metadata n→native profile,noquery-dependent width. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 098b499cfe129cc1e94e9cae19c2c2433e3d2f17234df9f4079a94dbb89597fb. + +## INV-ADDRESS-WIDTH + +every executed address, dead/sentinel address, and + encoded instruction operand fits the modeled machine word, not merely the + host array bounds. Constructor-exhaustive evidence must include register + identifiers, branch/jump targets, dormant code, and arithmetic operands; + +Original complete frozen row SHA256: 028f7525f577cd8e9d5884f8abee48c3a84db2a642ef01db3892dabce65b6524. + +Unchanged exact proposition/check (original evidence): + +Capstone PrefixProfile each prefix/Transition.Safe; PhysicalRun bounds extent/values/checked physical+logical reads; uniform bounds every encodedProgram word including dormant operands. + +Unchanged named consumer and object-composition chain (original evidence): + +Capstone continuousConstructionQuery_holds D→safety/physical/uniform via all_encoded_fields_fit; P actual B/cr,Q/qr+Ready Fits same w; inherited constructor-exhaustive safety unchanged. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 3b1679081d08c53ecd9f7857e8d762a4b47ecb5da2a6e76172276e50f396c9c5. + +## INV-INSTRUCTION-ATOMICITY + +each modeled small step performs the familiar + primitive operation it advertises. A constructor whose evaluator body hides + recursion, a variable-length scan, repeated rank/select work, decoding, or + several arithmetic categories is a macro-step unless that work is expanded + into charged transitions or bounded by an explicitly accepted primitive; + +Original complete frozen row SHA256: 8bb37be02a71f82707f67f91dc0b79191ac5607bf54d0a5c135ab6de1c0d6061. + +Unchanged exact proposition/check (original evidence): + +runThin calls unchanged executeArray and equals runOwner ∀program/state/fuel; only observation packaging removed,not charged primitive work. + +Unchanged named consumer and object-composition chain (original evidence): + +P T01–T07; G emitted actualcallee; protected instruction/layout unchanged; boundary4 and finite8271setup remain. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is a1f50411b8aee892440c87a86f13e1db4b18369d46171b3b4ea389007696d12e. + +## INV-PROGRAM-ACCOUNTING + +input-dependent constants and metadata carried by + executable code are counted machine data or are derived uniformly from + counted/public inputs. Calling shape-specialized data "program code" does + not remove it from the payload/state accounting obligation; + +Original complete frozen row SHA256: cce368cd52cec199bccfc4570ac9b66260ac055947c99963c7f2690e2b129d57. + +Unchanged exact proposition/check (original evidence): + +C(owner)=memory.size+encodedProgram.length+regs.size+8 at same w; cached program depends only model,not xs. + +Unchanged named consumer and object-composition chain (original evidence): + +P E01/E09/Q10 expanded capacity→Ownership.capacity; Capstone uniform encoded wordsfit; N native code/global inventory separately. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is c3ff96dca33fb153a59fdf8026d6e18ed880b77329133a2fd13b43e568ce3805. + +## INV-ORACLE-INDEPENDENCE + +executable fixtures and edge-case expected values + come from an independent specification or a theorem already connected to it, + never from the implementation result being tested; + +Original complete frozen row SHA256: ed440179799a4acd4f56d11d186f6bdbb0e8e19dab76a573a040f00438b2a3d2. + +Unchanged exact proposition/check (original evidence): + +Frozen expected answers derive independent scan/leftmost semantics; native state/control expectations independently reviewed after measurement,before Replay,not copied answer-as-oracle. + +Unchanged named consumer and object-composition chain (original evidence): + +F independent reference→packets; NC fixedxs[3,-1,-1,7],range[0,4)⇒packet2 and exact canonical memory; frozen rootreview records each resource/state oracle. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is e13bd979d5eee7355f8d13058027c7c690d60ca9a64aec3c7f68a4760b39f2ed. + +## INV-VALIDATION-REACH + +executable validation imports and runs the new + semantic layer. A validator for the predecessor implementation is regression + evidence only and does not validate the new machine; + +Original complete frozen row SHA256: 941a8e59025bb46c5d8f0790fdbf3c39574c196f08c2f99dc6d53deac2d71330. + +Unchanged exact proposition/check (original evidence): + +New consumer imports current Lifecycle/Observations/AdmissionContract; actual native clients link current generated DLL and return that runner status. + +Unchanged named consumer and object-composition chain (original evidence): + +L→DLL5stage→client8stage→F/CL/A exact stagedbinary; G actualcallgraph distinguishes import from execution. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 2ce89597099561eca62d5be778de6ae8c8eccc0073498700df08bf785cef7a5e. + +## INV-ALL-SIZE + +exactness covers all assigned sizes and edge cases without + hidden readiness or compatibility dispatch; + +Original complete frozen row SHA256: 529c8ded291c70a1d79d41cc3a26b0bcaf7e4215cfad1185fefea90d6b99819c. + +Unchanged exact proposition/check (original evidence): + +∀model xs endpoints,InputDomain+represented endpoints⇒ExportContract; word requires InputFits,comparison no key bound; no readiness/n-threshold premise; invalid packet0+READY. + +Unchanged named consumer and object-composition chain (original evidence): + +P U02/U03/E-Q→all-size Ownership/Continuous capstone; native finite host ceilings kept outside Lean conclusion. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 1ce149aa488b07148301b0a87f09c6927e24ef3249b5a356efef4af91588fd25. + +## INV-PROOF-SEPARATION + +proof-only fields never carry answers or uncharged + routing information; + +Original complete frozen row SHA256: b13b1033dc7b665e5da651dc9ed310ac8a7f938e71aad41429bdbf56f0d28f0d. + +Unchanged exact proposition/check (original evidence): + +InitialOwner/thin/executeArray/status carries operational arrays/scalars only; no proof answer/route; startup must not evaluate proof-only reference payload. + +Unchanged named consumer and object-composition chain (original evidence): + +G initializers/returned closure; P erased proofs+actualproducer; approved5macro_inline remove expensive wrapper initialization without proposition change. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 7449c432d4557a218f0241e02e92646015b58dc2c9a0ffd9a14f816f1805c94f. + +## INV-NO-SYNTHETIC + +synthetic events, decorative rereads, and post-hoc replay + do not support the execution claim; + +Original complete frozen row SHA256: d19ec60c17bf6190599b129cd8409811727875f62c106e05671ae2a6f5bb9dd4. + +Unchanged exact proposition/check (original evidence): + +Stats/receipts fold actual primitive transitions; occurrence has runprefix prestate and producing step; route labels need source semantics beyond instruction marker. + +Unchanged named consumer and object-composition chain (original evidence): + +P O01–O11/T/recordBefore; G observedrunner; RC source signatures+ordered actualpayload addresses/replies. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 63c361ceb44fb5dc4aa2be848024dfb82845bc3f4b86a7859537d063e9e5b9ab. + +## INV-CATEGORY-SEPARATION + +payload bits, proof fields, model ticks, machine + state, Lean runtime, and measured performance remain distinct. + +Original complete frozen row SHA256: 0863e6cac9f7cb4491c0bdd4e2e1957b234a4a3c85b65cabea01229d85fd3e2d. + +Unchanged exact proposition/check (original evidence): + +Modelwords/bits,proofs,ticks/categories,nativecontainers/scalars/code/globals,GMP andwalltime distinct; conversion/init/repack/observation not inside160257ticks. + +Unchanged named consumer and object-composition chain (original evidence): + +P capacity/steps/folds→N resource table→GUIDE/report assumptions. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is da618636d079db82071bf4a049ba8f62aa3233cecdccc89819fa7819fc34f7e2. + +## INV-PUBLIC-COMPOSITION + +a theorem combining space, exactness, cost, + provenance, or machine claims proves them about the same construction and + execution and over the same validity domain. Conjoining true theorems about + different payloads or guarded and unguarded executions is not closure. + +Original complete frozen row SHA256: fe85a124b8db2a7e067d96e795676d1e092eb21e9796a2d35f47156ade6a3650. + +Unchanged exact proposition/check (original evidence): + +All owner/memory/guardedpacket/capacity/observations/metadata fields concern same model/xs/endpoints; continuation same incomingREADY/haltedowner andrepresentedendpoints. + +Unchanged named consumer and object-composition chain (original evidence): + +P E01–E13/Q01–Q11,E12/B bridge; Capstone construction/physical/safety/executable/reusable/uniform same continuousRun/w. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 21d09f92009841588eeb8cfeabcae136a7e2af830953ea8403175770525d0627. + +## INV-CERTIFICATE-ANTI-BYPASS + +every mandatory field advertised by a public + certificate is projected by a checked typed consumer at the exact proposition + and object arguments required by the acceptance contract. Deleting or + weakening a field, or replacing it with a sibling fact, must break that + consumer rather than leave only constructor initializers and prose unchanged. + +Original complete frozen row SHA256: c93bc8c6cf1f54b62d3075fc9ad59b406cb0c3c43145b956b611ee6b4de349f2. + +Unchanged exact proposition/check (original evidence): + +All23mandatory fields independently projected at exact expectedobjects/types; B/O/T extra consumers; producer compile success required before rejection counts. + +Unchanged named consumer and object-composition chain (original evidence): + +P E/Q table+LifecycleNativeContract→frozen EXPORT_MUTATIONS34→intended theorem/range/type diagnostics. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is eb4986ee007073c8f6932d8c76c73b3faf91ad1d424ada032926c95b18045493. + +## INV-MUTATION-REPRODUCIBILITY + +when acceptance relies on an exhaustive, + production, or public-dependency mutation campaign, the candidate contains a + versioned runner or fixtures that replay every claimed case, check the exact + expected failure/acceptance surface, restore tracked state, and leave the tree + clean. Report prose, copied terminal output, and dangling Git objects are not + replayable evidence. A public theorem additionally has a checked exact-type + consumer that fails when the advertised dependency is removed; `#print + axioms` over the theorem's current type is not such a consumer. + +Original complete frozen row SHA256: 40d0308a594e221913d8c01639ed5b6a31708307542d896c0a94576e7dd21fd3. + +Unchanged exact proposition/check (original evidence): + +Versioned orderedrecipes/accept-reject/verdictsurfaces/finallyintegrity-cleanup; final delivery commits replayable files and exact identity. + +Unchanged named consumer and object-composition chain (original evidence): + +EXPORT34/NATIVE48/RUST17+callercontrols→rawactual receipts; frozen expectations distinct from discoverycandidate. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + H + explicit Rust17 applicability. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is f3d9cd95063f38619949cfb6c11fc345d74e4e259e87b50a96872144949fdef8. + +## INV-GLOBAL-PHYSICAL-MACHINE + +a physical-machine claim supplies one + pre-execution store/word array and a checked address translation for every + executed segment, including failed/dead accesses. A theorem for one suffix or + component is not a whole-machine embedding. + +Original complete frozen row SHA256: fc7a07fb9551b4bd07e0273548c940b1fb6372c7b56b931b2e0659e078a956de. + +Unchanged exact proposition/check (original evidence): + +PhysicalRun covers every continuous prefix boundedextent/lookup; indexedread actual runprestate+checkedtranslation+backedvalue; fetchedencoding backed by codeaddress. + +Unchanged named consumer and object-composition chain (original evidence): + +Capstone D→PhysicalRun/safety/uniform; initialState common preexecutionmachine evolves through imageTrace; P B/cr,Q/qr preserve sourceobject. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is f7f9d760a3877cd4bdafc0f87659828012330674826c60b9b3cda5f0b49766d3. + +## INV-WIDTH-SCALING + +one query-independent word-width declaration bounds all + stored words, addresses, sentinels, operands, and primitive results, and its + capacity/width is related to input size in the form required by the public + word-RAM claim. A standalone asymptotic fact about an unconstrained width + function is insufficient. + +Original complete frozen row SHA256: e8f74e2fb81ebf63c5d3bbcdde8707744f17675f3699dcbfb0347d34669ca368. + +Unchanged exact proposition/check (original evidence): + +Same w=wordWidth n obeys log2(n+2)+1≤w≤192*(log2(n+2)+1); all codewords<2^w; C(B)*w≤2n+rho with LittleOLinear rho; Q same bound. + +Unchanged named consumer and object-composition chain (original evidence): + +Capstone uniform+ExecutedOwner/ReusableOwner at same n/model; P E09/Q10actualcapacity/E01program; producedmetadata fixes n independent of query. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + N. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is e2a634a1b614009043b6af434a41f790cee38dcedd1abc05a515617eb6b252d8. + +## CHK-SCOPE + +exact base, branch, allowed paths, complete raw/Git identities, immutable prior matrix/history and clean committed candidate verified; both design ledgers and new import/consumer references close transitive scope. No broad .gitattributes/configuration/policy allowance. + +Original complete frozen row SHA256: 567dc530364ce71be1124b90e7258456324e89603076d5020e102541f8bf54a6. + +Unchanged exact proposition/check (original evidence): + +Final exact base3dbdebedcc6ba6b2a864df0d46dcc09ccaaa7536/branch/allowedpaths/3844rawGit/frozen55/bothledgers/importclosure/cleancommit must pass. + +Unchanged named consumer and object-composition chain (original evidence): + +scope_check exactbase inventory+approved5annotation patch; governance7b227c49ef2ec044b702126cc41c9add847eed01 skillpreflight passed; root final_checks/commit. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: S. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 9faafb212881dfa217da236752e02502a372709ad53d1b95d75285af94910e81. + +## CHK-LEAN + +focused new roots and independent export contract compile, their axiom inventories retain the permitted Lean/Std trust base, all required exact-type mutations replay at the intended client, and one final default lake build passes after implementation changes. No sorry/admit/axiom/native_decide/Lean.ofReduceBool or new unsafe/extern/implemented_by theorem shortcuts; legitimate existing runtime/FFI trust is documented. + +Original complete frozen row SHA256: d9509958045f01fed608dee8066a632f9c87282e59c459c4ffb014867b82aecf. + +Unchanged exact proposition/check (original evidence): + +Current narrowroots/consumer,21rootaxioms,34requiredmutations and onefinaldefault build must pass permitted Lean/Std trustbase without new shortcuts. + +Unchanged named consumer and object-composition chain (original evidence): + +L4roots→export34→AX21 exact inventory→DB final default build; root finalhygiene/scope. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: F + S. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 0c9df5c507ae186098b5fd4805405cddedaa599683b0a1e8074d401459cd120e. + +## CHK-NATIVE + +bounded startup, one exact selector, then complete frozen actual new-native registry and C/Rust/C++ consumers pass on frozen producing source with owned exits/streams/identities/capacity/failure controls. Preserve exact counts and attempted negative types; do not confuse components, retained captures and fresh actual native processes. + +Original complete frozen row SHA256: 5e6affb80e0915950bffddc3df6cd59c27a6e8423bec86f205d7cbe70e9ee288. + +Unchanged exact proposition/check (original evidence): + +Boundedstartup→focus→full13fixtures/10clients/23ABI/48controls plus17Rustcompile bind actualsource/exits/streams/predicates/cleanup. + +Unchanged named consumer and object-composition chain (original evidence): + +S→focusLN1-W-TIES→F+independentreview; DLL/client→CL/A; NC48Discovery→review/freeze→Replay; R17Replay. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: N + H. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is bc0bdb8a09fa78e166e5e277e962524cc5bd1094657f66a5fedb8effae0eafbf. + +## CHK-REPORT + +complete durable report/matrix/guide exist and final committed git diff --check plus strict exact-base design certification and unchanged-policy strict changed-surface claim checks cover the final prose/code/ledger inputs. Final HEAD, report bytes/hash, source commits, actual commands/results and applicability of reused evidence are separately pinned in an external delivery receipt. + +Original complete frozen row SHA256: 0c33e0636e38e9bd0eb581ebac5861568796c616270ea4d4d81f5aa5603ae431. + +Unchanged exact proposition/check (original evidence): + +Final report/matrix/guide/publicdocs/ledgers; strict unchanged-policy changedsurfaceclaims/design -Strict -Base exact40charbase; committed diffcheck/externaldelivery finalHEAD/prose/sourcepins. + +Unchanged named consumer and object-composition chain (original evidence): + +RootREPORT/final_checks→exactbase scope/design/claims/whitespace→commit→externalreceipt; matrixrequirementbytes frozen. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: S. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 2185174f515b56d34a4899646b77ce42893c91f0370b79b56ba383fe66df78be. + +## REPLAY-EXACT-REGISTRY + +a replay harness must declare the exact ordered + frozen case registry, reject missing or duplicate IDs, verify any ID-to-field + or ID-to-object mapping, and check exact verdict counts; a total pass count + alone is insufficient. + +Original complete frozen row SHA256: 049abd8259e9c2ab156d093dde162552c62276525fd43332819d7b42fa0c9cec. + +Unchanged exact proposition/check (original evidence): + +Full orderedID→handler/verdict mapping/count checked; missing/duplicate/reorderedmiddle/mapping drift reject before semanticdispatch. + +Unchanged named consumer and object-composition chain (original evidence): + +SC13fixtures/CC10clients/EC48native/EXC34export/RS17Rust→frozenregistries; actualreports matchedIDs/argv/projections,notpasstats. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: H + N + S. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 769546d0d97aee9e570b811d443c59d5d547a0d962cb89c3669fc57e815caa47. + +## REPLAY-SELECTOR-NONVACUITY + +focused selection must execute exactly one + requested frozen ID and must reject unknown IDs. Add cheap named controls for + an omitted middle ID, duplicated middle ID, valid frozen ID, and unknown ID. + Distinguish an omitted selector parameter from an explicitly bound empty or + whitespace value at the real script boundary; only omission may select the + full registry when the frozen contract permits that mode. + +Original complete frozen row SHA256: a4f11106d8cf8e1f42fa7b693a1b2f535c199e7702af0a441a1d276e6aaf2c92. + +Unchanged exact proposition/check (original evidence): + +Only parameteromission may selectfull; boundempty/null/whitespace/unknown/duplicate reject; knownfocus exactlyone; invalidselection no semanticchild/outputmutation. + +Unchanged named consumer and object-composition chain (original evidence): + +Five realrunnerbinder controlreceipts; CC historicalreuse rechecks36sourcepins/104rawcaptures. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: H + N + S. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 3410b7e6e9050d4aadf35b0f77a6a9b6cf9f9f3e3425b53852ee612478bcfb5c. + +## REPLAY-SUBPROCESS-DEADLINE + +every external compiler/tool stage in a replay + harness must have a positive evidence-based deadline, classify timeout as + failure, terminate its owned process tree, and run cleanup plus live-tree + integrity checks in `finally`. Implement and exercise owned-tree termination + on every operating system that runs the required gate. Add a cheap sleeper + self-test that spawns a descendant and proves both root and child are absent; + do not discover this control by hanging the full semantic campaign. +- When ordered dynamic-read agreement is primary and safe-footprint agreement + is a corollary, prove the read-region/segment containment bridge directly + from execution or program structure. It must not invoke the legacy safe + complete-result equality before reaching the ordered-dynamic theorem. +- If a public wrapper guards valid inputs, ensure every combined field uses the + same guard/domain. Raw adequacy may occur only under the valid-range premise + or in a guarded packet with matching invalid semantics; a bridge theorem does + not justify leaving raw adequacy unconditional in the same public record. + Test invalid, reversed, and out-of-bounds cases. +- For a whole physical-machine claim, cover every read-producing segment in one + pre-execution word array and relate its query-independent width/capacity to + input size. A component slice or unconstrained little-o width fact is not + enough. +- For classifier/linter work, treat named mutation fixtures as lower bounds, + not the acceptance boundary. Freeze the category being classified; add + category-level holdouts and allowance-bypass mutations; and exercise the + production final verdict, including strictness, path/line context, focused + single-file input, and absolute-path normalization where supported. Do not + validate a copied detector in place of the production classifier. +- Strict branch certification with scripts/design_decision_check.ps1 must use + -Strict -Base followed by the task's exact 40-character base commit. + Omitting -Base is a production failure, not a clean zero-change result. + Reserve the no-Base form for deliberate non-strict local-worktree advice. + +Original complete frozen row SHA256: dd285ddd062d5a1c2a07594604e449b4ce2807c414c036db70e429ba6103715f. + +Unchanged exact proposition/check (original evidence): + +Owned positive deadlines/finally cleanup; direct read containment, matching guards, wholemachine/width and strict exact-base design. Conditional classifier obligations apply to added output-language/diagnostic validators; unchanged claim-scanner policy is consumed by the final gate. + +Unchanged named consumer and object-composition chain (original evidence): + +ODC helper; P O09/O10 occurrence→Reusable.query_read_occurrence; E13/Q11; CapstonePhysicalRun/uniform; EXC actual diagnostic validator; FS actual component-language validator; root production strict claim/design calls. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: H + N + S. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is f082cc5d84b439949a3fbe8e6b1b6126279bfdbd04ec76652e63b5ee53a897e1. + +## FROZEN-ACCEPTANCE-ROW-BYTE-INTEGRITY + +when a prompt says inherited matrix +rows are frozen, verbatim, or byte-for-byte preserved, validate that claim +before any expensive verification. Decode the exact base blob and candidate +file as strict UTF-8, extract the complete frozen row for every inherited +stable ID, reject missing or duplicate IDs, and require exact UTF-8 byte +equality for each row. A row count, normalized text comparison, visual review, +or a read/write round trip through a locale-sensitive shell is insufficient. +Also reject recognizable mojibake such as `¬` or `“...”`, but treat that scan +only as a negative control: absence of those spellings does not replace exact +row equality. Record the base ref, candidate ref, inherited-ID count, and exact +changed IDs in the evidence ledger. + +Original complete frozen row SHA256: 27254535ce15d747ffd5ff7ce7138f81c199656f30027ddce24ed172ffaec161. + +Unchanged exact proposition/check (original evidence): + +StrictUTF8 exactbase/candidate predecessorrows equalbystableID,noomission/duplicate; mutabletable ID/requirement/scope cells equalfrozen55. Mojibake negative scan supplementary. + +Unchanged named consumer and object-composition chain (original evidence): + +Immutable frozenmatrix/contract→baseinventory/scopechecker; thisedit retainsfirst3cellstrings directly; rootfinalcommittedbasecomparison pinned externally. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: S. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 13ec55e3111e74207b4bc243d14e7c61ad3000e3a2fdadbb8a2234c0554370cd. + +## NAMED-REGRESSION-REALITY + +before a prompt requires an immutable negative + fixture to fail, the coordinator must independently reproduce that failure + from the exact objects with the same decoder, predicate, guards, and + quantifiers required in the prompt. Record the observed result. A mixed- + decoder transcript, worker narrative, or unverified inference cannot become + a mandatory negative control. + +Original complete frozen row SHA256: 63a05d728ac465ff7961999d4d184b92ca438edfc9a8f1607af29eaafaba6f82. + +Unchanged exact proposition/check (original evidence): + +Mandatorynegative requires independent reproduction atexactdecoder/predicate/object/guards; nondistinguishing controls disclosed. + +Unchanged named consumer and object-composition chain (original evidence): + +Historical NC48 Discovery→independent486pin/projectionreview→unchanged frozenoracles→current full-recipe rebind→NC48 Replay/independent6500-input review. Historical R17 diagnostics→current Discovery/equal17cases→rebind→Replay. EX34 Discovery→independent review→frozen diagnostics. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: H baseline failures + N unchanged measured48 oracles. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is b263d823304e9005d3f5d1fe465780efef961be8556b4b33dfd190c49c74bd6c. + +## ARCH-LIFECYCLE-ACYCLIC-EVIDENCE-ORDER + +before launch, write the task's +evidence and decision order explicitly. Separate owner choices that genuinely +gate evidence collection from choices whose justification depends on that +evidence. An output-dependent decision cannot be a prerequisite for launching +the task that produces its evidence. Review the order as a dependency DAG: +every producer must precede its consumers, and any cycle makes the prompt +`DRAFT_DO_NOT_SEND` until the lifecycle is repaired. Preserve legitimate +two-phase architecture governance: approve scope, model, and acceptance gates +before a spike; choose the route or successor matrix only after the spike +results exist. + +Original complete frozen row SHA256: 7013d08235d11f1222577388e47f1c839af0e19492621760cfe6435538a7e69b. + +Unchanged exact proposition/check (original evidence): + +Scope/model/acceptance freeze beforeimplementation; measured route/copy/diagnostics before dependentdecision/exactexpectationfreeze; Replay/certificationafterproducers. + +Unchanged named consumer and object-composition chain (original evidence): + +Frozencontract/approvedamendment→boundedinitializer-copyevidence→thin decision→currentDLL/fixtures/controls→review/freeze→Replay→finalsource/prosechecks. + +R1 disposition: Candidate evidence assembled; coordinator acceptance remains required. Evidence: START + VERIFICATION_PLAN + external binding approval before Replay + S before delivery. The source row and detailed original anti-vacuity/evidence cells remain in ../lifecycle-native1/ACCEPTANCE_MATRIX.md; its raw row SHA256 is 57eacd240478a8ee1c8f101f5ee880a1704d191da91e76317ace3ae97a6acdcd. + +## Added R1 obligations + +- LN1-SETUP-LIFETIME: actual owning selector runner fails after disposable acquisition when replay source is absent, retains incomplete3-pin setup, independently attempts integrity/disposal/durable receipt, removes scratch and launches zero semantic children. H1 integrity-fault holdout also fails its integrity check while completing the other duties. Original failed path reproduced first. +- LN1-ORDINAL-REGISTRY: all fixed textual fields require string type plus ordinal identity. Actual Plan/Validate boundaries reject all72 corruptions and accept both healthy rosters, before output or semantic work. Complete original selector/recipe controls also pass; original six ignored-character accepts remain retained. +- LN1-CONSUMER-CLOSURE: actual preflight rejects dll/clients/all with Codec3 versus Entry365 before output. Defaults371 cover Entry; Lean-only Codec remains supported. Actual receipt predicate accepts full healthy test-only fixture, then rejects body-only Entry mutation and missing Entry.c pin. Fresh defaults compile and consume the required371/365 closure. No observed stale DLL is claimed. +- R1-SCOPE-FINAL: ten committed holdouts test actual scope/file/pin predicates and actual final consumer language, including healthy full-receipt consumption, unexpected output/error/exit, missing/extra paths, protected/frozen-row/ledger-prefix bytes and changed pins. Final wrapper uses unchanged strict design/claim checkers; the exact WDD-only repair result has a separately tested consumer. +- R1-EXPECTATION-REVIEW: complete new recipe reconstructed with every source/tool/generated/artifact identity; every measured48 case object is unchanged. External exact-byte coordinator approval precedes full current48 Replay. +- R1-REUSE-APPLICABILITY: original export34/axiom21/Rust17 receipts retain original paths and hashes; current-source mappings and accessible captures rehashed;34 removed artifact occurrences require exact prior audited path/length/hash. No normalization hides a changed raw pin. +- R1-DELIVERY: clean private commit, both exact bases, final report bytes and final scope/design/claims/hygiene/whitespace/source checks are bound in .lake/lifecycle-native1-r1/delivery/DELIVERY.json. Aggregate/blind audit/acceptance/integration remain subsequent coordinator work. diff --git a/docs/internal/extensions/lifecycle-native1-r1/BASE_IDENTITY.json b/docs/internal/extensions/lifecycle-native1-r1/BASE_IDENTITY.json new file mode 100644 index 00000000..4a819f59 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native1-r1/BASE_IDENTITY.json @@ -0,0 +1,55057 @@ +{ + "schema": "lifecycle-native1-r1-base-v1", + "base": "c52c453a2f0f49c568886f502687e4d0667838e9", + "originalBase": "3dbdebedcc6ba6b2a864df0d46dcc09ccaaa7536", + "worktree": "C:\\Users\\poin\\.codex\\worktrees\\4935\\RMQ", + "files": [ + { + "path": ".agents/skills/rmq-audit-prompt/SKILL.md", + "mode": "100644", + "gitBlob": "7d6e7d91d8d564b49381cf138de17e79d8dbcdb3", + "rawBytes": 7761, + "rawSHA256": "B9251C2FC767B062C619F7A4F1F374BBCF68754D20AD4C86C36D7025FDDE40FB" + }, + { + "path": ".agents/skills/rmq-audit-prompt/agents/openai.yaml", + "mode": "100644", + "gitBlob": "f69fd9e873460adb911115421689c7a6dc07e85c", + "rawBytes": 249, + "rawSHA256": "6EA8CE45A5160862C6646748EA359571F9FA40724705130DA060A9BF86C8A12B" + }, + { + "path": ".agents/skills/rmq-coordinator/SKILL.md", + "mode": "100644", + "gitBlob": "33333638703f8f1871156df1de1706fd23971511", + "rawBytes": 34066, + "rawSHA256": "7F8A7515709636F103FFCE5FEAAFBB5DE6287485D5E1C76D1D9B17541640B357" + }, + { + "path": ".agents/skills/rmq-coordinator/agents/openai.yaml", + "mode": "100644", + "gitBlob": "eccfe94be283ac1bf6fff0f7637da61764702a5f", + "rawBytes": 365, + "rawSHA256": "9DA8E978450241010880DC28E5CBDE5CBF0EC46AEFA07AD1ADEDD18874FEB2A9" + }, + { + "path": ".agents/skills/rmq-proof-sprint/SKILL.md", + "mode": "100644", + "gitBlob": "bfc615ac32c4b737b34b21dab2f2d0dab672fabf", + "rawBytes": 10289, + "rawSHA256": "945A6BDD960A377B13FACC3D83F1DD78D40431027F17B35AD5A8A582455C1E9C" + }, + { + "path": ".agents/skills/rmq-proof-sprint/references/COMPLETION_GATE.md", + "mode": "100644", + "gitBlob": "b39ada83794b428be7184e0c633d3c1f2359f604", + "rawBytes": 31640, + "rawSHA256": "B760F0DF4F3C2B5949352FF926D672CFC4D04AFA43916218C5D207ED8F294330" + }, + { + "path": ".agents/skills/rmq-proof-sprint/references/KNOWN_FAILURE_MODES.md", + "mode": "100644", + "gitBlob": "dd32a880681871be6bb855f71809a8711c051a84", + "rawBytes": 22689, + "rawSHA256": "5C005D0611182863E39F4897B89F66F842DBF4956B208942EEC1E95F694C9ECD" + }, + { + "path": ".claude/skills/rmq-audit-prompt/SKILL.md", + "mode": "100644", + "gitBlob": "12df22787fb2239d3375a44c3c6fed1aba213a99", + "rawBytes": 1175, + "rawSHA256": "34A08A144703633031BE7BCC97C09F5754C74526A077ED07925F64369CEA9AFC" + }, + { + "path": ".claude/skills/rmq-coordinator/SKILL.md", + "mode": "100644", + "gitBlob": "9cab66de6ee49d9c3d027f643a2fe7a00b6b9470", + "rawBytes": 1599, + "rawSHA256": "54394177DBE1F39DFC3230813737588F2A819DD9CBDED6E18D6A5F30C57582D8" + }, + { + "path": ".claude/skills/rmq-proof-sprint/SKILL.md", + "mode": "100644", + "gitBlob": "c662632d335d3fca5a2c75db15e455f3f725d886", + "rawBytes": 1339, + "rawSHA256": "EC1A2AB7DDA9106ADC446D91637F8B23205275AFF7951F062E34D46B22ADB920" + }, + { + "path": ".codex/agents/rmq-frontier-explorer.toml", + "mode": "100644", + "gitBlob": "f54ef34cece2fd9d2fcaa5d80e534a0f5cabdd76", + "rawBytes": 964, + "rawSHA256": "D66EAD12F9F150ED7D9F2F57D083996EE35BC9E7C8153981C71365843E551C34" + }, + { + "path": ".codex/agents/rmq-proof-auditor.toml", + "mode": "100644", + "gitBlob": "65f377ee0a6421e9d90746f3a77bb65d60cf9d65", + "rawBytes": 980, + "rawSHA256": "E7048894E4907017AC30EAD0FF3CCF2A45D1937A3786366DAF833A6D931D6626" + }, + { + "path": ".gitattributes", + "mode": "100644", + "gitBlob": "97bb4605994f95b9537c5101f6e8ebc04f28db46", + "rawBytes": 2651, + "rawSHA256": "EA89E2A9E267B015CB36B496862CADE043E11BBCBC5F0155867AD2CA76D76D13" + }, + { + "path": ".github/ISSUE_TEMPLATE/audit.yml", + "mode": "100644", + "gitBlob": "5889caf0b7108144faa4745dfa07f9f6e915b037", + "rawBytes": 942, + "rawSHA256": "21F3B3CA815BC0D3A5A9A99757B3DE1F362C6F9D3845E7F62CFF94DA00A43EC8" + }, + { + "path": ".github/ISSUE_TEMPLATE/worker.yml", + "mode": "100644", + "gitBlob": "805bca44e1e6cf9651d5b852e7ecec70619a21f5", + "rawBytes": 1069, + "rawSHA256": "67244747915328742FA4E60A6A5B788AF9BEEC99106AB01E5767F5890B23C3D5" + }, + { + "path": ".github/pull_request_template.md", + "mode": "100644", + "gitBlob": "94d0423b1e267753e1914ce39242af5037d2a897", + "rawBytes": 583, + "rawSHA256": "65626244603557A30398F495C22FBD400B2CE08B0818FBAC94E0CCBCBD33FE89" + }, + { + "path": ".github/workflows/artifact-repro.yml", + "mode": "100644", + "gitBlob": "fbf428a2ac5d61f18aaa9561bfb5c7f986f67490", + "rawBytes": 2512, + "rawSHA256": "28F486036AF3A54A7EFA779083E8F9FD24DF134290740DB76DCF57DCBC9896B4" + }, + { + "path": ".github/workflows/ci.yml", + "mode": "100644", + "gitBlob": "6c4ffb3a4cb78445018f5f20b837fbcebab71962", + "rawBytes": 7319, + "rawSHA256": "13530E6F68D1F227C15D1C1CFB03FA5682A61FF48F2ECCA8A4706AA9B92EAF2D" + }, + { + "path": ".github/workflows/release-artifact.yml", + "mode": "100644", + "gitBlob": "16cff4ba7fddabe6238878cb4985ea1c0a8189a0", + "rawBytes": 2657, + "rawSHA256": "F9B3D23371D036A81021287D2DD1ABB2A4FA3E418738CB41D61A5045DCF2EAC9" + }, + { + "path": ".gitignore", + "mode": "100644", + "gitBlob": "488f3de89e106041cb078900c50b77ac5051eaf5", + "rawBytes": 621, + "rawSHA256": "49D597D1E8070A701CA1258753583D528EF183FE8D7F6AD7F4DFAE3DA10E102E" + }, + { + "path": "AGENTS.md", + "mode": "100644", + "gitBlob": "84dfcce40ad902fb3a11fea8d37f8664812ab9da", + "rawBytes": 10445, + "rawSHA256": "B057081A28A8B8BEDBDD8D0B33F2D311BD9DBA4591D7DB4764924BF267D1192E" + }, + { + "path": "CITATION.cff", + "mode": "100644", + "gitBlob": "514a6954dc371219dce5500545553f401e180fc2", + "rawBytes": 709, + "rawSHA256": "354676E89ECD2E3F4E9DF1C91F1B1910ABE43E434CFEA9F2792BE504AAE9DADE" + }, + { + "path": "LICENSE", + "mode": "100644", + "gitBlob": "67ec935563b584f1b6821d6122cc2aee79f7968b", + "rawBytes": 10613, + "rawSHA256": "D470BCE9F61C9F29FB6C6048A496A337B1F0C688217BED9E266017748D8BBD29" + }, + { + "path": "README.md", + "mode": "100644", + "gitBlob": "0b0521c844890d7628a7ced6108022e109d81f70", + "rawBytes": 33813, + "rawSHA256": "D2B55F25DF211647AF32323B167790791E3031ACDC2F5B5082439E4220C9C3FA" + }, + { + "path": "RMQ.lean", + "mode": "100644", + "gitBlob": "cdc7d2282a5bfb547c55960f54f89e198dc03c47", + "rawBytes": 6849, + "rawSHA256": "DB3B465F5FDF14F03D1B637F2AD76610FFAC8BDCA855FDEB201806EEA4E72EEB" + }, + { + "path": "RMQ/Archive.lean", + "mode": "100644", + "gitBlob": "cc4d7de492a35594c0e9c872102cb328964d5e06", + "rawBytes": 121, + "rawSHA256": "06BB171FB4B694E3D86582F94B6446FE88CDBEEF7C0EB1DECBB6646B0D60ACFA" + }, + { + "path": "RMQ/Archive/BPSpecializedCapstone.lean", + "mode": "100644", + "gitBlob": "9e4dd55c36468d16c10d573913eef33afcb78cc8", + "rawBytes": 589, + "rawSHA256": "98E4EFCCBDEA73FCD6F473360DBBE573D04ACC342F8DB3FE0E90EDB67C767E74" + }, + { + "path": "RMQ/Archive/SelectCompatibility.lean", + "mode": "100644", + "gitBlob": "e4b53c95fc68b4e962f495ed1da1d64f7bfc7cd3", + "rawBytes": 748, + "rawSHA256": "FCF3F44AD517C6D8B231D3DF9BA629C5C3D1489FB7813F90301F4CEFD7786FAA" + }, + { + "path": "RMQ/Archive/SelectObstructions.lean", + "mode": "100644", + "gitBlob": "4e54d93533f255a62ff05980d106a3f0874a6180", + "rawBytes": 4888, + "rawSHA256": "345120256155E07DEA1780B2C5340A20B8FC0CD47D46605761BF51ACC8EAC007" + }, + { + "path": "RMQ/Core/Amortized.lean", + "mode": "100644", + "gitBlob": "3704e354f66031252aa77745cb9b5b8c0e815ddc", + "rawBytes": 3560, + "rawSHA256": "F728A46FA03CBF2B7E527B695D1DDA37CD06A1DC820E9031523027E86D3B8FC4" + }, + { + "path": "RMQ/Core/AmortizedSequence.lean", + "mode": "100644", + "gitBlob": "985dccf1078f47ea9f94bad6f5387fe076023107", + "rawBytes": 5593, + "rawSHA256": "D32A05363608E5AACAC83535279368672F1F86C2BC1A6BC800E283F924062A94" + }, + { + "path": "RMQ/Core/BPCloseNavigation.lean", + "mode": "100644", + "gitBlob": "8ef2dc65cf9ce155f87c9577a6c4a6529cff329b", + "rawBytes": 397, + "rawSHA256": "9137D0EB03BE2137A7DFFDAF6C305041BF504684C818E96E6524F2F7D988F068" + }, + { + "path": "RMQ/Core/BPNavigationPublic.lean", + "mode": "100644", + "gitBlob": "7521c7796b0b2ef1096573c1a77ea3a56213da79", + "rawBytes": 71180, + "rawSHA256": "24592ECEB6BFD4A7B337234A0176ADB57FF70EB9E25654D0CC37D38803B01DBC" + }, + { + "path": "RMQ/Core/BPNavigationRAM.lean", + "mode": "100644", + "gitBlob": "93a78d77cea669c0448ad684d68a8bd785a51332", + "rawBytes": 117209, + "rawSHA256": "2116D4244AE2799B51ECED28D7EDB798069C785C45D1DBBFE1777409E26BC9D2" + }, + { + "path": "RMQ/Core/Backend.lean", + "mode": "100644", + "gitBlob": "98ef173870adf0f499dcefb7d70d3dddb557f8e8", + "rawBytes": 2179, + "rawSHA256": "8D911857ED6E9669936D5F8818149E23EBF4874C2C508D63CEEA889660ACC751" + }, + { + "path": "RMQ/Core/Cartesian.lean", + "mode": "100644", + "gitBlob": "2d3aec25e13ffc53227babb8aebe865327d1f1a6", + "rawBytes": 58487, + "rawSHA256": "A0C175425B7DF234F8CF59E177B36E3ED593D81D78337D40E6E2ED74028D9580" + }, + { + "path": "RMQ/Core/Cost.lean", + "mode": "100644", + "gitBlob": "1b6e0c28eb22efa8fdeb2a08a84e18abe6652f7d", + "rawBytes": 4898, + "rawSHA256": "887CDCCA893969756F6B7F785E1CA2249106F215A4155C6BA6FE714A6373BAA4" + }, + { + "path": "RMQ/Core/CostKernels.lean", + "mode": "100644", + "gitBlob": "ce894658ca90684799a4bf544b082848df05b9b3", + "rawBytes": 9261, + "rawSHA256": "E0576CAEF6459D8518A086AE1C83089B5482818E3DE1991B143061F28254D5E3" + }, + { + "path": "RMQ/Core/EncodingLowerBound.lean", + "mode": "100644", + "gitBlob": "62d880a3df139ac6e74bdacdfa5834141034efc3", + "rawBytes": 75412, + "rawSHA256": "BA555AADFA7F3AB3BF0B8DC1D09E093A33DE6A4747DCE6BA707FA68BCBAE61E5" + }, + { + "path": "RMQ/Core/EncodingVariableLowerBound.lean", + "mode": "100644", + "gitBlob": "5104dde50c44670ed460d841ec8bb893beff3b62", + "rawBytes": 14505, + "rawSHA256": "6659E77713800E028DF7904370FA868C1C5AE6C7FCF7B641884DAA9ADE595FD5" + }, + { + "path": "RMQ/Core/GenericSelect.lean", + "mode": "100644", + "gitBlob": "ec79f7bdc908086b1b32da0f7a1c7f22ebbc8f0f", + "rawBytes": 839, + "rawSHA256": "A228C7410792CBB98960E95888098D7967A189C6BD51E240FAC42290D422661A" + }, + { + "path": "RMQ/Core/GenericSelect/Arithmetic.lean", + "mode": "100644", + "gitBlob": "4855508e65a7b1168ab49870ad8556c8255d13a8", + "rawBytes": 7120, + "rawSHA256": "188659DFE14431FA924C60BE82D03EE1733CFC01AC5E5DB046FAB129DB4B88AC" + }, + { + "path": "RMQ/Core/GenericSelect/BPCompat.lean", + "mode": "100644", + "gitBlob": "358fe47e00c50073e52ccb18c46994b89212f986", + "rawBytes": 818, + "rawSHA256": "6E381A9CD5D679327AA67704A6F6E967A9F83DB61DCBDBD1E3E2BA8B919689F7" + }, + { + "path": "RMQ/Core/GenericSelect/DenseEntryTable.lean", + "mode": "100644", + "gitBlob": "a4d2da7e6a6897390570ad44b854c6f762f2e182", + "rawBytes": 24752, + "rawSHA256": "9AF07D6EC8A806E0F7966D3F62801989F8E7DEC84A20C245A9A80555F0655EAB" + }, + { + "path": "RMQ/Core/GenericSelect/DenseWord.lean", + "mode": "100644", + "gitBlob": "618fcc69f88be89e2a5ea7e59549c756ff460aed", + "rawBytes": 2843, + "rawSHA256": "771195F6125E8DE11C24F1F94876B620151CD4A2EA86DB3464E0C9E6E26FA728" + }, + { + "path": "RMQ/Core/GenericSelect/Directory.lean", + "mode": "100644", + "gitBlob": "b632c1770b65bf4ef4b139c433e437be340bce98", + "rawBytes": 12532, + "rawSHA256": "1B99217374A50A1DA29B9E2625D8884F89B1EF255FFF3EC643A32DA58CE246B9" + }, + { + "path": "RMQ/Core/GenericSelect/Entries.lean", + "mode": "100644", + "gitBlob": "dc70a09554c3d831ae2de40c29ab3ff8b4906328", + "rawBytes": 4640, + "rawSHA256": "AE17F58FF740414FE9DFB6DF59B1EE92D2912A26E50D0AB042DD26C813C341F8" + }, + { + "path": "RMQ/Core/GenericSelect/Family.lean", + "mode": "100644", + "gitBlob": "d2fe2f2f01bd208df25762624def8d2a7939a633", + "rawBytes": 14943, + "rawSHA256": "982BA48D8EB6EE8271FE6037BD0A84A0920AC1A5CFE6076B8800211EAA0F891F" + }, + { + "path": "RMQ/Core/GenericSelect/FlagRank.lean", + "mode": "100644", + "gitBlob": "d40802621c488d33f427b05b9de54d67a22721d9", + "rawBytes": 34185, + "rawSHA256": "25EF697C1D68E47DEAD370FFF58717279317E3BB7B5103CD9A5FD8E71896359C" + }, + { + "path": "RMQ/Core/GenericSelect/LowLevel.lean", + "mode": "100644", + "gitBlob": "b5ca40073719b7f43d03d42e9a197b04fcd8a8ee", + "rawBytes": 541, + "rawSHA256": "D80DC849E26E30EB31487C03865098CD582A62E89EEB2BCD7CAE1020AB306535" + }, + { + "path": "RMQ/Core/GenericSelect/Params.lean", + "mode": "100644", + "gitBlob": "f0030b8340bdf8f8fc00fbddd525c902d1945b11", + "rawBytes": 2278, + "rawSHA256": "05F8E4CB75A07792F6B51E5F561EE5E20EEB8F7F51EC05664CDDAF0E55440EA1" + }, + { + "path": "RMQ/Core/GenericSelect/Primitives.lean", + "mode": "100644", + "gitBlob": "430d6b28f7a2fd4868074b50d9a3a6a0cd8583ce", + "rawBytes": 39274, + "rawSHA256": "EAF0C05A429B425A40E8CC77044F268BC8FF36F8B9BB648473D6576F53DF6840" + }, + { + "path": "RMQ/Core/GenericSelect/RAM.lean", + "mode": "100644", + "gitBlob": "6143b2e670e3e52ea8bb0410c0f116d6375827b4", + "rawBytes": 111264, + "rawSHA256": "FEE4D7BE36077D93F928716E4909B4773F818CE39FDA17BC17E85E944EC2892F" + }, + { + "path": "RMQ/Core/GenericSelect/RAMStoreParam.lean", + "mode": "100644", + "gitBlob": "524d591d01fb49113f5ce05070aca9df74234d2a", + "rawBytes": 64263, + "rawSHA256": "F17C7F141928ADEA7320B3187C98F2983B34E3D95B9E6F629860AB4C1313A277" + }, + { + "path": "RMQ/Core/GenericSelect/RelativeSplit.lean", + "mode": "100644", + "gitBlob": "1d7334f67412184204726f60a24436837518b64c", + "rawBytes": 2281, + "rawSHA256": "89E4188223B34F322480147FE5EA4D57542E79A00763408B2EC45D4C80DD9C36" + }, + { + "path": "RMQ/Core/GenericSelect/RelativeTables.lean", + "mode": "100644", + "gitBlob": "cf79740ad57e99750245bd1afb2547c015ae5fd5", + "rawBytes": 59093, + "rawSHA256": "7131A37475059E917D114531BA34726E1C34432BC9DF271D56C166370DC9F1EC" + }, + { + "path": "RMQ/Core/GenericSelect/SelectFacts.lean", + "mode": "100644", + "gitBlob": "69abcd54c8c260281e7431f7a2ae1ce6e95f6d66", + "rawBytes": 11804, + "rawSHA256": "DF6E9CB61E7FEEE0659B62960379FB8CD851B6BD914347A2D3BD06785CF93C69" + }, + { + "path": "RMQ/Core/GenericSelect/SelectSource.lean", + "mode": "100644", + "gitBlob": "e0834e880f064703ecdc4fbc9c8f2de3ed36187e", + "rawBytes": 1220, + "rawSHA256": "222526C0D6D8AD56EB1E4FD5678111471961A6D3674614790BD5ACE58098D57A" + }, + { + "path": "RMQ/Core/GenericSelect/Slots.lean", + "mode": "100644", + "gitBlob": "497af76a21b762d2a87e55293fc25ec9b1e34bab", + "rawBytes": 44242, + "rawSHA256": "AE96B766A1D0CF34CE468B3EE9C9FDF82195AE25FA4ACA41E150AE426FA59051" + }, + { + "path": "RMQ/Core/GenericSelect/Source.lean", + "mode": "100644", + "gitBlob": "88bb4ce92623fdc5db9f69de83706910710d9cbd", + "rawBytes": 105875, + "rawSHA256": "D1A404009FB648D1F256AFB0EFC396594C00B6E0EC85192F978B16BC0F08932E" + }, + { + "path": "RMQ/Core/GenericSelect/SuccinctSelectLegacyNames.lean", + "mode": "100644", + "gitBlob": "76baf3b2d1231a390ef2a9c819946a08189ee0ed", + "rawBytes": 1492, + "rawSHA256": "B35DF308CC58F983D936656E5546E4F3F8328A61EE4C0466546351C289754DB6" + }, + { + "path": "RMQ/Core/GenericSelectBPCompat.lean", + "mode": "100644", + "gitBlob": "15f8de2b5c4dba9092ccecea79a131dc170de41c", + "rawBytes": 248, + "rawSHA256": "0096C7B78A76989DA01890B14D0DA27FCE77C507C98470A50D99A3A8BE8350ED" + }, + { + "path": "RMQ/Core/LCA.lean", + "mode": "100644", + "gitBlob": "e86dbb789225380edd59586ffb1f81b4d5a84333", + "rawBytes": 117400, + "rawSHA256": "E981D40A5C3429A6794BD7857AEB01A0B49653F869C1139232AFB8766F1B053C" + }, + { + "path": "RMQ/Core/ListLemmas.lean", + "mode": "100644", + "gitBlob": "3ab20ea828a62409ec2516003cc39c9b5510f9d0", + "rawBytes": 313, + "rawSHA256": "E4DF7A2D19754BC5BA77BA05235EC72E839DF226B00D4A38BAEB452B46ECA1FA" + }, + { + "path": "RMQ/Core/LowerBound.lean", + "mode": "100644", + "gitBlob": "4b308477d25958476ff640ae5cc1eda1b3df7333", + "rawBytes": 12042, + "rawSHA256": "FEFE56A46F206F5233C7E4B9EDAFC6BC1FA5CB0E04B03494FB94D9D0DFD6DF56" + }, + { + "path": "RMQ/Core/Microtable.lean", + "mode": "100644", + "gitBlob": "f0e39fe25cad9b55bdac752574bac6d70970aaa0", + "rawBytes": 19165, + "rawSHA256": "7AC16582B05226A39314CB12CF4032394BCC9802E01867697E1271BBD9C21A80" + }, + { + "path": "RMQ/Core/ModelHub.lean", + "mode": "100644", + "gitBlob": "bf6c5e4300c8d3815814f5ff468da5385a03dae1", + "rawBytes": 464, + "rawSHA256": "2C91A59EC51E3EB161AE15D288047E1F3F38BC06477E085BFBBA2F906FD200F4" + }, + { + "path": "RMQ/Core/PayloadLowerBound.lean", + "mode": "100644", + "gitBlob": "a00aab777e13c1f7d67e893508f78d74b31cb73c", + "rawBytes": 12120, + "rawSHA256": "24523EC8D3DD5859738DDBDF69BCC14C41FB0E21D7175ADDD494072FFF1BCA55" + }, + { + "path": "RMQ/Core/PlusMinusOne.lean", + "mode": "100644", + "gitBlob": "29e44ad0a9c66950a2a6ddfbc1a42687aaac2d75", + "rawBytes": 14979, + "rawSHA256": "F66CFC4256FA0F3806E4C64EB3DC530E9675A86F3D1C3082AF349DFA9A3F74EF" + }, + { + "path": "RMQ/Core/RAM.lean", + "mode": "100644", + "gitBlob": "6c9a930e494d4c2112a6bd7dbd6aa95abeb0295b", + "rawBytes": 10331, + "rawSHA256": "208E621844CA2A0F5CA73312B3C5688406AFD330EB753506987DAB603AADEF4F" + }, + { + "path": "RMQ/Core/RankSelectCompressed.lean", + "mode": "100644", + "gitBlob": "e609b2f644140f270d1875020f323dfbf9ac345d", + "rawBytes": 360, + "rawSHA256": "11D0D018293C63D496D63AD37894FBBCA663F27F3CFD30A4EF1EFA09D0DB3160" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Base.lean", + "mode": "100644", + "gitBlob": "22ab0b7d6c41db5320c3d91e6a007f7538681fcf", + "rawBytes": 827, + "rawSHA256": "36CB6AD2FECCE3695A8E0F87320242FBAB50D20FCC42EC0195CC51D57EC75462" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Base/ClassLengthEnvelope.lean", + "mode": "100644", + "gitBlob": "8651d57e6b4262fa5ac4546f84e4ecf38688d168", + "rawBytes": 153950, + "rawSHA256": "2AC9C81E77D27600B7644A1BFA17ED953C137F02959A1AFE527A559835BC48A9" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Base/Core.lean", + "mode": "100644", + "gitBlob": "3cd18bfd1c25963d345fbdee25e005e2eec06c55", + "rawBytes": 550, + "rawSHA256": "AC0DE53341B4D67BECE40494CA9A9416A36038CBD129DD0A1E1EA05F6835475A" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Base/Core/Auxiliary.lean", + "mode": "100644", + "gitBlob": "cc18ceacf6a66be1c6d2d75980679f6dcdd81348", + "rawBytes": 69320, + "rawSHA256": "CCE12C6C94E7EBDFE0FB64F708A16BCD2B84D0F2A2C809EE8BA6CF1C7EC424D0" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Base/Core/LocalRRR.lean", + "mode": "100644", + "gitBlob": "9496ba796fad7a2aadd7f98f97f0d93b77ca97cd", + "rawBytes": 59358, + "rawSHA256": "50F1D1031DD10306E438F130B1BA5E5D2F253897C8DDF27953FF770D17DBCF03" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Base/Core/RouteTables.lean", + "mode": "100644", + "gitBlob": "577f926ab19d6689054059ecd0e1b03eadc4a758", + "rawBytes": 49233, + "rawSHA256": "3ED334F08EC484BE5EEC2C012D67B6A306A505C9F0910C843A9A6C0D7106B31E" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Base/Core/TableBacked.lean", + "mode": "100644", + "gitBlob": "d975ef5eec7d5a381c053450bf3a0cbace0677da", + "rawBytes": 16926, + "rawSHA256": "60E223DD682C54C30D901467314C2E8F2D7B98F52CD8D33CFFE88B3D887F40F7" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Base/DecodedRoutes.lean", + "mode": "100644", + "gitBlob": "8d06a25419649be8d5c658a9e34444bdbaf73d2a", + "rawBytes": 67525, + "rawSHA256": "FCF7FFDF75AE228285F008EBA348B62E76A077BFBE390126C1F9B561C6B99EC3" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Base/LogChunks.lean", + "mode": "100644", + "gitBlob": "94b2467a07ae01c0d3077ad61cd54961d8ed96f1", + "rawBytes": 46397, + "rawSHA256": "339E8D1A5F129BB37B21FC8BE317CE95889BCD9006D6FEC6356185192023AC42" + }, + { + "path": "RMQ/Core/RankSelectCompressed/FixedWeightCodec.lean", + "mode": "100644", + "gitBlob": "e153398d3d9587948b2e34994eba6bfad3201bb0", + "rawBytes": 24068, + "rawSHA256": "8A6448A5E6FED38C083C2D6A31D5F052779BA4A010C965D75E8BFC38D28220BF" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Readback.lean", + "mode": "100644", + "gitBlob": "a7a40db75b200737879a6dc09bd6108274167493", + "rawBytes": 27080, + "rawSHA256": "DD8432ABDB30B392AB4AFBA052017850E3364ACDD936D9AC0813C52B10250BD6" + }, + { + "path": "RMQ/Core/RankSelectCompressed/TableRAM.lean", + "mode": "100644", + "gitBlob": "b3b08991fede6db7fde13baca0367df234e7089e", + "rawBytes": 85137, + "rawSHA256": "F14EA19D2F1BDC5140AA3A95D62C02188783BC57D66DC96D0D133A3143DC8B0B" + }, + { + "path": "RMQ/Core/RankSelectCompressedSplit.lean", + "mode": "100644", + "gitBlob": "f6abb9d96c94ea64613f74c0433dc998e9910e65", + "rawBytes": 59934, + "rawSHA256": "4D5001E41E3BA858364FF364CEC7141694B000E27BEB49C5EBA2CEAFB1E60A38" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLog.lean", + "mode": "100644", + "gitBlob": "467c8aac4109a2bd257dd8f7133fce8654f5bbd9", + "rawBytes": 107461, + "rawSHA256": "8375A9291724F3CD2D1CED79BC2D0CEBC647BA4F31697D29C0AB7B4FA777AA42" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogDenseWord.lean", + "mode": "100644", + "gitBlob": "f4db180de198d9fb24403776b5b4d7b59bd16d3d", + "rawBytes": 37815, + "rawSHA256": "AE50D15C00085E4CF939493556D9EDC36FE968F3578AEF69D563419DF93677B6" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogDirectory.lean", + "mode": "100644", + "gitBlob": "cdc590a21c0f9d56b6f6fdc9d915c07afdd52b55", + "rawBytes": 14899, + "rawSHA256": "D103BAB037ED5384E9AD67A7C75C1413CA12E69DA133D9DDCE50B504421A1269" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogPackedClark.lean", + "mode": "100644", + "gitBlob": "3a217cfe12c7b35da0c4e8cf370ac0067988035a", + "rawBytes": 22634, + "rawSHA256": "6680BC3363BA3FDD53CC969009A01C4B3798087D8EAC6625FA5F8259E12C3482" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogRAM.lean", + "mode": "100644", + "gitBlob": "7caa006d57460f179eaecd9cdcdfcf4c05bd8231", + "rawBytes": 693, + "rawSHA256": "4E88202592D1D079AA9D28C42791BBF6465F25B0B8FE7354718D1780A31F5BFA" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogRAM/AccessRank.lean", + "mode": "100644", + "gitBlob": "8b27619a1027a8431d92efddd4fb7d1098a6d5c8", + "rawBytes": 39877, + "rawSHA256": "3534BAAA57F6F89890190A834EC525DE855F7E5386D39BE34E84E6277ECC1914" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogRAM/BoundedProfile.lean", + "mode": "100644", + "gitBlob": "368fc337f12cd550ba386228aad635850e563003", + "rawBytes": 30376, + "rawSHA256": "252DAB632AF6357420D51FDF067D011455A8CB4D8E898D3D1432543973DA2427" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogRAM/GlobalStore.lean", + "mode": "100644", + "gitBlob": "95e117cb569058c6602ebb529dbaa7ecbe2905c1", + "rawBytes": 40797, + "rawSHA256": "73233117828F3F68E73A9C08956E72E4824081224DF65E55D3F93B2B8C2716CF" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogRAM/Select.lean", + "mode": "100644", + "gitBlob": "73e0e1d7098280b56444bf910b29d1e21c129de6", + "rawBytes": 96209, + "rawSHA256": "5FE065F75FB55FFF37BFCACE55E90BEA77AA803EF7216AEBC61E47873E130553" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogRankRoute.lean", + "mode": "100644", + "gitBlob": "33789cb8f370c331d331b3118d3db10837e9831c", + "rawBytes": 42290, + "rawSHA256": "E1DA9E164906D33E64E07896828D2C03EDC87C04C19694BF95DC52FDAECB856B" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogRoute.lean", + "mode": "100644", + "gitBlob": "8b225e804ae9de091c31b44a8ea1a133d7b0f7e8", + "rawBytes": 18358, + "rawSHA256": "350302F2CF8791098F6083D56BAEACF54E65030E0487780258CC237FACD7C12E" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogSelectRoute.lean", + "mode": "100644", + "gitBlob": "27af0637e8c7a4617d0d321192302abbd6ff3b2f", + "rawBytes": 10533, + "rawSHA256": "5B65A9ED62DA564C7E6C601EFD9134E87AF3FF82ED2C3F9B96576FCBCC826977" + }, + { + "path": "RMQ/Core/RankSelectPublic.lean", + "mode": "100644", + "gitBlob": "9c2179edebb3576efcd0c23ead4b9734328f8d34", + "rawBytes": 302, + "rawSHA256": "D7EDC9A444DF1B31DD630D149DC8CE2CFF83C1AD95ED139B3D808C1C7B7D5CBE" + }, + { + "path": "RMQ/Core/RankSelectPublic/Capstones.lean", + "mode": "100644", + "gitBlob": "7ace87b3d6e1aa7a7e0e0e0a74e335b2ebf5add6", + "rawBytes": 11344, + "rawSHA256": "09E4A34ADB9CC435C429975C40CDB8EF888C3B3D295C67D710A9BB82E4D152A4" + }, + { + "path": "RMQ/Core/RankSelectPublic/FixedWeight.lean", + "mode": "100644", + "gitBlob": "ab55aa2ca31745f3c2e70f48163b18838886c4af", + "rawBytes": 53031, + "rawSHA256": "50C7FA4C967A673A432C3154F291F5C821635B6740FF3FA6B2D86BDA7F953057" + }, + { + "path": "RMQ/Core/RankSelectPublic/Profiles.lean", + "mode": "100644", + "gitBlob": "46b3035ef581885e273b55aed6e7a2a845e84034", + "rawBytes": 127952, + "rawSHA256": "686C599B3D6854203036BDBAFBCA4655B37DA84DBF88DCB6DE5A868FAF465F5D" + }, + { + "path": "RMQ/Core/RankSelectPublicRAM.lean", + "mode": "100644", + "gitBlob": "e3339975d1c04e4165975d275c47b9d2c4acdf76", + "rawBytes": 62840, + "rawSHA256": "4D75C1AC9E941C4610555AEFE5E26FBB7E2C0CD714037A4617A2EAB32E806F1C" + }, + { + "path": "RMQ/Core/RankSelectSpec.lean", + "mode": "100644", + "gitBlob": "6d8ccaf62462655b0b0ce282e0bffd442b43c7a4", + "rawBytes": 11211, + "rawSHA256": "2D48B2089432B601337E7FDB6CF9B081D8382A44019068D5DF64FBC4867DBCD1" + }, + { + "path": "RMQ/Core/RankSelectTwoLevel.lean", + "mode": "100644", + "gitBlob": "8c220cfa8ac8d84aa69fe5607a6209f4135868c4", + "rawBytes": 10352, + "rawSHA256": "D8B45961567F50A3B679DB7CA454E717F105BCA4E931D7C9E1515E852D36BB22" + }, + { + "path": "RMQ/Core/Recursion.lean", + "mode": "100644", + "gitBlob": "dbd658aa8a3aaea0951902588e2325c74f318984", + "rawBytes": 17263, + "rawSHA256": "80ECADD010103A8197C845C285199186341F627FA266CC7B4491BFCCEB155B85" + }, + { + "path": "RMQ/Core/Reduction.lean", + "mode": "100644", + "gitBlob": "0ecc969d61e989643fb8dbbc3ec3f6d05e7a7446", + "rawBytes": 11885, + "rawSHA256": "A15808CA01F085C691CC30F73EEEB88E8AA858670D4BF0B707F2DED1AA1791EF" + }, + { + "path": "RMQ/Core/Refine.lean", + "mode": "100644", + "gitBlob": "ec8239cabaf375f3bfc214b6cc154c641403bd65", + "rawBytes": 7088, + "rawSHA256": "75953F297DE26411AF75EA9BE3CDBF2FD6D0403EE0AE88E3310DDCD5ABBBEB2A" + }, + { + "path": "RMQ/Core/SampledLayoutBudget.lean", + "mode": "100644", + "gitBlob": "e58a66eb35ef0936413b31ee3ad8736c87dbc136", + "rawBytes": 4929, + "rawSHA256": "B3F7627EF1903C5C590A405146C53A5B07469D5E45D59CA5A56D097FE07CD4AB" + }, + { + "path": "RMQ/Core/Schedule.lean", + "mode": "100644", + "gitBlob": "fcced7cb3c1047680835b2abce5f872d82112f3b", + "rawBytes": 1629, + "rawSHA256": "7361D7F853F3DFCE417A22B3BA4703D032E21F3F8789A8A2065E2FDD1EA847AB" + }, + { + "path": "RMQ/Core/Shape.lean", + "mode": "100644", + "gitBlob": "61ed0680524d79d62b059a447638f9ae944996f9", + "rawBytes": 72219, + "rawSHA256": "A29366B989E786A5C762764C2DA1FFC9DF1487BE212A113A122384D9A1E2C863" + }, + { + "path": "RMQ/Core/Spec.lean", + "mode": "100644", + "gitBlob": "603ca44bc712453e67d902798e74a78b702520e5", + "rawBytes": 8783, + "rawSHA256": "D32B9EF9873E9C9D8E2AEFE1227770F2B565122FAE01C0AE86737FA750F74AE3" + }, + { + "path": "RMQ/Core/Succinct.lean", + "mode": "100644", + "gitBlob": "b460c95c2bf20dc03edeab6d265a88d8c0d057c4", + "rawBytes": 51368, + "rawSHA256": "C81AF4978110198561B109893832045509D8C8846CF2FCB179C809B5BA67E74E" + }, + { + "path": "RMQ/Core/SuccinctClose.lean", + "mode": "100644", + "gitBlob": "8ee061df2db2a1ba62edd7511ec3c9ec60d4385b", + "rawBytes": 560, + "rawSHA256": "D0DCF4A2D323A65FE03D901AD6C37189281522A75DF01447B2C9CF9FDE56718D" + }, + { + "path": "RMQ/Core/SuccinctClose/BlockLocal.lean", + "mode": "100644", + "gitBlob": "569a5cc3c03291b3a3cc5ff0e5217932bf95ba96", + "rawBytes": 37150, + "rawSHA256": "818D93BC4665385FD6F5E45431DFC783E1A1D0860DCA35DCB9B75EFCDB5F0B62" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe.lean", + "mode": "100644", + "gitBlob": "458aa665971c7c7cffe71f26d48f3de64623621e", + "rawBytes": 332, + "rawSHA256": "47F178B980D4386FA297A3BC8352F5D8FFD73AE9CA5C8E5CE8C5994FAC04F6F3" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/EndpointMacro.lean", + "mode": "100644", + "gitBlob": "34089d1d97e38401562fef7d6699888830fc1d8f", + "rawBytes": 340, + "rawSHA256": "466D70E742C3B92EE02833F796B1776DDFC3BEA4CF487F0EB2F1734B48005732" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/EndpointMacro/MicroCodebook.lean", + "mode": "100644", + "gitBlob": "38329d0ad318d0ac3bd93d2803b32a8d5c4a9674", + "rawBytes": 67344, + "rawSHA256": "3E9DFFFD9C463376798509E1E88919A47EA52C39D7DF18D8369996954929BF04" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/EndpointMacro/RangeMacro.lean", + "mode": "100644", + "gitBlob": "40b4e597a0fa852cfa830f4ad71348cc20997da1", + "rawBytes": 326, + "rawSHA256": "F9E7C1471B2167BDAF3D049E187224E27AAB87971C3404C5F17298C55E0A99D9" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/EndpointMacro/RangeMacro/Concrete.lean", + "mode": "100644", + "gitBlob": "0e3f3210b373d23d4be91110331678bebcbca06e", + "rawBytes": 11573, + "rawSHA256": "1A72C3A22D9EC67B1F7D728E4E369E0AF4CC33384C8922583A971CA4224E74B2" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/EndpointMacro/RangeMacro/PayloadMacro.lean", + "mode": "100644", + "gitBlob": "1d699ea46e1c0b615a8e680572994b2f82cc4d66", + "rawBytes": 104028, + "rawSHA256": "9FA35FD83C7F46FBA374B549AE1F85F2733A2409FFB03B9CCBEAFCC6510CD08B" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/EndpointMacro/RangeMacro/RangeTables.lean", + "mode": "100644", + "gitBlob": "8e0b0bc90120bfa202a46739c3cfc6c9da91dfd1", + "rawBytes": 14161, + "rawSHA256": "C036F7B736ABF755A8B8D9B1A02CE5810AD441CDAC7F546993F8D5B5AF63F041" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/EndpointMacro/RangeMacro/RelativeMerge.lean", + "mode": "100644", + "gitBlob": "8f06664a417869aac1f4733bc3a24dcf86683f35", + "rawBytes": 3278, + "rawSHA256": "ABDEAEBF1C169C5EDE34EF2323C2C942D26C8052BE68C6E1E21D2FE0A86C09EF" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate.lean", + "mode": "100644", + "gitBlob": "5ca201264fc579ddcf4fdb1f1e96f2656450fa3b", + "rawBytes": 365, + "rawSHA256": "948813C73489C2642729997DC9AB448EB8FCFB70966A9F6307783F4DE5434BCC" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/Candidate.lean", + "mode": "100644", + "gitBlob": "e067e2942b2e845c872886763c774a430ed029ba", + "rawBytes": 18447, + "rawSHA256": "C843AABE9ADCA16A463EFC1307CF629604470E8847D3591131EC29784D4C6D83" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/InteriorDirectory.lean", + "mode": "100644", + "gitBlob": "6d74a5b2a8e982ae5e3d109657ece0b849c9642b", + "rawBytes": 512, + "rawSHA256": "92A2322E6DD91D8D2718E65F52B5DAC2572C142297501F0DF3882BF84534BC16" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/InteriorDirectory/Base.lean", + "mode": "100644", + "gitBlob": "89e5bda6d58ebf50e115591781fb84f8d7717b23", + "rawBytes": 197085, + "rawSHA256": "65522F59E57BE29618BCA88A624F9A867C8DE02469A42C526B48E087751391A1" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/InteriorDirectory/SparseLevelWidth.lean", + "mode": "100644", + "gitBlob": "b7826b9550926e5f60fa1c482c195cbf88180202", + "rawBytes": 98312, + "rawSHA256": "9902C625271049BC410B6CDE11CE8212A7451CD483133D90B199E87225F87875" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/InteriorDirectory/ValueDependency.lean", + "mode": "100644", + "gitBlob": "19a52aca2b9587c515cbca9a96c78f666ce32ac3", + "rawBytes": 57308, + "rawSHA256": "B10110A3A0231D1FAD754A830EE0397A55ECB894C16B0864B6DD8A0B6F607D2C" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/InteriorRAM.lean", + "mode": "100644", + "gitBlob": "4a14369e2544e5fee6537b1af15bc939688d2326", + "rawBytes": 138383, + "rawSHA256": "E6850BE91B2120958019452EE26658AB2AA13CDAFD42BDDE649B6BA177EFD956" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/LocalGlobalSparse.lean", + "mode": "100644", + "gitBlob": "ba73eba0435506a003eb8171f2c583b46a3fb887", + "rawBytes": 62216, + "rawSHA256": "B2A3B8866E5FCB52CC5A0884B22AFBE6DE2B74C92CED3D36B6F5C1CB8D29EFA6" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/RelativeScan.lean", + "mode": "100644", + "gitBlob": "398eab70ba29652f9b277543cc3dfbac7a0ab143", + "rawBytes": 19800, + "rawSHA256": "AD29744DA234215194478A2D8D0F2BF31FCCA119E5E9C9554A11970F2C9E0B21" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/TwoLevelCandidate.lean", + "mode": "100644", + "gitBlob": "6878e676d40435e66576dc18f81b5e09a6a88776", + "rawBytes": 30465, + "rawSHA256": "6900B5DDEB67DF79BA9A1A2B39682FEFCD9EA975E2E408ECD8291316748D15A8" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/WordReads.lean", + "mode": "100644", + "gitBlob": "021cc54525f70430c4674b5647a5c53390fbb37d", + "rawBytes": 21966, + "rawSHA256": "995F2E38D1F5C43FCAA1E4815FD2235EA481F7DBDCFFE3738EB5CFF7BACC37F6" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/PrefixRange.lean", + "mode": "100644", + "gitBlob": "951d7577d4c570889876a04d516e57c45815cb95", + "rawBytes": 361, + "rawSHA256": "A0FED5EE46F3152D63EF42F8791D802FA34CCF8AE9D4A98A3288DF1425302B0D" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/PrefixRange/AnswerSemantics.lean", + "mode": "100644", + "gitBlob": "e6b9080d609b8d54ca9bc056365ded1d4051c7b1", + "rawBytes": 38669, + "rawSHA256": "148B0E1DB197AADFD8F0927A82A89195D5F066F98B8BFF31C92718DCA1D66A9F" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/PrefixRange/LocalSparseOffset.lean", + "mode": "100644", + "gitBlob": "583fe8753c3a91d74ee1d15df25a77282eea79f3", + "rawBytes": 23523, + "rawSHA256": "717A2514A0255D9994D780C87E0BA952D193EE791EFFAFF440D194438765B82D" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/PrefixRange/PrefixArgMin.lean", + "mode": "100644", + "gitBlob": "e268cad4f307f063a6e39181e05282cba91dbf26", + "rawBytes": 19463, + "rawSHA256": "02EAC18E6679B60A7A78BA101C39E3269C18EAF8202178B3C0335441FE548CAD" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/PrefixRange/PrefixWitnessTable.lean", + "mode": "100644", + "gitBlob": "bd8dda3d4b12d29c9d9c32f9196c52203ea4618b", + "rawBytes": 11747, + "rawSHA256": "07538D0E27689BCB02915F5101ED158B5258A168ABB172F35DE0CF5733C2B56B" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/PrefixRange/RelativeSummaryCandidate.lean", + "mode": "100644", + "gitBlob": "2cc25fc32a01faa71ec17aafd5ce1b83a9cb7891", + "rawBytes": 24349, + "rawSHA256": "4092148FDDBF60A1F481128DC96EFFB2FABD121CAD14F8EAA0142DDF6F30ECAA" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/PrefixRange/SparseArgMin.lean", + "mode": "100644", + "gitBlob": "d8b7cc5835d0c4500800542e8c5aebd35b589c01", + "rawBytes": 26488, + "rawSHA256": "BD98AF45F9D43B75768E23013EAEC66400850215124102C7720BE4CA115A774E" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/PrefixRange/SparseLevelTable.lean", + "mode": "100644", + "gitBlob": "442916dd0d855afedf97f6017e8b34852462c5f8", + "rawBytes": 10643, + "rawSHA256": "15E23994297D09D37CABDCFB2277BC8F819FF76C307636AC6E3889C1B7E61043" + }, + { + "path": "RMQ/Core/SuccinctClose/RangeSummary.lean", + "mode": "100644", + "gitBlob": "3a7d2c6565961a4df9bbc04d8b5bc8b600a54f6d", + "rawBytes": 40726, + "rawSHA256": "4DBE30022D3066FB44C1405D2C52FD8D4469537B6DE0C589DB6F99FBABB9A7EE" + }, + { + "path": "RMQ/Core/SuccinctClose/RangeWitness.lean", + "mode": "100644", + "gitBlob": "e8d520c51bf1d0499d6b1e7187e4cb7b18833313", + "rawBytes": 53161, + "rawSHA256": "4A9EF0FAD0B84ED02F55A1313353375F5159322DA5B159DBC6081E8781F378DC" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro.lean", + "mode": "100644", + "gitBlob": "0ebcb3785a41601599b63b4c16236b0d9f88afcd", + "rawBytes": 421, + "rawSHA256": "9F55F443ED0234E9C509664F31CC90884C455C2783491FDB6EBA058FDFCD27EC" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/AbstractMacro.lean", + "mode": "100644", + "gitBlob": "f63c676eb883768f42e5432b28ffc9a6dc552bc8", + "rawBytes": 15565, + "rawSHA256": "4A368521FB415863E5FD77A7B0F4ED83CBD49983DBF4A7CD4A2B6921A0407553" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedFringeChunks.lean", + "mode": "100644", + "gitBlob": "337c4fc4d45377dd66c7fe7cd4d5bd32cad7dae8", + "rawBytes": 82770, + "rawSHA256": "7D3C02BF0F79FF53008D322C7FB92A99449252AA1303FB539222BB4F0B75CC6A" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedFringeSpace.lean", + "mode": "100644", + "gitBlob": "b87d4da61d9c810c3e475605e42fcf5946208bb4", + "rawBytes": 3057, + "rawSHA256": "9ABA710A3CF3DD8B830A03FAFC7643D79DD30EBB97E2CEB2DBEE8A432001CB0C" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedFringeSubstitution.lean", + "mode": "100644", + "gitBlob": "9fe5a3eb571d91f005766ad73b2173fb3e38d34c", + "rawBytes": 20474, + "rawSHA256": "A76B18F22F18D2F26F60136ECA544921FC6177B55718E092D6C92A74071D9BEB" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedFringeTableFacts.lean", + "mode": "100644", + "gitBlob": "7d65c1129bb43803addbb4d3097b159258eb25b7", + "rawBytes": 10551, + "rawSHA256": "CD0E8F62E7AA6F58EFF3CB7C937F2025B98D99AF5798C7B8EC55676224670744" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedFringeTrace.lean", + "mode": "100644", + "gitBlob": "acebacbfdaeea14d8de6d8c48749a36c37c76e23", + "rawBytes": 74753, + "rawSHA256": "3958821F9FFB5FE5A3E51664ECF50191AF3BC27FEF1303BCA27565D772B61E26" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedFringeWiring.lean", + "mode": "100644", + "gitBlob": "1a8f2906dd8980e5a3ce9693a46571f3cf22dc67", + "rawBytes": 32250, + "rawSHA256": "BE36BA283C012EA66699A85AACC45D435465BD6C535F6BD142F53A231BF2C117" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedRankSelectLeafTrace.lean", + "mode": "100644", + "gitBlob": "b60987b668c0877871ba2532f19897ca768d506c", + "rawBytes": 75619, + "rawSHA256": "418AAB560F5E0A6DB37CB4D5B3245D44580BE8004ADCC3A98528DEC598B87C96" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedRankSelectLeaves.lean", + "mode": "100644", + "gitBlob": "48ed35549651e348dd1502afb76b6aaf5ce6c66e", + "rawBytes": 29199, + "rawSHA256": "4964AD5844644F486DF44F75ABC31862DFFD3BE4A507B503E120A615657BB418" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedRankSelectTrace.lean", + "mode": "100644", + "gitBlob": "8c068a82ac6e13bc730681d1f078847bf1972e9d", + "rawBytes": 29916, + "rawSHA256": "D22D91D49051A544BC511FBB7D0663069323F41BAD782B092B147185707FB595" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedRankSelectWiring.lean", + "mode": "100644", + "gitBlob": "a943e146c835d31a5155737dee16d32fabcf96a2", + "rawBytes": 47685, + "rawSHA256": "E4CB679DBA4B995B33C411A7FDB49859C4DDA0B2D4402ED14C8F673F072D9570" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedSameBlockChunks.lean", + "mode": "100644", + "gitBlob": "aaa722b010cef2771317068ced8e16557af7f4db", + "rawBytes": 12425, + "rawSHA256": "F3E233EDD10FC8DE7098ED037A3A173A3096FB026043F6F81E9AA83F09D34470" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedSameBlockSubstitution.lean", + "mode": "100644", + "gitBlob": "4057bf9cfd07a629cf2772ca6984f442b3837841", + "rawBytes": 9052, + "rawSHA256": "CAA29118F8302CD07D50B7E824AFCC30A31C58991446DE9AF841CA99DA7B8C77" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedSameBlockTrace.lean", + "mode": "100644", + "gitBlob": "4ef06fd441d354b64d2da5f679cb6485c7d7a36b", + "rawBytes": 28767, + "rawSHA256": "F68059B658962AA7D00942DA93B27415B19D2D04A9D6E5A1614706A914D37373" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedTableRegime.lean", + "mode": "100644", + "gitBlob": "d6684eb8056439c13952a82b6cb6082dc3e4971d", + "rawBytes": 14583, + "rawSHA256": "5988A169FA0AFF43326E67252A63FB2C714AD4B2716A0D0F042E409027D38A08" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedWordChunks.lean", + "mode": "100644", + "gitBlob": "8f90421bcd0ce9c9837dab054b49fbdfe30a01af", + "rawBytes": 52061, + "rawSHA256": "32AFF7472532A2CD3FDBD8DEECB92148466ABBA6780CEAFF695BE52F83F467C8" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/CompactEndpoint.lean", + "mode": "100644", + "gitBlob": "bbff25d0a619aa246633377df0af032e4b837aad", + "rawBytes": 24687, + "rawSHA256": "383F30B3C6662F9C455632E6AE96F5935ADCA6EB65D25642676139DB08681761" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ConcreteDirectory.lean", + "mode": "100644", + "gitBlob": "895e3ae4f2c67e5eeee01ff85e6b658dbdb50d7d", + "rawBytes": 104087, + "rawSHA256": "823081F1FF979F77970BA2477CD9F9F5BB6E1255EA15129C061B726BA62CB7CE" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ConcreteDirectoryRAM.lean", + "mode": "100644", + "gitBlob": "15d6269a84fd881fce67bb18f5eb89421c926369", + "rawBytes": 179195, + "rawSHA256": "0CED594DE17F432C8FDB3BBDFF926FAF26F051BCACE6B9EB5040D70A91172E49" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ConcreteDirectoryRAMStoreParam.lean", + "mode": "100644", + "gitBlob": "3ad2cb80ea2286de321d1f174d12e0ee913bf4f4", + "rawBytes": 215174, + "rawSHA256": "074AE2026220430F9B6D00805FC51BA46917C8C0C50FD599A777245E029CC31E" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/EndpointCodebook.lean", + "mode": "100644", + "gitBlob": "c626e0488bd823c04db0105bf7890c5a0d269978", + "rawBytes": 53366, + "rawSHA256": "5029E982326AB8DEA8D0E0F22B0A29081F2D802B2C78770E5D7584158BDB66A7" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/LocalBPDecoder.lean", + "mode": "100644", + "gitBlob": "faa3508bc4cd4f0d8c17bd3a1a053e25dba3237a", + "rawBytes": 108893, + "rawSHA256": "54CAD93011FDA3A464BE6F93D102332A375712E3993E4A8380D88EDDBE5F5B8A" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/MacroMicroFamily.lean", + "mode": "100644", + "gitBlob": "d2307e9ccf38c3e0b99460c7ec3e8c95660f82ee", + "rawBytes": 38377, + "rawSHA256": "9D3CEED171681840D7A81D65E2D6507AA1C8922C4A268DA9EB4AB0253C01E642" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeSummary.lean", + "mode": "100644", + "gitBlob": "da0cefdd39bace8e0df283f1724e58eef71ed8b9", + "rawBytes": 181993, + "rawSHA256": "14346D7A6E5C881DA559C423A53CE82170EE2A78D77F7ED31282671504AF034E" + }, + { + "path": "RMQ/Core/SuccinctCloseProposal.lean", + "mode": "100644", + "gitBlob": "156bd6b2cfa097f0ca2aa474ddd6369fd0a06246", + "rawBytes": 37352, + "rawSHA256": "CFF28161C7CDEF76F9A9C4B2164F101DE8702CCAE68312DC7DA0CA36E47C3BAA" + }, + { + "path": "RMQ/Core/SuccinctFinal.lean", + "mode": "100644", + "gitBlob": "dfcc8f94113a9e2a11682d603aa0481d9e7f4e27", + "rawBytes": 112899, + "rawSHA256": "372A0C59D175950DC6111ACBD1E6E71FF8B913B2738912220CCB17D4C08BCFEC" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/AnswerValueDependency.lean", + "mode": "100644", + "gitBlob": "bd1b0038ef759d56c0535e90e5458e366937873d", + "rawBytes": 37376, + "rawSHA256": "98337D3B6531ADC12573115FB89A70A37C73135D0E66FAF8777A9EBBAC691F6B" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/ChargePolicyDependency.lean", + "mode": "100644", + "gitBlob": "c94c4983db7afa7b34705e9d1572a5f073b15a15", + "rawBytes": 7656, + "rawSHA256": "963C8592FF3ACE70EB6F32367B1367197608B0C52C94B78D8CB645A33025B443" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/FlatPayload.lean", + "mode": "100644", + "gitBlob": "abecf3e426f2672be5abe200d8fc55c50a61ae66", + "rawBytes": 114145, + "rawSHA256": "104480BB2E138921504FB96DEB7153D11B603DFA4085FA1DDE36B274244A07C3" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/GeometryClosure.lean", + "mode": "100644", + "gitBlob": "38a83b01367b56e5ed6e639efe5b96b1960f9ac8", + "rawBytes": 78203, + "rawSHA256": "67907F202156D3D0583041E4508D3BC33A57623598CB59A57407C41B02D3DDCB" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/Address.lean", + "mode": "100644", + "gitBlob": "ebc70588aeaa33d3acb15aef4d2dbba378589ce2", + "rawBytes": 3578, + "rawSHA256": "6E8F3EC58E4A1C7588FF98C425CE71098916932C5E8ACC26E244C8EE5426A119" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/Boundaries.lean", + "mode": "100644", + "gitBlob": "8914eb883e911674243db83f287d573cd8f562a1", + "rawBytes": 16584, + "rawSHA256": "CCF5D924505569FE557DB6BF3B6974ADA7322393C215656AB0D48DD35C5C5BEF" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ExecutedUniverse.lean", + "mode": "100644", + "gitBlob": "c8158a39d161b6941804c5b0287f835f6dd8ca01", + "rawBytes": 13274, + "rawSHA256": "F2A04D822F298BBCEBDF7D00CB27CD8E8CD5D018B3B888D23662FEB133A194D3" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/Header.lean", + "mode": "100644", + "gitBlob": "7b7e7d04457b10a1b73ee1ae21e7cf8fd1e5587d", + "rawBytes": 10048, + "rawSHA256": "2711A6F855F3A6D83C053B7C32C0A42F4940793266A44959FD804D9886644A2D" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/Memory.lean", + "mode": "100644", + "gitBlob": "a6d761a0d22a890996cedb8ed0a179544e356363", + "rawBytes": 11186, + "rawSHA256": "64F8BF4F8FD67CE1ADA3635CFA5608BE6F9235CBF3A502342C475E65A1EDDEDE" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/Payload.lean", + "mode": "100644", + "gitBlob": "e3b05f37485fdd5e846d1cb0690bc93fc166dfc9", + "rawBytes": 3060, + "rawSHA256": "500E2ADE7D46B6F9C884EBE06D19C031C1CFE7A75852150E3EC50C449CA54808" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/PhysicalRead.lean", + "mode": "100644", + "gitBlob": "4c7c769d3e78c70cd88bf8cd5dfd324a55cd3c7e", + "rawBytes": 20896, + "rawSHA256": "BB56CEF34E6E743B4CE522AFB8C85882D992E0C6C2128EDEB5C71970001724EA" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/Probe.lean", + "mode": "100644", + "gitBlob": "61fce2cf25b936c5d64b446e3159285d823d4a26", + "rawBytes": 36670, + "rawSHA256": "34E468F86DD5C6A35C83B4A5B36E9E217F4661CD94BA219709001C207473709B" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReadProgram.lean", + "mode": "100644", + "gitBlob": "d79bc285b16c4bf26708d2239730bc919479e9f4", + "rawBytes": 109273, + "rawSHA256": "391D87D69679A4D9A263AF6193DFDD1DF0979541C8B5805569B6215E3998BE15" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerArchitectureCapstone.lean", + "mode": "100644", + "gitBlob": "0ff047d065b64bb1ad7f1076b014d31f233cfe36", + "rawBytes": 45254, + "rawSHA256": "4B0BA7708F943095D030448F3FB5B439AFEEFDE0155CF4DD15F037A48E33D7E1" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerCapstone.lean", + "mode": "100644", + "gitBlob": "fd70769b0e7440d6a39dd2c969a40d1a0d8d3441", + "rawBytes": 147820, + "rawSHA256": "81EEA178FCA3BCA16139111DB452247ADDF1CDF1F823164D693A9080558C2394" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerCloseGeometry.lean", + "mode": "100644", + "gitBlob": "f947fbf9bcb771769babd6e44d94ea637aea8b64", + "rawBytes": 6388, + "rawSHA256": "B0828658CBD2453B7BC4178EC859D9C9C77006899C3B20195131F6CA8D8C270B" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerCloseRead.lean", + "mode": "100644", + "gitBlob": "91af3069b59c18350b04a8fa78eea04a5f3c77f5", + "rawBytes": 25600, + "rawSHA256": "E3377018D62A378D745B2402AE46BD61382A10D7F6B490727659E6F0724DF399" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerCloseWidth.lean", + "mode": "100644", + "gitBlob": "b8c35e4f11885d78d98697223105f935d8e71c55", + "rawBytes": 9430, + "rawSHA256": "E69298E7D3C8167609C2D74387D5482198F9A6CB783955BB6C6FF0F5BB20768E" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerClosedGeometry.lean", + "mode": "100644", + "gitBlob": "18ca8fdaae1cef137138d1f48ed864c30f7d18fd", + "rawBytes": 21018, + "rawSHA256": "3F97100E132680EA8F901884AA383532031224F99DEA4255AB807E8E20B677AE" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerComponentAccess.lean", + "mode": "100644", + "gitBlob": "04881332b811821d2846d80c027281b47982dee9", + "rawBytes": 26856, + "rawSHA256": "35DD259730F4861FA6A3B7CF01AF9E9C5B8D4BDB2F0F2F2C214236B7D7585336" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerConcatIndex.lean", + "mode": "100644", + "gitBlob": "af346375821b8054cbc818a9c3b8d17eb2f8bfe2", + "rawBytes": 2676, + "rawSHA256": "B7417D93358DED4340DF33CE8A04C4C4C925E54937789CE214488E0C940504D7" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerController.lean", + "mode": "100644", + "gitBlob": "bbd7a6b591a02a8674711a4b1aba44f272437b3b", + "rawBytes": 18511, + "rawSHA256": "AD9943085CF3E19D2F72129D5832AF1894C183229CD468DC6EECDBEC06572C4C" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerControllerAtomicStateProof.lean", + "mode": "100644", + "gitBlob": "57f72f0fd426bd60288c273b5124194363c55e85", + "rawBytes": 80787, + "rawSHA256": "32F77AC4A2E5CD72610FFB19D2F120AA9250D6F22F44A0CDAE825CC5238F8CEE" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerControllerInteriorStateProof.lean", + "mode": "100644", + "gitBlob": "a86164d6d74f777e78ff6dd7e49a334821ef57be", + "rawBytes": 169358, + "rawSHA256": "04C50199443EF903CB2A0394B47DF18CDBC2FCE75893FFD33B34CA0817C95064" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerControllerProof.lean", + "mode": "100644", + "gitBlob": "5948c993ad3ea8d877f524b1248c3f50e302eee1", + "rawBytes": 267859, + "rawSHA256": "1225A5D847B0F3D4D9653A51DFAA39A51A744A13D524261236286FC98E993401" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerControllerStateProof.lean", + "mode": "100644", + "gitBlob": "444998dad04b49577dc4eeef976dbb6591894a4b", + "rawBytes": 666290, + "rawSHA256": "1370F7C9761438A5A552B7D14AE408F680C77A5FEFF90F8BA96ECFE904CEBF58" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerCrossing.lean", + "mode": "100644", + "gitBlob": "c7153e9b189d8b8d4f18752dce746780f4a999bc", + "rawBytes": 6949, + "rawSHA256": "003BE10AA05F2B025F83ECE30EC7A91A4F092CA9179B5FF2EF33CEB433A2AE28" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerEntryAddress.lean", + "mode": "100644", + "gitBlob": "c0b2838b27f82f08f95aba2060a66495802103b7", + "rawBytes": 4461, + "rawSHA256": "41E67F063A92159E64467A56FEF20828AD65E8AC585A53CF815812177B96B214" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerEntryChunks.lean", + "mode": "100644", + "gitBlob": "0d00015db8fab7b4f74fb96e4cd1090d1d8bc69e", + "rawBytes": 5696, + "rawSHA256": "9B365EF07A62FE3D989C3EDDA7119D72D765B9676C88A40FDF258D12460A4FD9" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerInteriorCount.lean", + "mode": "100644", + "gitBlob": "60256fe7847d3d4a67cf7caefe13b77e3f5ba021", + "rawBytes": 5697, + "rawSHA256": "4F07D21A9FB1C6799131C4D4F778616A60BC18CCDA0B42C4D27251663F2731E3" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerInteriorProtocol.lean", + "mode": "100644", + "gitBlob": "d2854754dc95a9e31e51dc195a241b71fedd1632", + "rawBytes": 18142, + "rawSHA256": "AC1ECA986A2411B88393C5006C89CAAEBA97C86CEBD0B4AB67A8CD958547D159" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerInteriorRead.lean", + "mode": "100644", + "gitBlob": "8e9c438fed0647458f7a1327f75793606863a0da", + "rawBytes": 67674, + "rawSHA256": "074780F3536806DE36BC094BDA66AC0448529992E5C406F85824C63EDD75B1DF" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerInteriorWidths.lean", + "mode": "100644", + "gitBlob": "e1f31da3b9d75d7e39a15c9e737fb1ae35ee7572", + "rawBytes": 4120, + "rawSHA256": "F08390B3A3C5ACF0036DAFEAD1A6384607317681C31299E7B4225971EAF43B7A" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerLcaProtocol.lean", + "mode": "100644", + "gitBlob": "dfbb331734acb2caec2ac0a93bd3dfd2ad808a59", + "rawBytes": 14664, + "rawSHA256": "B06E4D6C57BAFA21EB75F76AF099B18BB975FFACE9025F3AB5F7EA2EF8016D7A" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerLength.lean", + "mode": "100644", + "gitBlob": "f90134ab632650a472376a717a16f42da3126eba", + "rawBytes": 9730, + "rawSHA256": "3589BC63E435F307A5A6457DA7043DCA5A2AF9DD4018F615EBED4A194C1068CF" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerLogicalLowering.lean", + "mode": "100644", + "gitBlob": "2761635255e7ecd0fc21657ed9b13671ea95e97d", + "rawBytes": 17195, + "rawSHA256": "CE1F85F0181467AC28E431DF8BE90010649FDB541038278A20D29D82CB3DB895" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerLogicalProtocol.lean", + "mode": "100644", + "gitBlob": "e7ae736b75083987ba8bab9145c3b869e87b107a", + "rawBytes": 21803, + "rawSHA256": "E9169BE01037693A6893CB46E5F99E4AE8F2AA79C415F0C9D2BAF0098DA19BB7" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerLogicalSimulation.lean", + "mode": "100644", + "gitBlob": "a6cc3b1e1af37c9bd8823575a2d393b043723491", + "rawBytes": 321234, + "rawSHA256": "7F2F353F7D53ED1E0BCB0D963A162193B6C87C912A8D80D5FCC683E0BA06E5B1" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerMachineWords.lean", + "mode": "100644", + "gitBlob": "9a99e1ff78af3cef013b8d6aff6337c7629edc95", + "rawBytes": 5023, + "rawSHA256": "63AAE89D756E47255AD8821B336B3D3D2FE1607FC03C7771F2B36C6A35BC400A" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerMemory.lean", + "mode": "100644", + "gitBlob": "ef3f7d4ea754abd4c0c3546cf1b2b4d36b8465b9", + "rawBytes": 8450, + "rawSHA256": "B25D62BCBA1BFF603EE1E364B8EA355A36010906D159927AAC800EB1145179F8" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerPayload.lean", + "mode": "100644", + "gitBlob": "0159323644e76ef425870fc819603dd8edd3e2c2", + "rawBytes": 3868, + "rawSHA256": "F383AC00585EF7389C72610BA44E2941F45F6B6E9CC13AD6FA39EDDD38B4C75C" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerPhysicalRead.lean", + "mode": "100644", + "gitBlob": "1986df34c14482836893e4d7bb3e8a9edf74e691", + "rawBytes": 17684, + "rawSHA256": "4C773AD3FA0EEC82DFABBE8F142A07AD583B4DBAE9455ABFD57CC593D1AB833B" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerProbe.lean", + "mode": "100644", + "gitBlob": "58bdcf99bb16576ed803a67f411a4d6eeb039bef", + "rawBytes": 24594, + "rawSHA256": "01280EABBC2CDB4BB38E1EA22E3A55E6C64FCB9EF8AC4723D11BC26215317BBC" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerSelectProtocol.lean", + "mode": "100644", + "gitBlob": "3081c1fb9cfc055c075aa6a3e2f35b00df976799", + "rawBytes": 15312, + "rawSHA256": "6BF0867042F07B9A4B8A26EF8AC83E5144C0A533932F10EA9E747BBC010F0A3C" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerSourceAddress.lean", + "mode": "100644", + "gitBlob": "0c5dec614ce2126b39c673cfe8b61701120ceda1", + "rawBytes": 15768, + "rawSHA256": "93EB4EF3697DED2867172D7E46E690550EBFFBCBC3D9003CA83863C2115DD9BA" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerSpace.lean", + "mode": "100644", + "gitBlob": "c7057764aa6b1f8c1a82e343d9009bd13ac4003e", + "rawBytes": 4177, + "rawSHA256": "56918F51DBDE05F1B69E449A6E41E944D706A65F2423D549426A3037B2D76BBF" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerSparsePrelude.lean", + "mode": "100644", + "gitBlob": "c87a9c2b16b7c2d97aec3ac36819b9f239edbc7b", + "rawBytes": 48493, + "rawSHA256": "3A99BA036F6651EEE2A0823DBF2A6BAC365D5D6AB78A52949DDA0D480ECE8DA4" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerWholeProtocol.lean", + "mode": "100644", + "gitBlob": "5cf50ea9ff605f87dbb030434272cdeaa8d47778", + "rawBytes": 7961, + "rawSHA256": "492436C51E2CAD4EFC13AB2B6D20704492780EEDB5F2B4BD9E3213F0331E045C" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerWidth.lean", + "mode": "100644", + "gitBlob": "2fae800525e8c8369c4e5074ff62847daa53251e", + "rawBytes": 8932, + "rawSHA256": "07F0A4D08CA3A599BD1DA8D747CB7298376A74DC24D8F722B411B41AD64E16D6" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/SourceFactorization.lean", + "mode": "100644", + "gitBlob": "acf7bb30e858cbe32c1647db2af04c03fdba6c2e", + "rawBytes": 54824, + "rawSHA256": "04500A8A27354B5B2A19BE2DB4067ED56D85268A8D266E4F411A82E7B9F4C693" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/SourceGeometry.lean", + "mode": "100644", + "gitBlob": "93255811da5f1425eee0de3d6be09c573f502090", + "rawBytes": 24195, + "rawSHA256": "99CCED87772781D6C4311F92831277DC08BB5481EF411BEF24DB8A5A0AA351F6" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/SourceWords.lean", + "mode": "100644", + "gitBlob": "e789fa5ca1abc60baa34da12545a4807bae30a6a", + "rawBytes": 46805, + "rawSHA256": "901CBE8A30F7FFA92AAD48F3DEB7E01B5384CFB17A7B912D32D999FF020B5F23" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/Space.lean", + "mode": "100644", + "gitBlob": "bf01a751a9fc492cbcc559889ebf88d1ff8df654", + "rawBytes": 7427, + "rawSHA256": "E128DB764C24210CFB01CA197CAC427EAE126DD743D5695F580C414071791FE4" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/WordWidth.lean", + "mode": "100644", + "gitBlob": "f2d02a7e57e5a2d64df9b137ab6c60c70ae729c9", + "rawBytes": 15289, + "rawSHA256": "462C7120F2480CEC505EB53E2F6F49FEADFB92EB968504912B1D9ADA086992A0" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/RankSamplePresence.lean", + "mode": "100644", + "gitBlob": "27de147785acd15a0ab9e6d982df9fefb76ad088", + "rawBytes": 3533, + "rawSHA256": "7CCDE8F52D75AB0F61EC809847DED226C93E3F167C35522E8E923ACA4DB1446C" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/ReviewerPhysical.lean", + "mode": "100644", + "gitBlob": "2bb6feeb97019a0272d2187731525a38a46ff935", + "rawBytes": 109271, + "rawSHA256": "0E506752E7843836CE715C57287CA3FC016D7CBB13E817C77A8DE6AC9D27DDB1" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/ReviewerReachability.lean", + "mode": "100644", + "gitBlob": "fb7118cf5d3290ee506d7db8a6fb79746449458f", + "rawBytes": 2229, + "rawSHA256": "AEEBF633C95249B42363291497FAB824930FA00389B218CC5E7F3C611E564B92" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/ReviewerReachabilityLong.lean", + "mode": "100644", + "gitBlob": "bba67f1127442705e77960222ad8e04a7712a0a0", + "rawBytes": 45733, + "rawSHA256": "564D7071713BD24A65324FC2BA323F652E3D446FF893D580878C27E4CC12F17C" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/ReviewerReachabilitySmall.lean", + "mode": "100644", + "gitBlob": "304a27908f4baf09a2296ec2223248a0636bf69f", + "rawBytes": 181933, + "rawSHA256": "E025FBCDDA65DF5DBEB9FE83F06F4E482F42207ED938C64F83FD1A9E12827C2E" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/ReviewerReachabilitySparse.lean", + "mode": "100644", + "gitBlob": "4e7f89b5ed2ab1c410f802fd6514737fd1f733e6", + "rawBytes": 52496, + "rawSHA256": "D9C8B7D2C3FA7D8412E2752F773AEFB3A92A3B107A9094F1D50B65860C1B4C11" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/Segments.lean", + "mode": "100644", + "gitBlob": "6810dd6d61d2abcccfd7ba66275cfefbe08da882", + "rawBytes": 13423, + "rawSHA256": "F99920A82633074FF9018646D221154B2D23CEBEF860A3BA3FF09164D0ABAC81" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/SourceInventory.lean", + "mode": "100644", + "gitBlob": "f5bcc60a95064495ad4c1281f0514fb225cf393e", + "rawBytes": 29029, + "rawSHA256": "5577B4EC99644DBD95E5BAFA326559DC039CEA3A33398B108AD51FAA949EAE04" + }, + { + "path": "RMQ/Core/SuccinctFinalModelAdequacy.lean", + "mode": "100644", + "gitBlob": "3825f4a6f4f69bdeeb96bd9eff39f9bdca45929c", + "rawBytes": 64523, + "rawSHA256": "C86323DB215E020CB46B88B2D92BAFF8DC210D8270E2B821B60EACD22F3E11B4" + }, + { + "path": "RMQ/Core/SuccinctFinalRAM.lean", + "mode": "100644", + "gitBlob": "0322bf5a41be302b34d896d0af4376e6cb99a186", + "rawBytes": 477273, + "rawSHA256": "86E5424B05BD18A81BAA544C4A0E1638B536A6B4A6FF3B7FA818E61297D3FC33" + }, + { + "path": "RMQ/Core/SuccinctFinalSemanticProvenanceAdequacy.lean", + "mode": "100644", + "gitBlob": "f5e97ca118f226b3a0b59b10b7f05112923065a7", + "rawBytes": 9411, + "rawSHA256": "9587364B193C18AFD385CB821F1E28E2048D7DD2011BC420D5A53817E99A1BB7" + }, + { + "path": "RMQ/Core/SuccinctFinalStoreParam.lean", + "mode": "100644", + "gitBlob": "14c0afabd2a1805872f5cc4bc7e82f872f5396b4", + "rawBytes": 177042, + "rawSHA256": "466DF9555BAB1EBE77567DC6D269C2DE7F73C421BD78BE15C0271B0D292C4636" + }, + { + "path": "RMQ/Core/SuccinctRMQ.lean", + "mode": "100644", + "gitBlob": "4feda48014aa356025889981762b78e31ed9f899", + "rawBytes": 478, + "rawSHA256": "73CA46469D58DD6C83A1D98E685D96C8BF148EA64192D6BC194C81592B5158E9" + }, + { + "path": "RMQ/Core/SuccinctRMQClassic.lean", + "mode": "100644", + "gitBlob": "01b511aad872612ce166c1d0d96d6081ba59b04a", + "rawBytes": 76386, + "rawSHA256": "07D34D2D79DC23B04235802D61ABFF2695F521131D0816304E79B3C1C6ECC177" + }, + { + "path": "RMQ/Core/SuccinctRMQClassicProvenance.lean", + "mode": "100644", + "gitBlob": "a37ca75cd7669238e05f4d19ee139e1242dc0940", + "rawBytes": 526, + "rawSHA256": "8E287FE880C7D032C577A1A5A3EFF2EFD7CA0474775F8B8206FC5557B9C9323A" + }, + { + "path": "RMQ/Core/SuccinctRank.lean", + "mode": "100644", + "gitBlob": "ba1ba86a9ab526bbcf5746c4c5400c57dd73062c", + "rawBytes": 85740, + "rawSHA256": "164F2C7BF988559DB4EFE7FC8C933E91DB66737C9C6F0297D6993831FFFF335B" + }, + { + "path": "RMQ/Core/SuccinctRankSelect.lean", + "mode": "100644", + "gitBlob": "82ebfd14204b919f3141fd7362afea7e1871756a", + "rawBytes": 401, + "rawSHA256": "6789432B6E1C59B2ECBCE3E5FC1DECF5A7CC2D82B4FD3A4DEAA98FDFB7D60FE3" + }, + { + "path": "RMQ/Core/SuccinctReduction.lean", + "mode": "100644", + "gitBlob": "94a75f24fa25cdc5426d5cfea4a1cef25b403804", + "rawBytes": 6584, + "rawSHA256": "966B4471C7205B46BBF1C318CD0EB72839AF33C4A787C50F1F08BF3CE5057B1D" + }, + { + "path": "RMQ/Core/SuccinctSelect.lean", + "mode": "100644", + "gitBlob": "dfce8f0617117c1b293fe9bc9da81c2c3c5bc182", + "rawBytes": 513, + "rawSHA256": "77AF4C71D354803BA080F4C07CB78112BD1AB5EC5EFE9B245596C75682F027FF" + }, + { + "path": "RMQ/Core/SuccinctSelect/AsymptoticFacts.lean", + "mode": "100644", + "gitBlob": "58c23a12a99c3fdad48652701c7715352d22b0f5", + "rawBytes": 4446, + "rawSHA256": "8E628E9C4A94F239AC78157F9A2874E5596B5C8E9CF37E765968CA1382086BFB" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect.lean", + "mode": "100644", + "gitBlob": "c5fddddf9a85fbce80438ac2b74c69c0bccb267b", + "rawBytes": 313, + "rawSHA256": "90E100621F7052B4545C153A3F97CFFB273CFA3EC8DB909885091DEB69CCB658" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/Basic.lean", + "mode": "100644", + "gitBlob": "69853b8a71f3024992567c410d0f005b53679e33", + "rawBytes": 11068, + "rawSHA256": "B845BF8D2D94D1C92BAD544D5A1BC8AFD7F13F2D2BE451D370D36CA3E20D0283" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/BuiltRouting.lean", + "mode": "100644", + "gitBlob": "2e109af66d7cd139b59c7dddecc8bb567f1f2e39", + "rawBytes": 288, + "rawSHA256": "6D7093C011DB8B7172463714B57556CFED2F22D19528002936DC67008748DFCE" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/BuiltRouting/FlagRankTables.lean", + "mode": "100644", + "gitBlob": "3360f878dffbc4661b1b8fd24ffdaf1de3157c12", + "rawBytes": 38260, + "rawSHA256": "F4AC00DF7B9C78AB09B9962F7A18D9AAB68A6FA1B6AC152D7E2C7258276EE069" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/BuiltRouting/LookupDense.lean", + "mode": "100644", + "gitBlob": "b02bdd80627bdb720b4d1a6fa1e6841f64dba8c0", + "rawBytes": 69962, + "rawSHA256": "29FB384ACE2DB0C5716E07211E52707345DA8E9E492A9030155EA419900A3B47" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/BuiltRouting/RelativeEntries.lean", + "mode": "100644", + "gitBlob": "5ddfae27199921e419672c3c37648fc808086f07", + "rawBytes": 34046, + "rawSHA256": "125C26C48D1BF6FAEC9D2F22AF23A171A3920F803C42F502692FA1D649B22361" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/BuiltRouting/SlotBasics.lean", + "mode": "100644", + "gitBlob": "e469e746c7765371ff3872d3fadb052529fd6a94", + "rawBytes": 21244, + "rawSHA256": "F71F91BC5CC954EC2BD4B979837F1D6D2E7924AEA42AF76B495F1867A3BAEDFE" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/BuiltRouting/SpanBudgets.lean", + "mode": "100644", + "gitBlob": "19c93d634b808f142daa3a4efb7931cd1272adc3", + "rawBytes": 48486, + "rawSHA256": "393E33B53C6311FB5982839D0A1ADF4B89F470A893CDA779AE98FC053C590A6B" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/BuiltRouting/WidthBounds.lean", + "mode": "100644", + "gitBlob": "f08f6a261fa432eba35412a6e569ee797dc0ead9", + "rawBytes": 24531, + "rawSHA256": "0F179C2CD32543C45759957FFD726E426400954F8A045D1C0AC880E3AD55B955" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/RelativeSplit.lean", + "mode": "100644", + "gitBlob": "3f863a3f82dc237bed13456dc9750261189dc191", + "rawBytes": 63699, + "rawSHA256": "9AC682EA9A955744E44E79235112FC7609BCAABE6AF3F04DBE63E6BF50631BF1" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/SparseExceptionCloseData.lean", + "mode": "100644", + "gitBlob": "8a10e10b09ba760fedef5f0459192f379f72053c", + "rawBytes": 291, + "rawSHA256": "4CC881E966D4FBDEB725E2810718338464741C339F934AECC09AA747796AE482" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/SparseExceptionCloseData/BuildProfile.lean", + "mode": "100644", + "gitBlob": "506da76c581dbd3d93c2a06769ca4f0c51b07390", + "rawBytes": 21950, + "rawSHA256": "5B43A04B43B22E69ABAD58A00394A6F54B519B84E9938473638A2CFB6D4609C4" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/SparseExceptionCloseData/BuiltExact.lean", + "mode": "100644", + "gitBlob": "b0e90c53da64b634b5783d591d375096aadc27e4", + "rawBytes": 52144, + "rawSHA256": "D1FA216A2236B3DD3CA6924373AF9A93D0644DEA9BCB338F2BCDA18C76C3DF36" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/SparseExceptionCloseData/DataSurface.lean", + "mode": "100644", + "gitBlob": "44cbd5a1e69af52a787b564b488eadf01bfa3a27", + "rawBytes": 37534, + "rawSHA256": "42ED0155C69A52FAB233C97D370FD8D94A112497E527AF21A4C5AE08C56D02AB" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/SparseExceptionCloseData/Obstructions.lean", + "mode": "100644", + "gitBlob": "a5ee14903331f8ace20f90bb2eebd0fb573ec24f", + "rawBytes": 14078, + "rawSHA256": "F8A9EFE1125544E95CDFDF72D1BE46E215E2F470298C65DE5F47E1868D4EC837" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/SparseExceptionDirectory.lean", + "mode": "100644", + "gitBlob": "283fa43325de9f3385663ccb1f3b8c589a9da1b3", + "rawBytes": 12680, + "rawSHA256": "60CE8CB87F721A02EDCAB06CE16FDD164C276C93E393D51A911CB5E8D35E6A7E" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/TwoLevelObstruction.lean", + "mode": "100644", + "gitBlob": "3291b9b7af347fb9bcf5217442a2908e96d8f8d0", + "rawBytes": 10997, + "rawSHA256": "E77B820C1C3505CECB3F9DA5A8DAB6E0CAC55CA7DE6CD9C0F00787931E0F696F" + }, + { + "path": "RMQ/Core/SuccinctSelect/DenseLocalTables.lean", + "mode": "100644", + "gitBlob": "fa88b2ae3d53b69e2573977945f5e8004a6aa479", + "rawBytes": 29803, + "rawSHA256": "EB63021D1866BF0F9A621270FCFBB0D43FD5CAC72FEAAEC230D3CA0FB57245BF" + }, + { + "path": "RMQ/Core/SuccinctSelect/Obstructions.lean", + "mode": "100644", + "gitBlob": "5e798a009b817f5af9daf132d5eafe0374b29646", + "rawBytes": 4942, + "rawSHA256": "793840F544CF0BA04FDE983E19CD19FAB4B37FB86DC3E0442B0EE4B399599F30" + }, + { + "path": "RMQ/Core/SuccinctSelect/TwoLevel.lean", + "mode": "100644", + "gitBlob": "bb789ffa7b1fc5a667e4dd38e6899d35d98fbca3", + "rawBytes": 308, + "rawSHA256": "016C04966B6641D8DD2011856D1BC953F5A8769C2808B7EDA81416E94B8DE74E" + }, + { + "path": "RMQ/Core/SuccinctSelect/TwoLevel/BPCloseNavigation.lean", + "mode": "100644", + "gitBlob": "06db1a1962d39a7591b7f59a7b17210373382ffa", + "rawBytes": 31111, + "rawSHA256": "4BEF79B1C636F11DEFE0A48035461C25958A4B203F3D2C6BF04B1D3E812A825E" + }, + { + "path": "RMQ/Core/SuccinctSelect/TwoLevel/ClarkSource.lean", + "mode": "100644", + "gitBlob": "a12c8e170af24ae46ec589a1c17875fdd19a610d", + "rawBytes": 40412, + "rawSHA256": "5BC9B60B0A33EE3CE6ECF02A9E6F4B05A8D308FBDC1A83905110F78FE598ED86" + }, + { + "path": "RMQ/Core/SuccinctSelect/TwoLevel/RankSelectAdapters.lean", + "mode": "100644", + "gitBlob": "a2ae1db530305b1a4c0e850d4a5a5c8723fdc18a", + "rawBytes": 48810, + "rawSHA256": "4EAEF65F1BF992E99862E839C2B66EB928280812FE696A29F3C53593CEE51C61" + }, + { + "path": "RMQ/Core/SuccinctSelect/TwoLevel/SelectData.lean", + "mode": "100644", + "gitBlob": "9d472b979908fb983b5e298edf46d9508d5b10bf", + "rawBytes": 44328, + "rawSHA256": "9D53AA16D945BE4AC2EF041AD3850F7150FEFD99B7696A0CB75AA38B4246092C" + }, + { + "path": "RMQ/Core/SuccinctSelect/TwoLevel/SelectSamples.lean", + "mode": "100644", + "gitBlob": "3517212958a3693e10dad86c687190413d6074c5", + "rawBytes": 18838, + "rawSHA256": "03B22A47CCA422EDA459FAD2B14EFF1EE8FA822F0D54B254A72C7D6AE9A8A329" + }, + { + "path": "RMQ/Core/SuccinctSelect/TwoLevel/WordExact.lean", + "mode": "100644", + "gitBlob": "581f2c827a37acc6eb74bdde22cf1e37168b7394", + "rawBytes": 52552, + "rawSHA256": "C50B1CF6D8B98AE698918955B84EE490DF1BDCC662B68B5B0E8A3441AAD9BC22" + }, + { + "path": "RMQ/Core/SuccinctSpace.lean", + "mode": "100644", + "gitBlob": "d783c95f6cb3df03726974799c3c5c45d4a9eeb5", + "rawBytes": 973, + "rawSHA256": "2DB86CA92D7EFBEB75B4DEB59A039ACA1E1C9DFE9BD597330A814568A12D7FEB" + }, + { + "path": "RMQ/Core/SuccinctSpace/Asymptotics.lean", + "mode": "100644", + "gitBlob": "af612389cd21990dd0ef4d9bb01d463acde8ed16", + "rawBytes": 26945, + "rawSHA256": "39493F9BD2B86C041ED7471C310244E4FCED9DE831C566A8FEB8593EA783FFCE" + }, + { + "path": "RMQ/Core/SuccinctSpace/BPAccess.lean", + "mode": "100644", + "gitBlob": "b62d57c1c04c29150f263d9b1447997524213fff", + "rawBytes": 52646, + "rawSHA256": "F79B2360503863665F30953566AEFF88BAC736063F725C599858460F13F344DF" + }, + { + "path": "RMQ/Core/SuccinctSpace/BPCloseLCA.lean", + "mode": "100644", + "gitBlob": "9d66a2f1e072b06b6b04f4b04dc595f8d8266e44", + "rawBytes": 17239, + "rawSHA256": "00C85BEEA48B2DFA4BEFA8A3DAAF70ADA06F876B71F7DAE6CC185FF47DC465AF" + }, + { + "path": "RMQ/Core/SuccinctSpace/BPCloseLCARAM.lean", + "mode": "100644", + "gitBlob": "ac21de8f4ba5461e8c51097d651d57d947a70c00", + "rawBytes": 5072, + "rawSHA256": "776D7F64C12CF9F6515D121FECFAA28C963887C0C9DD34E834CFC9B2FEF3C1DF" + }, + { + "path": "RMQ/Core/SuccinctSpace/BPCloseLCARegisterRAM.lean", + "mode": "100644", + "gitBlob": "8607c7e164cc3a9c302d141c2d4c92d68473a72c", + "rawBytes": 4528, + "rawSHA256": "B0A06AA49AFCE16A491B65A4CCEF84B0C406C00DA2C6E66A2470D1326C6C65E4" + }, + { + "path": "RMQ/Core/SuccinctSpace/BPCloseRMQNavigation.lean", + "mode": "100644", + "gitBlob": "e8e8389d7d3dd442a58b134b84a568e1137e08ce", + "rawBytes": 59260, + "rawSHA256": "9F7FA7CCDDB6F4106559D483EA35313BD1AE34B00F27259723DA6AD9E4A1AB55" + }, + { + "path": "RMQ/Core/SuccinctSpace/BPCloseRMQNavigationRAM.lean", + "mode": "100644", + "gitBlob": "42ba05060237de74f6921164e0078bba0e446a04", + "rawBytes": 16474, + "rawSHA256": "11541F260779F41468BECE8C941B16B6ED06AB32487AEEA9F916279DC36248DE" + }, + { + "path": "RMQ/Core/SuccinctSpace/BPShape.lean", + "mode": "100644", + "gitBlob": "b83298be618d812bd3d7e0c313fd98f1a57734f3", + "rawBytes": 17600, + "rawSHA256": "633C2CFCEE96751D7CB84B5492A16E1DE3A79B7BE4904C799188363D5B75A00F" + }, + { + "path": "RMQ/Core/SuccinctSpace/BroadwordRMQ.lean", + "mode": "100644", + "gitBlob": "84c7b31c15a4ba1eab3737e7331847b69ee04677", + "rawBytes": 21930, + "rawSHA256": "FB21261792E59FEC4A48350A968076CA8E45454F7F7CBA32EF36538DB5F163AD" + }, + { + "path": "RMQ/Core/SuccinctSpace/MachineChunkedTable.lean", + "mode": "100644", + "gitBlob": "26a623359419bf1491798cfcd9d1bc4155c3ddd5", + "rawBytes": 19547, + "rawSHA256": "CA5804E728E7CCB5AEE8C8BC2EBC220D5E7AE27A5BD286599337BC6EB682576A" + }, + { + "path": "RMQ/Core/SuccinctSpace/MachineChunkedTableProgram.lean", + "mode": "100644", + "gitBlob": "7466cf23d244db2b6e548a2fc4a9cdd4d8958aee", + "rawBytes": 21392, + "rawSHA256": "E8BAA33AA98DBBC67CD12E033B85DA1BC0B3A46303938A6A47A400C5FE34FB80" + }, + { + "path": "RMQ/Core/SuccinctSpace/RankSelect.lean", + "mode": "100644", + "gitBlob": "131618d64c79cbb4ad657ed53afd65e367b63a11", + "rawBytes": 54995, + "rawSHA256": "8DDB5D45C8EA60413EC5A0478C968895172406E855A4B1E5BB8405ECFE66B4A4" + }, + { + "path": "RMQ/Core/SuccinctSpace/RankSelectRAM.lean", + "mode": "100644", + "gitBlob": "3eb3b4e8c0607c54848dfb03e6ec3ee597132240", + "rawBytes": 19827, + "rawSHA256": "42CE073D6492EE4FAD5E45A3D41F26B73BBE6493B33ACC189AEAB8681342F0EE" + }, + { + "path": "RMQ/Core/SuccinctSpace/SelectSamples.lean", + "mode": "100644", + "gitBlob": "10cdeafad9e07c0b8a476be754f2128e85c5198a", + "rawBytes": 26310, + "rawSHA256": "62B18FA9CB7301DAA61490224C65068A38B3FB10D48B9E9FEF57359194B23495" + }, + { + "path": "RMQ/Core/SuccinctSpace/SelectSamplesRAM.lean", + "mode": "100644", + "gitBlob": "1cd7e04d03968c80346d1fe316f6e1c07ae29720", + "rawBytes": 6806, + "rawSHA256": "4931E8C80A9490DF33ADD8DE32ED3DE84041FB16A7E01B8031F400C44C01AFF4" + }, + { + "path": "RMQ/Core/SuccinctSpace/Tables.lean", + "mode": "100644", + "gitBlob": "6c88706b7cc13246ecb83ca81e057c35bf31f12f", + "rawBytes": 21024, + "rawSHA256": "5676C8B39B17EB0C183C9CE7C7E5B7210CEB947182D44933355A24BFB34A3BBF" + }, + { + "path": "RMQ/Core/SuccinctSpace/TablesRAM.lean", + "mode": "100644", + "gitBlob": "27090541304ff011ec275db5059355b5adb4cf57", + "rawBytes": 11069, + "rawSHA256": "6E5E99094B6B9D4C273AF2A6D3988C7627FEACC8EE0F75ADABB2652FAD4322BE" + }, + { + "path": "RMQ/Core/SuccinctSpace/WordStore.lean", + "mode": "100644", + "gitBlob": "3c07a23045937c7ad80fdcc7803ec009555f119d", + "rawBytes": 26560, + "rawSHA256": "E508F5EEBA21D642E94D391B29E0DA85228A941539C341BCC97B333D2A23BC34" + }, + { + "path": "RMQ/Core/SuccinctSpace/WordStoreRAM.lean", + "mode": "100644", + "gitBlob": "c23a0e494a12689299f48c09d65cca477bebf609", + "rawBytes": 4183, + "rawSHA256": "E73D6D9DB3D61E28CFA9F108E23C97E8CA3C7176A59C28E14B91C320574EA5C3" + }, + { + "path": "RMQ/Core/TableModel.lean", + "mode": "100644", + "gitBlob": "9fb40d4a2f2c8d1045b991d639359c00d4a1adae", + "rawBytes": 7753, + "rawSHA256": "B015B94A0B2E130B6E6ABBB44415868B824AD5242148D614355E580EFA5D8159" + }, + { + "path": "RMQ/Core/Window.lean", + "mode": "100644", + "gitBlob": "d8cfc10c688f5193eb862f900103c5335cd0658d", + "rawBytes": 4323, + "rawSHA256": "C135E68A11AF7FF52623A7CCD8439330A93D5758B2E548330889BBF04B08432C" + }, + { + "path": "RMQ/Core/WordRAM.lean", + "mode": "100644", + "gitBlob": "611e796270c9413f36f1ed40842118b5641f5d1a", + "rawBytes": 53644, + "rawSHA256": "7A47CED349D84C379135918115E3A0424B1DE2D9F4DDA0BB774FF42A94A174A9" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/AccessExecution.lean", + "mode": "100644", + "gitBlob": "e2069d581b36fbf2393dc27f75ba14df24b40df9", + "rawBytes": 2350, + "rawSHA256": "966E88F15B6CED25C337F4614B774FE85AAA0358E44F7EFDEBFB5BE0A0087300" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/AccessProof.lean", + "mode": "100644", + "gitBlob": "6152250b759c657f138216585a314614e3ee289b", + "rawBytes": 15716, + "rawSHA256": "0077FE19D2E693D7F02936FDB4A9592D68B9E67AC1FB9A1E905D361F1DB30DE2" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/Allocation.lean", + "mode": "100644", + "gitBlob": "e51fcf76f8884a8ccf440e199b8d30d1cc8218a7", + "rawBytes": 3101, + "rawSHA256": "B4DE6C3B923589A2AA890399D7D0B8236E3C46E1608ADE74F8CEFE65B60F392B" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/AllocationFacts.lean", + "mode": "100644", + "gitBlob": "56b5fb206f1faf1eb5014a9f24d3fc6ef896ca0b", + "rawBytes": 5997, + "rawSHA256": "F189969208B13333219EE460DB8581D43BABB88F18480C68A37F47C070801623" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/AllocationLayout.lean", + "mode": "100644", + "gitBlob": "b8d3e4fd9a544e7e50ba8ac7aa7d8b36da6c203d", + "rawBytes": 9104, + "rawSHA256": "EDE611982080F8600CE5F59BE89D8D331DC7920855F55B969A66F39C60E99ACF" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/CanonicalLimits.lean", + "mode": "100644", + "gitBlob": "7e8242cc21cc1b621bfbd990c5f7f4900fb714d0", + "rawBytes": 4764, + "rawSHA256": "1B0B761C9A42D0CE4C3EF3972B3EB43E3FE02BF56B9D3B7D501D23067C4D5A1F" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/CanonicalMemoryBounds.lean", + "mode": "100644", + "gitBlob": "364db7641887acb7b5170996dae16aeeaa3219fb", + "rawBytes": 24957, + "rawSHA256": "182406E5BCAD21C8EF5EE236B92F3EBB63441B8DEECB15B9E46019CB8A97AA21" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/CanonicalRankAccessSafety.lean", + "mode": "100644", + "gitBlob": "ecb32418258e80e9ab11fa8e4e76c37e22b70557", + "rawBytes": 12856, + "rawSHA256": "1C39E9D0A2637C45B7306DBD5077DD2319BA2F6C2AF7CA43D0DE189F9BBAC03C" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/CanonicalSelectSafety.lean", + "mode": "100644", + "gitBlob": "4864b9eaf10566dfceb4bb5921cab056281bbe44", + "rawBytes": 12395, + "rawSHA256": "FCBC3B363E47BC16298DEDBDE693921EC4CA45672753AD564161807D6CE7D753" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/CanonicalStoreBounds.lean", + "mode": "100644", + "gitBlob": "51cf5724de9260ab9009443a697b05bea3d6a549", + "rawBytes": 6254, + "rawSHA256": "1209D9A14B0B92D5CCD6455197C57189903CF65C1502BB049DF25CA4472038BA" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/Capstone.lean", + "mode": "100644", + "gitBlob": "8184759bbac7eb8b54cfe5acea62c9b86cb8211b", + "rawBytes": 11412, + "rawSHA256": "1C6CD0A85B77FBA7706C77DA87DE358808A24FA661D5635A3C4B3BBF96005D69" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/ChargedSetup.lean", + "mode": "100644", + "gitBlob": "35117138a48053376485d68acede42d8d6d2d96d", + "rawBytes": 13339, + "rawSHA256": "21440D54C844202F5AF6816C5BFD1DFBE07EFA18ED23A7C546F8BF29948476E9" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/CompleteLayout.lean", + "mode": "100644", + "gitBlob": "19ac167e084b45596766e61a49d2f8197f882ce4", + "rawBytes": 8778, + "rawSHA256": "E2C61B99E504E99940B3D63645F62CBE805FF21FF4B28473C1DE7646E08803DD" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/CompleteReadStore.lean", + "mode": "100644", + "gitBlob": "052c94c46807ae43f0863d75055c1799f732f768", + "rawBytes": 3348, + "rawSHA256": "3A8A6F6F57CE5C7368C8115D4A95521DBC92FF25934BF9B5CD8D8A31AB92FD46" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/CompleteReader.lean", + "mode": "100644", + "gitBlob": "21731c25e9198d0e3c786d24a85acdfebede937f", + "rawBytes": 6971, + "rawSHA256": "53926E3596E4C98A76D939E14CFBB26BFC939950E7A25CB774FBDB0617F73055" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/ControllerInterface.lean", + "mode": "100644", + "gitBlob": "2a665f4fac1fd416ef2212bd006ffbe86a8ad469", + "rawBytes": 3906, + "rawSHA256": "14F14B5A78FC77DB768536BF78DA47CB60922364538859535198C1E440B30981" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/DescriptorReader.lean", + "mode": "100644", + "gitBlob": "6fd93bc362f340f31f2ba08bfe8e886c2df197dc", + "rawBytes": 3796, + "rawSHA256": "A85C55E8962F8F9F78E0FB00EDD81ED9DFF7E870792F62830DB6CADB54F45108" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/GenericRankProof.lean", + "mode": "100644", + "gitBlob": "aaf46b982c21755434366b0b05a410e74f7c2727", + "rawBytes": 45313, + "rawSHA256": "01544E3B71EBCB90B7ABF34F8C241BA6ED6F7954027C3E22443AD9AC65192F94" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/GenericRankSafety.lean", + "mode": "100644", + "gitBlob": "cef3ac8de0fc6addc06a24a662a44073649ee1f0", + "rawBytes": 50086, + "rawSHA256": "46D1C897F34BA42A3DA76B5B9876D3C7CE46D05A63950FE9E1F2F9E513D3B4A5" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/GenericSelectProof.lean", + "mode": "100644", + "gitBlob": "be500e482a5ba36a7d4f851987805547695b3a95", + "rawBytes": 96314, + "rawSHA256": "07D1090314E454341CCECBEFB74009600C9AFB40A812DC218C6810C450790EA0" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/GenericSelectSafety.lean", + "mode": "100644", + "gitBlob": "ee7dcf3531c1f4107818aae0c84c5844402f47f2", + "rawBytes": 105343, + "rawSHA256": "DE8C9B1CD5C13C0B4D630839872DE55542116046EBDB4CC9B823C53B59C5B678" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/InterfaceProof.lean", + "mode": "100644", + "gitBlob": "1d24385ecf3d73b29084a6be08380c36a757ddba", + "rawBytes": 3974, + "rawSHA256": "9B04897F77EF88A00B85F71BD7A43119572157F9266E74DACEFB726856D431CF" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/MemoryLayout.lean", + "mode": "100644", + "gitBlob": "3918218d1ae2dc3be48f1a99f6d8803294635e05", + "rawBytes": 15097, + "rawSHA256": "2CB94877358664BDC93234128FE2115B626C10442AEC87C9429A89395B0D6A24" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/Metadata.lean", + "mode": "100644", + "gitBlob": "2d3462a49e9f2899c5ee46b44f9d7d702a11ce3c", + "rawBytes": 4117, + "rawSHA256": "CBA9B8CC9B574EC9D66FA4CCF8E4CE277BE6AA864B68BCFE6B9AAAB7AE955720" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/Normalization.lean", + "mode": "100644", + "gitBlob": "17c5b788d2cf3c8019439bc73d7df303680bdfa9", + "rawBytes": 7993, + "rawSHA256": "BA10A82917C9914E0BB11F619A15A51CFC65E2C0842C066F372339C77FF5F9D4" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/NumericReader.lean", + "mode": "100644", + "gitBlob": "82acb93da4d1fce444286f3a07f5e01f09e6c848", + "rawBytes": 20770, + "rawSHA256": "7E2CC443F2DE7351112460B7C2B0699C2879B51E760DEC3261B055790133897D" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/NumericSafety.lean", + "mode": "100644", + "gitBlob": "9e70908570f1ead32aa97ccda0395c03ebe11a63", + "rawBytes": 23639, + "rawSHA256": "621FC88A3FD86C8188A3074608CB254FA1D507CC4482F21C9EA13F8888A02C92" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/Observations.lean", + "mode": "100644", + "gitBlob": "a408a2f1c45f508ce1446c24c686f68ca5a1d246", + "rawBytes": 2369, + "rawSHA256": "76B7CAE29F31ADDEDD6A90D0FD80BA52FB62F26A6FEF02D94BA41FD731CE880B" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/RankExecution.lean", + "mode": "100644", + "gitBlob": "40d01f3f91ea03cb75cd8bdee49b0d9f2a6c89ca", + "rawBytes": 7591, + "rawSHA256": "BD4BDCDE4443E60E624DCEB0CC87673CF51321AD277DADE3A33DC898559A3B7F" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/RankLayout.lean", + "mode": "100644", + "gitBlob": "a456427bafe46356e63fead72ed0be7f191ca13b", + "rawBytes": 9815, + "rawSHA256": "7A5756940175BD775A0F4F0928EBB01F222C7C8DB0461CB12C74770A6F8D629B" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/RankSemantics.lean", + "mode": "100644", + "gitBlob": "bed0b99b8f005b63887a1f8a09a37367bfec998b", + "rawBytes": 6212, + "rawSHA256": "9AC0B86BC1630635EAA63A3DC3C3889206A0FDFB0205DD86C36ECF7F5516AB7C" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/ReaderGeometry.lean", + "mode": "100644", + "gitBlob": "b7c518be92f7ed1283500a8bffe98f08e64ef680", + "rawBytes": 4774, + "rawSHA256": "F8FF6C3B35B86208E3C56B09FFA5CA1113FE17650F98EE51E8EA5D9515394133" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/ReaderInterface.lean", + "mode": "100644", + "gitBlob": "143ce2d70af8c7016a83c216a7b037a3fa37c129", + "rawBytes": 4462, + "rawSHA256": "ECD8043060AAE4A3F753B81ADCFE47F9E22B2914744DB6686ABBFB18A218A210" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/ReaderProof.lean", + "mode": "100644", + "gitBlob": "55242103f2a899c21839f90ad71e212f20481cf3", + "rawBytes": 5436, + "rawSHA256": "99773E1BA134E76C19A774433D54E1C26A281421ECABA099F7F019EC4A083921" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/RegularLayout.lean", + "mode": "100644", + "gitBlob": "e8d03a2b9a35f9897b9fef3280ce9261d6707eb7", + "rawBytes": 10776, + "rawSHA256": "172ED0F83F0D8E63136F7A3063F8EDC009F71D57C4BF8B1D311067F1AC53638C" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/SafetyInterface.lean", + "mode": "100644", + "gitBlob": "9cb438ac74ec077fe7a2a852c5ab08f0ffd20fb6", + "rawBytes": 6230, + "rawSHA256": "9BD0732D2863E80F4311D92C75366A0F280B7EBB250D51C32F66DA4540766CD5" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/ScratchFrame.lean", + "mode": "100644", + "gitBlob": "d54970423e9f276e955835c299895dfef93e159f", + "rawBytes": 4640, + "rawSHA256": "0EB35B270F66D55C250D9EF6DC46D897F7AFD1AA8E07D5EA40A6EB2D7784905A" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/SegmentMap.lean", + "mode": "100644", + "gitBlob": "8b4ebc1d1ed74b2da293dac729a1feb0c5446e7b", + "rawBytes": 7460, + "rawSHA256": "8F9454FD730B9B857A99BBC33530DAF23E2F185AC66E21CC0845F29742C55B41" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/SelectExecution.lean", + "mode": "100644", + "gitBlob": "c46372d8a9a31d28740d4726e6f54fdf07884725", + "rawBytes": 6519, + "rawSHA256": "580DB81FDE442C341332A1185FD524C2925E45744F1B6918447D915E1E3FD4D0" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/SelectExperiment.lean", + "mode": "100644", + "gitBlob": "5a65069626ce5b7547792f31cfe8a123a1cceaeb", + "rawBytes": 6301, + "rawSHA256": "156744CBE4DEC77C874114E10408820F7B107B86D5635068D6B855B8363AF0E8" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/SelectSemantics.lean", + "mode": "100644", + "gitBlob": "29d6bb1f9682d8819ed84536100a9f1af47ca418", + "rawBytes": 21230, + "rawSHA256": "D950323B3DE006F320335F68AF96BE9F8A7D50A425EDDB35B493EFA2AB8DD3A2" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/Source.lean", + "mode": "100644", + "gitBlob": "612b69d1f71358b78578cc7b96199810446564c7", + "rawBytes": 3605, + "rawSHA256": "8277F15D876437BD6C35835C57C9332E839AAA94EA63EC8A9F10B8BC661D1074" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/Space.lean", + "mode": "100644", + "gitBlob": "0895c7a92874e4059d8a2447916f28720fada803", + "rawBytes": 5575, + "rawSHA256": "DBF34F5508AC1A1FC57F722DEF6A4724B6B495B5416AE2A9970179E5780BEFC1" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/Width.lean", + "mode": "100644", + "gitBlob": "9e45fbe78a222bbb7eb2b966d571d2fe35adbfea", + "rawBytes": 1589, + "rawSHA256": "873FE2E55102BEEB0E5B0450E86BF83CEF569303EF76C93D9B8AFC7A26860556" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/WordBounds.lean", + "mode": "100644", + "gitBlob": "6ff6d508b93db01d2bfea818c49ce0e12cd22b24", + "rawBytes": 4605, + "rawSHA256": "756AD2CF263E310966CEE28F214B0190B3F748365C9D5B6E808D1BD994956AB0" + }, + { + "path": "RMQ/Core/WordRAM/Construction/ArrayRun.lean", + "mode": "100644", + "gitBlob": "505dbf020aea20a8bf4dc7f02f1722b07debbe89", + "rawBytes": 24346, + "rawSHA256": "DEF5837D2C7462CDF5A331B4CEA13EC27C65AF128316A7092567744FEF4A610C" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Access.lean", + "mode": "100644", + "gitBlob": "145f909dc08d08b555e1e499f55149b0f23ef058", + "rawBytes": 12186, + "rawSHA256": "A62C60C1031DD01AD496E42765963A8C69CC1FF6C7734E828201AFD03261E4AB" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Cartesian.lean", + "mode": "100644", + "gitBlob": "16cf799f4c650787fec347ca899349e390f592ea", + "rawBytes": 3335, + "rawSHA256": "EE2EEC58420DE15782A7DEE29F66F90484232DFCBB9F99A3E08973E6253813C9" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Emit.lean", + "mode": "100644", + "gitBlob": "fbeb1c355f39a903580efa19f4b83ac12c17b23e", + "rawBytes": 3220, + "rawSHA256": "DFB36F53C9F3744E56FEA7A8D34D23680F834CF795250D5756BB1A1FE51240BA" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Finish.lean", + "mode": "100644", + "gitBlob": "0d5575362987f6425f727854759eb467ec795023", + "rawBytes": 3658, + "rawSHA256": "B65120BB381931C47FC42FCBC40627F487F61F8ECE7F99A8D459E83D52B5B3C1" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Geometry.lean", + "mode": "100644", + "gitBlob": "3e3851b52e0b643f2ecf52dc97b983b0c7634513", + "rawBytes": 6708, + "rawSHA256": "99422E111C8A1CCCF692A246ADF20A8CEF0DD88DD6889DC583592EC14891D088" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Interior.lean", + "mode": "100644", + "gitBlob": "17cbd5c3a9f7556f05165065bbfad8581638234f", + "rawBytes": 8981, + "rawSHA256": "43C7D5815CD3C71E94DEBBB35C8B1F8A71E83DF944F5F130B008B708A161FDC5" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Micro.lean", + "mode": "100644", + "gitBlob": "d39904de90bc94dea340d874afea7ccc07fecec2", + "rawBytes": 5052, + "rawSHA256": "88AFA5C11C4706A392ED51EDD517571B6888650D20BA4063B84C200594950703" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Output.lean", + "mode": "100644", + "gitBlob": "4a8f9d1dc8b6335a28782fa658d2a910d0dd991c", + "rawBytes": 11449, + "rawSHA256": "F7C2890C942159EDCCAD5D7D12D2A4A00F87492DDAA8870B00E2107CE8BF5D23" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Program.lean", + "mode": "100644", + "gitBlob": "019a5da76784d78a0298872da1e377ee8131f663", + "rawBytes": 3408, + "rawSHA256": "451AE09FA62D30B89B0CFF174E977259FBA58FD3D96D535CAA4D59129CAF436C" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Registers.lean", + "mode": "100644", + "gitBlob": "8500679c3f9a3da2ab373dae74d332dfc2d99dae", + "rawBytes": 10675, + "rawSHA256": "995F80DFEE6AD0A9844B0AA752FF84873BBF79D064D96DB2840772790A645684" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Calculus.lean", + "mode": "100644", + "gitBlob": "8257561b1a47bd49fe64a4c2d560b83a65f28f5a", + "rawBytes": 34685, + "rawSHA256": "88296C2AC88169D656A07C254DF0F2F79C67E8CCC8A7809F66669CC6A4AB3FA6" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Capstone.lean", + "mode": "100644", + "gitBlob": "13f6615354b75df44312ef078d2d09c6914a4bd5", + "rawBytes": 8479, + "rawSHA256": "3B794806DBA32D3B59950705185CA8D3C57F470DFBF4D3ADDA5564746D857833" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Compiler.lean", + "mode": "100644", + "gitBlob": "895f2975970ae1258554358413955f82936ee6aa", + "rawBytes": 31031, + "rawSHA256": "A3A98226A10866B775AB45E6BE9F50AC016826F4B9565F9E8926BE3E35A2E65D" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Conservative.lean", + "mode": "100644", + "gitBlob": "001346d022f7acbd204e247937449bca0b3bf911", + "rawBytes": 7706, + "rawSHA256": "3C2ED59F22C42CA83774BCD96F92FA8EEFF604DB2A6B5F338AD4615BF8F54B9A" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Contract.lean", + "mode": "100644", + "gitBlob": "ff5e08816a561f3667bacf057ff1a89e1f66de06", + "rawBytes": 2872, + "rawSHA256": "93E6C1A264C2BE7F5DE3D9CFCCB5B7AAF10C28DC3F6F6C51385DCDADDECC6FD6" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Controls.lean", + "mode": "100644", + "gitBlob": "8ea487ac1a97b3af7f9b08b457cb74f39b551746", + "rawBytes": 5475, + "rawSHA256": "580FECAC1C2FEA11AB8EE0939082AA69981017E3225CB630B1937431D5A768CA" + }, + { + "path": "RMQ/Core/WordRAM/Construction/HeaderUse.lean", + "mode": "100644", + "gitBlob": "13ca961f29518163ce004905b6f32ef3b829ad96", + "rawBytes": 8270, + "rawSHA256": "2645AC2122F304B26DE7630C1E441346F1E6D8659C8D5F4DAB47C356A01CD8A5" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Input.lean", + "mode": "100644", + "gitBlob": "53afec2a48fbd6ce18622153c468926591b53d82", + "rawBytes": 7558, + "rawSHA256": "B8311F6583D9A108324A952CA01B23C701682E6C16A83B908CF0932BDD6D78E0" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Loop.lean", + "mode": "100644", + "gitBlob": "ca054024193bbcf5c932b632cf74305257cb20de", + "rawBytes": 6376, + "rawSHA256": "4EBA2279F29B509FBEDBE7E668D236A2A9F61C0ADE5D7E604915B4FEFD5AA6DA" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Model.lean", + "mode": "100644", + "gitBlob": "d1687b7cebe1278482801cd8c390bbb77bd8b3a9", + "rawBytes": 4743, + "rawSHA256": "601630664B80C2EB0C26778A1AD2982BC4E0D3B59C43B5E349321998CB11DA7A" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Primitive.lean", + "mode": "100644", + "gitBlob": "7f44d513249a2e4650a8af799e87cc32238741ff", + "rawBytes": 7450, + "rawSHA256": "9D296EF6A7D08CBCBCAD7E262430F466FB9BF41021C55CD1997D2E8F92B77A69" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Program.lean", + "mode": "100644", + "gitBlob": "6cc79066cfbc9e2b5e80b98a49dc044abb9fcba1", + "rawBytes": 6741, + "rawSHA256": "5817BB879D48FFBA924D8662DF22FA5F6A3DC62E0B0BBF884CBA79AA0316DE0E" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/AccessEntries.lean", + "mode": "100644", + "gitBlob": "01837bd03186249cb9953c317a2cd605c511f3fc", + "rawBytes": 51749, + "rawSHA256": "362E9BECCBB7A11BA120DFA4134CA2A4BCFF322C068596EA48751D7775DC19F6" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/AccessFlags.lean", + "mode": "100644", + "gitBlob": "0480e6b7a635f7d0b59a87e32d4efbc71bb74b03", + "rawBytes": 62054, + "rawSHA256": "0C24AA03601CD4E30F5552EF508975EFFA245A2FBD576CEAF1ABD55277016C38" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/AccessHalf.lean", + "mode": "100644", + "gitBlob": "074f691965cc5a3c6cb39c871c2b9b671fdd7c6d", + "rawBytes": 31042, + "rawSHA256": "8D75996B1003644986B12D33328C99111B95DFE55C78FC8083FECE2AAAA027BE" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/AccessRelative.lean", + "mode": "100644", + "gitBlob": "e8e16e4d116f3aa3c152a36f0e89fa32210d4fd1", + "rawBytes": 48917, + "rawSHA256": "5C1170974B6CD0BDDA27732F448402D7ABF9A548406970B713434F2B36E6FD8A" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/AccessTables.lean", + "mode": "100644", + "gitBlob": "ba471626d5bf304ba5a09b2308320686bc7bde31", + "rawBytes": 57158, + "rawSHA256": "096B78F02198D730BE642E4E916BA74EEEB2252C3FDF9134CCF47E73CBF5B22B" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/BPEmit.lean", + "mode": "100644", + "gitBlob": "db372f4f5b39785e8f863b39cdf8fdfe7fefe652", + "rawBytes": 17329, + "rawSHA256": "AAC79854CCD58562096257EE5B3BF4879F90DA21E05B79125E4A13A6CC940FF1" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Base.lean", + "mode": "100644", + "gitBlob": "06c668b98b6404ebb71579461aabc5f44c8ef03d", + "rawBytes": 13701, + "rawSHA256": "53D1EA39E9880101F8A681CD21DC8766C6C384B92F1E7FEAA1F239B17BA5510A" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/BlockStats.lean", + "mode": "100644", + "gitBlob": "f8c826088c09bf35b321f06be1742383c9de9907", + "rawBytes": 45115, + "rawSHA256": "1F8D540F1BBDAE16D6E5471366E16E872CE6E26F7D3F13168D82D40C6FA68584" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Buffer.lean", + "mode": "100644", + "gitBlob": "986f07cc7788b5f493e5f9a3c8e7e4cfa3777531", + "rawBytes": 42894, + "rawSHA256": "53C4AFCFFCE034D40C1AFF30CDC2F43A9F52D82F7954C15B800088555BA83041" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Cartesian.lean", + "mode": "100644", + "gitBlob": "05f980c7f3513fd5768a096ce2bae804388ac52f", + "rawBytes": 42201, + "rawSHA256": "800DEC258F93A73E47239F40B8616620BF2DB82C03FB690E340F2E248CF67AF1" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Constants.lean", + "mode": "100644", + "gitBlob": "8c642c6672752183e00b0a9806f0e6e612e0ef64", + "rawBytes": 6561, + "rawSHA256": "C88BEB478A7DFD290F74E498B5571600F0A951A4FB43D7D523E3C5A21174C0CA" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Emit.lean", + "mode": "100644", + "gitBlob": "5f89a0f3118d7a6fc8cbb49fb9a5ff47cf113bbc", + "rawBytes": 32918, + "rawSHA256": "00035A07F35101CEC056DDA45A45EE1986E91615AD81B0BEB4269C8FF0FD3971" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Exact.lean", + "mode": "100644", + "gitBlob": "4840b7ead4b2abdf9531648f49ef4384b3ec4a4d", + "rawBytes": 14919, + "rawSHA256": "E643891EC57618CB046B81BA332750091A9407A466427946EE48B06B99E138DA" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Finish.lean", + "mode": "100644", + "gitBlob": "3d62e6a32cc3cd3f3b31e6eb2adccb49619816df", + "rawBytes": 22409, + "rawSHA256": "CC9997DF8AC50F00557E500B5DB5D09A14442163B0E32488F1A3CF201BDDF497" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Flow.lean", + "mode": "100644", + "gitBlob": "5b8b1e08a88ee7bd583c40ff5792c37b34b51caa", + "rawBytes": 13046, + "rawSHA256": "4CA5C92D0DF1C65E92D241A083CDAD3AB0ECBED50CAE1CFF904C20C42EB91830" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/FlowFacts.lean", + "mode": "100644", + "gitBlob": "3d92bd8c5eef589d94a2e38ab83bae2452f0b1ec", + "rawBytes": 27076, + "rawSHA256": "3DA76A721A7C033D2DB86879ACC53A5738F8CD6B60D8A8743E1AF8F3E5D5E5C4" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Frames.lean", + "mode": "100644", + "gitBlob": "ffcfb45e9fd1b5441cd8dd05d29c760d7937eac3", + "rawBytes": 56185, + "rawSHA256": "0F9A820BF49F974D802C4222212A5FB571A859825A285CE2F9C2BC16AED30E80" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Geometry.lean", + "mode": "100644", + "gitBlob": "a74cd94e6d049ed9b12fc4fac1535131c4529339", + "rawBytes": 23265, + "rawSHA256": "3FA714FB27852A50D19011DEC0EFA377F88BBC74CD251034FDAE1B6DD46B1439" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/GeometryBank.lean", + "mode": "100644", + "gitBlob": "48b76d907ee3eeb605855f1940e13ccc9e9e5208", + "rawBytes": 72212, + "rawSHA256": "81A4E60A32563A6FC29B48FB090FE28DCE989234FDE270AF1CD80017787A9613" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Interior.lean", + "mode": "100644", + "gitBlob": "c0c71cb5f624edbd0607da0e8e550315c89deb82", + "rawBytes": 9298, + "rawSHA256": "C21D32BD43EB0B8D12711A74032C44274AE18F5F5A7CC017A9439F1705E2E208" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/InteriorClose.lean", + "mode": "100644", + "gitBlob": "1f633a2344e545dc723a6ffa4b0855a763e6c58d", + "rawBytes": 32686, + "rawSHA256": "9C5EF1100271195F71E0786CD9BB6E07AFFDF4FCCA0D47AD340484302D55D72F" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Leaf.lean", + "mode": "100644", + "gitBlob": "e917618efae25460f79263037ca9ceed34144d5c", + "rawBytes": 2716, + "rawSHA256": "AD992B6F2E15387555B6718457E335DFED1BCEDDD9206B9EA249CF91479C8C76" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Leaves.lean", + "mode": "100644", + "gitBlob": "d599e95e8b939db0c5f9efe7be22337ae3d2475b", + "rawBytes": 10981, + "rawSHA256": "7D41252DDA2325AE1336459D2C14CD21B1A46EC3705E9457C7E244E6033E4ED9" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Lift.lean", + "mode": "100644", + "gitBlob": "7e2963703b3b912f6bf4ce3a20e6019f0ead7d92", + "rawBytes": 5822, + "rawSHA256": "327FFDA34FC73C4812141188719E79285294DEFAB6ECEFAEA56835DE332295F6" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Loops.lean", + "mode": "100644", + "gitBlob": "c247da9e5cde757bc27ac8bc5b14f6db55a18732", + "rawBytes": 22381, + "rawSHA256": "628CF71605058ACB3AF40C134F0EACF70E7A25BAE890F3AA6604C2708423B5EC" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/MetaBounds.lean", + "mode": "100644", + "gitBlob": "b76ca524951c026fc5b9a5027d5cdd3840bd51d5", + "rawBytes": 19752, + "rawSHA256": "C4461877876E35B3F594305DF1FA7A7C8E04737ECF851DD63E9235EE87121407" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/MetaChain.lean", + "mode": "100644", + "gitBlob": "2bead3b749b076a551b28989a2fd578ab50783f1", + "rawBytes": 78471, + "rawSHA256": "37467F7D8F8FBE88A33A9551F14CD9181865B42AB3E41FA53C1F5ED443FBCD1C" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/MetaSteps.lean", + "mode": "100644", + "gitBlob": "e251fec241f0c34334a989cd9d2611baf54d7fc0", + "rawBytes": 70136, + "rawSHA256": "9046F2772C770052805852FAC57F154C99A0977A25697ED85805123C8670C59D" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Micro.lean", + "mode": "100644", + "gitBlob": "1afb5d412836eaa7ff10c909e2705fe13120cc6f", + "rawBytes": 37006, + "rawSHA256": "DCCBD07C037F2141225602AECF74756982A3E042DE3E49DFCF6D59B31A472C07" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Output.lean", + "mode": "100644", + "gitBlob": "83f3ba46e1003b126802a9ee173a70ba79754685", + "rawBytes": 58277, + "rawSHA256": "463D5728DA4F7C03BCC7A6A2825FDE0E16E0244C11BADEA3FCA68AFD2DF82A32" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Ownership.lean", + "mode": "100644", + "gitBlob": "2946170192705db1d2860979c0aa45ab7d7e5a25", + "rawBytes": 12181, + "rawSHA256": "7BB0860DEF0136514C44B8F1C4B9FFF0E75F7AB14BB92E47C47B3827702AF076" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/PosPass.lean", + "mode": "100644", + "gitBlob": "edf6f0279331076d8e2a4b09baf0d515115cedfd", + "rawBytes": 25164, + "rawSHA256": "A88CA1DE05F251C2C42D550D2724592B5EB36BD419E94926DAD671A8FD46EBA0" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Query.lean", + "mode": "100644", + "gitBlob": "553a37df6d2a2ed7617a5c5d550cc41bae33b962", + "rawBytes": 10360, + "rawSHA256": "85A8C7DAF88A6E35F08CEE29EC4A97EBD629E333DB6A2A9B946DF1DC48BFB9B5" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/RegSpec.lean", + "mode": "100644", + "gitBlob": "82298d167f2b91f9ffa7220e5d369feafb428e59", + "rawBytes": 25592, + "rawSHA256": "E0BD0D62203FBD53DF6D18C54D00A47FFB873B7D1474FE88ED7DB20F6C848A99" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/RunFacts.lean", + "mode": "100644", + "gitBlob": "4ab983a5e85dc16ea0176ff2bdc365d7759917bb", + "rawBytes": 19676, + "rawSHA256": "57B4CC8FEAB8C65C65841D0B05264AB388211E52BE2FD39C90016D04D02A16CC" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/SparseMemo.lean", + "mode": "100644", + "gitBlob": "62dafd9df10f0b3f4c82a8d8acc827f13b50005e", + "rawBytes": 67449, + "rawSHA256": "1E0A5082591CE57EF93C8FCCD2735D4E253FDE7703F41CA734BE255341E31759" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/SparseTables.lean", + "mode": "100644", + "gitBlob": "ff7510fe81a95dd7f89cab218679608bcf17bd53", + "rawBytes": 26024, + "rawSHA256": "5B0850DBBD889CB89FE506C48A69E16EB723CD829CA00889C480D8467CBA9D1D" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/StackPass.lean", + "mode": "100644", + "gitBlob": "3a9a7f7e7e325ee698cd62315efb0c4483272a4f", + "rawBytes": 24176, + "rawSHA256": "FC1B5AC801626D79AA737408B1515CA23E01CDDE703FB137EA0C1075CF5558A4" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Stage2.lean", + "mode": "100644", + "gitBlob": "964779c2d2c0494bf9daf618485653527f5daf5e", + "rawBytes": 8256, + "rawSHA256": "C34D6A2A0A28C22AE461B4FA48124A3CFD55D4BB67155EC3D5F62E3A955931A0" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Static.lean", + "mode": "100644", + "gitBlob": "7be4917accfe8859db9f9c2c530fcc2d8b31f457", + "rawBytes": 6949, + "rawSHA256": "775276DCA095B9BDB63AE9299C2AE6920DABEC05B091E67D8112D5D00A7A765B" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/SummaryTables.lean", + "mode": "100644", + "gitBlob": "3ab485ffe6ae1eda7e6022613d197f13c16eb7de", + "rawBytes": 31255, + "rawSHA256": "3F7E6BF04B9A9CD60193D0101EFF0E7B5B8D370AB8DF465E0EDBF1EDDFEF65E6" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Tail.lean", + "mode": "100644", + "gitBlob": "2751f21e327a4ab3a86a79a06d54a49c902323e1", + "rawBytes": 12404, + "rawSHA256": "965FEC76AA87BEBE5369ECFEC58C53064C1AB58C6A6CBF1CEE25909226A16137" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Safety.lean", + "mode": "100644", + "gitBlob": "02677487865e12900f10bd8fd6d1dc9dbe8a6b16", + "rawBytes": 8042, + "rawSHA256": "0556BB89B4CD4AF1026DA3DAD249A426EC501B1BF722033637674F6467147C4E" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/Access.lean", + "mode": "100644", + "gitBlob": "4eba41aaed31d816ae787a9f82702fadb7c26284", + "rawBytes": 3307, + "rawSHA256": "A9577E0A6BEB788443E1A9A2CD862980CCE8DFDC69D6242E7E4A1D4475FA8161" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/ArgMinSplit.lean", + "mode": "100644", + "gitBlob": "8447814b228abeef4546292cc974f6896d2797d8", + "rawBytes": 7000, + "rawSHA256": "00738F5E8CE9E6EBA0F191D20089818F102021BBEC71E5513CEE35D8CF8739FE" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/BlockStats.lean", + "mode": "100644", + "gitBlob": "0658f9d2f306c2373b93149cfbdc6c2efef081f2", + "rawBytes": 4724, + "rawSHA256": "DC47A17FA33EE8680C088580C5E0E0BB1768A64F7EFF470259C2E1A914ED8CE5" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/Dyck.lean", + "mode": "100644", + "gitBlob": "48d1cee1e3665a1dc2f938de06682ea3aa4f9b4a", + "rawBytes": 6347, + "rawSHA256": "75AC54D8A2D8471A41DDEE045D6537F44324D2663E279C571E9FF10C2A861844" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/Envelope.lean", + "mode": "100644", + "gitBlob": "829953667c58e03d16bdb8d5239572de8de87b2f", + "rawBytes": 22168, + "rawSHA256": "863FB13879921EFE8923330AE85382D347C709322044549A787ED4483D61093C" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/Metadata.lean", + "mode": "100644", + "gitBlob": "a9edd97d631a2e0f5412e6f56cb63af757e097cc", + "rawBytes": 54701, + "rawSHA256": "37483440B657030E28C811D6C2CF0C410C06216C70CC6DC3388858B929167FC9" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/Micro.lean", + "mode": "100644", + "gitBlob": "aa36996fec60c578fba967d9e8c53f997474b83b", + "rawBytes": 8030, + "rawSHA256": "72E352C14F60080F631B390FC5ED1ED4BB7E1D8EB6AE9513096C51072FB20632" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/OpenCounts.lean", + "mode": "100644", + "gitBlob": "67c90271e4315863aa98b0fbc902f6fb7a5147b2", + "rawBytes": 7099, + "rawSHA256": "91BA567EE52FDE9385A3CBE9E1679695EAA57DE7FE71FCE84303416F7B7F08DC" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/Plan.lean", + "mode": "100644", + "gitBlob": "43c659e113f08d7ec7598965039a952d4ee127d1", + "rawBytes": 26900, + "rawSHA256": "747C3A77DD71C36A8D354258D8B47939013C4D37E906A896BF1DDD918A4DBA42" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/Positions.lean", + "mode": "100644", + "gitBlob": "fe3fd6e9b1d1dc133c535103dfbe4533a7354692", + "rawBytes": 16672, + "rawSHA256": "6A9E1D83F2FD0978FC3D4153CF211447FD6E7098A79A4842F50F6EB364F05473" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/SparseMemo.lean", + "mode": "100644", + "gitBlob": "01bf5e7b085b92c61a29ba7581e095b4f2f8b45f", + "rawBytes": 4880, + "rawSHA256": "128CCE8EEFB880B81D90AFBCD971F97C47945CABBC859F155072D874CCE46440" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/Spine.lean", + "mode": "100644", + "gitBlob": "8d99a071326a006d5e614a539e4dc8813109ca88", + "rawBytes": 10132, + "rawSHA256": "F6DCA9CC8AAD0ED8D0FF345964144902072BB854B32BE7798A9D4E3FEA39E9C9" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Structured.lean", + "mode": "100644", + "gitBlob": "207462d7005a94286da399da474dec168f8d71d0", + "rawBytes": 16947, + "rawSHA256": "D6321BE4381E84895CC6DAB6919503951DEF71C8A153307B1575694FF61C73B3" + }, + { + "path": "RMQ/Core/WordRAM/E1DenseSelectBlock.lean", + "mode": "100644", + "gitBlob": "41ca260240960f10d902cedfbbec99d29e0b918f", + "rawBytes": 73585, + "rawSHA256": "9F032FE04340FA74F3ABD0C3FE0587E38FE7C70872FEB8639127BF3DD2BE2B59" + }, + { + "path": "RMQ/Core/WordRAM/E1FringeArmBlock.lean", + "mode": "100644", + "gitBlob": "0532dcf528d161b1269ac5efdb6135eb03ce2a1a", + "rawBytes": 47124, + "rawSHA256": "99C40C4DC753CB0C2BAF2FC85AEC1D823C62AB7F465123478F5F6C68C53EA9A7" + }, + { + "path": "RMQ/Core/WordRAM/E1FringeBridge.lean", + "mode": "100644", + "gitBlob": "c8a3dee6bed0831fcbb463c5f25a6d1992d7d3db", + "rawBytes": 17269, + "rawSHA256": "B0287F964144901282A2949DC7FDCE9B682506EFB34F0BEC15F9098A5C8351DF" + }, + { + "path": "RMQ/Core/WordRAM/E1FringeFoldBlock.lean", + "mode": "100644", + "gitBlob": "f03253656cbc4aa162005e69b0491d0ee0720ad7", + "rawBytes": 58055, + "rawSHA256": "40764E78EB45B27F4F297D5C737689F5064B01F203CCC6DC98F61D9008CF36BE" + }, + { + "path": "RMQ/Core/WordRAM/E1Machine.lean", + "mode": "100644", + "gitBlob": "5646ccb1d9d21fb561b5e624f5e451d00819fa38", + "rawBytes": 23725, + "rawSHA256": "69CC3DDEFD185F7B6E9B09B64E8B2FB0FEFBE0669210E3D17D96CA707F3E1F94" + }, + { + "path": "RMQ/Core/WordRAM/E1MachineCalculus.lean", + "mode": "100644", + "gitBlob": "18e794f2a79e78a2186c579fc0eeed0f23dc52db", + "rawBytes": 17864, + "rawSHA256": "15138768C905F6B462B52C2A128801B94E57A70411AAE7439CBE36183446FE66" + }, + { + "path": "RMQ/Core/WordRAM/E1QueryBridge.lean", + "mode": "100644", + "gitBlob": "5b1bcb4b7e80bc0b7432365a6218adfa78d186c1", + "rawBytes": 5666, + "rawSHA256": "D2581FE4A89435853E1FCF873CB3FBBC527D3B995C2EBE44D6C299E137D937CE" + }, + { + "path": "RMQ/Core/WordRAM/E1QueryProgram.lean", + "mode": "100644", + "gitBlob": "d116a384d1b0de706d680cea95cf145f76e9a31c", + "rawBytes": 24472, + "rawSHA256": "7AA365A2546AC3BF03940C922BE6D047AAE803B1A72E85E96C2A592442BA1F47" + }, + { + "path": "RMQ/Core/WordRAM/E1RankAtBlock.lean", + "mode": "100644", + "gitBlob": "00830758e171b88ac77530c2a93b526f7edadb23", + "rawBytes": 22104, + "rawSHA256": "B28CB35B0A8C39FFBE287B221CAAD7C4A860CD1B630228915E72AD381BF58AAA" + }, + { + "path": "RMQ/Core/WordRAM/E1RankBlock.lean", + "mode": "100644", + "gitBlob": "85187e40713589b82268b047441f10775724d783", + "rawBytes": 43362, + "rawSHA256": "8FD21D490A4652F799E3428AA2CDEEC28B8EB7DF14890D999B29C3F05F410ADA" + }, + { + "path": "RMQ/Core/WordRAM/E1RankBridge.lean", + "mode": "100644", + "gitBlob": "6e1eec24542ffb497076e9c497846d2906416207", + "rawBytes": 17770, + "rawSHA256": "40754A0D37317F48F88125E66E6CE207683F639BB4DDBEDDA4669D80BF1B4ED0" + }, + { + "path": "RMQ/Core/WordRAM/E1RankCanonical.lean", + "mode": "100644", + "gitBlob": "1cd734c77ca27ffe678389b575c1570a41e2a78f", + "rawBytes": 17704, + "rawSHA256": "0A056927249262FB06917370BA3BC89DADB4CE3676B37CC8275409D1164FC9FC" + }, + { + "path": "RMQ/Core/WordRAM/E1RankTrueBlock.lean", + "mode": "100644", + "gitBlob": "f27d8640fd9f6e62b5854e5b22e70273d309dcce", + "rawBytes": 37429, + "rawSHA256": "EEE41E50EEFFDB5215412F1CC70BBB0B31BC8C5B21C875B52590463303E79053" + }, + { + "path": "RMQ/Core/WordRAM/E1RouteDecomposition.lean", + "mode": "100644", + "gitBlob": "71c261dc0e05f32855566b9fb124b5ae1f351e41", + "rawBytes": 8367, + "rawSHA256": "5F3AD98AFA01B98398316B5A027907D3B6715557E83843AC0FB6D3BD0BD7BD58" + }, + { + "path": "RMQ/Core/WordRAM/E1SameBlockArm.lean", + "mode": "100644", + "gitBlob": "2bd5e5784e9d4e9fd09cb5ef059cc57363e2f003", + "rawBytes": 26223, + "rawSHA256": "8724AD3CB2A17AFFA4148C5506E2C233EB049758ED4A66D4D6B8727268FE2064" + }, + { + "path": "RMQ/Core/WordRAM/E1SameBlockLeg.lean", + "mode": "100644", + "gitBlob": "5b7082fc4756627bb019098bddb89c0059504f1b", + "rawBytes": 27439, + "rawSHA256": "1001BD1BB66BE8C612A178179FEE50D3070619617B01FFD9841E95AAA302EC9C" + }, + { + "path": "RMQ/Core/WordRAM/E1SelectBlock.lean", + "mode": "100644", + "gitBlob": "bdc243642440376d5236147633d266928129c3f4", + "rawBytes": 33317, + "rawSHA256": "E0A00BA45005BC2B83BC18FB776839CD4FC3058CE22E1D9118DF93395F65160D" + }, + { + "path": "RMQ/Core/WordRAM/E1SelectBridge.lean", + "mode": "100644", + "gitBlob": "e1299f1a9e3fb389596f3be2510b77234abb21f4", + "rawBytes": 24487, + "rawSHA256": "20101739899D2939691506FC3B453653C999A7A490899DD9805D42CDF584B602" + }, + { + "path": "RMQ/Core/WordRAM/E1SelectCanonical.lean", + "mode": "100644", + "gitBlob": "ca8fdd96a25cc68f0c9de790a276a2961520fa7e", + "rawBytes": 13074, + "rawSHA256": "5374F6652FBD35C22C98E523D71A64E02A0E6D1F26894EB5B92CE668CFAA890A" + }, + { + "path": "RMQ/Core/WordRAM/E1SelectDispatch.lean", + "mode": "100644", + "gitBlob": "8f866a3cd6043092835b6c04947c6a1337a7f12e", + "rawBytes": 96358, + "rawSHA256": "80D39B97653BE2F30988FC9BBD5BC2FEA8588FBAE952C9DB8E917A5459C7588E" + }, + { + "path": "RMQ/Core/WordRAM/E1SelectLegBlocks.lean", + "mode": "100644", + "gitBlob": "90e02d52a97f46e7e8bb9d8735f856b5483efdbb", + "rawBytes": 28145, + "rawSHA256": "33BB4C588CB7508E1FE9F1C5F2F2BEE635AE5D02C10E0A48CCB8D3DEF6C5A8A4" + }, + { + "path": "RMQ/Core/WordRAM/E1StraightLine.lean", + "mode": "100644", + "gitBlob": "4a4d841111aeab1968dca60d5fedae10d31b894e", + "rawBytes": 10359, + "rawSHA256": "CB35ABC7263CA27F93F702E0A5C110D2D6F31F1FDABAC21AA7E840E0CECAC2A2" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Accounting.lean", + "mode": "100644", + "gitBlob": "ff3d382804d84885409f7c072270bbf9a4929968", + "rawBytes": 3507, + "rawSHA256": "F57E0758F80EBE6820648E1BF71A1F810FE1D65E9814B7351713D8D00E6A0D94" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Agreement.lean", + "mode": "100644", + "gitBlob": "d6f7a480c8e604911d06ac611bb39b98b520fb2a", + "rawBytes": 20605, + "rawSHA256": "64EC32E23F112847053DCCFA29503D6889CF8F757ABEE1076915C1EAFC245146" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/ArrayRun.lean", + "mode": "100644", + "gitBlob": "58e7f35043be168daadb0230fbf8447df9e84a28", + "rawBytes": 34169, + "rawSHA256": "E9342577949EC6AF15ECE43EBAA742D30142F7B6769C8036B9E95F22D59DD0C7" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/BoundarySafety.lean", + "mode": "100644", + "gitBlob": "558706446150cab142e76a563b0fd8caaa2ffb64", + "rawBytes": 5959, + "rawSHA256": "DDD3151AE95F579BD8531DF8C8B5D5E94F8F48501E4020E85565F1DAA3FCE49C" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Builder.lean", + "mode": "100644", + "gitBlob": "54bde55b848d829e9d30dfb9ccfb1fbfc765c193", + "rawBytes": 13873, + "rawSHA256": "95E14947A06C81C42439666D59D5959B387E75CA38B8157B717E8CAF6CD55383" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/BuilderProvenance.lean", + "mode": "100644", + "gitBlob": "c81d6a1dbd4c2117caa4a7c9634dbd93bb5deefe", + "rawBytes": 13651, + "rawSHA256": "4290EDA7E8EEC442E1D823FC50A74F06AC85E6BF2C25B34E5815724C6CF81B93" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Calculus.lean", + "mode": "100644", + "gitBlob": "6fc1e652a2c20fe2393fdae68fbb580fb7703b8d", + "rawBytes": 10079, + "rawSHA256": "E962506395C90EEBA73B070A18365449F93C27CD5719A37E1D679D64FD3DF9B3" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Capstone.lean", + "mode": "100644", + "gitBlob": "9cb036d133da1bbebdfb93943dc6c9ccec62d310", + "rawBytes": 13580, + "rawSHA256": "DA6402BFBBD286831FE18237686BC01A535DBA8A35ABE92290194D15F20C3E3D" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/CodeFetch.lean", + "mode": "100644", + "gitBlob": "1b4d2c82b171845216f1cbe58ef462d11ae32ad4", + "rawBytes": 3157, + "rawSHA256": "748474489F06988205A567F63474122BB0FE1D3DC59CB51FDECF75C2B95440C5" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Construction.lean", + "mode": "100644", + "gitBlob": "bb8788cfb3ce643bfb1bd542445a1f91d6a4021f", + "rawBytes": 15250, + "rawSHA256": "BFFF5EA62F452FF86ED80C0B22B781E3D538B8511FEC9C54239A41DADB28BB76" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Continuous.lean", + "mode": "100644", + "gitBlob": "c75d2790f3c9336a9bdf8cf632ee8ac3314051cc", + "rawBytes": 12794, + "rawSHA256": "DC52EA63307898E7D00511B1CE6FFDE89641237BC94DB0F0CA207B851A933207" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Controls.lean", + "mode": "100644", + "gitBlob": "59f3749798a51b19adcc55cfae596d61b375c64a", + "rawBytes": 13170, + "rawSHA256": "207F4D5CCACA1C33143C6E457C90129AD876672BDC0786E29FACE52F434E8828" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Descriptor.lean", + "mode": "100644", + "gitBlob": "22db7d7e11e469c46f09a2032849529b8e92d6da", + "rawBytes": 15700, + "rawSHA256": "789B974B76E89264EED035DEFD97559D1E823031A19FA990EE35085436BCFD64" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Executable.lean", + "mode": "100644", + "gitBlob": "5aea1c1267ec5c3d5e7cb12f56b17f797516b417", + "rawBytes": 43297, + "rawSHA256": "7ED53FD5715A4EA1D6628AE52F626B1573B2F20BB4E6B9B983C0A2C32DE41BAF" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Finalization.lean", + "mode": "100644", + "gitBlob": "49e18b6e158ecfcd0c7247402a3502a4097a8630", + "rawBytes": 29881, + "rawSHA256": "8288249EC0341D280B3B78A23A73A34BDDAE36B2DFA345D0FE097E0E15085865" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Finalizer.lean", + "mode": "100644", + "gitBlob": "69ee3460aacba441914d77c1433eafd6ebfcd6c2", + "rawBytes": 43977, + "rawSHA256": "0AE34DD1731D0D51AF30FBAA0D26E27ABB0FB63C2F8E5D19C5543C765812354B" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Input.lean", + "mode": "100644", + "gitBlob": "2df3df361dee8c9556de50a792de6d8ca903169d", + "rawBytes": 6850, + "rawSHA256": "3B54BFBA5E08ABEF39F3C50991F2224DEBAAD792418B329C8C6CF90B8A3F21D9" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Machine.lean", + "mode": "100644", + "gitBlob": "f4dca3838293d7f94d663045d2c13c4c44fd55f4", + "rawBytes": 7428, + "rawSHA256": "BBC0E439FB2FA55AE75E440AC3A6C77E6203FC6F7B39B2CAE8B95E1ED2B8D57B" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Ownership.lean", + "mode": "100644", + "gitBlob": "adbcae8fc33a4fa670f421e7198e5f421dcea345", + "rawBytes": 6211, + "rawSHA256": "094FD2AEB50DBF66C209FE9C52ED1352E8D413205C281246FF983DD4DFF7197B" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Physical.lean", + "mode": "100644", + "gitBlob": "e6aa6e48bde045042b857da4a7c9383af37254c0", + "rawBytes": 36552, + "rawSHA256": "22DCD8903F457A75C581D771C4804CA2E5375BC1F5D1AFD539227494D6240C5E" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Profile.lean", + "mode": "100644", + "gitBlob": "7f876238f299df195f564015ade9a4b6fb91de86", + "rawBytes": 5061, + "rawSHA256": "9B2D904D9A585BC134E0D74E89E91F6FBC4B6F20F880D0AD718D9E86C7D5800B" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Program.lean", + "mode": "100644", + "gitBlob": "02f4dc48ca2a2b7e6c053d3742ac4d0e2331f820", + "rawBytes": 8412, + "rawSHA256": "BB40B5AB3B7532EA4F907BF1D174DD2DE14013C5E022454CB7C3B99CC2707DFC" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Provenance.lean", + "mode": "100644", + "gitBlob": "4c878fa3cbe5818bff3941de3f47f195e51bb7cb", + "rawBytes": 13708, + "rawSHA256": "C5AA67539106246D4461DAC3D5617C01B24730F7348B44A95F046DC031FE3308" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/QueryBridge.lean", + "mode": "100644", + "gitBlob": "54b8e510b3417e75ac20a6b3a39cc2af8e8b6c28", + "rawBytes": 8004, + "rawSHA256": "DF9AB7E58C853FC33A047B0F01BAAFCC2BC40D359657CDD1FC824DA6C0E78265" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/QueryEntry.lean", + "mode": "100644", + "gitBlob": "d385098fbb0938f83c7d6f37226b2569c8ecd856", + "rawBytes": 25120, + "rawSHA256": "5FE765C5ED664E87A9FFC43A4C00B9DC294CE6D2DD75FD6AEEC51DBD469FE25E" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/QuerySafetyBridge.lean", + "mode": "100644", + "gitBlob": "245e77ea37749b542b2a2db99ff9de33818fbd8c", + "rawBytes": 24516, + "rawSHA256": "B0324D42D7309664380842C74FBBAB479B0F20146AC32C07CF78583C96D96043" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Resources.lean", + "mode": "100644", + "gitBlob": "a23a9004547c96deb5e8384a3bc80da172177823", + "rawBytes": 5950, + "rawSHA256": "BD931D49482D8AF1BBEC8E8DD78BB7D9DCDF6FA1F65E814856A099964055EC62" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Retained.lean", + "mode": "100644", + "gitBlob": "154cedad80ea3feb1c53210581db8e5dab086fb7", + "rawBytes": 4593, + "rawSHA256": "FF6ADA49C394E940E68ECE8BDC52DC39C436CA6299837BFD9FF639EF7EE95301" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Retirement.lean", + "mode": "100644", + "gitBlob": "08495761452e2dfbec9450c6041901eaa698861f", + "rawBytes": 23754, + "rawSHA256": "248106288060C2B3316A3FC133093385E498E3775C91BC73C005136DB879FB4B" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Reusable.lean", + "mode": "100644", + "gitBlob": "2d0de18da29bab15beb0a5e8a1b18b1aa0ae60ca", + "rawBytes": 26810, + "rawSHA256": "087D46AFB3B9DA6CFD7373CF8B3C7752FB7B538B4C20942775180B1957C8FF67" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Safety.lean", + "mode": "100644", + "gitBlob": "38b82010e24f51fce11681ebc95680e92d20c97f", + "rawBytes": 5960, + "rawSHA256": "1C0F972965596DFBB631B7BD44AAEA00B1178EE9B6C40DDB7D2BD45D95F4C490" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Service.lean", + "mode": "100644", + "gitBlob": "2591a4f4b65519301bd05b9e2568a1b53bd4ff45", + "rawBytes": 8157, + "rawSHA256": "F4157493517F232A6A83BB52C87B751F6A0C2C1F9CA9C98FB6CAE036542A34E0" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/ServiceSafety.lean", + "mode": "100644", + "gitBlob": "891afe0e832c8e22493afb3c882c3aa569a12c18", + "rawBytes": 20576, + "rawSHA256": "121A2BCE2ED5BDE35BFCE6A8FE7180814531CA3C1487CC77F768993D5BEB3A31" + }, + { + "path": "RMQ/Core/WordRAM/Native/.gitattributes", + "mode": "100644", + "gitBlob": "6ed29baa59dbd6707dfd833d6fba125f605a0a68", + "rawBytes": 94, + "rawSHA256": "B551B88139A88AFD228E5532B8D82F6DF705A9B82ECE640523E3543C9B089E0B" + }, + { + "path": "RMQ/Core/WordRAM/Native/AxiomChecks.lean", + "mode": "100644", + "gitBlob": "54229006f8805c07ddadd1a13c7cca2b6a90e257", + "rawBytes": 4353, + "rawSHA256": "013D4C738E37228F323ECDD606CED8AB0B5D7E5D515225A3CFE6A8D1A2AAF379" + }, + { + "path": "RMQ/Core/WordRAM/Native/Binary.lean", + "mode": "100644", + "gitBlob": "54687742f4641fc517329a10e97575ec03fe7a0d", + "rawBytes": 25637, + "rawSHA256": "C50741D0A9AED1797919F405E8F7440410C0CD13DD2B9F299D0E6AB5E959AE16" + }, + { + "path": "RMQ/Core/WordRAM/Native/Binary/Bounds.lean", + "mode": "100644", + "gitBlob": "08c99b2453cf801c8586e792142d099342eec086", + "rawBytes": 6807, + "rawSHA256": "1ADF9BE737AD6C86AAC6E5FBA75ED3384876AA029CCEFBBD76CDA03DF70C339E" + }, + { + "path": "RMQ/Core/WordRAM/Native/Binary/Checks.lean", + "mode": "100644", + "gitBlob": "5e060cf492707eb7062963eab9fb649c74cb00a0", + "rawBytes": 12340, + "rawSHA256": "03B4786F8AB00028B09AB6270EFE3B9CF9E178E7DB4CA4D98C98D0EEBC255CAD" + }, + { + "path": "RMQ/Core/WordRAM/Native/Binary/Codec.lean", + "mode": "100644", + "gitBlob": "1ba71e9c2c9fbf454268eb21b8c4907bd8612ae6", + "rawBytes": 16260, + "rawSHA256": "E46F05148BB2F4D1D25C848EC804B0E2E0881EFB536F988A90AB9CB7371C11F7" + }, + { + "path": "RMQ/Core/WordRAM/Native/Binary/Cursor.lean", + "mode": "100644", + "gitBlob": "46b3370b0116fc071f9102c48205fdeaf151e69f", + "rawBytes": 10733, + "rawSHA256": "FA032A73E3CAAB84A874D736D26CA8B833CECC526BBC880BDF09AC8647E68F45" + }, + { + "path": "RMQ/Core/WordRAM/Native/Binary/Cursor/Checks.lean", + "mode": "100644", + "gitBlob": "6bcaf6c3ae76f7d413e7eba37f177b3c12d2e69f", + "rawBytes": 7833, + "rawSHA256": "F7B081BA8BB3A4E11FAA1AB75660D7F24613FAD1E4745FE7EDC7EA2A07F1A0A2" + }, + { + "path": "RMQ/Core/WordRAM/Native/Binary/Cursor/Core.lean", + "mode": "100644", + "gitBlob": "a8f6d49eed485b7036ab8f06c2c2e71cc6e04581", + "rawBytes": 24281, + "rawSHA256": "18F42ACEE5D218DA5CB6B787E7DF25C69C572C72551E3008D1106A6CFA660E28" + }, + { + "path": "RMQ/Core/WordRAM/Native/Canonical.lean", + "mode": "100644", + "gitBlob": "cf5aca6ff7b7554bd3d89c93c1b317015a2fd237", + "rawBytes": 6847, + "rawSHA256": "D61C7C1AA6C5FB521995A96F5EC0EBDFE8BDBE4A58CB1F6E159080E365AB857D" + }, + { + "path": "RMQ/Core/WordRAM/Native/CanonicalImage.lean", + "mode": "100644", + "gitBlob": "b3a3245bef846330952f8bd4628625ef8e1c285e", + "rawBytes": 4727, + "rawSHA256": "2A8469798F8A7700F22DA9F01AA157BFDE5F5BF7FE7282132DD53675FD74EE75" + }, + { + "path": "RMQ/Core/WordRAM/Native/Capstone.lean", + "mode": "100644", + "gitBlob": "7fe78d055cdec2f8a4bd91d068ee1a6db93220ba", + "rawBytes": 17145, + "rawSHA256": "E2B2FB55223A271B3383AACB70361D85126ABEB3C252ACB0E314467729C6FA0D" + }, + { + "path": "RMQ/Core/WordRAM/Native/Contract.lean", + "mode": "100644", + "gitBlob": "878e44a24c63ce9fb1f0712e6b9245191308a394", + "rawBytes": 13766, + "rawSHA256": "A8DB1EAAC6445F2F8490A6C344A3F573FD169D3FD7B82E6637C4947159E306AE" + }, + { + "path": "RMQ/Core/WordRAM/Native/Entry.lean", + "mode": "100644", + "gitBlob": "85c45b3d794212d40b7bdf0de43246e23c891c9a", + "rawBytes": 2266, + "rawSHA256": "ADD666450D8CF6B724F1467CC2CD4182E8B5EEFC50AE1BF369AEFC5A2A4B7832" + }, + { + "path": "RMQ/Core/WordRAM/Native/Execution.lean", + "mode": "100644", + "gitBlob": "a229ae59c36c222cedf433c8211d725cd2e7df16", + "rawBytes": 8989, + "rawSHA256": "1367785E02684C7A81C93DF9815D8B736A3490F32046619C75A1838BAF469C06" + }, + { + "path": "RMQ/Core/WordRAM/Native/Finite.lean", + "mode": "100644", + "gitBlob": "987577f5e33326093ecb0903ee5ae332e5f60a9b", + "rawBytes": 11537, + "rawSHA256": "8EDC747F2F0BBB7D4E6F6849B63869016969C4F7535D62E99A6E4D01901223DF" + }, + { + "path": "RMQ/Core/WordRAM/Native/Host.lean", + "mode": "100644", + "gitBlob": "ef898ee5cdc78ee2b4732ebe1fb0a9e52d2b3405", + "rawBytes": 2820, + "rawSHA256": "290F2DAB5985363FD2994EE3F96A21924F3EBD63F3A79A9F2E7DF476173001F0" + }, + { + "path": "RMQ/Core/WordRAM/Native/Lifecycle.lean", + "mode": "100644", + "gitBlob": "5eccad3416e7de0e87143307d8ce246962f8ec48", + "rawBytes": 251, + "rawSHA256": "1DD052446E9CEAAC61A94875F04F5746AE0E67882533AF041EE2A8A7769D9288" + }, + { + "path": "RMQ/Core/WordRAM/Native/Lifecycle/Admission.lean", + "mode": "100644", + "gitBlob": "b8ec310dd2107b761e28b271d5940c7f26e485eb", + "rawBytes": 11538, + "rawSHA256": "36BF7EB2FBC592FE178BEF884591C5962A43A34B6870405789287B4106F3E6D4" + }, + { + "path": "RMQ/Core/WordRAM/Native/Lifecycle/AdmissionContract.lean", + "mode": "100644", + "gitBlob": "39e55e326e6d8d2fa539b1101085e4450a5429c4", + "rawBytes": 8956, + "rawSHA256": "98E6CC6CA683B93EB288F692FDCFF6C63800FFF879490E2665B68FBF420D67EA" + }, + { + "path": "RMQ/Core/WordRAM/Native/Lifecycle/BoundaryProofs.lean", + "mode": "100644", + "gitBlob": "c61bd032e0caff6286a3a63b456313620865c305", + "rawBytes": 10281, + "rawSHA256": "519D089C5B26C2A75153F2C6FEE666333F921DA3766892411178B313023CC879" + }, + { + "path": "RMQ/Core/WordRAM/Native/Lifecycle/Codec.lean", + "mode": "100644", + "gitBlob": "8681132a10ab7e3a95d9236cc5067a993d4a5632", + "rawBytes": 6872, + "rawSHA256": "219669A34FA433EFE27B6CFB8E98C22813C98D96CC4E7DCD018C3F044FDF84CA" + }, + { + "path": "RMQ/Core/WordRAM/Native/Lifecycle/Contract.lean", + "mode": "100644", + "gitBlob": "23d8cdd93957c3450b5acd68b4b8df16d61bc60d", + "rawBytes": 7502, + "rawSHA256": "A61D3359B1D3066ABE8F8CD5D3F3BE3597798EA4A2D09E0CB825F9EF5ED7BAEA" + }, + { + "path": "RMQ/Core/WordRAM/Native/Lifecycle/Entry.lean", + "mode": "100644", + "gitBlob": "3cb62996781c160aebe7146a08edaea2047b1269", + "rawBytes": 8601, + "rawSHA256": "176189BA4C8218A6E8F397580230A4FA2FBDE0BE2C875741C9F7CA8D80BB0901" + }, + { + "path": "RMQ/Core/WordRAM/Native/Lifecycle/Observations.lean", + "mode": "100644", + "gitBlob": "85c734bcc05be29e390f019ba61ea6f937eb2109", + "rawBytes": 32943, + "rawSHA256": "1216FE255E14175F2EE67B2C77C28CDB0509606C3BE4B0063FD22D39867DBB96" + }, + { + "path": "RMQ/Core/WordRAM/Native/Lifecycle/Repack.lean", + "mode": "100644", + "gitBlob": "a03c06935e0957b63acd713f1ea05d5bdc2dd9bc", + "rawBytes": 2485, + "rawSHA256": "B229BDB19781AE318694FAA62A83B57802634FEC27C7EDB2D4B5899DB56B2639" + }, + { + "path": "RMQ/Core/WordRAM/Native/Lifecycle/Run.lean", + "mode": "100644", + "gitBlob": "ddfd5c22dfa2e4a744dfaca89300b155a5179795", + "rawBytes": 2333, + "rawSHA256": "FAA4FCABD70CF8462670691E43C1B0DF9FF6D7C7CE9FC19F4AC87571910FEC36" + }, + { + "path": "RMQ/Core/WordRAM/Native/Lifecycle/ThinRun.lean", + "mode": "100644", + "gitBlob": "f82d12a49b541a8ba008493e964f50c9973c1d80", + "rawBytes": 2386, + "rawSHA256": "962DD0D1B1ED610835B04BAE4A5309CC194E610F8B8200462B04EC03545E2602" + }, + { + "path": "RMQ/Core/WordRAM/Native/Limbs.lean", + "mode": "100644", + "gitBlob": "fc5ac5b4cac019a10c8c604c2d8216aede5faa97", + "rawBytes": 15313, + "rawSHA256": "06D057D0DE50E263E701D2D5FEA1A4B0E1F6C3DD9A6BFDB6F2F9EDE71A7803F1" + }, + { + "path": "RMQ/Core/WordRAM/Native/Limbs/Checks.lean", + "mode": "100644", + "gitBlob": "6b7b6bf5cd189e7bffa50eb3d282e1f5cf8ca964", + "rawBytes": 5602, + "rawSHA256": "C78560DBEB2076F12A5EFBBB3E9CF9389387CACCF7AB9A3F8C6B3B16EA3E643A" + }, + { + "path": "RMQ/Core/WordRAM/Native/Machine.lean", + "mode": "100644", + "gitBlob": "7808441654336fecb7dbc00d3c960e512f6dcba6", + "rawBytes": 38858, + "rawSHA256": "F5286E6B52A5C5A73571BBF831E7CA9C5D731F7F5998F3ABA724E17F7AB94B3D" + }, + { + "path": "RMQ/Core/WordRAM/Native/Machine/Checks.lean", + "mode": "100644", + "gitBlob": "74dcd3d152f7aaaa5ab16ebe36a3759185822f74", + "rawBytes": 7330, + "rawSHA256": "F8B62700DFFCF1BF1948EE63BE1FFCBE5A9E10757A569E3DF8A7EEC8F27614C2" + }, + { + "path": "RMQ/Core/WordRAM/Native/Machine/CodeFacts.lean", + "mode": "100644", + "gitBlob": "25413782c337fb100dfa2c8f4b0fd3d488b98a4e", + "rawBytes": 7126, + "rawSHA256": "94AA115EA137C32F0D11E3714A0E6C0ADD87165ED1306CDBBC22ECC4C0030C00" + }, + { + "path": "RMQ/Core/WordRAM/Native/Machine/CodeFactsChecks.lean", + "mode": "100644", + "gitBlob": "42fc709b74722a236fdaa6ded2ec08f758575905", + "rawBytes": 1432, + "rawSHA256": "A3AAC86CE95AF7B8F477B499D8DFD6AD8A304EDE8CEB20461054A2E0A6151ECE" + }, + { + "path": "RMQ/Core/WordRAM/Native/Observations.lean", + "mode": "100644", + "gitBlob": "b02321cd8584c6c9c0bb85f413f2349854685f85", + "rawBytes": 3164, + "rawSHA256": "BC3C825AB7598810F9506B36D0EC9F34031DF7D9715F2AB68FEDB823009679B6" + }, + { + "path": "RMQ/Core/WordRAM/Native/Route.lean", + "mode": "100644", + "gitBlob": "ed34016488095d90560f26a6fa6a91ec6d569452", + "rawBytes": 7462, + "rawSHA256": "C00240A5A2E994DD1A996C79A52FF54780A0B5A87010B3DBCF4ED3A61244A5C5" + }, + { + "path": "RMQ/Core/WordRAM/Native/Runtime.lean", + "mode": "100644", + "gitBlob": "886d698777ec9acce552a8459683cb3dfcb3dbd5", + "rawBytes": 6120, + "rawSHA256": "23EF158FCC87169566CC443401BD6842197F9373E39CF5DF172165B765FEA847" + }, + { + "path": "RMQ/Core/WordRAM/Native/Thin.lean", + "mode": "100644", + "gitBlob": "7fd0365ff4bc40be2e95386c428a1ee6e3ab3ede", + "rawBytes": 4498, + "rawSHA256": "26D984386EEA21CCCC49EBF6217CD824B7896CF98785F8F843C6AD9E2EB69845" + }, + { + "path": "RMQ/Core/WordRAM/Native/WitnessExport.lean", + "mode": "100644", + "gitBlob": "cd5a1e59c85fbb2afcb0df4c55c9455928e70e51", + "rawBytes": 13585, + "rawSHA256": "4CF5C928FCD784DF112115A8BDFF87A8CA3FFC85AF04B679E320402106466F70" + }, + { + "path": "RMQ/Core/WordRAM/Native/Witnesses.lean", + "mode": "100644", + "gitBlob": "2192ef86e5d8abdee7c7e5d8c5f3a0971bb6cbb7", + "rawBytes": 10501, + "rawSHA256": "8E732E615A9E69646AD6B6D2FDA5F632DF9826D2A22CA1B2DD71C98FF016B642" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/BranchBound.lean", + "mode": "100644", + "gitBlob": "48157b1318258ad86649efed70af04471f1f8e5b", + "rawBytes": 17543, + "rawSHA256": "64F539C5E8F0247A630B5099E6F9A0D4E8BD00F6DFC8F0073E8179CB870B66D0" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/Capstone.lean", + "mode": "100644", + "gitBlob": "7eeebe68bbd2ea3077fe825a5b01462e1b8f09a4", + "rawBytes": 7574, + "rawSHA256": "6F960B2C3D01676E2A5FE29509622B901DFA97072E2529D6D6BEFE70B3158A63" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/Certificate.lean", + "mode": "100644", + "gitBlob": "9d47713c26a491934ab17526750b08761c6afa87", + "rawBytes": 9238, + "rawSHA256": "4750350391BBCA77AF33F4952AFCD091142FA62A788841A58F03B9ED2DC40430" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/Compact.lean", + "mode": "100644", + "gitBlob": "42259f79f94c26bc4e06e89ca5c4ed4588bcbfb2", + "rawBytes": 3208, + "rawSHA256": "7BDE1173B5661A8C68ACFD13F5E9911D176CF8E55F7FBD635E8A5E5819C8DE17" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/CompactProof.lean", + "mode": "100644", + "gitBlob": "c349a1ad48cdc85169623acbe7647d43cf292925", + "rawBytes": 31141, + "rawSHA256": "54BF190DDFAA28AA410583942DAEB219937E8DB061AC4CE6CA8CF1BA201CB5B4" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/CompactSafety.lean", + "mode": "100644", + "gitBlob": "11a777f9b21b4c946b5c8d01df3aa2e953bc81db", + "rawBytes": 34678, + "rawSHA256": "6B84A73FCF1D9DDC6D5C7117EA5B55D4FCD840B6676CBAAB717FBBDD7476563E" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/CompactStatic.lean", + "mode": "100644", + "gitBlob": "b0164a73b49c8407267ff30c779fca3d39025843", + "rawBytes": 17274, + "rawSHA256": "5C5F1AB987ABE38D7BB41B93DC67BA6DCDF15C6ED805F4EB1C95037A338875A2" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/Consumers.lean", + "mode": "100644", + "gitBlob": "7a78c403e548df7ba7e7782ab081f08c4f4ad32b", + "rawBytes": 25172, + "rawSHA256": "47A1C35EC6EA7DB27A16ABE4CB282A1043EF315F54485806BF4F986E7F5D5597" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/Query.lean", + "mode": "100644", + "gitBlob": "3f1829809423696c204372ae2056348c4a7ff2f7", + "rawBytes": 9432, + "rawSHA256": "1FE89CF2B3F2833C330C91DB9C93EA35B6C37A3F98BC85A4B241D6AA63C36C05" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/QueryProof.lean", + "mode": "100644", + "gitBlob": "aeaf3b8ab78f7c316d1e6fc267447e72bf8d1daf", + "rawBytes": 6442, + "rawSHA256": "F5520F3B203A20EB8EBFACD2C0381C4EC2503DC9A975E4876B361D16D40CEB58" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/QuerySafety.lean", + "mode": "100644", + "gitBlob": "c414eb89274fd85807fcd6fe070ebfefb1a362d1", + "rawBytes": 2379, + "rawSHA256": "E546204B1380775F78A82F45BDB07616B86BACF55DD73D06FAABFE60E7DA41D5" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/SourceRelations.lean", + "mode": "100644", + "gitBlob": "089d6b1a3e9768bca1be2c60510e5570b8b0b255", + "rawBytes": 17566, + "rawSHA256": "B6CC636BFD691D18F4BDE989AFE188365D12007B68565CAC98CC3CC394E3A0DB" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Accounting.lean", + "mode": "100644", + "gitBlob": "986ef250b8dfaf17ef712c559bae6c3fce61ac5f", + "rawBytes": 2876, + "rawSHA256": "9429C3D715B22D587D4CAD41BC5F288987D1A27D51DA345ED6C6EEC85333E2CB" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Allocation.lean", + "mode": "100644", + "gitBlob": "39d65f0bc8a19dfc8467d16263bfc631e99c6551", + "rawBytes": 9520, + "rawSHA256": "7FDC39400FF3AB877BECD63D2E367E24ACE0C71F373C7F54017039EE578E7D49" + }, + { + "path": "RMQ/Core/WordRAM/Packed/AllocationLowerBound.lean", + "mode": "100644", + "gitBlob": "8806fc00da8501ed57de269a32f6f3135450f591", + "rawBytes": 26743, + "rawSHA256": "D571B5F875EC5C34BE3056841DBF90CFAF00CFB3FF4FCACEA19E1D83253D6D06" + }, + { + "path": "RMQ/Core/WordRAM/Packed/ArrayRun.lean", + "mode": "100644", + "gitBlob": "0e6484f9a5238cd7805ed31a8e406fbc9081e844", + "rawBytes": 2050, + "rawSHA256": "CD45C07C1F822C1BA57B65ACCA2F5CE916FA735B33269AFB7CEB17F4E3B9C82F" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Calculus.lean", + "mode": "100644", + "gitBlob": "1a4908d33997a2f6222a64a080d772f37ccc6a81", + "rawBytes": 17807, + "rawSHA256": "2BA830CA4AD97FE7A51A6561C5F18EAFF7D2BC4084EDD0D124FE47C41D955A45" + }, + { + "path": "RMQ/Core/WordRAM/Packed/CandidateProof.lean", + "mode": "100644", + "gitBlob": "c0d507aa3126cf91b8d4b752e0d25b4ae838e1d6", + "rawBytes": 5101, + "rawSHA256": "122EFD67E9A359275F949A85185CC45D406B6648211091A6704805C5CB3033A2" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Capstone.lean", + "mode": "100644", + "gitBlob": "4bdf1fda17b0eceee714c7719175e8357bcd3ced", + "rawBytes": 11554, + "rawSHA256": "D9C7BB7D158D54C9F221080453C58F7DA6960497D287B7ACCC39BEBB3F931A2C" + }, + { + "path": "RMQ/Core/WordRAM/Packed/ChunkArithmetic.lean", + "mode": "100644", + "gitBlob": "824723043427fc36a9a6e5c0a4ce8ca47b13bc9f", + "rawBytes": 10439, + "rawSHA256": "0F1B3DE7E3CF3DC37036335DA47FEA5F4A859E06BFBDF47314F23C6312A982FE" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Compiler.lean", + "mode": "100644", + "gitBlob": "2cd06337d200b1c778145a286d7a08146bcef910", + "rawBytes": 29873, + "rawSHA256": "C7AAA88DFB6A24099F8E7B22D7AC77942043476A47874A414BDAB58C77EE5505" + }, + { + "path": "RMQ/Core/WordRAM/Packed/DensePacking.lean", + "mode": "100644", + "gitBlob": "fc07693b13a3362e22ccb4b2b6e239d55cdf4a7a", + "rawBytes": 8009, + "rawSHA256": "75487722A3DBB6BCB3D445B0C242E8380F7B9F77A0762354D83F692CBC956913" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Frame.lean", + "mode": "100644", + "gitBlob": "da57356278dbd5a6cb1febf3d3e1cada43857a80", + "rawBytes": 3216, + "rawSHA256": "480EA8DF315B6DEE0F2048EEEAC03131368FD27EF09E0AAFA21DA2A676929939" + }, + { + "path": "RMQ/Core/WordRAM/Packed/FringeProof.lean", + "mode": "100644", + "gitBlob": "884ca054aaaaf20b33aec0afcfb4fbfd32cb8cb0", + "rawBytes": 49982, + "rawSHA256": "80E9DCC3C7410D60ED99EBEBD7F2A40D8FAF54F634BD5310F326319EBE589FBB" + }, + { + "path": "RMQ/Core/WordRAM/Packed/FringeSafety.lean", + "mode": "100644", + "gitBlob": "1bd86ca09a2d07f86886d3667bd79a9f68cc3652", + "rawBytes": 56146, + "rawSHA256": "9D582E04A68534074A62F4494969E60264102E87A554DC4C0A9328327B841F2A" + }, + { + "path": "RMQ/Core/WordRAM/Packed/FringeSource.lean", + "mode": "100644", + "gitBlob": "7865a9671d9453dc9ac8bf66af2c8642e4360f10", + "rawBytes": 8756, + "rawSHA256": "BC779A746A938C7B10FDB4B93C84003E9CA91D27FB3A3813ABDF5944920B96C2" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Guard.lean", + "mode": "100644", + "gitBlob": "8cfeba2892f8321956d799eb3514c7522bf46a7b", + "rawBytes": 5782, + "rawSHA256": "B911E50388FBDCDCD82A8E3ADEDD754473B6E5AB162A0D5D25B5C009A9160FFC" + }, + { + "path": "RMQ/Core/WordRAM/Packed/InteriorCandidateProof.lean", + "mode": "100644", + "gitBlob": "536c476bcebca4833366a5f3f0be3d5d19d4a09e", + "rawBytes": 131852, + "rawSHA256": "CE6073BE51D918B221216B6DFAD4CB913D2372E3D2F5EA66A3F09233589C4987" + }, + { + "path": "RMQ/Core/WordRAM/Packed/InteriorLocate.lean", + "mode": "100644", + "gitBlob": "2b76d6235136a8bb9afc1daac7fe67df6ce34012", + "rawBytes": 7310, + "rawSHA256": "E570243D505D2498085A4CA289DEB74E7CCC98985F08AFF7BFB9D9D3151600E7" + }, + { + "path": "RMQ/Core/WordRAM/Packed/InteriorReadProof.lean", + "mode": "100644", + "gitBlob": "e59f716c11e9cdc0b323265220e0e5633e87789f", + "rawBytes": 38897, + "rawSHA256": "922E483A25D0BB212358C7DF4285FFF17F98ACF057E6D15207796306F185A605" + }, + { + "path": "RMQ/Core/WordRAM/Packed/InteriorSafety.lean", + "mode": "100644", + "gitBlob": "9af0ede08be43082e459e6b97a578f008b5ff551", + "rawBytes": 135916, + "rawSHA256": "5D38792A31319F871C6BB9FDDE4374DF51588A78905B65E1036DC702E9B0D631" + }, + { + "path": "RMQ/Core/WordRAM/Packed/InteriorSource.lean", + "mode": "100644", + "gitBlob": "920906f499c5b95eb3c9dd5b87927924ceca09cf", + "rawBytes": 11666, + "rawSHA256": "656C25CFFD3D7BEC326CA03C9E068250B9287402AAF6091E71E5A234C0879949" + }, + { + "path": "RMQ/Core/WordRAM/Packed/LCAProof.lean", + "mode": "100644", + "gitBlob": "76f4ee5df246d48cbaebb4e7a640e4304dd4a244", + "rawBytes": 43679, + "rawSHA256": "281F6C63FDA95699292EB9EED87DCF362D3EC549D99CBCB5A0A0CFFE0CFFF058" + }, + { + "path": "RMQ/Core/WordRAM/Packed/LCASafety.lean", + "mode": "100644", + "gitBlob": "04eb3caad4c2e088e7bea13142bd6d4174d4080e", + "rawBytes": 27935, + "rawSHA256": "E0EA8687C328AEFC33CE385A53D8BBE9BB6FFEB1C974756FFAEF80E3E562047F" + }, + { + "path": "RMQ/Core/WordRAM/Packed/LoadSafety.lean", + "mode": "100644", + "gitBlob": "d072778216d7d44539636bfcb766e74213ccc57b", + "rawBytes": 42584, + "rawSHA256": "AA7F502022E29C3D10A808E68CA0C9BB1481A0032659FA3C05BBB6D860850369" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Locate.lean", + "mode": "100644", + "gitBlob": "a610d7777cb91a176575c41bc722b1bea7dc17a6", + "rawBytes": 61614, + "rawSHA256": "3220FEECE22BAEF77AB8466675B8BDE65BD3FEF3A3C3832AEB176ADB4AF81578" + }, + { + "path": "RMQ/Core/WordRAM/Packed/LogicalSpan.lean", + "mode": "100644", + "gitBlob": "e23de1a5946d8a55c17dce7d382369dd18e54c34", + "rawBytes": 28689, + "rawSHA256": "3A3BF287E8221FD1825D2205260FD7E5F02ED75FF930CEBF603FBA67420B1573" + }, + { + "path": "RMQ/Core/WordRAM/Packed/PhysicalRead.lean", + "mode": "100644", + "gitBlob": "6efea650e46a7d4b1ed36adc6483e030b4332ec3", + "rawBytes": 15311, + "rawSHA256": "49C9CE18F81B0B7A00E96C0E32F12121EE27401412146752DB845CE22581558F" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Primitive.lean", + "mode": "100644", + "gitBlob": "9ee7a8069c8e55407e4199dc620e5b8551e3093d", + "rawBytes": 7448, + "rawSHA256": "4C73250DF41AE328F6A9C6CD33FCEA48190A8A77AC81F09F1731B789D79B05C4" + }, + { + "path": "RMQ/Core/WordRAM/Packed/QueryCertificate.lean", + "mode": "100644", + "gitBlob": "23d6a4c6f83832eb2ebe83e8779f29f77df60496", + "rawBytes": 10150, + "rawSHA256": "363EEF84524D4942D755BB84176CCC843FE2169F87C8B503D52A227F1249DDB3" + }, + { + "path": "RMQ/Core/WordRAM/Packed/QueryCorrect.lean", + "mode": "100644", + "gitBlob": "c5eb674a2bbe8f2e6d600fb0f85766386d6eca04", + "rawBytes": 4565, + "rawSHA256": "F6F8066E4D71DB8298F1BD902F6ED1E98E5CB3AECF572B5996B63926B925125D" + }, + { + "path": "RMQ/Core/WordRAM/Packed/QueryObservations.lean", + "mode": "100644", + "gitBlob": "a42907e59bd5f1a9280c44a814b45cd4bae6a3eb", + "rawBytes": 4588, + "rawSHA256": "A51A79C3D201495A4538C7D04A7A35D9B3BEAC350C1BA01FC0F4C540891B4C05" + }, + { + "path": "RMQ/Core/WordRAM/Packed/QueryProof.lean", + "mode": "100644", + "gitBlob": "6bc4493a814eee485dfb7cf36da2d1c006e41779", + "rawBytes": 34048, + "rawSHA256": "868D310396B232719B24B706709C9FEECF7CF0672E1ADA87FA26578367BD9399" + }, + { + "path": "RMQ/Core/WordRAM/Packed/QueryReference.lean", + "mode": "100644", + "gitBlob": "afe47b8a32832e53701e28dc3b008f1d6d32b8f7", + "rawBytes": 5808, + "rawSHA256": "BE9C1ECA68416BF8DF4844DED3CC8D243FC2480E6D2A4834DBCBC0A276E3FBD6" + }, + { + "path": "RMQ/Core/WordRAM/Packed/QuerySafety.lean", + "mode": "100644", + "gitBlob": "64eb0bc513349545f81cbac2475f92895930a4c7", + "rawBytes": 36470, + "rawSHA256": "B2139F2396502E4E01D7F666F5B7D2EEB68C03BCBB61390AB23E2A77DE716E33" + }, + { + "path": "RMQ/Core/WordRAM/Packed/QuerySource.lean", + "mode": "100644", + "gitBlob": "077f3b3803468dd60f58736caf979b4c879a827b", + "rawBytes": 6040, + "rawSHA256": "DFCB57325902A1EEBAFABCF24FC5437AED88A2EA32DF416B5CB2BBCE98F51415" + }, + { + "path": "RMQ/Core/WordRAM/Packed/QueryStatic.lean", + "mode": "100644", + "gitBlob": "a6a6c8af4ca92fedc10bab730056c3a6d2d03513", + "rawBytes": 5433, + "rawSHA256": "F8724BBE814A5A752EEEF4C1E192698FE8E6941E776D604C10A92D65A43B3D2E" + }, + { + "path": "RMQ/Core/WordRAM/Packed/RaggedWindow.lean", + "mode": "100644", + "gitBlob": "c25aa9a82983f898417ecb1b5d9849e7713c7605", + "rawBytes": 6002, + "rawSHA256": "5520399E6DA36ED822F7F8F95505168ACB673779521A95BBF402CB7D5805BBD4" + }, + { + "path": "RMQ/Core/WordRAM/Packed/RankProof.lean", + "mode": "100644", + "gitBlob": "57d719c4b0015fa534dc2340a1c194b36861a0ad", + "rawBytes": 83941, + "rawSHA256": "52106920B98F295C699008619DE132D320A3F97258074C8027FD8F6B2D5231BC" + }, + { + "path": "RMQ/Core/WordRAM/Packed/RankSafety.lean", + "mode": "100644", + "gitBlob": "2932df9d0b444aab14914558f7425c8948c2eed2", + "rawBytes": 87035, + "rawSHA256": "BFF7F9CB3BC558EC41B0B1BC4B73C08F4F8F2ACC5DF9EB734E7FF20D9974D4F4" + }, + { + "path": "RMQ/Core/WordRAM/Packed/RankSource.lean", + "mode": "100644", + "gitBlob": "b5f57f94ce458a38dfcf83801c89333029704414", + "rawBytes": 5803, + "rawSHA256": "B10BA599D21313AC0E5FC7D837D1FE1B999D270280959CA1AE30B8690AB4F6FB" + }, + { + "path": "RMQ/Core/WordRAM/Packed/ReadInterface.lean", + "mode": "100644", + "gitBlob": "0a68f62355dfd798bab3f2579e43135b8fcdb588", + "rawBytes": 5106, + "rawSHA256": "75509F98331EB79E87809851B1BFB340BC3157E4482405F9F47D1D49A7C1EA87" + }, + { + "path": "RMQ/Core/WordRAM/Packed/ReaderSafety.lean", + "mode": "100644", + "gitBlob": "37b534eac23885a9e17856adafb111c766eb5db9", + "rawBytes": 50353, + "rawSHA256": "AE8AA18EAE3C6639AE66843EFCA0A4A4E4CA9F52ED974756F092214408BAEA44" + }, + { + "path": "RMQ/Core/WordRAM/Packed/RegularLocate.lean", + "mode": "100644", + "gitBlob": "26e636e0cd038f1783541ab60545d6c0bf025bb5", + "rawBytes": 5670, + "rawSHA256": "047ECF38990BD410085689FDE702417C035785C59C738BA6E1D66B248709D360" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Safety.lean", + "mode": "100644", + "gitBlob": "a2aa663ac41075c94a9f973c7c6c83dd53a35328", + "rawBytes": 43628, + "rawSHA256": "EF0273D4B16F5876A949CAD219EC421864D7533FDDD5BB492BFF360C0134CC1C" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Scalar.lean", + "mode": "100644", + "gitBlob": "ba905d2a82b6e5947fa62baf346ba3ae2c380e4c", + "rawBytes": 3522, + "rawSHA256": "5D25C758D77F5523DF8AE1C1136AE85FAE12BD9B11BCB6E472DBFABF97506493" + }, + { + "path": "RMQ/Core/WordRAM/Packed/ScalarSafety.lean", + "mode": "100644", + "gitBlob": "9490454d58fb0c531469f12934f5cc04370954f4", + "rawBytes": 11712, + "rawSHA256": "E7AFB1FB9E238AD9F051DFC5236E3E095EF259B4D0CFD875E4A757C10AF858BC" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Scratch.lean", + "mode": "100644", + "gitBlob": "ad08e91a31b1323abdcb3c7b8d4c50be3971bc92", + "rawBytes": 4433, + "rawSHA256": "320DDD6C1F6549902951B99CCF99C66B231D2A0106487A710D8638372EF32E64" + }, + { + "path": "RMQ/Core/WordRAM/Packed/SelectProof.lean", + "mode": "100644", + "gitBlob": "1a1d2bfe44a2bb29ed46b6cc2266617d1db3ae9c", + "rawBytes": 162352, + "rawSHA256": "292AD12DC2879B2F523B29300DB2E5251AEA57BBACC5AD2154B2660DAF8946FB" + }, + { + "path": "RMQ/Core/WordRAM/Packed/SelectSafety.lean", + "mode": "100644", + "gitBlob": "42e973fa4096490518fabbd098ff960ce49a1624", + "rawBytes": 121690, + "rawSHA256": "43C6C183A6B08B38B58521C42320F56A7AC87C27D23DC7AAF0DD5F73EEFC13E3" + }, + { + "path": "RMQ/Core/WordRAM/Packed/SelectSource.lean", + "mode": "100644", + "gitBlob": "893b7deee585ac83ed3121312d476b695574233f", + "rawBytes": 9735, + "rawSHA256": "9C41270FE301B417CA622E523F6546E1EB4CB707FDF68D38F64F2975A97C9A5D" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Setup.lean", + "mode": "100644", + "gitBlob": "9fc02c520da4b841a3a519d833e251c6d90e5d62", + "rawBytes": 20542, + "rawSHA256": "B1BEF6D6859A63C33E8ABD31387697012C002209503D3E13F79B2C8145E6A918" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Span.lean", + "mode": "100644", + "gitBlob": "2631671b135a4400597b4b266a1430f23b8be00c", + "rawBytes": 15105, + "rawSHA256": "54E1A81BDDE51E0C460C9BA5ADFD57A04254FE5D14CA6A77259F4108A64584B7" + }, + { + "path": "RMQ/Core/WordRAM/Packed/SpanAssembly.lean", + "mode": "100644", + "gitBlob": "0e8cd2d15968d0425355049571dbe484fa4d118f", + "rawBytes": 26016, + "rawSHA256": "EA0B7CA706C9750A6E0CDF6220F5F8B411A54CEC33CFADDDED4F010020239106" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Structured.lean", + "mode": "100644", + "gitBlob": "680f1585b4d833318b86b67b5f511c258a66d563", + "rawBytes": 4052, + "rawSHA256": "F7F580A6A5E7BE2BED61F3C126AC83720046FE3A3D18C07286CF6B5AEF81A887" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Width.lean", + "mode": "100644", + "gitBlob": "a776d3e2ba49ab867683dff49deb7956b6a0cc02", + "rawBytes": 25342, + "rawSHA256": "6FB1D7DFE053E4A415B861819E46E448750EE056F8A0A6CAB8ED904277F9F9E5" + }, + { + "path": "RMQ/Core/WordRAM/Packed/WindowProof.lean", + "mode": "100644", + "gitBlob": "0b65303bb54e5e30b5ca1f09b58540979407854e", + "rawBytes": 20240, + "rawSHA256": "B0923835A5B9039D6041C15DE61D2FD02AE3BEA82AD79B83B7726FCDCC9D8408" + }, + { + "path": "RMQ/Core/WordRAM/Packed/WindowSafety.lean", + "mode": "100644", + "gitBlob": "42cea2741f64970b5819e52974db7335d53d20a8", + "rawBytes": 19064, + "rawSHA256": "21C514E1A3CD6E90B8FA31FCAC2BB71D147D5BAF66E0EC3B47CBDC7FCF394FA4" + }, + { + "path": "RMQ/Core/WordRAM/ReadStoreEval.lean", + "mode": "100644", + "gitBlob": "35435e9d3b9e224b458f8fbf898d7736757a3d8d", + "rawBytes": 29601, + "rawSHA256": "862496D886BE52077FD0B6F9A8AD6D4E49EE0C39234DCD3213C3DF33300397D2" + }, + { + "path": "RMQ/Core/WordRAM/Register.lean", + "mode": "100644", + "gitBlob": "eca2029a512cdbae6596467ccb0898139b45af13", + "rawBytes": 39440, + "rawSHA256": "93284E2A6DCACF9C3B425C3267EB8A0568E38CB2CDB083D21EC93FCDB32B783D" + }, + { + "path": "RMQ/Headlines.lean", + "mode": "100644", + "gitBlob": "b6072633607106b0d20372f551f5f5c92f10865b", + "rawBytes": 7201, + "rawSHA256": "FB71FD41FD5A395A725A9500023FD3F46363CC599EAACBA7AC0624BD9474CFD1" + }, + { + "path": "RMQ/Headlines/Lifecycle.lean", + "mode": "100644", + "gitBlob": "0ad61bd2b279519a254e2b4b412366eca6e5b7d1", + "rawBytes": 687, + "rawSHA256": "989B80022D6286E66033A99462C28AC346312D4454A41FD1360F11A6ED269AE4" + }, + { + "path": "RMQ/Headlines/RMQ.lean", + "mode": "100644", + "gitBlob": "4411ba0c8c555efa181a19ead7ff28751dcd0e3e", + "rawBytes": 44746, + "rawSHA256": "1B0703827DA6802B22649DF8CEA6C49BFD66E5F3F3E6F24EECBEA4658761E3FC" + }, + { + "path": "RMQ/Headlines/RMQCompatibility.lean", + "mode": "100644", + "gitBlob": "2ab3a1a46b8f7f7d2325564bcd402648ab794913", + "rawBytes": 9464, + "rawSHA256": "22E197BE5CC074B088460CDD19148E4283304C755DDD4E0C692467A156582546" + }, + { + "path": "RMQ/Impl/Equivalence.lean", + "mode": "100644", + "gitBlob": "fdeab7d65d2f6310cdf9a0f4f766e28731e8ede2", + "rawBytes": 8235, + "rawSHA256": "CCED314E3758108D9023D6927A58B6CF49DCC5C727E2B78AA2A05C5AFAD0AC36" + }, + { + "path": "RMQ/Impl/FischerHeun.lean", + "mode": "100644", + "gitBlob": "6ae0c496a2c200a6fd74c6b285ed0c9a422f5343", + "rawBytes": 82108, + "rawSHA256": "52B3DDAED6FEB9982AFFEC6FDCA9CEE0D73C57FBE388AB670D98F00DB45DF4A3" + }, + { + "path": "RMQ/Impl/FischerHeunCost.lean", + "mode": "100644", + "gitBlob": "b0875b2474683f5a96a1a03aeb2892040b37e311", + "rawBytes": 20541, + "rawSHA256": "1C4108A5B4D2E12D5F70DD00AEEEDBB1701FAE2C5063FF24C7556B639F5FA7F4" + }, + { + "path": "RMQ/Impl/HybridBlock.lean", + "mode": "100644", + "gitBlob": "8f627f319efb9253d42f2d5289a47c542f94ff9b", + "rawBytes": 21313, + "rawSHA256": "6E2B60C9912E30DBCA95DCBF6D91687A155B55C0417AC5B002BA54E1F32A4072" + }, + { + "path": "RMQ/Impl/LCACost.lean", + "mode": "100644", + "gitBlob": "f1667aa132ecc4a3e0d2eb4be51b3c1bcbe2f156", + "rawBytes": 58796, + "rawSHA256": "E9550C8CD1ACB63F1A11BFF7D5B440EBFDF2D5736C32DBF706E3AE2F50C63618" + }, + { + "path": "RMQ/Impl/LCAFischerHeun.lean", + "mode": "100644", + "gitBlob": "72098e48cafc01af47c07ea1ea815e0c5ec0a88b", + "rawBytes": 34730, + "rawSHA256": "BCAC2C38F5473504C5F42CC991E57CAAE682740BF43B904CECBB077DBA47B3A3" + }, + { + "path": "RMQ/Impl/LinearScan.lean", + "mode": "100644", + "gitBlob": "2b4132443e230e922c3e563d7cdd9034da262bba", + "rawBytes": 2878, + "rawSHA256": "45C4A2B92FF08DC802571AA726381DFE3930D861A769FD3529E0A45A50BCB208" + }, + { + "path": "RMQ/Impl/PlusMinusOne.lean", + "mode": "100644", + "gitBlob": "9d5d1336208da32e6a8ed5f8cc8b164426ee4bad", + "rawBytes": 3658, + "rawSHA256": "0F410278B15EAF10D160B9D8504D247579FC674A47F424FF2E1C8FCF7357309C" + }, + { + "path": "RMQ/Impl/RecursiveHybrid.lean", + "mode": "100644", + "gitBlob": "f8620ecf0e7e89bb3864901bb0e4e8eb25141baf", + "rawBytes": 9144, + "rawSHA256": "3B389A2E68278A919DBB2D470A259B67D375F607E004DDC8F804DA442D6DA931" + }, + { + "path": "RMQ/Impl/RecursiveHybridCost.lean", + "mode": "100644", + "gitBlob": "2e0a0697173eaace00fc9f5780f3d25e9a14644a", + "rawBytes": 10711, + "rawSHA256": "E03F0ED4A547FF9D3A6F8E45D6447394D179B23ECBA61096C79EA1F997DDD229" + }, + { + "path": "RMQ/Impl/SparseTable.lean", + "mode": "100644", + "gitBlob": "ca40d0a916ac41b7e6d9ef324ecf112f2bcdf459", + "rawBytes": 11287, + "rawSHA256": "9384FBAC678F74FD7E8B1B0C646AE55C42EE0CA78557C770B5C93099817FE69C" + }, + { + "path": "RMQ/Impl/SparseTableInstrumented.lean", + "mode": "100644", + "gitBlob": "f5838d5e2ee6d1e8bbdb59ecfdf235e09e3ec923", + "rawBytes": 33186, + "rawSHA256": "BEE384F2F29E57BCD71E1B9DC77C85F6B9DE36FFC40552513AE1CF835367BE76" + }, + { + "path": "RMQ/Impl/SparseTableMemoCost.lean", + "mode": "100644", + "gitBlob": "7ab7db7d6b690b1bba46def1ba026762bcfeba71", + "rawBytes": 16091, + "rawSHA256": "EF2E212C2391E7312DF93925EB3618F9F22357B4EEEF6EAE3274B31B00E46FF6" + }, + { + "path": "RMQ/Validation/.gitattributes", + "mode": "100644", + "gitBlob": "26dabad73bbdf2a327967dad24c74389970ba652", + "rawBytes": 107, + "rawSHA256": "AC74EC4BE7080E08E819BA40FF241A4A351CEA1EFE44997C5F722345A2FF51E7" + }, + { + "path": "RMQ/Validation/EGCPFinalFalsification.lean", + "mode": "100644", + "gitBlob": "e761c7f4b7abdd38e84448e09991ea336c2ef212", + "rawBytes": 152858, + "rawSHA256": "8ED9529DB28EE3A5E964B4305A32BB3E776AA9EC9766673ADF6E4A6BFFDF7AFC" + }, + { + "path": "RMQ/Validation/EGCPStageA.lean", + "mode": "100644", + "gitBlob": "bb94d1b7c5accfb982027e5175fcd3bf1a064067", + "rawBytes": 37004, + "rawSHA256": "96E5F6A0EFC5C87738B1570DECE59D2CA0C81331A2E7B57F79B1CBEFACC70773" + }, + { + "path": "RMQ/Validation/LifecycleContract.lean", + "mode": "100644", + "gitBlob": "cb87275bec76845642e33406c1c6496fc0379192", + "rawBytes": 12403, + "rawSHA256": "F7022AC916813779745B9847B43D9091A90F4F2356615BDBF3B560F2861AD9EC" + }, + { + "path": "RMQ/Validation/LifecycleNativeContract.lean", + "mode": "100644", + "gitBlob": "d6c52fb86b7b7ee89b3f9ea81f5901a796efc0b5", + "rawBytes": 46399, + "rawSHA256": "4075AA30A3587995091DEBE002AEA8CA0B111DDDBF210082F0E9A019FD6314C2" + }, + { + "path": "RMQ/Validation/PackedBitvector.lean", + "mode": "100644", + "gitBlob": "702061d81a8595ad940019bb5ec572e768eb78e7", + "rawBytes": 9387, + "rawSHA256": "333B0A6BD8FB3082051845D2F1BD333668B9D33758A9030A68B25695CFEE068E" + }, + { + "path": "RMQ/Validation/PackedLifecycle.lean", + "mode": "100644", + "gitBlob": "69d6ade9d2ec84521c208b559af1912561b80316", + "rawBytes": 14971, + "rawSHA256": "624236001FC72817441CC3DC536DA9C299CCB1DC9C050687B09896B7F1679C14" + }, + { + "path": "RMQ/Validation/PackedNative.lean", + "mode": "100644", + "gitBlob": "a759468a851ab432eebfa22d315f70d6e74945e0", + "rawBytes": 13565, + "rawSHA256": "437808A44FA6AAA92422B544B2036AD2F6CDFAD79297DF8BF94BFB402E081EF7" + }, + { + "path": "RMQ/Validation/PackedOptimized.lean", + "mode": "100644", + "gitBlob": "dfc6b3639a7224ec900c05736f512d28cfd21088", + "rawBytes": 12485, + "rawSHA256": "894A4048230E1ED095EAB24BF78E8EE594251579C5BDA1163185722AC821EEED" + }, + { + "path": "RMQ/Validation/PackedQueryContract.lean", + "mode": "100644", + "gitBlob": "1862749764fbacf3460faae49a7392b9aa98f73f", + "rawBytes": 21736, + "rawSHA256": "01F6A3F2B77F86D2C647D963EED8B6E79188F7C2D381EADCF96B128E2B52B1BD" + }, + { + "path": "RMQ/Validation/PackedQueryRuntime.lean", + "mode": "100644", + "gitBlob": "46399d6ed85585e4d2b2e061b0a89a0b15553c96", + "rawBytes": 12838, + "rawSHA256": "2F84A5E5B5C4470A07E9455B1292D8967239BC170D9D75FC0555BE9F8FF14FE4" + }, + { + "path": "RMQ/Validation/Preprocessing.lean", + "mode": "100644", + "gitBlob": "357d646ec8d701a93609657bf187f4db72a0e085", + "rawBytes": 11578, + "rawSHA256": "12FDF7FBEB1E40CA038CACB97F100E2ED5319471522D0BFA6E115F4DE04A98E8" + }, + { + "path": "RMQ/Validation/PreprocessingContract.lean", + "mode": "100644", + "gitBlob": "edcfca8e096f62db1eee312826f43c112932b22e", + "rawBytes": 88557, + "rawSHA256": "5893C423560DDCCF5FC63F8E7BA58C6334F90F70E1D6AF3C9E1735C1FBFEEB2E" + }, + { + "path": "RMQ/Validation/SuccinctClassic.lean", + "mode": "100644", + "gitBlob": "42658ef96a3f28283d3812b95596d7cd4db3a8a1", + "rawBytes": 18280, + "rawSHA256": "48883DC1C7FFEE53C69425F81560F72467F39F2D5B70E075B66C8C2B75D3DDC6" + }, + { + "path": "RMQ/Validation/SuccinctClassicCostHarness.lean", + "mode": "100644", + "gitBlob": "3f362837f206559783edd4b7ec616ad87af247ad", + "rawBytes": 27425, + "rawSHA256": "95ABCB4D3302CEFF84F14BBFA88D65D425867BF408C4C8BCB7E026080B6D33D8" + }, + { + "path": "RMQ/Validation/VariablePayloadLowerBound.lean", + "mode": "100644", + "gitBlob": "9dbf530287981149d5c8ae099b7cac34d9ea5c86", + "rawBytes": 29145, + "rawSHA256": "DFCEBF64749A43348FF7786C7305D01152093F469C6CF817405CFE8C90814598" + }, + { + "path": "RMQArchive.lean", + "mode": "100644", + "gitBlob": "2a75e345b97a0471346159db82425bfca499c32f", + "rawBytes": 217, + "rawSHA256": "E2E8CBDF62B8AF143AB21D2E31F5EAD8E2299C904311FEF8DC979BFF9DF9E704" + }, + { + "path": "RMQBPNavigation.lean", + "mode": "100644", + "gitBlob": "13d99a09bff63c97392a2e6de62b1d75b4688193", + "rawBytes": 2022, + "rawSHA256": "74D883C55E5492A73C5AFB9123D62DC24067E23521EAB0695C684766D8E1F167" + }, + { + "path": "RMQExamples.lean", + "mode": "100644", + "gitBlob": "ead80ae7ed6bf6be72066e7bcb5aa269f22bfc6d", + "rawBytes": 353, + "rawSHA256": "8156EBD4D3F50075F710F912307312676FA8E9593F8206114569A945852C3B28" + }, + { + "path": "RMQExamples/BPNavigationImport.lean", + "mode": "100644", + "gitBlob": "1fa4c62a9dab4c8e1eb6f471841fde5db05672a4", + "rawBytes": 1956, + "rawSHA256": "C3BAEDC76EE811FCB28080061E93494DD7A87876BFADE213BC5D57D6E37A8509" + }, + { + "path": "RMQExamples/Concrete.lean", + "mode": "100644", + "gitBlob": "82c72907f49bed98eb069c2865dad5a8c540377b", + "rawBytes": 11051, + "rawSHA256": "999523D23318CA959F8C9EB5C3BB4005995F15D59C8513638233183CAE5F6D52" + }, + { + "path": "RMQExamples/LowerBoundImport.lean", + "mode": "100644", + "gitBlob": "7a91da9876659eb2196c434b6d203d967e40aef4", + "rawBytes": 440, + "rawSHA256": "12052183C19045768FA576BA54E744CD0CCFA208C5FDBFE3342509DA59CACBEB" + }, + { + "path": "RMQExamples/RMQHeadlines.lean", + "mode": "100644", + "gitBlob": "5a17994899922772a2ad4d120d514ef91a253729", + "rawBytes": 1426, + "rawSHA256": "8CE6B0A60EB512FA98A322CCB109EC5F3B57544FF00E4F8779F154D3C7244936" + }, + { + "path": "RMQExamples/RankSelectImport.lean", + "mode": "100644", + "gitBlob": "8a7071f6bc781a65454f8ea63ea85758357b01ec", + "rawBytes": 1613, + "rawSHA256": "81325EA75D985130B35313185E6AE0A7CC2B6896AD5F6AF240DAE5DA4B4BBF42" + }, + { + "path": "RMQExamples/UnionFindImport.lean", + "mode": "100644", + "gitBlob": "47aa1bb122f510fabb0924934a36d8ff52ffa44b", + "rawBytes": 812, + "rawSHA256": "2DD1AFDEF4A2040C332EE244020E5B33EF9304631FD1657C48BDB79562274504" + }, + { + "path": "RMQHub.lean", + "mode": "100644", + "gitBlob": "519416922e5c33415a687e53f45bd867fd231b4b", + "rawBytes": 297, + "rawSHA256": "D56A4DB9EDE4FF8E34B20A3D3F4A4D4B7693482392F68C3FAE570FF317200544" + }, + { + "path": "RMQPaper.lean", + "mode": "100644", + "gitBlob": "14f3f66c82c0a340e67af42f0411c1bc67ecbdc6", + "rawBytes": 787, + "rawSHA256": "7583544715DF9F29F6747A327CA38A48F448AB329173916F430BC6C3AB93FAF0" + }, + { + "path": "RMQRankSelect.lean", + "mode": "100644", + "gitBlob": "91ddd891416da473b234c2f3c10dc6e24ab40a5a", + "rawBytes": 2854, + "rawSHA256": "F1CEF44E3E309373F5E125B40897C315F72F2A8B07BCAD05F2F13988D21D2BE0" + }, + { + "path": "RMQUnionFind.lean", + "mode": "100644", + "gitBlob": "2a5a9bd133c39b02118dedefcdec7c5241601a30", + "rawBytes": 13745, + "rawSHA256": "C15BA8E45198C46C8C5E31B4A571D6351995E1B4784CE61383BC6F93D613709A" + }, + { + "path": "VerifiedDS.lean", + "mode": "100644", + "gitBlob": "04e59c51cc5da1502b9fdf66e8926d1c23ae234c", + "rawBytes": 799, + "rawSHA256": "B5A0F4EBCDBD59135CFEBC03ECFAAB57286448FA067BFB20D20B116CEE60F63C" + }, + { + "path": "VerifiedDS/BPNavigation.lean", + "mode": "100644", + "gitBlob": "433cf90a05fdddc0fe57963861f87d50f2ffe78c", + "rawBytes": 279, + "rawSHA256": "3851302587CFEAABA9AEC1C0A652967B6D6FF94E08A0AA2E740580C7965738A3" + }, + { + "path": "VerifiedDS/Hub.lean", + "mode": "100644", + "gitBlob": "f0a84d6c204590a8b64fba456e8fa1af96ddd403", + "rawBytes": 394, + "rawSHA256": "137DF45FE00021F19F9ABA0D1C170AEA7BBF0F06DDFA1A978D5D56E7CDAA67E5" + }, + { + "path": "VerifiedDS/RMQ.lean", + "mode": "100644", + "gitBlob": "3411da19f09add718ce43641cc5fc04f5304fcec", + "rawBytes": 326, + "rawSHA256": "26E398A29C91E875FCB48AAAB46FA603E491EA5F250E5812DAC425F74A36639C" + }, + { + "path": "VerifiedDS/RankSelect.lean", + "mode": "100644", + "gitBlob": "5b55b874edb8f62686fca54705602a9a57e2a834", + "rawBytes": 328, + "rawSHA256": "26702BCF437F2DCC02599D0FF8753805EE5C45C7BEE0996E99636B6D7DBAFAAE" + }, + { + "path": "VerifiedDS/UnionFind.lean", + "mode": "100644", + "gitBlob": "f169bad9c58158536d63a726c1c3513fa3449ec8", + "rawBytes": 21800, + "rawSHA256": "6E79CC628AEBD259C25EBCC799A220FA65D55AE557C111551213F369CC609BD8" + }, + { + "path": "VerifiedDS/UnionFind/Forest.lean", + "mode": "100644", + "gitBlob": "3713c97ba25bca8a33c5eec8356facf873e6ea48", + "rawBytes": 796, + "rawSHA256": "FFAF07ED86FCDBB4F1887C440082010EFB7F3012B0C5BFD5E906459CCB1C5D13" + }, + { + "path": "VerifiedDS/UnionFind/Forest/Amortized.lean", + "mode": "100644", + "gitBlob": "39fc20f1610f7618f411992321064bc17059fa51", + "rawBytes": 30429, + "rawSHA256": "01FBBB2309E1A85857B2A8DA30BFB282A9198430387C25E17EC3F7172C937228" + }, + { + "path": "VerifiedDS/UnionFind/Forest/BackendOps.lean", + "mode": "100644", + "gitBlob": "f6b89fc8a0e36475478e677ce438119d154a5780", + "rawBytes": 52287, + "rawSHA256": "457622B148B1C5016F1E834B985AC63723AD503ADB4072F718D9DC784F5A53F9" + }, + { + "path": "VerifiedDS/UnionFind/Forest/Base.lean", + "mode": "100644", + "gitBlob": "3f2183c884b9af563ac10a28bb9a8f99d6dc28e5", + "rawBytes": 122271, + "rawSHA256": "20D06974E67C14E6330F79DEA290EA8B780326F16144021FB3691DDBD5423CDC" + }, + { + "path": "VerifiedDS/UnionFind/Forest/NoCompression.lean", + "mode": "100644", + "gitBlob": "f0e446f4e9d300ea252b94ca44e6b5aee402dbdc", + "rawBytes": 25086, + "rawSHA256": "DC247F6594551F78149F93777E719A006BF631FD97EC3DE83EA9CA1EAEFF1E57" + }, + { + "path": "VerifiedDS/UnionFind/Forest/PotentialProofs.lean", + "mode": "100644", + "gitBlob": "0520c04917567f4194be50ed6079d06d7d1323f8", + "rawBytes": 75885, + "rawSHA256": "9B5CD389AC103ABD0898B369D7FE64FEEAA2288450969E51824A72BF47199A89" + }, + { + "path": "VerifiedDS/UnionFind/Forest/Potentials.lean", + "mode": "100644", + "gitBlob": "b38697b9c2e098d3ce194a2462910ac609054d9a", + "rawBytes": 25740, + "rawSHA256": "72080D765E29016DA66D9AE84D4BDB3AA3C9E79A036F0A40F97B699A6A134B92" + }, + { + "path": "VerifiedDS/UnionFind/Forest/Reference.lean", + "mode": "100644", + "gitBlob": "bfb6f36c8052cb406a7f64a6f7ec00461491404f", + "rawBytes": 9008, + "rawSHA256": "03906C94D5EA14C0C783C00603E5BF687E99879628B0FE6EB97090A84E83273C" + }, + { + "path": "VerifiedDS/UnionFind/Sequence.lean", + "mode": "100644", + "gitBlob": "f3118eb08d02d6cf70fc37e6cc17002cb358e7f2", + "rawBytes": 25608, + "rawSHA256": "05A15CCC89F74C88EC8718FAEDF91C0A5C58D583221864F7996C2872E1AD386D" + }, + { + "path": "VerifiedDS/UnionFind/TarjanEvents.lean", + "mode": "100644", + "gitBlob": "822d8fe65571515e1daafd53bce50b752818b1f5", + "rawBytes": 106912, + "rawSHA256": "5F8C7E692D500C8D00BDF135E9E329729C2058BFD05D6198F43AD213FB5265B1" + }, + { + "path": "artifact/CLAIMS.md", + "mode": "100644", + "gitBlob": "3bfc6fc7fe905b123608539752bd97d1a4593103", + "rawBytes": 22134, + "rawSHA256": "7C0220C36E0C57CE60C3772D79254EA3A709583965D00CEB9EF07872AD02B697" + }, + { + "path": "artifact/README.md", + "mode": "100644", + "gitBlob": "235975868c8a484c5cc1a7c9b6a1a37f60b1ae37", + "rawBytes": 9868, + "rawSHA256": "0786161A511128DFB4BE3730CC657D19BB2590B3D6150C81153EED215FAA99FC" + }, + { + "path": "docs/ADD_PROVENANCE.md", + "mode": "100644", + "gitBlob": "a09581e68eebfed57e370be40bb7ca0d28064708", + "rawBytes": 14398, + "rawSHA256": "7F044DDA48DD6020B0757F79D7FD1B98BBB74AA349E2CA10D670C5CBEC09AA76" + }, + { + "path": "docs/AI_ASSISTED_DEVELOPMENT_NOTE.md", + "mode": "100644", + "gitBlob": "02b9280a175a8a687122ae5ffcf3a657aa452fab", + "rawBytes": 1786, + "rawSHA256": "96FAFE668251BCB9A9D5F47CA4695C360E675AA9A966E107C0EC4A356DE0A4DE" + }, + { + "path": "docs/ARTIFACT_REPRODUCIBILITY.md", + "mode": "100644", + "gitBlob": "cede178ff2a119fcdcad436481b73e25a3e0a238", + "rawBytes": 4351, + "rawSHA256": "F586E566F540B619F563A064A9BE4FC8B24A618FD6820B5B942DED619F4FF1D1" + }, + { + "path": "docs/BP_NAVIGATION_FRONTIER.md", + "mode": "100644", + "gitBlob": "588080a108a7887822a09adf2d910a008a780f0f", + "rawBytes": 15495, + "rawSHA256": "755D40BD8E1DC0051F04A808FB6B91468775B1BE07F8044574878B0863A53043" + }, + { + "path": "docs/CLEANUP_AND_ROADMAP.md", + "mode": "100644", + "gitBlob": "eaf4da5f1d2281ba9e369727de1ded452b77ea11", + "rawBytes": 25004, + "rawSHA256": "F9C55919F49EDF095C41529BCD638535C0B67936F18BC22F1799184D0DF1F9DE" + }, + { + "path": "docs/CODE_MAP.md", + "mode": "100644", + "gitBlob": "46d96a75efad3b38f4a097dbb9cdfc7bb82b9d5e", + "rawBytes": 10970, + "rawSHA256": "D4E3CEB5C6EF18F077F6C0EA19847A9C0D12345E5ADB621CDA9FD359760BAE07" + }, + { + "path": "docs/DESIGN_FRONTIER_OBSTRUCTIONS.md", + "mode": "100644", + "gitBlob": "76949015c11f53e0c178aa9b85ca5390318b08e7", + "rawBytes": 12517, + "rawSHA256": "237558DA1DF3CDC7510DA60305B339CD505626D321A5A447446E51BED818DDE9" + }, + { + "path": "docs/DIGESTION_LOG.md", + "mode": "100644", + "gitBlob": "840b11567ec10cb1126a086587e42ea760a07d12", + "rawBytes": 137798, + "rawSHA256": "9D2F0FCB56251D7206AC28A4E4F81FF873FD003E6E463EE6892D00A11DCF82C9" + }, + { + "path": "docs/FAMILY_SUMMARY.md", + "mode": "100644", + "gitBlob": "8e23fc0b539f73502140b08361990f5e65a04776", + "rawBytes": 263167, + "rawSHA256": "157DE64086B3647EB8FF0CACB14520A65E66BC5C0EDB2BC318D8AEC6364FA21B" + }, + { + "path": "docs/GENERIC_SELECT_REFACTOR_SCOPE.md", + "mode": "100644", + "gitBlob": "b5d866fd91d2a89b84dea8e2232b9b17cd14a41e", + "rawBytes": 7392, + "rawSHA256": "F5514B395D486956B8E331526A01B1E5AC5EC6DD72C250F79339B7CCE910A637" + }, + { + "path": "docs/HUB.md", + "mode": "100644", + "gitBlob": "2d76742cd8343b838a0e79c0dfe494747a5cada4", + "rawBytes": 3333, + "rawSHA256": "4DD923FC85D9AFAA33CBAC9C40F89AD2E907FC8240998248937A408590898006" + }, + { + "path": "docs/INDEPENDENT_CHECK.md", + "mode": "100644", + "gitBlob": "a7a088158e7d24733a5f72cb128cef01591051ad", + "rawBytes": 3800, + "rawSHA256": "3EC0C4D14EB3F71010CD3CF18A90683E0A5BB9173514FF17AC8BC148BEC228F0" + }, + { + "path": "docs/PAPER_CLAIM_CORRESPONDENCE.md", + "mode": "100644", + "gitBlob": "1d7fdffc49820a5452133eec6f0431df938cf651", + "rawBytes": 28735, + "rawSHA256": "0C20CB3092758E8363BFA8190E767F74486AC452C5A85C48C4B732FE5F2E89A6" + }, + { + "path": "docs/PAPER_MAIN_THEOREM.md", + "mode": "100644", + "gitBlob": "ace4407ddaa578db16a2d64f19cd70effcf64dc5", + "rawBytes": 9786, + "rawSHA256": "1733F0E1C8C97EB4C077FD279A3E94B30764880DD6B684F837FDBEE820A20B4C" + }, + { + "path": "docs/PAPER_MODEL_ADEQUACY.md", + "mode": "100644", + "gitBlob": "dfda528a280b220d02c5f56f1dac1ae84e64b999", + "rawBytes": 27210, + "rawSHA256": "3E7C1E71C91E1E0CEE656B2AEE05423B2FB16CC1831F19C671B204CB67BBA2BB" + }, + { + "path": "docs/PAPER_RELATED_WORK.md", + "mode": "100644", + "gitBlob": "89bc05f09002541702f23e943e9966f2765b4a73", + "rawBytes": 8688, + "rawSHA256": "63DEC791CDA51C6BE5EA157E3210CBCE3C064B48DB0BC4A2C0E6AE996A770A20" + }, + { + "path": "docs/PAPER_THEOREM_MAP.md", + "mode": "100644", + "gitBlob": "55dad2e14ac9157899d48820c02744df73e8d4cc", + "rawBytes": 15517, + "rawSHA256": "6A65EC3C44C6B82B9F7BE5AACC248F5A2BDB71FAD4A69E2836C646EEC275341F" + }, + { + "path": "docs/PUBLICATION_STRATEGY.md", + "mode": "100644", + "gitBlob": "788593c1a2620ae62ea5d1a0dc436d6a39c76b63", + "rawBytes": 15320, + "rawSHA256": "7C030D2A663F32B78A19803FCE6D231ACC3E96B71D24A98A331FA66BFDDC7462" + }, + { + "path": "docs/RANK_SELECT_FRONTIER.md", + "mode": "100644", + "gitBlob": "19ea58cfdc2163a4f67636aeb295e839b2702dc8", + "rawBytes": 56713, + "rawSHA256": "F90E27A9F0247EC2E4EC9EC43A3747947337062B51C21A02EA69F59DBA30196B" + }, + { + "path": "docs/README.md", + "mode": "100644", + "gitBlob": "6a6479c2bcf8d664039d467a9dc61288329645ac", + "rawBytes": 5354, + "rawSHA256": "3C89AD41D454B5BA47857455B1451476757277D4627961EADD3A474024495F86" + }, + { + "path": "docs/RELATED_WORK_AND_LIMITATIONS.md", + "mode": "100644", + "gitBlob": "7c2e614c596174e4bb27ab79c448b36ea8f4566f", + "rawBytes": 4470, + "rawSHA256": "DEB52F76C995E2BC519F564E91B5E0712E01D3ADB02B1F5A1616B87709567C5F" + }, + { + "path": "docs/REPOSITORY_STRATEGY.md", + "mode": "100644", + "gitBlob": "24ec5930892f8d2e79545121214c48024c86625f", + "rawBytes": 4740, + "rawSHA256": "6827392394C750523A1E96CD6EA6EE82371E73F98AF489E21EDE126A9E098776" + }, + { + "path": "docs/RMQ_EXTRACTION_FRONTIER.md", + "mode": "100644", + "gitBlob": "7697a757bc3d0de5a8bb9e475b98ba7566483506", + "rawBytes": 4113, + "rawSHA256": "96760B9360B7D5CA0B679453672EF7864EB00745A7F1ACBFE6ECD0CA230E36DB" + }, + { + "path": "docs/RMQ_IMPORT_CLOSURE.md", + "mode": "100644", + "gitBlob": "0db19bd5c87e5fa92b9d57955dd08071182a816d", + "rawBytes": 6260, + "rawSHA256": "ADED17637F124A674A7C11C2263B7F1F4AFA56DA45DA42CEEFA7CE3CB2CA3584" + }, + { + "path": "docs/ROADMAP.md", + "mode": "100644", + "gitBlob": "d3d421f88644ece0f2d834e1c0189e457b66d582", + "rawBytes": 44671, + "rawSHA256": "F1E9D5B0475188F3F67A2DDED5C7AA87730AD5DF04A84B24EE064C5FBC44A59F" + }, + { + "path": "docs/TRUST_AUDIT_PACKET.md", + "mode": "100644", + "gitBlob": "a6b0f8b9c84fdd120f9af3a33ca46ef9b65a2b5f", + "rawBytes": 9958, + "rawSHA256": "2FAFA5D1E4CF5D51B5947280F26644B90E155A8EF1D1155BCDAF976E93BE7432" + }, + { + "path": "docs/TRUST_BASE.md", + "mode": "100644", + "gitBlob": "ae2574658093410c16b143c91ab3ce565b0f1ada", + "rawBytes": 3755, + "rawSHA256": "7ECF5B8AB4055505EFB2FBC04E3EDBA5F99C4095D49563DA3EAEB5425947C84F" + }, + { + "path": "docs/UNION_FIND_FRONTIER.md", + "mode": "100644", + "gitBlob": "2f51367d588989ec81050fcfb1ba2a26c10d4d5d", + "rawBytes": 59337, + "rawSHA256": "9EE00A4E7B0D903B6AB86182F11430DC61822619349D8D38C6DE83181876B1FA" + }, + { + "path": "docs/WHAT_IS_PROVED.md", + "mode": "100644", + "gitBlob": "fcb8d780d8f8a41d88b8c67d4157b80098ef8760", + "rawBytes": 56552, + "rawSHA256": "81DAD0BD1D323B37622EF28A139684C8048925FA2285A3BE02B3460D67C0E3BA" + }, + { + "path": "docs/WORD_RAM_REVIEW_PACKET.md", + "mode": "100644", + "gitBlob": "49461932ce3dbb908c99c6a8fc0441027957c98c", + "rawBytes": 13498, + "rawSHA256": "3DB4397DE2B733029E38609008A69818A8BF7093E22431350CFE858BE43CF288" + }, + { + "path": "docs/digests/COORDINATOR_COMPLETION_LOG.md", + "mode": "100644", + "gitBlob": "c181568cd483f6c792d71ea94f9fa491b497e7f6", + "rawBytes": 6721, + "rawSHA256": "0C2FF3B85806131013F4DCDC557B4E6C859EDD1B792352629AAC26595B497FEB" + }, + { + "path": "docs/digests/DEEP_PROJECT_DIGESTION_2026_06_28.md", + "mode": "100644", + "gitBlob": "0987ec0e5470ce977f640849e8f564eb7d3d2543", + "rawBytes": 40254, + "rawSHA256": "BAB09EED7B25890F595DA25C48979ACFB0C5D8BFD7E0F47D6BC225316269A801" + }, + { + "path": "docs/digests/LIFECYCLE_PROOF_GUIDE.md", + "mode": "100644", + "gitBlob": "e343d1c9b575ed2edc0e873bc348c888ff2fd864", + "rawBytes": 9262, + "rawSHA256": "9C43098ACF0D96BA74EA6A9D6E2CA5382277568E3E326DE46307B2F4CDE44C2F" + }, + { + "path": "docs/digests/PROJECT_DIGESTION_CURRENT.md", + "mode": "100644", + "gitBlob": "c7623b0d37e8406b71481dbdfec1eb2e370f2e07", + "rawBytes": 13370, + "rawSHA256": "26D32D8761D94E25D408DC210656D30AF250EF180EE6DF35C65879C36E7ED424" + }, + { + "path": "docs/digests/PROJECT_STATE_2026_06_28.md", + "mode": "100644", + "gitBlob": "109c282d8bdabfcd5418c5220e126e0f840f2941", + "rawBytes": 15749, + "rawSHA256": "7E7749709D9E1D5A729CB2B0A83592678B121ACB330383E5BD83FAE27A0E4EA9" + }, + { + "path": "docs/digests/RANK_SELECT_COMPRESSED_FID_2026_06_29.md", + "mode": "100644", + "gitBlob": "6bde4e2cacc1cc1452cb42a8c198e284cb87b611", + "rawBytes": 11378, + "rawSHA256": "D9D31C8BFEFFC2C89BB0B259F04C090F3A05E4D09324258A9D3B0E89C4B4B3A7" + }, + { + "path": "docs/digests/RANK_SELECT_FID_FRONTIER.md", + "mode": "100644", + "gitBlob": "47a0e4c6b3675efd73d634e29a1cb6521083b86c", + "rawBytes": 9546, + "rawSHA256": "C70F9937E59F71B4A18647D9B231FF4FF0F9772AF23A162F9E1393776300BE0E" + }, + { + "path": "docs/digests/RMQ_CAPSTONE.md", + "mode": "100644", + "gitBlob": "28a69dbad66bedc65e2fb7caac3672b42d8f9fe7", + "rawBytes": 4860, + "rawSHA256": "9CB8669A7A728B1668956A40B7F671DDDF1FA579A89683FF483C5D5F2B6ACAC9" + }, + { + "path": "docs/digests/RMQ_PROOF_MAP.md", + "mode": "100644", + "gitBlob": "5dd011ee673e8605085eb1259785f3582e008bb5", + "rawBytes": 3338, + "rawSHA256": "63BAC42CCACC6FF0B64F2C1C646487D87944783AB9E1767D26898178F2ABCAA9" + }, + { + "path": "docs/digests/SUCCINCT_RMQ_COST_COMPATIBILITY_HISTORY.md", + "mode": "100644", + "gitBlob": "a2435ade2189ae5c20db0f1b561a294fcd3d6f63", + "rawBytes": 4000, + "rawSHA256": "5D8063A67A3D26038205392C32809D4A22670E47B39CA721FCC85AA67E98AC26" + }, + { + "path": "docs/digests/UNION_FIND_AMORTIZATION_FRONTIER.md", + "mode": "100644", + "gitBlob": "2344588e1bada681ac20630f6c84213f54cd9329", + "rawBytes": 18119, + "rawSHA256": "6751CB73D96AA3ECD1ACEA14D31DC066A63BA1CABA143C24BD2C2A35BD5FB127" + }, + { + "path": "docs/digests/UNION_FIND_TARJAN_ARCHITECTURE.md", + "mode": "100644", + "gitBlob": "e76d0aed69d29dac397ccda288f8765c3de67a9d", + "rawBytes": 10566, + "rawSHA256": "7BD1635E4927DFE2E820276D48AC277770BCC14A23632B912E52AAFFBD37276A" + }, + { + "path": "docs/internal/ADD_WORKFLOW_TOOLING_PLAN.md", + "mode": "100644", + "gitBlob": "9d2ddd852d0629ce88bc568cf01d0ae8ad1d91b5", + "rawBytes": 5220, + "rawSHA256": "153797B759671E5A3E229335B8134654482840960B9D8E823B51A9C8777DBFC9" + }, + { + "path": "docs/internal/AUDIT_2026-06-18_FH_MIGRATION.md", + "mode": "100644", + "gitBlob": "d5941c311e5c84507d13c5362c41e5cec017de8a", + "rawBytes": 5017, + "rawSHA256": "29455612C7F8E4972BF467F97F0E65EA72EBD9B912576E0E8690BBA0EF0510B2" + }, + { + "path": "docs/internal/AUDIT_AND_A_DESIGN.md", + "mode": "100644", + "gitBlob": "83ca4fc67e1d871f3a2eff3881e97b70b1bb1eeb", + "rawBytes": 63623, + "rawSHA256": "55CDF774DD05380B7A679BF01309575B8C7C2037F681CD6A6E8FED0AD0C36824" + }, + { + "path": "docs/internal/AUDIT_PROTOCOL.md", + "mode": "100644", + "gitBlob": "63b32de746ba9c893ac8e3327b0d355904a846f6", + "rawBytes": 8758, + "rawSHA256": "1A651F51812D9B67EFF15E6E5A3B94B026512D13AFC0DA128F762ADA0E1C5719" + }, + { + "path": "docs/internal/B2_CHARGED_FRINGE_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "3ff455634ed07fcd22dc623b022fa469e93503d9", + "rawBytes": 137221, + "rawSHA256": "D27A19EBD471D12F564C9E3DEF634D5437708B41F17367CF866517AD75597CA3" + }, + { + "path": "docs/internal/B2_WORKLOG.md", + "mode": "100644", + "gitBlob": "5a80aea77f6ac5611adbeb2d08fae563d2508e86", + "rawBytes": 18783, + "rawSHA256": "07A74A0A074B0D58EF2B88333F6C43E3EFAB88E383AA867EFCC66D1029D7A08B" + }, + { + "path": "docs/internal/B3_WORKLOG.md", + "mode": "100644", + "gitBlob": "2d152ca701ae3132670f43d3b3f13b9b3b22929e", + "rawBytes": 40020, + "rawSHA256": "66530EDBDDF3A8F8C9D46FE10DCB464AD7DAB07C65923D1F359C35ABCA79D51A" + }, + { + "path": "docs/internal/B4_WORKLOG.md", + "mode": "100644", + "gitBlob": "c828ae8f60388acdd5c324c831db0b6411a12881", + "rawBytes": 14427, + "rawSHA256": "930C90CC55ADB3DCA2F8ABA572F311962759D3B92FBAAF77F8FC2B79C0FB70A4" + }, + { + "path": "docs/internal/B6_SAMEBLOCK_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "8779db9d2f4914353a42aabde281207533be49ae", + "rawBytes": 34904, + "rawSHA256": "1985363E41D62044BEB29CD24446DF1620147835ACC81096A194C274E2A4E5E4" + }, + { + "path": "docs/internal/B6_WORKLOG.md", + "mode": "100644", + "gitBlob": "03a6008d7a1d930217f630cd2a747e9da9769452", + "rawBytes": 28274, + "rawSHA256": "054566E0441DEC87FF258AB97C32A4A8DF2FDC85A8325F0D21EC84F503AF0824" + }, + { + "path": "docs/internal/B7_SPARSE_LEVEL_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "b33aa1482393b379b532b5ede2f77171c27f5afd", + "rawBytes": 129119, + "rawSHA256": "BE80B57364E51BBFF1FE68406504D0CA57E493529751D97E06B138FD4BC99533" + }, + { + "path": "docs/internal/B7_STEP2_WIP.patch", + "mode": "100644", + "gitBlob": "765199018b6ca6cd896bb8d018a80f3b1c4441dd", + "rawBytes": 101242, + "rawSHA256": "D5910658DF43F1ECB435BEDE1846F43ED351AB0CA30A51872E6BA9C1CAECA791" + }, + { + "path": "docs/internal/B7_WORKLOG.md", + "mode": "100644", + "gitBlob": "088e2f3aa1973c5b9aee2f8e705001adbc2ef1ce", + "rawBytes": 163862, + "rawSHA256": "23D8774EBE2083D610297FDC1D3CF6B9C4D05121B3E9BE58F3E56333659C4519" + }, + { + "path": "docs/internal/CLAIM_DRIFT_POLICY.json", + "mode": "100644", + "gitBlob": "491791898dca137d2a7d94126b87402545ccaa9d", + "rawBytes": 21046, + "rawSHA256": "4096C7A708DF686F0AC7B62D935B22C13C1F1212494A3B39FD2ADD127AD43CD9" + }, + { + "path": "docs/internal/CLAIM_DRIFT_POLICY.md", + "mode": "100644", + "gitBlob": "2cbf8cb57c7ab1c73c8018a2274d4e6106412f39", + "rawBytes": 18325, + "rawSHA256": "F12148DB46880580D2879EA4F8ADCD75CEBF2C8BDD0D31312524FAE1DE48384F" + }, + { + "path": "docs/internal/CODEX_AUTONOMY.md", + "mode": "100644", + "gitBlob": "b2c785e62e0f36141be8af69ac92bf85df63c016", + "rawBytes": 2305, + "rawSHA256": "2AB7188ABB78F1F0A7AE415EECF9392E17DA3AB9AF4E6781CF79E70DDE42F0C2" + }, + { + "path": "docs/internal/CODEX_ORCHESTRATION.md", + "mode": "100644", + "gitBlob": "ab26a72e9ce269c0eb7198b7a6866e5b3e947fcf", + "rawBytes": 2233, + "rawSHA256": "72AEA81DCDB221BA822CDB89A51358EF616B19FFB8CDAFF5B23ADA2EEED17EB0" + }, + { + "path": "docs/internal/COMPACT_EXCEPTION_LOCATOR_AUDIT.md", + "mode": "100644", + "gitBlob": "9192e995984b6d78d697c985e8ee54e20a84f08e", + "rawBytes": 14788, + "rawSHA256": "7E328A3A96072238ADE0421BE83293E67ED7C170ADB2508ED22BAA03630E6A6A" + }, + { + "path": "docs/internal/COORDINATOR_RECORD_STAGEA_TO_V1RC.md", + "mode": "100644", + "gitBlob": "a3483dc722cebb401b0cf298dca34238fe05d3a2", + "rawBytes": 18944, + "rawSHA256": "2A496D10FFA3143626775FEC5510A98D034C07F9CC5F943E12788A430C82943F" + }, + { + "path": "docs/internal/DESIGN_DECISIONS.md", + "mode": "100644", + "gitBlob": "8086e978bf50c04bb57ddafa50ef3c6a2b3f26bf", + "rawBytes": 845563, + "rawSHA256": "784B625AB72E3C991B5136FD3C7010401F5085F53E6B26D62FE3AE99F3F75294" + }, + { + "path": "docs/internal/E1_AMENDED_MACHINE_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "05b4b693c18ed12fc39ad722614d601e605cc039", + "rawBytes": 26223, + "rawSHA256": "52900E7CE1DF7A9899D0E6C750B2A1645A906D864577A980FA0E6E8DBC00EF51" + }, + { + "path": "docs/internal/E1_ARCH2_B3ROUTE_R1_WORKER_TERMINAL_REPORT.md", + "mode": "100644", + "gitBlob": "f31b68c0880398515b58217f5dc707bfff74c577", + "rawBytes": 5782, + "rawSHA256": "2F3E4EDA6953393275DA48AD12229A83DAC2E8B25F3398E3425F10513EB02B7F" + }, + { + "path": "docs/internal/E1_ARCH2_CONTRACT_REPAIR_PREP.md", + "mode": "100644", + "gitBlob": "69a92ddaea704f63294d821d59b90fce6b2ad8d1", + "rawBytes": 23913, + "rawSHA256": "B871B94EC8F3449451248467D8FCF8E0ED9EA2D590F41C6EC40CEBAE4DF2485B" + }, + { + "path": "docs/internal/E1_ARCHITECTURE_COORDINATOR_HANDOFF.md", + "mode": "100644", + "gitBlob": "d8ff6358929fb6b5fbc40ca92de434a7b1939297", + "rawBytes": 28486, + "rawSHA256": "B7F35B50957C3E73BFE6D871F9364FF8F3ECDAC1B8427F1345515EAB8F93CA63" + }, + { + "path": "docs/internal/E1_ARCH_ADDENDUM_C05_2026_07_23.md", + "mode": "100644", + "gitBlob": "cf4c612e6c993f02c04e18cecd82e4fdb51ea22d", + "rawBytes": 16230, + "rawSHA256": "1F7E0C29DB1B0971ED7541C30D98397517BF22A369ADAD3BA8F142849D7DA0B6" + }, + { + "path": "docs/internal/E1_ARCH_HANDOFF_INDEX.md", + "mode": "100644", + "gitBlob": "220d60692865fed77f7e6cbb4f865d4ebfe83949", + "rawBytes": 4412, + "rawSHA256": "5AE23FEB08250669473EFB32D1A25D13D69AFD86D4D629BC1A68A7F562276AE7" + }, + { + "path": "docs/internal/E1_ENDGAME_F03_CLOSURE_RESULT.md", + "mode": "100644", + "gitBlob": "ccbec11854a93a5aca7b14f679555d95752d1a88", + "rawBytes": 11277, + "rawSHA256": "7A93B99CC1A28ACA330D7CCB44C6E4AB0E6CB10FA53D188072E95CE9C26FC259" + }, + { + "path": "docs/internal/E1_ENDGAME_F03_GEOMETRY_CLOSURE_CAMPAIGN.md", + "mode": "100644", + "gitBlob": "db91f904ae93bd50fe1e6703a8b46cd0b52d7f24", + "rawBytes": 19995, + "rawSHA256": "970739B783E4CE2C53E7ED09EDB2E0EB2BC8F4466818F145EB22C6BCB4E9E55E" + }, + { + "path": "docs/internal/E1_ENDGAME_T1_SELECT_LEAF_RESULT.md", + "mode": "100644", + "gitBlob": "2ade44b1ab2970d1168a222f4394f6122ba7b1fe", + "rawBytes": 7854, + "rawSHA256": "DCEEADB6250270EC472A33D96C8977242E37736F982982B05EF21AE56CF403D4" + }, + { + "path": "docs/internal/E1_WORKLOG.md", + "mode": "100644", + "gitBlob": "5d4c16907ab2acd838910f290f477bb866174a50", + "rawBytes": 157184, + "rawSHA256": "BEDA07A9C3FAE6D4E2C1B31D3B1036A4F0980209FE62B590BADA8DA8F8273C7C" + }, + { + "path": "docs/internal/EG_CP_FINAL_FALSIFICATION_MATRIX.md", + "mode": "100644", + "gitBlob": "46be6c10c5cc05cbab7e8838ec059b78bff9fa54", + "rawBytes": 152998, + "rawSHA256": "94CA97260F83248445736EFDC87F6D05D34BBC36F65AB5E12E943A78A6E6AF6E" + }, + { + "path": "docs/internal/EG_CP_FINAL_FALSIFICATION_RESULT.md", + "mode": "100644", + "gitBlob": "0bd5c6d7fe7ba2e4efa811a84bd38c8e11867caf", + "rawBytes": 57615, + "rawSHA256": "EE8D63DACED9661E8F3BF13CC18FB2E23247A6611AB7701142B1236FD1AED58A" + }, + { + "path": "docs/internal/EG_CP_STAGEA_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "69e32a5da5d5e26b25f87638d8914ffea49b1370", + "rawBytes": 72266, + "rawSHA256": "353754BA798D26A7B483CFD985F98652BCCA3D6694B11FA3CA73C9F1542E8BF9" + }, + { + "path": "docs/internal/EG_CP_STAGEA_RESULT.md", + "mode": "100644", + "gitBlob": "088a57b8d0d54a9279b04fb9d1545d511a0e321b", + "rawBytes": 48199, + "rawSHA256": "A0EDAA9F6CFC08DF0F0F9197A193E3E288C2FF2B6B655069E4307C90474E57B7" + }, + { + "path": "docs/internal/EG_CP_STAGEA_WORKLOG.md", + "mode": "100644", + "gitBlob": "107e22baf6a5e4138fca06a7b50f1d7caf893e62", + "rawBytes": 8338, + "rawSHA256": "4B6397862117F4D90B69C8F81E2AA1E411250FE9EF0DF5366D6021DA365E2719" + }, + { + "path": "docs/internal/INTERIOR_NAVIGATOR_DESIGN.md", + "mode": "100644", + "gitBlob": "44350df412d5989b20991e22ee97bcf602341f2d", + "rawBytes": 7968, + "rawSHA256": "796B3E353A15F8D89D6C0260344BA5B3CD0E74347A8578AAB8737951864304CA" + }, + { + "path": "docs/internal/LOCAL_BP_DECODER_PATH.md", + "mode": "100644", + "gitBlob": "e13aa53b847ab48bb6b431b14a1bb4789e179325", + "rawBytes": 11243, + "rawSHA256": "C5062983AA244162CAE7988793C4AFC280D7A8AC87092381E9A05FD22A8BF1CE" + }, + { + "path": "docs/internal/M1_REVIEWER_NATIVE_ADEQUACY_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "21b42ee8babefe6d96234a92c3f3e12b34cb1451", + "rawBytes": 213412, + "rawSHA256": "194F2E9562D2394DC5724D85414228CB8DF2DB36E5233B642CDC85132688F7FC" + }, + { + "path": "docs/internal/OPTION_B_CHARGED_FRINGE_DESIGN.md", + "mode": "100644", + "gitBlob": "a9c47741422d4e2066daa8e71cdc63b8e2dfda98", + "rawBytes": 7311, + "rawSHA256": "EFD64A2C1D21E9AE72AC1866F34C0FBD1B61BB20D53785BCBA6BD6F316EBF670" + }, + { + "path": "docs/internal/P1_POLICY_HARDENING_WORKLOG.md", + "mode": "100644", + "gitBlob": "d63e93d0fe563f66b14bdb21d36e6d4cd0c94f5e", + "rawBytes": 55440, + "rawSHA256": "32BD7EF286CD43867C39E51A3C00DD430A014C719C16AD9112BAC5F776F0ECD1" + }, + { + "path": "docs/internal/PLAN_AUDIT_DISPOSITION.md", + "mode": "100644", + "gitBlob": "af4b6f015a5690bbd9980e6a9422b31cbdfe8ff6", + "rawBytes": 19313, + "rawSHA256": "D25D29AD74A5274FB25E3405C406442269A0EE702814B541D9CC10C3EB5CD949" + }, + { + "path": "docs/internal/PLAN_AUDIT_DISPOSITION_v14.md", + "mode": "100644", + "gitBlob": "fba5c499de4f098bfc340aa9de4e8b2c49381b3c", + "rawBytes": 2740, + "rawSHA256": "633A9D49D0CC9050AA0A3B198E2783726686AB46621A82D4361F3A5A02F77B39" + }, + { + "path": "docs/internal/PLAN_AUDIT_PROMPT.md", + "mode": "100644", + "gitBlob": "5f44abc94c224b996430dbbd01d240a9e8e113fc", + "rawBytes": 5308, + "rawSHA256": "1DB8E3239315498AE5DCB8DEF2FA543BBDDDAB937D3B787AED6BA52C7C5AAB52" + }, + { + "path": "docs/internal/PLAN_LINEAGE.md", + "mode": "100644", + "gitBlob": "6946a670f3dbadd1a3f39219ccc30ca4803dfb10", + "rawBytes": 5914, + "rawSHA256": "6DA92669C550C57DB3B8339AC1799B695C397A5A7DC4282A7E1B0DECCAA2C12E" + }, + { + "path": "docs/internal/R1_WORKLOG.md", + "mode": "100644", + "gitBlob": "7f1fcd286dfdd23bb17b12735b8a31ee922ea2ae", + "rawBytes": 154831, + "rawSHA256": "04CC6278D24B5667AD0146E84F9D4DB089EF305AB1CD56749A62D98F9C375842" + }, + { + "path": "docs/internal/R2_ALLSIZE_WORKLOG.md", + "mode": "100644", + "gitBlob": "e7a186aa514e628c89f00f1e14c49806d5a5726c", + "rawBytes": 7922, + "rawSHA256": "680AE226FAB901E12F6160F6DCF9B593A8C07BB00413FBEC660796B7F3760541" + }, + { + "path": "docs/internal/RC1_CORRECTION_HANDOFF.md", + "mode": "100644", + "gitBlob": "a10679e4644342042aab6b0f6e604133ad5ab1f5", + "rawBytes": 12088, + "rawSHA256": "4C641ADA92B59D5D112AA6EF8C73AB5D203E487CB64D7F3917E64080B40BC187" + }, + { + "path": "docs/internal/RC2_CORRECTION_HANDOFF.md", + "mode": "100644", + "gitBlob": "b58efba8c2e711fc1d26385f5004039d02f4355f", + "rawBytes": 4073, + "rawSHA256": "6FFF3D4BB100477766ECF2180EC422E823C69C1B7999BDB2C29D0CD36D115373" + }, + { + "path": "docs/internal/RC3_DISPOSITION.md", + "mode": "100644", + "gitBlob": "3865ca3628cc2993e14c5aca752c102646db0179", + "rawBytes": 14779, + "rawSHA256": "143510DA80F7EDE92503F57E8953C49B3E25C0974993428EDB0CA6918169BA34" + }, + { + "path": "docs/internal/README.md", + "mode": "100644", + "gitBlob": "b64fa2654f86ccb99997291839f05379b0750b50", + "rawBytes": 2621, + "rawSHA256": "88DB538D661D063F3F39DC77A3B7E71D0E4A35F3B9006A443E771A4817521654" + }, + { + "path": "docs/internal/RELATIVE_RMM_LAYOUT_DESIGN.md", + "mode": "100644", + "gitBlob": "8dee2aa4be55c63b261fd967f96524f46c84f0ae", + "rawBytes": 11442, + "rawSHA256": "526089E3FA0CF23DDEED2A6C880F580C3B444979031DAFF8A91B4B37E0396369" + }, + { + "path": "docs/internal/RETROSPECTIVE_CERTIFICATIONS.md", + "mode": "100644", + "gitBlob": "5a8d1a9ca909e92a597c98913f6fa8b48fced8d6", + "rawBytes": 6942, + "rawSHA256": "C8A21045EA24DA6DDE9F24C352BCB14B20412B18582B02B76B47F2C6FA3052FB" + }, + { + "path": "docs/internal/RMQ_DECLARATION_CLOSURE_2026_07_10.md", + "mode": "100644", + "gitBlob": "56457fecc6acc34f3ff226355c036ddd5cce5ddd", + "rawBytes": 5760, + "rawSHA256": "03F0E045829DF97963F532C8872E79DFE50EB87EDFC4564119E57271118C7E4B" + }, + { + "path": "docs/internal/RMQ_ENDGAME_ROADMAP.md", + "mode": "100644", + "gitBlob": "12f84ba455d4bb8f19385575a7d5a74e95753953", + "rawBytes": 52798, + "rawSHA256": "D3C05249E0BF43ECAF527A3168B14D28F8398ABC530CC3260101AC6D05AB1C47" + }, + { + "path": "docs/internal/RMQ_FINAL_ROADMAP.md", + "mode": "100644", + "gitBlob": "73f67afb0e98c7358640a2a791d319b7b0679875", + "rawBytes": 32220, + "rawSHA256": "E8A69418D01424EB4C3772A6E4C673145D2443FFB4B88D2C94D6805C42054EFA" + }, + { + "path": "docs/internal/RMQ_PROGRAM_PLAN.md", + "mode": "100644", + "gitBlob": "37eaaae37a884cd15369393df5bf6f1cd44b2793", + "rawBytes": 44761, + "rawSHA256": "E66111A9545DA6C8E9F472BBAFCF81C3752AD734961853C9612EF8F07B113B86" + }, + { + "path": "docs/internal/RMQ_PROGRAM_PLAN_2026-08-13.md", + "mode": "100644", + "gitBlob": "b14cd7ccc5232bfbd3f53e8d46be5e417f4f53bf", + "rawBytes": 25557, + "rawSHA256": "98C1FF8029CAC4065C174588423F87D5778490C60395ED39AEA0D0E29CF54E6A" + }, + { + "path": "docs/internal/SUCCINCT_FINAL_PATH.md", + "mode": "100644", + "gitBlob": "bfd1aded8b9c1328b94f8c5d9388fb9006a2cc21", + "rawBytes": 46398, + "rawSHA256": "D0E06A2A3BF75ADFF0755BC6559B9051A8DA12BDCF12EE5F1DF94A9267443F0E" + }, + { + "path": "docs/internal/SUCCINCT_RESEARCH_AND_PLAN.md", + "mode": "100644", + "gitBlob": "2547359289338442007831917d13b57ab6f25464", + "rawBytes": 10217, + "rawSHA256": "4BE951CC893BCBB7C71EE38C55B5E1C9DB0803A575A3F8EEF359E93889BDF9F2" + }, + { + "path": "docs/internal/SUCCINCT_SELECT_LOCATOR_ARCHITECTURE.md", + "mode": "100644", + "gitBlob": "7cc2c626a6142ef7e0d6f7d01b2c29c878011218", + "rawBytes": 14339, + "rawSHA256": "92E0EA286726AC054B17FFB8FA1322D2B3A6EE0BC19B3A3F1ACFCBCEFC03F77B" + }, + { + "path": "docs/internal/V1_RELEASE_CANDIDATE_AUDIT_PROMPT.md", + "mode": "100644", + "gitBlob": "48335dec906409193ab4f4d02c2c53b1f45a0fda", + "rawBytes": 19322, + "rawSHA256": "B176E0F704E03C201114166BF9494D5A3AE7656BF1DB73BB965F184C4EB3A524" + }, + { + "path": "docs/internal/W15_U2_CANONICAL_PAYLOAD_WHOLE_MACHINE_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "054c97db8f3d6877df3af3149575149834eec13c", + "rawBytes": 114378, + "rawSHA256": "8453FCE1283460FF01DF74A7817DC8383C4812A4FCAC0CD845AF1A5484E44AA6" + }, + { + "path": "docs/internal/W21_U3_PRINCIPLED_ALLSIZE_COST_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "e2adac84f4d7267e01ed5ce90509d8c0b4d411b2", + "rawBytes": 27110, + "rawSHA256": "BC47D95743947A88AAEAE202E94A2254C785374C8DA003E3526E8AFF1652D283" + }, + { + "path": "docs/internal/WORD_RAM_INTERPRETER_REFINEMENT_PLAN.md", + "mode": "100644", + "gitBlob": "b59c6fa60709c2b9b2bffe70780f835a8cd941c9", + "rawBytes": 27836, + "rawSHA256": "FCEACE7A313C65CB64FF7E37E40CE109A06281C70F4274A35678E9F5C0EF1A0E" + }, + { + "path": "docs/internal/WORD_RAM_REGISTER_CONTROL_PLAN.md", + "mode": "100644", + "gitBlob": "cc8a0fe7be50bea0740c47d6f50e5cbe81244e04", + "rawBytes": 14505, + "rawSHA256": "93201A03D35CDB422E76438F6BDCE9AA33337782B6DAA2BEEFEE99337FBB40C9" + }, + { + "path": "docs/internal/WORKER_INTEGRATION_CHECKLIST.md", + "mode": "100644", + "gitBlob": "89ce88aedd0947308ef8c2cdbd619a9f2b85ea3a", + "rawBytes": 5552, + "rawSHA256": "4B9DFF882C4936E8E65F8F01D97940941468F3FC5F39456752780AE5D51FDB4E" + }, + { + "path": "docs/internal/WORKER_LIFECYCLE.md", + "mode": "100644", + "gitBlob": "fc58b9d056aae55007fde2ecdac6a31cd7fbbbad", + "rawBytes": 6149, + "rawSHA256": "1A2CCE5D2B9ED935295D34BE45E4B7A3D7F88E6A48C2E67030DD56019FA00BC5" + }, + { + "path": "docs/internal/WORKFLOW_DESIGN_DECISIONS.md", + "mode": "100644", + "gitBlob": "2c7f7e897bb230a978033fd5d8961e1b3c9cef9c", + "rawBytes": 958591, + "rawSHA256": "E194FAAD6C54714B1B277966682871AE7A1673F6568D5D2C52B80C42EDC8EEEA" + }, + { + "path": "docs/internal/audit_packets/EG_CP_STAGEA_AUD1_PACKET.md", + "mode": "100644", + "gitBlob": "f992d829411e729398996986ac7681d194e78b8c", + "rawBytes": 10784, + "rawSHA256": "0F10A17E4DFAA9C8BB71D633C70A23476066D944903CD58C5E3B12B16979C034" + }, + { + "path": "docs/internal/audit_reports/2026-07-09_A01_rmq_frontier_audit.md", + "mode": "100644", + "gitBlob": "43b21e3fe52aa4f0be36be81814c96437f6108b4", + "rawBytes": 4389, + "rawSHA256": "1EB28B6A2C14756210645E99DE970418728D148C3DD93A5E37A197C3503DB27D" + }, + { + "path": "docs/internal/audit_reports/2026-07-09_A02_rmq_pre_w10_frontier_audit.md", + "mode": "100644", + "gitBlob": "83bf5c84d81f3d8ffb5a7f9cff6580ed99750f85", + "rawBytes": 20026, + "rawSHA256": "4FD892636AD6096E143A7FE802835A97565C089D156A1E7DD1CED1D51530AE39" + }, + { + "path": "docs/internal/audit_reports/2026-07-10_A03_u1_total_layout_audit.md", + "mode": "100644", + "gitBlob": "0f46e151df3cb03183ae6844c81c1556d18d3f98", + "rawBytes": 20349, + "rawSHA256": "23C3BBC662C0B0B1AABA6D8B7DE5DDD5513E61AE27320993BC6D3FE538236562" + }, + { + "path": "docs/internal/audit_reports/2026-07-14_A04_u2_blind_acceptance_audit.md", + "mode": "100644", + "gitBlob": "176fb015c8613505ee76ddfbe3235e617ee5a123", + "rawBytes": 29411, + "rawSHA256": "13706DF623B47AC1B8060C4AD1A49A66BE4DEB9CF408CAB0B78CBB2E19E79E8B" + }, + { + "path": "docs/internal/audit_reports/2026-07-19_A08_b7_charged_sparse_level_audit.md", + "mode": "100644", + "gitBlob": "642f057c9b947c9c041bc5aff1a648efcae461a3", + "rawBytes": 29641, + "rawSHA256": "119D0065712D8C9DE3225F000ECD89C2A1F126824A72B9DCA4F8DB76EE31D961" + }, + { + "path": "docs/internal/audit_reports/2026-07-22_M1_R5_R9_fresh_blind.md", + "mode": "100644", + "gitBlob": "bc5144abff8d4974799ae285782b67b0669bbb90", + "rawBytes": 42457, + "rawSHA256": "BB4849E925543CC3027C0B62B29731BE9D156C97958826AF4C0609CAA613D34D" + }, + { + "path": "docs/internal/audit_reports/2026-07-24_C06_e1_arch_handoff_package.md", + "mode": "100644", + "gitBlob": "98d7d07a93b1e778d5760df8814f1deaa034a7d0", + "rawBytes": 10975, + "rawSHA256": "00454BF5240E58A5B37F8E83AE379563E8260D0AADBDAE5EFE995045421B0CDB" + }, + { + "path": "docs/internal/audit_reports/2026-07-25_A09_endgame_plan_audit.md", + "mode": "100644", + "gitBlob": "836c11307aa2ad3ccf87db5594b609d47b168314", + "rawBytes": 38964, + "rawSHA256": "7270B33B0C9D73D6B03EF78A94B112506CD8590BDFDE5E4EFB5E2BC680621502" + }, + { + "path": "docs/internal/audit_reports/2026-07-25_C06_e1_arch2_b3route_r2.md", + "mode": "100644", + "gitBlob": "9132abe7256bb4f5789d620649717fbda5c39c26", + "rawBytes": 11171, + "rawSHA256": "CDDE31471D572737670E8AAF9ACB7DBAB429408EC8C060F5212ADE37B449DB74" + }, + { + "path": "docs/internal/audit_reports/2026-07-25_C06_e1_arch2_b3route_r3.md", + "mode": "100644", + "gitBlob": "dc394bf9f1476b7aa042dcef77606364b976e2fa", + "rawBytes": 10976, + "rawSHA256": "1E3BC6B60EAD54CAE11CFF5D938D2CDA05A71BCD31A700D75028F265BB5FB0D0" + }, + { + "path": "docs/internal/audit_reports/2026-07-25_C06_endgame_adjudication.md", + "mode": "100644", + "gitBlob": "69108651015651c9e9672bbde68a7acd5c2ffa32", + "rawBytes": 7483, + "rawSHA256": "A0A59FD93018DA7D585003AE38551DF32DC307BFA224FF367BB8488BFC5D79AD" + }, + { + "path": "docs/internal/audit_reports/2026-07-26_A10_f03_geometry_closure.md", + "mode": "100644", + "gitBlob": "a1e168cba058e6dd0aac4e8207c49a266775196a", + "rawBytes": 19446, + "rawSHA256": "004B070A1A27F9112CB9C59720C9B898E483B8AD5DF6D4DCFFDD1133D3E779DA" + }, + { + "path": "docs/internal/audit_reports/2026-08-05_EG_CP_ALLSIZE_R2_fresh_blind.md", + "mode": "100644", + "gitBlob": "d42272ee1d0c3adebabcbaabd280cd97c5db8f14", + "rawBytes": 18981, + "rawSHA256": "D4B511134AC09190EAC0DB6513F891D15208BBE941B259D92123C3CAEDC4B783" + }, + { + "path": "docs/internal/audit_reports/2026-08-06_EG_CP_STAGEA_CLOSE_R1_fresh_blind.md", + "mode": "100644", + "gitBlob": "fbcf778a1c22ce6a56a8de1b94d69a8f2f8f7ce1", + "rawBytes": 59918, + "rawSHA256": "D6D0FF08F971EFB3A94F2FCAE244E586B56242C61069356B4333B569C2CC9CC2" + }, + { + "path": "docs/internal/audit_reports/2026-08-06_EG_CP_STAGEF_CLOSE_R2_fresh_blind.md", + "mode": "100644", + "gitBlob": "2c24bdb5a70248591bc32d563683c06cdd59c113", + "rawBytes": 39645, + "rawSHA256": "11A671E3BF9006E49F38B52EC97F521041F28760ECCA137B34BCDD723E0C2326" + }, + { + "path": "docs/internal/audit_reports/PQ1_FRESH_BLIND_4c89378.md", + "mode": "100644", + "gitBlob": "55c1b95b4fc1440687dca94337449c7c600006f7", + "rawBytes": 45505, + "rawSHA256": "D14773AC45B93D75E03EA19B7D2B5B3263AA46980E65D87A0955759529B97E02" + }, + { + "path": "docs/internal/audit_reports/PQ1_MERGE_READINESS_20260912.md", + "mode": "100644", + "gitBlob": "c594f8e49ed5ce7a85813c23a48ec179ecb51514", + "rawBytes": 5403, + "rawSHA256": "002AD25F67054DA39A92DE63C88F5F6B359107EADA801935801B39DD8D4430F3" + }, + { + "path": "docs/internal/audit_reports/README.md", + "mode": "100644", + "gitBlob": "c7dc3b458fc6c1210f1136959cd8390bd60f34fb", + "rawBytes": 986, + "rawSHA256": "3E9CC023AFC4BFA4BEC3C4CDD999CAEA8E872F8B9B5BA86F2C13C55F848F1B30" + }, + { + "path": "docs/internal/e1_arch_prompts/A10_F03_GEOMETRY_CLOSURE_AUDIT_PROMPT.md", + "mode": "100644", + "gitBlob": "0a07cd8f284d4fcee7090213078e515b84fe3c25", + "rawBytes": 11877, + "rawSHA256": "037E044CA5C912F65AD45742A0F8691BC640A22DBD0DD79F1CBF9751039411FC" + }, + { + "path": "docs/internal/e1_arch_prompts/A11_F03_AMENDED_ROW_AUDIT_PROMPT.md", + "mode": "100644", + "gitBlob": "39304aadfbd4794e9cc55cfc656be0621400f1fd", + "rawBytes": 10078, + "rawSHA256": "848A175DCE1923EC974286F5281C61B50AEBFCACB0F978DEDC4E9E05A00B9C1B" + }, + { + "path": "docs/internal/e1_arch_prompts/E1_ARCH2_B2DESC_R4_PROMPT.md", + "mode": "100644", + "gitBlob": "0479b7c62bf911cb741625a0b8113f6a67cf5b2c", + "rawBytes": 18623, + "rawSHA256": "A3EC3C3077FEE9A34D34FBD745D393ED2DF9BAB92DA081CFDB79F5F6091A47CF" + }, + { + "path": "docs/internal/e1_arch_prompts/E1_ARCH2_B3ROUTE_R1_PROMPT.md", + "mode": "100644", + "gitBlob": "0941ab7a97dc319513c023833983366bff59a76e", + "rawBytes": 22058, + "rawSHA256": "EF0112772907E0005BF5B6A978EF7903957CFA0DEF948CF1FABB3F064165D320" + }, + { + "path": "docs/internal/e1_arch_prompts/E1_ARCH2_B3ROUTE_R2_PROMPT.md", + "mode": "100644", + "gitBlob": "e74a01f7150366776bfbe3e5eba728d2977684c7", + "rawBytes": 32547, + "rawSHA256": "24C9466DFA3F58CD76A9578E71A2131AB21DB9D012F2373FA4BD8882BF0BF4B1" + }, + { + "path": "docs/internal/e1_arch_prompts/E1_ARCH2_B3ROUTE_R3_PROMPT.md", + "mode": "100644", + "gitBlob": "6b065ae8f143d00c64e454a05564ed86ba879cad", + "rawBytes": 28154, + "rawSHA256": "E23313D7AA7C62CECFDF08D059BD0730213B987D3B9C5485A73B69257A0CAA7B" + }, + { + "path": "docs/internal/extensions/bv1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "d91d42d39bad8f1ed37e3ec5d31af119d9e8ee5f", + "rawBytes": 29096, + "rawSHA256": "80BD59A314FD33D37076802954444DA24F65C87A2A91DE23BC668B6AF9CCEB24" + }, + { + "path": "docs/internal/extensions/bv1/ACCESS_PROOF.md", + "mode": "100644", + "gitBlob": "68e4e7e569063951f0e91652b3eef0396b9672b3", + "rawBytes": 12485, + "rawSHA256": "5406A336BC4E4C2B82355FA32C6FA91D4A74F6D5548619974ECCC4C605445A09" + }, + { + "path": "docs/internal/extensions/bv1/ALLOCATION_FACTS.md", + "mode": "100644", + "gitBlob": "1f0821f98776b638be4c8b61f5a3fbe9df36b2b5", + "rawBytes": 14852, + "rawSHA256": "772E12F6D8B484500C9F8DDB3A2156C750CD7A5D824D2297D04522C351164935" + }, + { + "path": "docs/internal/extensions/bv1/ALLOCATION_READER_PROOFS.md", + "mode": "100644", + "gitBlob": "aadfa6d496896c348265dca699e0d0f5932c1c39", + "rawBytes": 15449, + "rawSHA256": "418A6C7840C1D3A7607803596B05F67727EA1B51325A8F570D2DDB5FA9B300C2" + }, + { + "path": "docs/internal/extensions/bv1/CANONICAL_MEMORY_BOUNDS.md", + "mode": "100644", + "gitBlob": "707444d9f5c4f1873d2bb3b8c35fb93d4561d0af", + "rawBytes": 14017, + "rawSHA256": "CCFB35D6C2AD82E0D0182C1C963F5635670863CC8D3C384B34526A7046A94324" + }, + { + "path": "docs/internal/extensions/bv1/CANONICAL_RANK_ACCESS_SAFETY.md", + "mode": "100644", + "gitBlob": "10ae75797d11de63753b0e26de722510402bfe93", + "rawBytes": 13931, + "rawSHA256": "625FC059C257F6B427A76B3168F391E7BE3DB8E978897EF98F0F819E5175328C" + }, + { + "path": "docs/internal/extensions/bv1/CANONICAL_SELECT_SAFETY.md", + "mode": "100644", + "gitBlob": "3611d7ea4131c96126a2d13982024e8e3ea5de98", + "rawBytes": 11616, + "rawSHA256": "25BE7079BCFB495E451458D54C54D9736D53344D8D6EBBA9D3260FAD03410067" + }, + { + "path": "docs/internal/extensions/bv1/CAPSTONE_COMPOSITION.md", + "mode": "100644", + "gitBlob": "2d38d6e273a47c2dcc7c411c24b7d518d9ecb33d", + "rawBytes": 18510, + "rawSHA256": "54E865CAB745C9E04988F3097024704678CDDEC3776B39C573984851799D0646" + }, + { + "path": "docs/internal/extensions/bv1/CAPSTONE_SCHEMA.md", + "mode": "100644", + "gitBlob": "f21a76e3014ef96b5542fd95401b361ae632ab1b", + "rawBytes": 5697, + "rawSHA256": "89B40DF3C68CF7FB50903984CC37D519D0A6EC567E4B6FF29E155C302CF927C4" + }, + { + "path": "docs/internal/extensions/bv1/CHARGED_SETUP.md", + "mode": "100644", + "gitBlob": "586b27fcbb4ca359e0afd6fee1a751e91749f303", + "rawBytes": 13047, + "rawSHA256": "02B99ABB531178C17602ACF8A5329DEAB47A621F9DC9C0F16FABEA0735524614" + }, + { + "path": "docs/internal/extensions/bv1/CHECKOUT_BYTES.md", + "mode": "100644", + "gitBlob": "b8a442c0ce14a3eb517d5ad59669a13f0c301103", + "rawBytes": 7745, + "rawSHA256": "11AD1F389569CBFB7C9A8FD05811278B828F45B066CB21C92164307D013B22FB" + }, + { + "path": "docs/internal/extensions/bv1/CHECKOUT_BYTES_DISPOSITION.md", + "mode": "100644", + "gitBlob": "503190799f369fd809cfd73321eb87794e42a6e0", + "rawBytes": 1725, + "rawSHA256": "7F8810E67213EE3071044DFE1E72F354B52D3C6C2D90D1D1A56462B9E2926396" + }, + { + "path": "docs/internal/extensions/bv1/CHECKOUT_BYTES_LAKEFILE_DISPOSITION.md", + "mode": "100644", + "gitBlob": "21bcc4371b2777f04af0c58c30d7ad39bd0b76a9", + "rawBytes": 3028, + "rawSHA256": "F43488628BCDBDED05BC7139719F6E9CCFF3B5272BB138B14B14EB316101F512" + }, + { + "path": "docs/internal/extensions/bv1/CHECKOUT_BYTES_LAKEFILE_PATCH.diff", + "mode": "100644", + "gitBlob": "59bf1a16cb8caa7035c5519ac26c6a889980d287", + "rawBytes": 363, + "rawSHA256": "A6D7771DAEEEB3618E55A9FCA3302E88A8D402455425B66616EEDFA6511E1CC6" + }, + { + "path": "docs/internal/extensions/bv1/CHECKOUT_BYTES_PATCH.diff", + "mode": "100644", + "gitBlob": "f8b4240fc07d93dbc03c2e6021fa23371ca7d28f", + "rawBytes": 679, + "rawSHA256": "22681770C2D5B2A42389E00BC00080A79B75ACDF968C27320FB0A90F2224E40B" + }, + { + "path": "docs/internal/extensions/bv1/CHECKOUT_WHITESPACE_DISPOSITION.md.gz", + "mode": "100644", + "gitBlob": "99cf52e863c580fa5aca2eef4c1e0ce5fa375947", + "rawBytes": 1854, + "rawSHA256": "1E5B6C40E1D751154DE9BE02201FB0B26054A2DF69CFF54CF426C178ECF7D011" + }, + { + "path": "docs/internal/extensions/bv1/CHECKOUT_WHITESPACE_PATCH.diff", + "mode": "100644", + "gitBlob": "ee97a7188cc5e75808f140f4604bf19c97ff4b39", + "rawBytes": 1927, + "rawSHA256": "8ADDBDB7B260ACEB3712CE30D59E066A2144C01013164F4E52352F1D464B057E" + }, + { + "path": "docs/internal/extensions/bv1/COMMANDS.md", + "mode": "100644", + "gitBlob": "48f4278afd76ad2de82e8926238ff0905af95e95", + "rawBytes": 15024, + "rawSHA256": "9F3C35C92863ECAD365DEA7EF89006164DB87EC6741ADABD60EF5609C6633122" + }, + { + "path": "docs/internal/extensions/bv1/CONTINUATION.md", + "mode": "100644", + "gitBlob": "6f5eb3acb81bc8ac86ac0fa41cb77d46c5395a3f", + "rawBytes": 4689, + "rawSHA256": "265264BE0EE49D12B258089EFB1C74EBA213B6DB8115E2311CC88750694EB18D" + }, + { + "path": "docs/internal/extensions/bv1/CONTRACT.md", + "mode": "100644", + "gitBlob": "cf852503874fffe3ffd7a3f7aa1c2ab183d01789", + "rawBytes": 10151, + "rawSHA256": "1F8FD493DB9896E66288DB850A9EA456A0CDAA05D55B6FE9686CCFC766FD4A00" + }, + { + "path": "docs/internal/extensions/bv1/CONTROLLER_PROOFS.md", + "mode": "100644", + "gitBlob": "95ecfc9cb0578a7debd235899f9c6e67813948da", + "rawBytes": 27322, + "rawSHA256": "A065C80BFE3C29B898D31587EB643D148ED7F662E18BD5DF19F7DDD0D7E7622A" + }, + { + "path": "docs/internal/extensions/bv1/COORDINATOR_ROUTE_DISPOSITION.md", + "mode": "100644", + "gitBlob": "d1dd25457982a7a90bcf5d63656be04afb7c7f00", + "rawBytes": 6169, + "rawSHA256": "BA1F222D4904290527417B951489B54F9833999DE3D0F1060A0E6E060002CAB3" + }, + { + "path": "docs/internal/extensions/bv1/EVIDENCE_MATRIX.md", + "mode": "100644", + "gitBlob": "1dc49c8954db1192a6a2200635bcd40eb157eebf", + "rawBytes": 22376, + "rawSHA256": "E6F34B2DE09FB86C0ADFCD5527C3F7944FB4F24A9D940EA153E60E83D7803FA4" + }, + { + "path": "docs/internal/extensions/bv1/EXCEPTION_CONTROLS.md", + "mode": "100644", + "gitBlob": "565928e6f5288c6655700a70042f88f2d966c6d2", + "rawBytes": 13721, + "rawSHA256": "F676ED4A5F4CBDC25B2B868EB081288D73A65C05762A1C7022A77A55692981A6" + }, + { + "path": "docs/internal/extensions/bv1/GENERIC_SELECT_SAFETY.md", + "mode": "100644", + "gitBlob": "e01643735009b999eb9414eb215eaa80c820cd3a", + "rawBytes": 16708, + "rawSHA256": "258B27BBB14229787F19B2391110F4044312DF2D3FAE42112FC106F7E9FA6C38" + }, + { + "path": "docs/internal/extensions/bv1/LEAF_CONSUMER_REPLAY.md", + "mode": "100644", + "gitBlob": "12bfa7976c58ae75277d809bcea611538c0477f6", + "rawBytes": 10324, + "rawSHA256": "AF80E6176EFD1715EE1A30CFC009258135FD1F0D94AFF79A1B07B1AAF0206DE7" + }, + { + "path": "docs/internal/extensions/bv1/MACHINE_CONTROLS.md", + "mode": "100644", + "gitBlob": "999d63f08f3fd0ea560d7576fdb1078be41c94ca", + "rawBytes": 20162, + "rawSHA256": "EF319FA374972399CAF190E3C1C3F0AFC9E1B6FC6CA98DDC57C2CAEB398C8190" + }, + { + "path": "docs/internal/extensions/bv1/NORMALIZATION.md", + "mode": "100644", + "gitBlob": "78f9f12db749b9783924758c92bc73b1510aca32", + "rawBytes": 14640, + "rawSHA256": "519753D23F9BC91BFE97F3120FCA21815328FA361E1E6494A9C60A4F7CFEDDC8" + }, + { + "path": "docs/internal/extensions/bv1/NUMERIC_READER.md", + "mode": "100644", + "gitBlob": "c898fdb857250e9cbf32a95b5909eb72a67ff8a5", + "rawBytes": 10280, + "rawSHA256": "D2BC1E797619A434F7B3B24140D776AF2203AC4B774EB7A55659FCB977C0446A" + }, + { + "path": "docs/internal/extensions/bv1/NUMERIC_SAFETY.md", + "mode": "100644", + "gitBlob": "9ffc6562256cf30dc027902e9808515e3cd63c05", + "rawBytes": 15029, + "rawSHA256": "48D2C5A4B30C3D501FED52F54C036D8B05E86E9564B8D7D3B9C4B4EEB5547690" + }, + { + "path": "docs/internal/extensions/bv1/PREFINAL_COMPOSITION_REVIEW.md", + "mode": "100644", + "gitBlob": "6621f00e3c9c6a059b75e8216cbf9eaaf18018fd", + "rawBytes": 15579, + "rawSHA256": "6795A463A9F640DF504B140652C633EAB0A6D15EE13A93CA7FDEED8235403B93" + }, + { + "path": "docs/internal/extensions/bv1/PUBLIC_MUTATION_CONTROLS.md", + "mode": "100644", + "gitBlob": "069b7e6715fa5164a28f5d4ab38c4449c8710f9e", + "rawBytes": 29772, + "rawSHA256": "00B9C435B65B5F5C5516D255B67DCFE558E243AA4537D358DB734C511D1D8C59" + }, + { + "path": "docs/internal/extensions/bv1/RANK_LAYOUT.md", + "mode": "100644", + "gitBlob": "16b536a7773e8428d93deeb2d3d87899301b3d42", + "rawBytes": 11351, + "rawSHA256": "01EDD5E631D3CD73E4D508B6C47A45083380BC52E432FFE20FE522F0B18D2304" + }, + { + "path": "docs/internal/extensions/bv1/RANK_SEMANTICS.md", + "mode": "100644", + "gitBlob": "2f090c860adfb708d908b9f2946cfbcfe8dbb4f2", + "rawBytes": 16494, + "rawSHA256": "BE503531C70F68A9AFAC08DC1A301729A9CA645CD1F6EFD9FA6A457AD8E1C8E7" + }, + { + "path": "docs/internal/extensions/bv1/REGULAR_LAYOUT.md", + "mode": "100644", + "gitBlob": "7c1792c56640296b01c4813a9593bbf82a5bb962", + "rawBytes": 17776, + "rawSHA256": "5E620E761B9D41FEDB6849354322A7F5882316E1FE1C13DE1CC4BF8023BA43FA" + }, + { + "path": "docs/internal/extensions/bv1/REPLAY.md", + "mode": "100644", + "gitBlob": "74c438e509841f719a3855dba945e7f475a241af", + "rawBytes": 5316, + "rawSHA256": "1387EE95A1C281A7AFF6C7BA959BAFD28F59C573D0868480FF6C9ECEDECF87DD" + }, + { + "path": "docs/internal/extensions/bv1/REPORT.md", + "mode": "100644", + "gitBlob": "d1eef7b4031bb23bb08e0c99024b9e37b869d9e3", + "rawBytes": 11579, + "rawSHA256": "5B3D640ED84691A596EE3DFF087D8AC589B41649D83AC9D6B5FCF0D8CFE30381" + }, + { + "path": "docs/internal/extensions/bv1/ROUTE_REVIEW.md", + "mode": "100644", + "gitBlob": "edac5b71a31dc37e3551be094c02256b460f08cb", + "rawBytes": 3091, + "rawSHA256": "24DAF17F573C3C45B17FE73AB21F5F04D2037F61EF8D9565367E990C37F12E29" + }, + { + "path": "docs/internal/extensions/bv1/SCRATCH_FRAME.md", + "mode": "100644", + "gitBlob": "022a95d51ad9a8273bd5a60e04232d519c17118f", + "rawBytes": 8079, + "rawSHA256": "8726F87B832549C0DD5132A163D4059B64E22D68579952517BCA1E122D9B031E" + }, + { + "path": "docs/internal/extensions/bv1/SELECT_SEMANTICS.md", + "mode": "100644", + "gitBlob": "df24efaebfe9bc9bb1a610513e662b82da794c58", + "rawBytes": 14847, + "rawSHA256": "07759680FC451FC55DD89DD99F8CA35B5AC2CF6A65D9DC18BD489CBAAA2AA46A" + }, + { + "path": "docs/internal/extensions/bv1/SOURCE_FACTS.md", + "mode": "100644", + "gitBlob": "715ea00f2c322dd95fb3dffcd0bb745bd5ab367c", + "rawBytes": 5764, + "rawSHA256": "1EE1F6908B5EFE8A139B0FBD197B9A0933B39DCBCD6B1FDA5E0DF6C98D098DBD" + }, + { + "path": "docs/internal/extensions/bv1/VALIDATION_CONTROLS.md", + "mode": "100644", + "gitBlob": "d5736de37d7416b6278ca72ade8dbdd74a8c8e5a", + "rawBytes": 18381, + "rawSHA256": "DF1268C6147D15D9C2A72AEF90A2C2C169544E3E9CB24FE609B609E6AF9F9FFC" + }, + { + "path": "docs/internal/extensions/bv1/access_expected_type.lean", + "mode": "100644", + "gitBlob": "0b9d6153194b473b2fdf895b2d9b01a6fa973974", + "rawBytes": 1344, + "rawSHA256": "AF77F97FEF74247BFC45061D2078EF8D4709D22EF5A77C00F7F11A9BB018FB54" + }, + { + "path": "docs/internal/extensions/bv1/canonical_rank_access_safety_expected_type.lean", + "mode": "100644", + "gitBlob": "de9465d826161dd834ca8254522f690f29fb4d2f", + "rawBytes": 3471, + "rawSHA256": "09503EDC196B297B331C3ADDCC938D863D2568AA85C161D34A2EE7BB84221E71" + }, + { + "path": "docs/internal/extensions/bv1/charged_setup_expected_type.lean", + "mode": "100644", + "gitBlob": "e0bb8975f68a2ba334bfda8d620120dcf4972119", + "rawBytes": 2428, + "rawSHA256": "5CCC0D63D945734387F6E8DDB4A9AD6D10F39A2EEDBD285DA48C46D5ACD2FB86" + }, + { + "path": "docs/internal/extensions/bv1/check_build_manifest.py", + "mode": "100644", + "gitBlob": "e2c92216c88873a169458d5230ba741f71e17a1f", + "rawBytes": 2232, + "rawSHA256": "B4424A7CF836C3E44B929D8AB77FFF7F04562E586A9E334C112D1424E229093E" + }, + { + "path": "docs/internal/extensions/bv1/check_checkout_bytes.ps1", + "mode": "100644", + "gitBlob": "0c7f548313c55209d3572b01a390c47755271f1b", + "rawBytes": 10854, + "rawSHA256": "C2689D8B37F7BBF6EDE527295E1DAD543132E00FF847D9D654FBE2C5290A0807" + }, + { + "path": "docs/internal/extensions/bv1/check_frozen_rows.ps1", + "mode": "100644", + "gitBlob": "2d4fdff09ff1673af8ebc479b626be43747e8fce", + "rawBytes": 4714, + "rawSHA256": "8487D2F0F9B5906802F44B305A866F0DF652ACAC31E0329803FE562D4B292AF9" + }, + { + "path": "docs/internal/extensions/bv1/claude/canonical_scalar_payload.json", + "mode": "100644", + "gitBlob": "1744925ad30252125b009a9b7deac0a2c7b8e37d", + "rawBytes": 2273, + "rawSHA256": "1013E7050CEFE6236962EF40CC87A427D2F4ADA890648BEFE3D8F9B3C1DA486F" + }, + { + "path": "docs/internal/extensions/bv1/claude/canonical_scalar_scoped_start.json", + "mode": "100644", + "gitBlob": "61bb3f8feb441460f15b78bc7213922fcb5a50ed", + "rawBytes": 8432, + "rawSHA256": "E862D492D924221EC3240B8949AFC4BC908DBCE4459038B5789352B30FAF3E06" + }, + { + "path": "docs/internal/extensions/bv1/claude/canonical_select_bounds_start.json", + "mode": "100644", + "gitBlob": "d478b7ae0e564e2860f124c1cbc52a48b928f54b", + "rawBytes": 4131, + "rawSHA256": "2E60B940238C0B9426006D65FCA25757E30368F6849215B537F311421FEF51D2" + }, + { + "path": "docs/internal/extensions/bv1/commands/access-proof-build-final.json", + "mode": "100644", + "gitBlob": "1c7801f4a3af0bdb4f4d7ed88a32a0a2b0685728", + "rawBytes": 227889, + "rawSHA256": "2E1100897CFDF434DDAF542BF075C59CC7EF9151E5DDE07922DD16C2A5C5F5A0" + }, + { + "path": "docs/internal/extensions/bv1/commands/access-proof-build-v1.json", + "mode": "100644", + "gitBlob": "b5c2c8fe70abdbafaf9e69c06c27de75cd0aaa67", + "rawBytes": 250137, + "rawSHA256": "D9CF58B18F8AC9375CF7558F6D64DEC123DC51E1A5468A9A586333DD553E1C0A" + }, + { + "path": "docs/internal/extensions/bv1/commands/access-proof-build-v2.json", + "mode": "100644", + "gitBlob": "e90afdb4a9890b92f020a8d50725cd8c535f1e8a", + "rawBytes": 246898, + "rawSHA256": "6CE84A2406CAE1769AFFCFB90ECB38FEC0D1EE0134BCB2D0021CAAD10AE7FF3B" + }, + { + "path": "docs/internal/extensions/bv1/commands/access-proof-build-v3.json", + "mode": "100644", + "gitBlob": "bf2ffdb82261a03e0a513397e8ced9febcba1406", + "rawBytes": 251357, + "rawSHA256": "D07C26CDE8B9D891807F7BD8FBA0C2855AF6EA8610E61711DF1C00CE2E6333E3" + }, + { + "path": "docs/internal/extensions/bv1/commands/access-proof-build-v4.json", + "mode": "100644", + "gitBlob": "60e3015cb5cb4c6d7e876db4f32a0c0df5d9df22", + "rawBytes": 250333, + "rawSHA256": "0D4C132ACC0A77CDACA5CA56DF571038217B6152CBFFE6FE8D817B3293A35BB7" + }, + { + "path": "docs/internal/extensions/bv1/commands/access-proof-build-v5.json", + "mode": "100644", + "gitBlob": "3e466e10618733363fa12fd031ce83c1b3d88e33", + "rawBytes": 242163, + "rawSHA256": "9F3AC7BEADA117BEC09F9F7B3554EC2F47062A01EF115B7E33A86FDFEC8D459C" + }, + { + "path": "docs/internal/extensions/bv1/commands/access-proof-consumer-final.json", + "mode": "100644", + "gitBlob": "60a2d61e1ed6c7cb3595a4420fccbdb500a42a3c", + "rawBytes": 20819, + "rawSHA256": "C49930F05884D6C8468995D7FE152D83EB2F79149DA6E6852D88B5D77D5E350B" + }, + { + "path": "docs/internal/extensions/bv1/commands/allocation-facts-axioms.json", + "mode": "100644", + "gitBlob": "c6a57ff53b6524ce4f8eb8e71d222747cd451032", + "rawBytes": 3977, + "rawSHA256": "41A36C0A915F3781786BC69961E0D95DC32E3B1E5D1C4B7974446ECD35565BED" + }, + { + "path": "docs/internal/extensions/bv1/commands/allocation-facts-repair-1.json", + "mode": "100644", + "gitBlob": "0e1a8a40839dc12df84ba1db0c055709bcde5019", + "rawBytes": 2450, + "rawSHA256": "FF46DD9E2FF614E2FC4E589FD9A2715E9FB7D39F165339342D6C0883BED43717" + }, + { + "path": "docs/internal/extensions/bv1/commands/allocation-facts.json", + "mode": "100644", + "gitBlob": "c4cf81f868cc3366001597132f8426d457c0e175", + "rawBytes": 5442, + "rawSHA256": "6C357989DBD4EB1868295F728BB20B392C3A24F409FC1EB4845219812C2FCAD4" + }, + { + "path": "docs/internal/extensions/bv1/commands/baseline-span-assembly.json", + "mode": "100644", + "gitBlob": "72609b03a5cc929c20603c68ca00e9bd1e9c542e", + "rawBytes": 17480, + "rawSHA256": "AD4C9B82BAD324C9A35DD2340C9E70D08F7F881001503FE53C271358950CDE44" + }, + { + "path": "docs/internal/extensions/bv1/commands/candidate-checkout-bytes-v1.json", + "mode": "100644", + "gitBlob": "59b13536c3ef6e516db00467681fecfd75484b66", + "rawBytes": 1220877, + "rawSHA256": "1E7944DDE24967717E629E632025B45E6DF7A7D6A6DA9A08A2FFF8425D30EE0B" + }, + { + "path": "docs/internal/extensions/bv1/commands/candidate-postcommit-policy-v1-output.json.gz", + "mode": "100644", + "gitBlob": "91c19ea59fef4ece6a4cbc7d770bfe7119ce18da", + "rawBytes": 576, + "rawSHA256": "24EC2A88C88DE6AC4F14D4264DCEF25EF6F7D7DE818FEA7A882879B34D50F7F3" + }, + { + "path": "docs/internal/extensions/bv1/commands/candidate-postcommit-policy-v1.json", + "mode": "100644", + "gitBlob": "483cae7e7ea35f34b62bfbfe5440228194d98beb", + "rawBytes": 1047, + "rawSHA256": "FCC5CFD8F90C85F3E78A74E7D6E54EAF37E8E2B4B66E43E1D36613BA4DAA6155" + }, + { + "path": "docs/internal/extensions/bv1/commands/canonical-rank-access-safety-build-final.json", + "mode": "100644", + "gitBlob": "893a8b3011dd25b6434d604913fd2205379c54d4", + "rawBytes": 235734, + "rawSHA256": "5347984506CDFF0C3CABFCA354DAA01ACC37C3A1847B15536BE72DB8EDB35AF7" + }, + { + "path": "docs/internal/extensions/bv1/commands/canonical-rank-access-safety-build-v1.json", + "mode": "100644", + "gitBlob": "77507292a152fa82dccb16c3718b5adf0c59dcfd", + "rawBytes": 243569, + "rawSHA256": "847BB8FEA147863856CE31B8022AE092300A110BD5C6F85B28D36E3D8D185DE4" + }, + { + "path": "docs/internal/extensions/bv1/commands/canonical-rank-access-safety-build-v2.json", + "mode": "100644", + "gitBlob": "ade853ca238651b361065a041b1c0fac380ef260", + "rawBytes": 239165, + "rawSHA256": "332AD83D70ECD64A3DDF02BA089616949011C3A62C397BE0824838F5552565ED" + }, + { + "path": "docs/internal/extensions/bv1/commands/canonical-rank-access-safety-consumer-final.json", + "mode": "100644", + "gitBlob": "b36908468e339f0f0ea565b18e409321eaf8f6e3", + "rawBytes": 24627, + "rawSHA256": "B720AB8236895EA7FA00541F973DE25A29AECA78F4D4091242BD4F5F46F5871D" + }, + { + "path": "docs/internal/extensions/bv1/commands/canonical-rank-access-safety-static-final.json", + "mode": "100644", + "gitBlob": "0c2f9dcf5e2f028f59801aea3e57cb90b246f3d3", + "rawBytes": 800, + "rawSHA256": "180840C62D7E92E228702F347085B558DFB2919AE042DE211C7666E10DE1C91C" + }, + { + "path": "docs/internal/extensions/bv1/commands/canonical-select-safety-1.json", + "mode": "100644", + "gitBlob": "9ab590d57278b087834a7bc59c00951c2bbd7e81", + "rawBytes": 244296, + "rawSHA256": "1E95BD3EA3D8D331362DCE7E9CCD6C591D4BF7417BB3F2887C13BEACE48F35FF" + }, + { + "path": "docs/internal/extensions/bv1/commands/canonical-select-safety-2.json", + "mode": "100644", + "gitBlob": "a0f54876c81a993995d035752285f031baefd2a8", + "rawBytes": 232084, + "rawSHA256": "22BB586A3AFD4626FFFF7180BED167AD7808AC2E9F0BC9F1CCF1103DAE3327C2" + }, + { + "path": "docs/internal/extensions/bv1/commands/canonical-select-safety-consumer-1.json", + "mode": "100644", + "gitBlob": "558eae3221c9670a92daf4ff309b358b35c9df7f", + "rawBytes": 24780, + "rawSHA256": "B059995C121C7002E704E99117E25F4C47BFB7E8728D2EAD6BEA7566ED620D92" + }, + { + "path": "docs/internal/extensions/bv1/commands/canonical-select-safety-consumer-2.json", + "mode": "100644", + "gitBlob": "ac2b06864ef92c079de174aaef511dde91e4c77c", + "rawBytes": 24237, + "rawSHA256": "61CFEC7DF405152D480E58D10CE1FD1384EB162A7FC26027E5290E121FE27785" + }, + { + "path": "docs/internal/extensions/bv1/commands/capstone-allocation-reader-consumer-v1.json", + "mode": "100644", + "gitBlob": "5a83a4d06d1cd1bcb3ebb9159c94caab6ccc5415", + "rawBytes": 29844, + "rawSHA256": "875E393DE82148EF9BA60EB0FB6DE83000A4E16C8211E1699EB9C4F66059038C" + }, + { + "path": "docs/internal/extensions/bv1/commands/capstone-build-v1.json", + "mode": "100644", + "gitBlob": "097fed3967f82e7e348fa63fbdb2e99993e8159e", + "rawBytes": 239614, + "rawSHA256": "C4498F08ADD230F1540B50E8DE665BCE41E6B78547AA061EED9D3407B810BDE8" + }, + { + "path": "docs/internal/extensions/bv1/commands/capstone-public-consumer-v1.json", + "mode": "100644", + "gitBlob": "5718ef8df097da7b2946057f09f0d1546115aa07", + "rawBytes": 37322, + "rawSHA256": "D90182DF1D0A7137BA6A095FB6EA7E2500DE82410AB41A6E1AC2031659F9FE0C" + }, + { + "path": "docs/internal/extensions/bv1/commands/capstone-public-consumer-v2.json", + "mode": "100644", + "gitBlob": "ef61a0e10eab4308f1bb53b6938a1168a3b6f2bb", + "rawBytes": 34377, + "rawSHA256": "136F18B21A308CAF06B28A5D6449A9763A74B9786B01FD1470FFE39BE889204C" + }, + { + "path": "docs/internal/extensions/bv1/commands/capstone-static-final.json", + "mode": "100644", + "gitBlob": "9cc5b93d473e93a3a99f0d6a7dff95adfd3a23a9", + "rawBytes": 548, + "rawSHA256": "07A61E7E16F87B2DF7D276702BC53D34C59098BE5D94E458422D46E3AB44F556" + }, + { + "path": "docs/internal/extensions/bv1/commands/charged-setup-build-final.json", + "mode": "100644", + "gitBlob": "5443c2669c03c6924bf729eb6d1a582cb9ff88fc", + "rawBytes": 221825, + "rawSHA256": "5AAE919523725A57D2AA18A2221E3620668E755C11E4806810A357F7D17668CA" + }, + { + "path": "docs/internal/extensions/bv1/commands/charged-setup-build-v1.json", + "mode": "100644", + "gitBlob": "9cd5d58378023e67ee1dff263ea8fdf27ac42d6d", + "rawBytes": 20570, + "rawSHA256": "A2F95DB09E1C3A3A500E75EA2AD58A102A1A37174053FD741E085FCE89701730" + }, + { + "path": "docs/internal/extensions/bv1/commands/charged-setup-build-v2.json", + "mode": "100644", + "gitBlob": "47651df9d2b919996d188a677213a41563d3d27a", + "rawBytes": 1022951, + "rawSHA256": "3B6A902FC15C2E620295A0B688E0A55AC5D8015072D2BD23B2DC257F0D4D5001" + }, + { + "path": "docs/internal/extensions/bv1/commands/charged-setup-build-v3.json", + "mode": "100644", + "gitBlob": "6799a479ce801bb9a188a416275d4d1d2c62b6b7", + "rawBytes": 229697, + "rawSHA256": "9450EEA3E4784071CE7A9A8E6856D7E13F9AB26EF66C71F7E63436D07C0A680E" + }, + { + "path": "docs/internal/extensions/bv1/commands/charged-setup-build-v4.json", + "mode": "100644", + "gitBlob": "e24a71a455738c6a2f2f5f5d7dfdd2e5a5f0290a", + "rawBytes": 222342, + "rawSHA256": "AA1509516C658000069225F5E2CC53F95468CA8368C2D156350CFB67AD3DD3CE" + }, + { + "path": "docs/internal/extensions/bv1/commands/charged-setup-consumer-final.json", + "mode": "100644", + "gitBlob": "58db6ce468e7327bfc9701c6322097cb43d6dead", + "rawBytes": 16555, + "rawSHA256": "83A4D989A92326221B66E676E6612647BC8AC2FAB4F29A9ED8B3F43C9C1D0F8D" + }, + { + "path": "docs/internal/extensions/bv1/commands/checkout-lakefile-observation.json", + "mode": "100644", + "gitBlob": "e123b3d734c4b64ed66c83a09e43dd03b24aee07", + "rawBytes": 855, + "rawSHA256": "ED856DE5AA0475D6B95677A71E927839543FF4D60C9D54F6831E3A09A2D7AA2D" + }, + { + "path": "docs/internal/extensions/bv1/commands/complete-layout-11.json", + "mode": "100644", + "gitBlob": "d3599091f73218d28970105eb1d2bbafe93db32e", + "rawBytes": 223463, + "rawSHA256": "0855ABEE6C4811A99B862D8D26BF79E445030AABD4687F07482D7F9BF5D68BD0" + }, + { + "path": "docs/internal/extensions/bv1/commands/complete-reader-12.json", + "mode": "100644", + "gitBlob": "bbb354a37a47c500e5f08694471b13cbc4827e70", + "rawBytes": 233313, + "rawSHA256": "3C95147E3F37848C125BCE040B7E228316974FC73CFF67EAD53BD53EE3DC970C" + }, + { + "path": "docs/internal/extensions/bv1/commands/complete-reader-limits-13.json", + "mode": "100644", + "gitBlob": "239a13a0c4f3391c6f788fbee9e1b3c8ed82f8cd", + "rawBytes": 229651, + "rawSHA256": "65D9B24CAFEB1F9C98E4B3A1AABA26DED0459F549992A3907E8FB915952D4644" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-generic-rank-r3.json", + "mode": "100644", + "gitBlob": "241d9695933fc19c9de1e0d1cd9a75dc43fa801d", + "rawBytes": 217176, + "rawSHA256": "B8F2878F1D3919156E60B21002013627DE2FFEF2E8B5FD3AD3D9641DEE4B77C2" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-generic-rank-r4.json", + "mode": "100644", + "gitBlob": "b0f26f876ed9463409ded81143d52ea763000be1", + "rawBytes": 218791, + "rawSHA256": "EB3C01DF188E217F979FB8518E902903C5BE3D3E4904729E62D41E6990C9660A" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-generic-rank-r5.json", + "mode": "100644", + "gitBlob": "b180ea95fbaae0b74b6f138b8d92292601345cf1", + "rawBytes": 214203, + "rawSHA256": "2CBB14B1C57DE4CBD0D2FDAFF4010BCB80436305094989D0D785A2CE588BF726" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-generic-select-r6.json", + "mode": "100644", + "gitBlob": "2c4cdf202355ec45b8c4cf9fbe012a1e2ab565cf", + "rawBytes": 221006, + "rawSHA256": "00136C2BD049BA567C02E0E42F509A32EB22AA7F44B8058A1C5F989CF2796303" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-machine-known-r17.json", + "mode": "100644", + "gitBlob": "f247765216bf3d31fa287f11118d74419bdbea63", + "rawBytes": 27014, + "rawSHA256": "1B2D79A1B8D52ABA452E154F0DC65B45FF108EFD9F5C437AA4B636AE871FBE93" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-machine-selectors-r18.json", + "mode": "100644", + "gitBlob": "cde8e50a269f8ad04aa65ca0d18671e068344271", + "rawBytes": 26247, + "rawSHA256": "6D22D44AF537072771A3392544C3934EAABF117C6565E0F7918056A90E5E54A3" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-machine-startup-r16.json", + "mode": "100644", + "gitBlob": "d3a54675bf2e394e203957cb72ab5f38b4495a11", + "rawBytes": 24348, + "rawSHA256": "2C2D0D42022800E613DA9B74939371AD907414BC1C1A97B7D1F932283B8E3CD8" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-machine-static-r20.json", + "mode": "100644", + "gitBlob": "eb661e2ccfc6259527bb777a8a5fb7188cae7c9a", + "rawBytes": 42482, + "rawSHA256": "17E1DC942B1FB86EDA0CC7DA407A1BECF876C32216C0219B2A39D19BF76057FA" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-memory-consumer-r15.json", + "mode": "100644", + "gitBlob": "41d8d90a7e48ab5f0c046b67b1cc24db3d3a3221", + "rawBytes": 27010, + "rawSHA256": "B4DFC1911A842B9AF973B0B1CF36D0DE6AFFDD116394326D196694D027DAC454" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-memory-r11.json", + "mode": "100644", + "gitBlob": "810b862525f734d2d42a95bf5d9bccdf00bd791f", + "rawBytes": 229780, + "rawSHA256": "F47A0C1B86A54231E27E8650CB827908CE2BB4E283B9E01FB84F3EDFE8931A5E" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-memory-r12.json", + "mode": "100644", + "gitBlob": "dc35b4682d58bbc41e4bd3428d334dadcdf36aeb", + "rawBytes": 226332, + "rawSHA256": "1342F5964633C4F77FB9BBD68DB85E8EF98267AEE67C80B361FDADF23E736C03" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-memory-r13.json", + "mode": "100644", + "gitBlob": "804543422acf385e0c5d01f23ac206da14f99d9c", + "rawBytes": 232507, + "rawSHA256": "88391794ED5640F5382B6F5C614708751FF27C914A605621D23948863DCD319E" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-memory-r14.json", + "mode": "100644", + "gitBlob": "f65b10013a1ea5a430ff8e6cf6f97e13df21ef01", + "rawBytes": 229048, + "rawSHA256": "DE1D61FF8ED4049B1BA21179BDA03877CC3969443BEC6893D55D267A3542D682" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-rank-prerequisite-r2.json", + "mode": "100644", + "gitBlob": "c72f7d95c08f8ba1cbeaafd49b8b015cb458043e", + "rawBytes": 213772, + "rawSHA256": "4AC098274B138DD83A2F1C2F3A017623CD72AE6403A111E73EC147F6ED91B20C" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-rank-r1.json", + "mode": "100644", + "gitBlob": "3b5cbb41be0931cd8c942f13f4ca396404d82d56", + "rawBytes": 177860, + "rawSHA256": "81AD5CC2B6A88853E024186CBC219DF39EE4542E56DEAED558792F6DB899E4E9" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-rank-safety-r9.json", + "mode": "100644", + "gitBlob": "3c11b83294edd56fd0be547fa120119cd7f9af7a", + "rawBytes": 218295, + "rawSHA256": "0562EBAF4F7ED430CEF43E8FFC1C7DD5E404707E4CEEC6F3CF8322E5DCC4B1EA" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-safety-consumer-r10.json", + "mode": "100644", + "gitBlob": "3733a0b28fb6545669d55edb495b6bb1de9ed6cd", + "rawBytes": 18863, + "rawSHA256": "E5F7147B0D66B3EA1A4891BCBE6C1F10E62C81395A66556E4A2A519BEE0D3152" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-select-interface-r7.json", + "mode": "100644", + "gitBlob": "4e4b0f26a2550eae0b5ac58994d4a3ca533e82e9", + "rawBytes": 216983, + "rawSHA256": "8AD42A4F414B9F3F2E822D88214040C6C9BE0C3089CB4670C2AFDA7F0AC23688" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-source-consumer-r8.json", + "mode": "100644", + "gitBlob": "b0b7e385882b6e1a35049d795b49d04a89587277", + "rawBytes": 15652, + "rawSHA256": "0461B4472FA13F4F5239F02F7282EC132533EF667A2EA493BCEA11C1AED1B39D" + }, + { + "path": "docs/internal/extensions/bv1/commands/crossing-known-case.json", + "mode": "100644", + "gitBlob": "f3d8497fb24ba1ec972dd649336bd0f32427a7f2", + "rawBytes": 3346, + "rawSHA256": "107B024045569970D416F968D0B68B9E5C467AEED4C3560F2C95A382E3A3B7B2" + }, + { + "path": "docs/internal/extensions/bv1/commands/crossing-startup.json", + "mode": "100644", + "gitBlob": "4fd441d66e48f23adf973c6d7c647861f86463d6", + "rawBytes": 2554, + "rawSHA256": "7DD909F870DE9B660097E37B5C4EB3E7E39211B0EB0975E33F6528D846EB3FF6" + }, + { + "path": "docs/internal/extensions/bv1/commands/crossing-v2-known-case.json", + "mode": "100644", + "gitBlob": "f7dce17e3b381e8c851f3fdde8b7187151b4e0b4", + "rawBytes": 3667, + "rawSHA256": "FC96B072493C6B7C9B746156203F77E582FE28D28BECAA9320D69B97A0303204" + }, + { + "path": "docs/internal/extensions/bv1/commands/crossing-v2-startup.json", + "mode": "100644", + "gitBlob": "3e98f1fb820dab2305ce3ac2f233f84210a04933", + "rawBytes": 3419, + "rawSHA256": "B1EBFABD762C9FFCB6193F1A4C27A589AC0E274547D973EE28C6186DF3E09799" + }, + { + "path": "docs/internal/extensions/bv1/commands/evidence-design-correction-v1.json", + "mode": "100644", + "gitBlob": "9b5735c02316af730a3815f0e4949ad3df454085", + "rawBytes": 713, + "rawSHA256": "43BFBC62162D0A650F1E6658D9EB9A391F4933A8D7DF33A8048A03E3ACBE1F51" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-known-v1.json", + "mode": "100644", + "gitBlob": "2239cef887031ff52282c59354c8ce07baed950c", + "rawBytes": 61727, + "rawSHA256": "CF68372361F73C40D5A281B80003A482A42C30B3E520AE8D9E0F085FBA93FAC4" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-replay-v1-omitted.json", + "mode": "100644", + "gitBlob": "faf7ff06b11c4f93b8c67d6f51dfc2172845a721", + "rawBytes": 64111, + "rawSHA256": "F53E60AEE1ED2DE4D4DDEF95AC5EB9801107FC39A3BB623836CAC1872AEB99BB" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-replay-v1-route-accept-after.json", + "mode": "100644", + "gitBlob": "7dc4edb1729429dd43d1a3177316e90a56ebcab9", + "rawBytes": 62934, + "rawSHA256": "D6A6A614F1D2E5A262739A0F0FD371D0E947439304029454EABE1FC9C69BDAAE" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-replay-v1-route-accept-before.json", + "mode": "100644", + "gitBlob": "a3165fa5698d0176401856db698c46cdc13c4dc0", + "rawBytes": 62742, + "rawSHA256": "8FED62F8546109CE6C9194327F555A7DFFAE44818234E9C37F000AF2E9C92FD8" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-replay-v1-route-reject.json", + "mode": "100644", + "gitBlob": "f843de2da00247226860dbd881001adc4ab6531c", + "rawBytes": 62798, + "rawSHA256": "8C346BB716311C1A313A0E185CD7E7FCC56F0A1A5141A601FB4C8C5394E5CBD2" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-replay-v1-valid.json", + "mode": "100644", + "gitBlob": "809271bbf0af5286e161dc73ff65d3ada620f434", + "rawBytes": 62555, + "rawSHA256": "77605BB5447FB564C2422AD59DC3B32E46E5E0B477BB10F688CDC780F54A0018" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-replay-v1.json", + "mode": "100644", + "gitBlob": "25696570b45a29fc74b54c1dea07a46dc606aed9", + "rawBytes": 84679, + "rawSHA256": "4BD36879A9C95006D943A2DC7D0A6ABB285954759B8ED0147697F5D97E51B64B" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-startup-v1.json", + "mode": "100644", + "gitBlob": "cd0e482f990dd30aca6fe67f0f547fc266ee94aa", + "rawBytes": 109465, + "rawSHA256": "086C4C43EAB8C703A88FD4E2AE0B893811E8383F379A7F10A7B46155CEBF0584" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-startup-v2.json", + "mode": "100644", + "gitBlob": "30b87560a78c5b855dcc2aecc660010e802152be", + "rawBytes": 62975, + "rawSHA256": "7EF191F1DC401A7BA573AE5A7FB5B51145FE7D50C4EE7288CF6421255B3AB791" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-startup-v3.json", + "mode": "100644", + "gitBlob": "6c6459f2e99f832c028c3ffe2527a79b4756501b", + "rawBytes": 60950, + "rawSHA256": "C122E720B82056894069AD050ACD39A35031D1A6E25C3A8380A719602E0C2367" + }, + { + "path": "docs/internal/extensions/bv1/commands/final-report-claims-v1-output.json.gz", + "mode": "100644", + "gitBlob": "3cd9f82831b5399997204fa895ceb27ca134ca62", + "rawBytes": 31557, + "rawSHA256": "E3215C620F71942E895536119117F17831C1F7061272D4B5AB31121D41B34839" + }, + { + "path": "docs/internal/extensions/bv1/commands/final-report-claims-v1.json", + "mode": "100644", + "gitBlob": "9ad61183cd77e1baa4cfca4c9badf242352626f3", + "rawBytes": 799, + "rawSHA256": "BD863F1BA5984E24B4D445AC67C0BE4609824CDB7BB8144917A60FC3F87282E7" + }, + { + "path": "docs/internal/extensions/bv1/commands/frozen-rows-final-policy-v1.json", + "mode": "100644", + "gitBlob": "0c9f60b7e5cbc67cd70bc0ec24706176b5d661db", + "rawBytes": 10146, + "rawSHA256": "CD4357F022324752A0EB66D97A59B1E846139061483C38A81E075B365806F824" + }, + { + "path": "docs/internal/extensions/bv1/commands/frozen-rows-implementation.json", + "mode": "100644", + "gitBlob": "cc0e2effa5d7d9d29288f9d1a9dab57a88cec790", + "rawBytes": 10145, + "rawSHA256": "C5F23AE4FB9D86F72AC83727B05415D1553ABABC929C7F2B898D454B7575A186" + }, + { + "path": "docs/internal/extensions/bv1/commands/frozen-rows-pre-replay-repair.json", + "mode": "100644", + "gitBlob": "eff0d7703f4a7e1842f809c80d88826900acad4d", + "rawBytes": 10148, + "rawSHA256": "943BA6D806B9AC8C4A49C707A0D1935C532D87555F4E235E4A3DCE6D6BFB94C8" + }, + { + "path": "docs/internal/extensions/bv1/commands/generic-select-safety-1.json", + "mode": "100644", + "gitBlob": "58993f3a4094b1fee533cd4ea334dca109e6c887", + "rawBytes": 227111, + "rawSHA256": "69DE0DC7B6F832BB3BE3630C14C2E3FF64789E70C089E898506388ECA2D1BBB3" + }, + { + "path": "docs/internal/extensions/bv1/commands/generic-select-safety-2.json", + "mode": "100644", + "gitBlob": "1f134e5e5bd16ec7e616cd678a4a0ef733285e2e", + "rawBytes": 223496, + "rawSHA256": "D4F0FC074429485BF62638D52A5344A6C2E35F61B115A3C2587C7CD5D20FF9F5" + }, + { + "path": "docs/internal/extensions/bv1/commands/generic-select-safety-consumer-1.json", + "mode": "100644", + "gitBlob": "5d5e4a3955deab9247afe1a2b4ce9fb6900544a0", + "rawBytes": 19411, + "rawSHA256": "072F87ECCAC657BBDF46083797677B22E57D6BC10A7BB32996E8FE772069962D" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-final-policy-v1-claims.json.gz", + "mode": "100644", + "gitBlob": "3458e3f047c34a19e59ff17b8490465ddd0aa00f", + "rawBytes": 1198634, + "rawSHA256": "C80D9E825FD18A7F974138295ADD19245E286C4FFCBAAFF7B668118F6B2336F6" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-final-policy-v1-design.json.gz", + "mode": "100644", + "gitBlob": "f23d5dc6caeac20dced49f2e9fe17230834db162", + "rawBytes": 279, + "rawSHA256": "23F0243C259ED54A450630688D909E61444D0F01E09DD538D425547C4588CFDD" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-final-policy-v1-native-trust.json.gz", + "mode": "100644", + "gitBlob": "1559476b22a5c124bb3615e19e842e0a8cbfcfbd", + "rawBytes": 216, + "rawSHA256": "CF8320C46A07D78091BD847A1B5D0D681E3E8CB99E3E762D105000B6BBEDC576" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-final-policy-v1-range-diff.json.gz", + "mode": "100644", + "gitBlob": "3324b2c6c23067a936638a93d3945b7fc7a546b8", + "rawBytes": 216, + "rawSHA256": "9DED06C4403978C0C54091287FDA10B4E6C617AFA34623E9AA0815EEF3B08446" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-final-policy-v1-staged-diff.json.gz", + "mode": "100644", + "gitBlob": "6040be92a1f479e13083119efab6758a5a2f520b", + "rawBytes": 281, + "rawSHA256": "202C1ED84A83095AD7B52145F088CE42C70221ACD0C5C440ED1CAB03BE70326E" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-final-policy-v1-trust.json.gz", + "mode": "100644", + "gitBlob": "acf324fe2cefb446f8bb83208a65b902c6b323cf", + "rawBytes": 209, + "rawSHA256": "5565C3124076B9D6413B814CB9ED803CED1BFD7628B5F13859E67AD1323D2924" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-final-policy-v1-working-diff.json.gz", + "mode": "100644", + "gitBlob": "1e6c3cb4456fe828c920c54397b88c73718dcf6d", + "rawBytes": 216, + "rawSHA256": "7DD79014E0D19958E001CFC1EE1DE101DFDDADB88DE3C8533FA52249FE35227D" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-final-policy-v1.json", + "mode": "100644", + "gitBlob": "91f71ab740946de70475454bdd471c40e8accd50", + "rawBytes": 5851, + "rawSHA256": "2ED077B782C67ADBB7ECDF84E85287F38075123C287D39D5FC4A3A0D1970F352" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-precertification-claims.json.gz", + "mode": "100644", + "gitBlob": "b7d20ec4bcc0a86baae618cfeeb4e2aa6eed7b0b", + "rawBytes": 1188985, + "rawSHA256": "24698F2B225CD0574316514CDD4B1910C70B1674E43943C72D98E32676D05AC6" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-precertification-design.json.gz", + "mode": "100644", + "gitBlob": "9400e0b0fdeb9a145d6db0ef05de26b1d1cb74c1", + "rawBytes": 274, + "rawSHA256": "E457741CF1809D9576208ED01FF5EF13FC993DEA98E81335F6DB40AD91739305" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-precertification-native-trust.json.gz", + "mode": "100644", + "gitBlob": "6d04ad56dd8b69d7bfde6344066d1e22af2c15c0", + "rawBytes": 212, + "rawSHA256": "05A3BCF86170144ACCCF79626736792D3D8A195A5F45897782A05AF1356AB33A" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-precertification-range-diff.json.gz", + "mode": "100644", + "gitBlob": "e0fe46c801dd6f95e37462d2bce8cd38dd637ae7", + "rawBytes": 211, + "rawSHA256": "9323A76D487EC99FC1769DB47F432676A00D2D37ED45E44AC1F6668F6AD7E489" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-precertification-trust.json.gz", + "mode": "100644", + "gitBlob": "7593c2628e1ef421d67ae1d789ef46d3f85cdb7d", + "rawBytes": 207, + "rawSHA256": "3E7CD96BFDDB6A2C1B13D01979D4C96766C07DA38B32B79D4548DE4BE11A88E0" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-precertification-working-diff.json.gz", + "mode": "100644", + "gitBlob": "aacdbce67c4e75b2aa80bcc6ef17f094f58921a8", + "rawBytes": 485, + "rawSHA256": "EE28ADFDA9282557955164CD9DA62FA69B44F2EA9F0E8B3639EAD012851757A3" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-precertification.json", + "mode": "100644", + "gitBlob": "e2df599d80c36ddf420aea835de4f278c2876d21", + "rawBytes": 5420, + "rawSHA256": "319D1E77EC69984EF8447459689532A7EA9C3D535B0EDD292D7C038F25FDC265" + }, + { + "path": "docs/internal/extensions/bv1/commands/index-byte-final-v1.json", + "mode": "100644", + "gitBlob": "37b360668df697f544cdc21ae136203cb7b38709", + "rawBytes": 287230, + "rawSHA256": "692121A53FC12712DFC64E0A1AE611BC88A449AE6624C45F6C527598B9CBF6F6" + }, + { + "path": "docs/internal/extensions/bv1/commands/index-byte-preflight-v1.json", + "mode": "100644", + "gitBlob": "3bd41399a3e7cd06118d0b71d489dd2a1a689aff", + "rawBytes": 10557, + "rawSHA256": "EEFA2A706BA1616C8898536318B4F472E3338B111C4415AC4B42C7E30C25CE25" + }, + { + "path": "docs/internal/extensions/bv1/commands/index-historical-eol-v1.json", + "mode": "100644", + "gitBlob": "f22fb2438356b038cf4e2202134891f5d3505b56", + "rawBytes": 8868, + "rawSHA256": "AB7CD75359F43BAB5A3FB302A2DD0B6C46E40915BD047C164685CA9BE2BE6861" + }, + { + "path": "docs/internal/extensions/bv1/commands/leaf-replay-20260912130101742-canonical-select-safety.json", + "mode": "100644", + "gitBlob": "49bfc225cb86e3b9429b4cce912d497fd455272f", + "rawBytes": 33671, + "rawSHA256": "CDEB96061245BA59F592DC827288A0EC041FED5DD40057053BC40315A134BD5A" + }, + { + "path": "docs/internal/extensions/bv1/commands/leaf-replay-20260912130101742-generic-select-safety.json", + "mode": "100644", + "gitBlob": "3161c2bba3d0a5a8dd5324c37b4da1e3ba26e1e1", + "rawBytes": 33627, + "rawSHA256": "71412F83A9780B15AFADC835B7CC955E938F415015C62DDB0EEEA0FC6903C024" + }, + { + "path": "docs/internal/extensions/bv1/commands/leaf-replay-20260912130101742-rank-layout.json", + "mode": "100644", + "gitBlob": "d5933e58ddd4dd43429b72a368b1aa3b9568f6bb", + "rawBytes": 34025, + "rawSHA256": "8E1B2F9E875CAD259CEA07C8A065D9C04CF8E16D41D349551F0CA9451F7B6A20" + }, + { + "path": "docs/internal/extensions/bv1/commands/leaf-replay-20260912130101742-rank-semantics.json", + "mode": "100644", + "gitBlob": "3f994a65b48211159cb61871014e444a53c63308", + "rawBytes": 32293, + "rawSHA256": "608D67251A2E366CD44D26B2FB6100FBE13121DFD87B83724ABFFB0FD910FBD5" + }, + { + "path": "docs/internal/extensions/bv1/commands/leaf-replay-20260912130101742-regular-layout-axioms.json", + "mode": "100644", + "gitBlob": "13611dd697d0768912cfacf89b89367f230e60c5", + "rawBytes": 32062, + "rawSHA256": "05C7019250A1087E44981111DFB9CB8D4E1017C0CF40C1D622F833689DA79FD5" + }, + { + "path": "docs/internal/extensions/bv1/commands/leaf-replay-20260912130101742-regular-layout-types.json", + "mode": "100644", + "gitBlob": "e61066772bc9b3836916de8013ace1c55643ff24", + "rawBytes": 33849, + "rawSHA256": "B56A4907AA7B8BAEC6106ED24696134F055A2DBA8A574F8409E1F934A8905598" + }, + { + "path": "docs/internal/extensions/bv1/commands/leaf-replay-20260912130101742-scratch-frame.json", + "mode": "100644", + "gitBlob": "43c65303a72a18f2ae6f33a4552cc8d82ff73829", + "rawBytes": 32945, + "rawSHA256": "06FA7F9769EDD48C758933F457D88B40144DA0CB882F261810104176B8B8063A" + }, + { + "path": "docs/internal/extensions/bv1/commands/leaf-replay-20260912130101742-select-semantics.json", + "mode": "100644", + "gitBlob": "a3779286f93976686658b0b498f877d2108a26f1", + "rawBytes": 32926, + "rawSHA256": "9EE21F88A484CB7E5D203998436B3F026B1E0813A5A578C058169794D09ED71E" + }, + { + "path": "docs/internal/extensions/bv1/commands/leaf-replay-20260912130101742-summary.json", + "mode": "100644", + "gitBlob": "262e1e8df6ef68b88276b750272578e8292a2b8e", + "rawBytes": 13668, + "rawSHA256": "E1A6FCF86B0F856DC1ABB486836A13E42CA31240FE458248230F6D81402C2C30" + }, + { + "path": "docs/internal/extensions/bv1/commands/machine-controls-v1-20260912111911796-bcf37cc6.json", + "mode": "100644", + "gitBlob": "88bb6e70fbc73a273a76f51c758a58d068a1c5c1", + "rawBytes": 60033, + "rawSHA256": "CACE30F722697D762E31EC2814D28AF89FFB2B45DA789FFD841991A4B266407D" + }, + { + "path": "docs/internal/extensions/bv1/commands/machine-controls-v1-20260912111955043-999b380b-omitted.json", + "mode": "100644", + "gitBlob": "a1816068efe33d11f90fbe0b72290158f4464bf2", + "rawBytes": 67995, + "rawSHA256": "95F84FD158C4E46A9A0490272DD99A2E3D283F173EE9045939B93693B6350E2D" + }, + { + "path": "docs/internal/extensions/bv1/commands/machine-controls-v1-20260912111955043-999b380b-valid.json", + "mode": "100644", + "gitBlob": "4c70a9387caf4ecf8ec2172a0889d2af53e753b2", + "rawBytes": 61089, + "rawSHA256": "B2C64DA938E9C3C120D78C49CF6A44AE6B0776F2AC1BE1D063E88792CF8A373B" + }, + { + "path": "docs/internal/extensions/bv1/commands/machine-controls-v1-20260912111955043-999b380b.json", + "mode": "100644", + "gitBlob": "3079c79d4fcd0f4680c7d6de19c5c689c93f0fd7", + "rawBytes": 77385, + "rawSHA256": "109AAB4B6E6FFD90B6DA496B6C1A46F104A68138C7D8031C1C5C5F67D403B086" + }, + { + "path": "docs/internal/extensions/bv1/commands/manifest-raw-staging-v1.json", + "mode": "100644", + "gitBlob": "7b84b3fb690bbcc17ccaf6b8c6fd6e497f39efc0", + "rawBytes": 510, + "rawSHA256": "4BE7C5B09AF0824ECC8F28AA0454C7D69EDE5085A06B8D40EDB81A76B555B890" + }, + { + "path": "docs/internal/extensions/bv1/commands/manifest-semantics-v1.json", + "mode": "100644", + "gitBlob": "2db43595677687c846b6b480ad96b39604bdc6cb", + "rawBytes": 770, + "rawSHA256": "B78A8150F50CC0D80541FEABA2EC32A04B6C834F88D7D03C04EE6EC17875C44C" + }, + { + "path": "docs/internal/extensions/bv1/commands/memory-layout-1.json", + "mode": "100644", + "gitBlob": "54bcbfaaea209c6758b2bafc29f890327239d004", + "rawBytes": 8119, + "rawSHA256": "0B3CED500236DCBEB8BC43B89089A70053CFE733D0B89F0FA90F2E299FE625AB" + }, + { + "path": "docs/internal/extensions/bv1/commands/memory-layout-2.json", + "mode": "100644", + "gitBlob": "3916fa31fe824189baf2f8494174db1b00124627", + "rawBytes": 4037, + "rawSHA256": "8F4BC4C1B1DCCC13D565057E6BC505EBCF7A9C6101D58C94820452744E12DFEF" + }, + { + "path": "docs/internal/extensions/bv1/commands/memory-layout-3.json", + "mode": "100644", + "gitBlob": "daff23e0e115e621a38e8e16b7f071869f2f4e6e", + "rawBytes": 18941, + "rawSHA256": "DC0FF4C4546996A45814C697BF9C3B6FEF94A57DA455F4DE8F5C967ACF7390CA" + }, + { + "path": "docs/internal/extensions/bv1/commands/memory-layout-4.json", + "mode": "100644", + "gitBlob": "f2a26643409cbdc8f822afaf1dc2f90aa1db0408", + "rawBytes": 33124, + "rawSHA256": "251B09244B5C3C2433B608071A3D33E9DADF5826E587FAC23905DCA188B7ADE4" + }, + { + "path": "docs/internal/extensions/bv1/commands/memory-layout-5.json", + "mode": "100644", + "gitBlob": "f1bd1b8bb44380eff44db77dd7f808c7b0332112", + "rawBytes": 15728, + "rawSHA256": "485ECBF4803E634AD95E3A7B734ED7B8247DB13D709540D6CEDD25C7C258D005" + }, + { + "path": "docs/internal/extensions/bv1/commands/memory-layout-6.json", + "mode": "100644", + "gitBlob": "3ea7e8b6a9c90eb54332e232ee4f17049535a5cc", + "rawBytes": 13176, + "rawSHA256": "04A7ADA5D6573D7C6B1F310B0310D5E548973A0BCFEF0F83AEFB2EF96C022012" + }, + { + "path": "docs/internal/extensions/bv1/commands/memory-layout-7.json", + "mode": "100644", + "gitBlob": "a09894ca8ef39b4a18925d145e781ef8bcea3757", + "rawBytes": 111350, + "rawSHA256": "0B72CB3B2B115A5C8FEBA3BBDC6C5A77B0F3BD2B4871E3028C1FE68183EE8695" + }, + { + "path": "docs/internal/extensions/bv1/commands/normalization-axioms.json", + "mode": "100644", + "gitBlob": "65e7898d575f389c123a1dc6c18ff35fe22a20a4", + "rawBytes": 2674, + "rawSHA256": "5A396EA974D67BDAB45F3B26BF37BFEF7124712925D9F1C4E8AB67758CC5C7FB" + }, + { + "path": "docs/internal/extensions/bv1/commands/normalization-final.json", + "mode": "100644", + "gitBlob": "a2cd0b172c58c4a2f29dff73820e13700b3d0071", + "rawBytes": 1077, + "rawSHA256": "FFAB97E0C967554B6D5202C71A928911FAA14DECC913502485382EC987757D62" + }, + { + "path": "docs/internal/extensions/bv1/commands/normalization.json", + "mode": "100644", + "gitBlob": "1faee7b38c0da895e822989bb514bced7156d145", + "rawBytes": 2327, + "rawSHA256": "AB3DE5F3277A7F22BB8892CCBCEB606208062F5F441540829C25CE4B5D46B2CD" + }, + { + "path": "docs/internal/extensions/bv1/commands/numeric-reader-build-final.json", + "mode": "100644", + "gitBlob": "956d3e7e3b3aa6ba3bcc947d8ec81caee6d349e6", + "rawBytes": 11276, + "rawSHA256": "4D1E351B22CF9F1719DB7499BDB5FD56FEE5D878F95C48F876BB69CE56B4FA93" + }, + { + "path": "docs/internal/extensions/bv1/commands/numeric-reader-build-v3.json", + "mode": "100644", + "gitBlob": "5158d4b38791caaa6fb5c0db2cabd6a6b69ae79d", + "rawBytes": 19376, + "rawSHA256": "700AE87D2C708C737044C52829D17D71171CBBF8B4327FD71E29EDD36B3F3FE3" + }, + { + "path": "docs/internal/extensions/bv1/commands/numeric-reader-compile-v1.json", + "mode": "100644", + "gitBlob": "2e77d83bbff18e080f23713df4f83554af00f653", + "rawBytes": 179644, + "rawSHA256": "3C233DA69003757FE9033D8F079D0A324BA10B5A11C0582074880097F8FA8BFA" + }, + { + "path": "docs/internal/extensions/bv1/commands/numeric-reader-compile-v2.json", + "mode": "100644", + "gitBlob": "a238778aabe2b5dac12f36b1fc2eae53a570c0c3", + "rawBytes": 110529, + "rawSHA256": "C65EC384AAE9B489859C218F3FD8F57F35179DC76D428623E179AEED79CD7F55" + }, + { + "path": "docs/internal/extensions/bv1/commands/numeric-safety-build-v1.json", + "mode": "100644", + "gitBlob": "7271f25b043026c0ad21939e35a3dbc8b7a5a1ca", + "rawBytes": 284233, + "rawSHA256": "C256ED07C731F93739AD917E3D182DCD2D1790A1E90A147D9050660A5A3E2F03" + }, + { + "path": "docs/internal/extensions/bv1/commands/numeric-safety-build-v2.json", + "mode": "100644", + "gitBlob": "ed7e447e26e6a1d4fedb2b2c2a659301ea9bdcfd", + "rawBytes": 280144, + "rawSHA256": "72CCD651EE1259A9CF27477C2210EF22637C75AB0ADEE8CF9FAE860D71F3AE53" + }, + { + "path": "docs/internal/extensions/bv1/commands/numeric-safety-build-v3.json", + "mode": "100644", + "gitBlob": "6987e6ce78a7946b585ae69cb0bd540117815f40", + "rawBytes": 220931, + "rawSHA256": "5A7BA4F2CAF4D9ACEFCC9F42525BB00C08B7E12ADBF89B4B928122DD4F007A3E" + }, + { + "path": "docs/internal/extensions/bv1/commands/numeric-safety-prerequisite-v1.json", + "mode": "100644", + "gitBlob": "f77ec5cc85892bbd9266259b809bada10a600307", + "rawBytes": 216014, + "rawSHA256": "CC17C6EA8763FCD36C1A26C212FB029A427D93441DD96421D062DB292D3B1857" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-14.json", + "mode": "100644", + "gitBlob": "8e9f0bd6198fea645d72f01fc50433d863de565e", + "rawBytes": 241595, + "rawSHA256": "3C34CE19B0AB0350BBA52DBD952BDAB74CD9758488D66E4B204D42D52A325BC0" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-15.json", + "mode": "100644", + "gitBlob": "3d56532248940fb80da3eca90b705049cdaf193e", + "rawBytes": 228977, + "rawSHA256": "1EE190588BF5AE4AF023F53B27609AEF80ED1FDC339CA0B1FF18C0BEF50E698E" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-16.json", + "mode": "100644", + "gitBlob": "524b49c8e356660b003990157dee89be3dfc4330", + "rawBytes": 237399, + "rawSHA256": "92C924674719C11DF4EDDD153B76AE76DB79C6E7677F2EA2ECB6161D8AE5AD38" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-17.json", + "mode": "100644", + "gitBlob": "37fd623828aa03c3561e79e91aec985b90685b4d", + "rawBytes": 23725, + "rawSHA256": "C6799EDD33BE6994DA943AD4F1F0D640DE64B03CEFDFA015B1E3CCD3D328DF86" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-18.json", + "mode": "100644", + "gitBlob": "ef4cb6d0ecd4db75cceec3a89f3162aa1139c790", + "rawBytes": 235181, + "rawSHA256": "3CBAE330E9D31141AE546950E9CB773A32165BD545908FE6AC729D15BFF5E353" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-19.json", + "mode": "100644", + "gitBlob": "fc02b6c30d34f8e404ed195f155545972c5ccc8e", + "rawBytes": 236878, + "rawSHA256": "8BEBEE33C93B34D4DCD967B45B3CB98B9A01A0BA8B58204BE275B4B3FBB2D8D3" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-20.json", + "mode": "100644", + "gitBlob": "2bd071817760a4e4615ac8c3787ceddf852ed24f", + "rawBytes": 240813, + "rawSHA256": "117F6B72E0AD9BFF652A29775D362BB409552BC8F6D18B1701F06D5C45D979CD" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-21.json", + "mode": "100644", + "gitBlob": "e7099c0ffaa0ef6dd70b42a5fec05171f9bc8786", + "rawBytes": 241344, + "rawSHA256": "1B22A8AC734B7C9AE0ECD56784FCC0C8E0F67C4A0B4D04112A481B217F804A44" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-22.json", + "mode": "100644", + "gitBlob": "1e1edc8d31f14dd8d8ec5e231c220a92cefecc79", + "rawBytes": 243818, + "rawSHA256": "CE7DF6C3641842B57CF287199CB2DF8591939A2262C1C3B357DA89CD7B755469" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-23.json", + "mode": "100644", + "gitBlob": "9937545cb1f67bc6b1bcd0e0c13f0b08ad2c7c75", + "rawBytes": 238075, + "rawSHA256": "D6DE55FAF1E3FA977251A7E3CFEFEEC3F4ABD9008647ECE1D9D8BEDC0502C2DD" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-24.json", + "mode": "100644", + "gitBlob": "a528935d34b6f81d03b4e2f97666dd5257e5f88a", + "rawBytes": 251683, + "rawSHA256": "AF9B7575B97DF5C5F6FD1836A54EA35C5EFF107AF6D4D47974053EA035E80F70" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-25.json", + "mode": "100644", + "gitBlob": "a231fb5685fe7c90003b56324515fb67b1b6e771", + "rawBytes": 269368, + "rawSHA256": "15B294ED5B2AC1EE5C4D2104A4C75CDEE51EEDEE886C1914527A8FCDA0E2A9C1" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-26.json", + "mode": "100644", + "gitBlob": "5a0730dd4ea5b3f9d0a6151cb700ea516a4fc57e", + "rawBytes": 285902, + "rawSHA256": "8A92C0876CA1E64FE8AF6E6EBAB63232279D199D2F8C4062868CD9BB8D2E65A4" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-27.json", + "mode": "100644", + "gitBlob": "0c6e87eecf6588a7c0342a32d03d3645da2732fa", + "rawBytes": 498706, + "rawSHA256": "BAB8667CE6D220683F33FBCB708E73808C3BF9FCF65D6F09BC06ABF337BB7B81" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-28.json", + "mode": "100644", + "gitBlob": "4d626b3047a3246897fa58277fe4da0152da1cbb", + "rawBytes": 269113, + "rawSHA256": "0823F9B639A6CABDFFCB47601D28C00ADC098BE0D76B8D15CCC449B1CD73F01E" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-29.json", + "mode": "100644", + "gitBlob": "d47c09392b9564ed7ac9b932d5a103cd3f40651c", + "rawBytes": 242550, + "rawSHA256": "DCCF072C0BEE703486C53774581610E86087D645D4B116D7785EAC6F2EE434E4" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-30.json", + "mode": "100644", + "gitBlob": "3e449dd5de06f0373163a4802acc92254294c37e", + "rawBytes": 236329, + "rawSHA256": "53B5A876C863E8755AF4FBEF997A7D12A25B82C966FCFB4D5034C1F448D15D59" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-postcommit-claims.json.gz", + "mode": "100644", + "gitBlob": "e54977658cc9d98b96604c175136fec49b10ff49", + "rawBytes": 1169364, + "rawSHA256": "2B00B67D50BC0DABD6A090B6CAC08B3FC3F5D34036A76363B9BC7A3DD84A210A" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-postcommit-design.json.gz", + "mode": "100644", + "gitBlob": "352cc6be08c69be6527daca763114ba8c0718f79", + "rawBytes": 267, + "rawSHA256": "E418D4B3534D507734FC121531C8C98E925872A78A0B918029B095BF1C1F0F9F" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-postcommit-native-trust.json.gz", + "mode": "100644", + "gitBlob": "b4b3d0ec8a31e079820f0b6a25cd9024838ad4ee", + "rawBytes": 200, + "rawSHA256": "E064A06AA3BF0E51DA32F9D274C96827979495491F3368FC4EC3DD0721B12311" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-postcommit-range-diff.json.gz", + "mode": "100644", + "gitBlob": "2f68097dc24fe33d8815eee20b968bcb7ab4778b", + "rawBytes": 203, + "rawSHA256": "A56C74DF68E9FACF093E30BC7E9A3749249C7429F688E95FE0635360F4B153DC" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-postcommit-trust.json.gz", + "mode": "100644", + "gitBlob": "843b3578ec4c3c53cd38fdc72d9c920491187e5b", + "rawBytes": 197, + "rawSHA256": "1B2754223EE3C894871AE071BD549EECE417285BF24E0F03E21D51EC6D06C629" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-postcommit-working-diff.json.gz", + "mode": "100644", + "gitBlob": "a3ff3bc7a56fb757eb08a6647a0f66c06d4fd177", + "rawBytes": 341, + "rawSHA256": "76FF7E8C1FEB573509A09E9A03CDDFC2B03515EE83214A6C143E84860D0CC2D9" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-postcommit.json", + "mode": "100644", + "gitBlob": "aa1e570784914100d6a8b04cafb12bde350f6a53", + "rawBytes": 5306, + "rawSHA256": "1E3AD9EE5C0850BDF2FC38D5F93D9043A05EEEB16DB11381B3F2C3D7062AD4C9" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-claims.json.gz", + "mode": "100644", + "gitBlob": "f442ebd3be0bde366c6ccafae68783d6548d4b2a", + "rawBytes": 6330702, + "rawSHA256": "1C81DF3849FF0498E1316AA317616CB7FDE17C92B04B41ED47056EA1C7545C5F" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-design.json.gz", + "mode": "100644", + "gitBlob": "1e0c61fcbc12b6154cd3982e9f5b5d67a2f37f30", + "rawBytes": 266, + "rawSHA256": "872999DE12B7F7D0A5A8AA37F88B78088BCF70C0F59713EBC14926A88E7CB472" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-native-trust.json.gz", + "mode": "100644", + "gitBlob": "9eec55a615f0aec1e19f8c3869142f4e95ed4486", + "rawBytes": 199, + "rawSHA256": "42905804016161CEB5B0B4252A2EC0C9D8FEA31B907400FA7A10A624CC70E63C" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-r2-claims.json.gz", + "mode": "100644", + "gitBlob": "042aa05aea2b25c960be59d40e21ac754270e195", + "rawBytes": 1166740, + "rawSHA256": "6690DD4F178C64CB249FD1A84B6987CEACDE4A56414133B79168ED5ED8D0EADC" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-r2-design.json.gz", + "mode": "100644", + "gitBlob": "cb7b7a98b593bceb4b70eed1c79636b71e63aed4", + "rawBytes": 269, + "rawSHA256": "571136FF0B2A2B23036182E65437A6CEFDE9770491C5AA93E072B6C6722DF632" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-r2-native-trust.json.gz", + "mode": "100644", + "gitBlob": "9fae177fb666127d55428cfea55a7e7ed4b7db41", + "rawBytes": 205, + "rawSHA256": "993ABF75D1371778197A7D16D13A6EF860D21386C2DB42A5F95988419A295A82" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-r2-range-diff.json.gz", + "mode": "100644", + "gitBlob": "c4f0de2d2a654626829dc35cbdded15a1ac7d695", + "rawBytes": 205, + "rawSHA256": "807CC5071BCABD70147C2622D4F812D9AAE3853466811A1121E32B071C5FCB86" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-r2-trust.json.gz", + "mode": "100644", + "gitBlob": "78b999c3300ea3324bac89a5b32716b8554d424d", + "rawBytes": 198, + "rawSHA256": "E7985C7CD3BF688DDD343B6436D66A23F4648C99F65604A7FDC7940D24C514E8" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-r2-working-diff.json.gz", + "mode": "100644", + "gitBlob": "7cc4424b29afb44dac54adf3a6852b2da4f79839", + "rawBytes": 340, + "rawSHA256": "D89861C04B553DFC878E51963933634646B993E3C36E709B56FDB8907DA0EB39" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-r2.json", + "mode": "100644", + "gitBlob": "4fa8c8c1bf79fb8c232f44314a2a547529e6a6ee", + "rawBytes": 5294, + "rawSHA256": "23FDDDB8FF6E71877C1252FB1B1A2EDCF1BA8142E7550BA394A2D905256D1B9B" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-range-diff.json.gz", + "mode": "100644", + "gitBlob": "bbc7179392ae9c441151f27fceceaf853c545cd2", + "rawBytes": 203, + "rawSHA256": "7CFAD20856E23B7B578DACC15A1C4D5CB26DE74F26503C1307189DF94916FF9E" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-trust.json.gz", + "mode": "100644", + "gitBlob": "8b00e7b8c2a107fce34c31e117e75492e48316b3", + "rawBytes": 198, + "rawSHA256": "EB7EEEE7DCA17FD5FC09DC43DEDFC0767D94E635639AC6E553010072A10FF585" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-working-diff.json.gz", + "mode": "100644", + "gitBlob": "9741b0b5200877c755af4df26734489d8961ead3", + "rawBytes": 335, + "rawSHA256": "85730978D93FCC33C8EAC2FF93B9D7AA3F6D50DF1A0EAF86FA6B958DDC3486B6" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit.json", + "mode": "100644", + "gitBlob": "b3d72ba9464faaea4a7b092faf2fdd1655afd49e", + "rawBytes": 5278, + "rawSHA256": "FBB6F49B8A0B6D7F819DB4F6AF97FE7C68C142893B9F6674DC918E1FA8F2968E" + }, + { + "path": "docs/internal/extensions/bv1/commands/provisional-evidence-design-failure-v1.json", + "mode": "100644", + "gitBlob": "43ca2e497649464c552f2b9a79c085f30ce10322", + "rawBytes": 1068, + "rawSHA256": "AC6784565E14D08144E063FE9FFB019FAE0A44177A8BE58B23C67E6FF08FECF7" + }, + { + "path": "docs/internal/extensions/bv1/commands/rank-layout-1.json", + "mode": "100644", + "gitBlob": "a454a331514f0a5ebfa2da49e663ecc17daf39af", + "rawBytes": 13865, + "rawSHA256": "980F203778BE1E513B1AD9536231AD8BCB0EC93F81CA3267C7ADC3CF871BE44A" + }, + { + "path": "docs/internal/extensions/bv1/commands/rank-layout-2.json", + "mode": "100644", + "gitBlob": "0bb0222b0ea260b9355d0a2e6b993c38b344d0f6", + "rawBytes": 13644, + "rawSHA256": "22ACCD5AB23DDE3D05BC7AFA07F9D2BC4AD07031E6DB25E7F06A7A5D48D13116" + }, + { + "path": "docs/internal/extensions/bv1/commands/rank-layout-consumer.json", + "mode": "100644", + "gitBlob": "a53c64c246bb626259ad1f38b6fb0256e10ba9b6", + "rawBytes": 16312, + "rawSHA256": "60056965796ACF009363DAB4F86CF5B08FFEBEF98960673FE8C2941AFE155256" + }, + { + "path": "docs/internal/extensions/bv1/commands/rank-semantics-1.json", + "mode": "100644", + "gitBlob": "e32249b49c5968551edc0bae05c7eff0a4172093", + "rawBytes": 29218, + "rawSHA256": "1B2A87914D3550FA7C2B8B76BCE143A0369E2FBB0C779C2B841AEE7283199E8A" + }, + { + "path": "docs/internal/extensions/bv1/commands/rank-semantics-2.json", + "mode": "100644", + "gitBlob": "82e96d5ec6b2dc1917e5da6c4a814d659488ecc7", + "rawBytes": 21528, + "rawSHA256": "9650366E79E29F7EDF98A0140CCDE3F879D69A9BEA6ECFCFEC7EF942ABA29234" + }, + { + "path": "docs/internal/extensions/bv1/commands/rank-semantics-consumer-2.json", + "mode": "100644", + "gitBlob": "905e1ccf8815baa06849b9fc758fc6e94db7f89b", + "rawBytes": 12308, + "rawSHA256": "2F6566E97767D9BD2EC7D3748592EFA0C668DF2A1BF75291A2BACBABC4C5D301" + }, + { + "path": "docs/internal/extensions/bv1/commands/rank-semantics-consumer.json", + "mode": "100644", + "gitBlob": "ba2e521a614491f51dac2497988c5c2bbc937f3e", + "rawBytes": 13804, + "rawSHA256": "40BE56DE7D32A3FF5434F58228AFD49A083803579A3E5A2BF27FFC8FCDE3FC02" + }, + { + "path": "docs/internal/extensions/bv1/commands/reader-geometry-9.json", + "mode": "100644", + "gitBlob": "4b4b146c7cac460bf125fd08eb4fc6402fabd0f8", + "rawBytes": 223997, + "rawSHA256": "E731C733040F2B68754B51E15C5D19363349A4CDCC0E613C86A6F9B3202C890E" + }, + { + "path": "docs/internal/extensions/bv1/commands/reader-space-10.json", + "mode": "100644", + "gitBlob": "8880fb4d686abce2119f891463dcc6a58cc64404", + "rawBytes": 232365, + "rawSHA256": "30FD3E8FC6BAF88AC38949D5F64719B689BBAF7F3F4617259424122F79F9ECE0" + }, + { + "path": "docs/internal/extensions/bv1/commands/reader-support-8.json", + "mode": "100644", + "gitBlob": "185bccae6fd776a5176e4c341297c4765a9354fd", + "rawBytes": 14000, + "rawSHA256": "05C98DF23E912CEB165AD4BA7A888EA23C73E5A8DC117C6CFC8215C183D51053" + }, + { + "path": "docs/internal/extensions/bv1/commands/reader-typed-axioms.json", + "mode": "100644", + "gitBlob": "2cc623dfdc2c8d713dc6110b92c2fc70d2b66cef", + "rawBytes": 3642, + "rawSHA256": "030CE603AEB22900875BD950D695B69DD4B78B5B9F5E023EBA1EF38850DEF1D1" + }, + { + "path": "docs/internal/extensions/bv1/commands/receipt-report-claims-v1-output.json.gz", + "mode": "100644", + "gitBlob": "ac929cac455b65808ed5fb9167a2a3ac448d51c6", + "rawBytes": 5742, + "rawSHA256": "B476D2B78B3A6A0A1D2DB89CE4A2FA94A0E354820F0F2C085A4D917374D16C93" + }, + { + "path": "docs/internal/extensions/bv1/commands/receipt-report-claims-v1.json", + "mode": "100644", + "gitBlob": "f73f0a5be1b62385f42ee5f8ff1f18e45228ac1b", + "rawBytes": 1017, + "rawSHA256": "0B7B3F309BCFFA3E82CC634E6010CC6C2F91689E05A71227A446AB23793C2DC8" + }, + { + "path": "docs/internal/extensions/bv1/commands/regular-layout-1.json", + "mode": "100644", + "gitBlob": "523fbfa0cf48dcb72e2cb0e207b8d94bb43660f0", + "rawBytes": 17427, + "rawSHA256": "576BB8609C564D2B248415EFF83C42F602A598A32D01379F3272AFAB9C63C8ED" + }, + { + "path": "docs/internal/extensions/bv1/commands/regular-layout-2.json", + "mode": "100644", + "gitBlob": "f9c859595da0030396b58cb7de015f117481acfa", + "rawBytes": 8858, + "rawSHA256": "8B6F9776B7463DA434077995EFBED54DA8AF5E1D0F90BECEB717C9DC97038ADC" + }, + { + "path": "docs/internal/extensions/bv1/commands/regular-layout-3.json", + "mode": "100644", + "gitBlob": "323ba6c5649532bd4f6c51303d9de6254e74e489", + "rawBytes": 5972, + "rawSHA256": "438A8BE409A500A6FB503C568C73CD95C3EDC503D19387C0E08962081D134F6F" + }, + { + "path": "docs/internal/extensions/bv1/commands/regular-layout-axiom-source.json", + "mode": "100644", + "gitBlob": "a64ee11026ac2b1687cf3a4a83e5c6f1969401e3", + "rawBytes": 7040, + "rawSHA256": "DE8754EDCA0C6E67DF9E74BECF74160100FCA5E9DED29E7288800CB05B95C209" + }, + { + "path": "docs/internal/extensions/bv1/commands/regular-layout-axioms.json", + "mode": "100644", + "gitBlob": "ccf91b61c0a73de55ebfbd8db5531fb0782875c1", + "rawBytes": 8846, + "rawSHA256": "B59C60E80DCBCE5A41CDA7CFF5D87633E883E48A59AAFDD41F26E9D9DE97E079" + }, + { + "path": "docs/internal/extensions/bv1/commands/scratch-frame-consumer-1.json", + "mode": "100644", + "gitBlob": "2254024d06e215768e88cfe006dff29d688e32f7", + "rawBytes": 23491, + "rawSHA256": "8E5DB3407733F593D9B5D027908BE4F49A9E18482FC822B13486BE0C7787D8FC" + }, + { + "path": "docs/internal/extensions/bv1/commands/select-experiment-compile.json", + "mode": "100644", + "gitBlob": "17fe04b8891d2c19072413e44e1810d30d739e41", + "rawBytes": 4192, + "rawSHA256": "8497256A6218E97D3642041669BFBD15C12AF56DE826E07873985536F1F74962" + }, + { + "path": "docs/internal/extensions/bv1/commands/select-known-case.json", + "mode": "100644", + "gitBlob": "e6faef7593a7dc2debc4f7090f0416f9c6e5ddf7", + "rawBytes": 2397, + "rawSHA256": "EFF5E47AAA2B941A7F9274622968D8C8DDF749E7AFBE0B7EA60E9C10C367E18E" + }, + { + "path": "docs/internal/extensions/bv1/commands/select-reader-compile-r2.json", + "mode": "100644", + "gitBlob": "5a4d5fef7f573198d732ab83d1d925a1b618f409", + "rawBytes": 1258, + "rawSHA256": "105BD8BB6BB420D28F1CC2124533220F7C9D0B0568881F632A500D445B0EC24D" + }, + { + "path": "docs/internal/extensions/bv1/commands/select-registry-v1.json", + "mode": "100644", + "gitBlob": "429613884ea30d28d314176c6b5c18e871820ead", + "rawBytes": 6761, + "rawSHA256": "C7827D26A18C302F09CE6902E03B9D90429D6FBE358F9D370E915427C29DD142" + }, + { + "path": "docs/internal/extensions/bv1/commands/select-semantics-1.json", + "mode": "100644", + "gitBlob": "d06f3db059afae7610c941882d02b5cdc77c576c", + "rawBytes": 36028, + "rawSHA256": "FDCF3F46B691D093B9827EB47C62481623D6EA02AFFC13A5C46488B2AE585FD9" + }, + { + "path": "docs/internal/extensions/bv1/commands/select-semantics-2.json", + "mode": "100644", + "gitBlob": "d19a70aaf4b9cf6d5cf4ced877b11b56967118c4", + "rawBytes": 80670, + "rawSHA256": "ADAB4D5D52D975D2D3F3C21F5881F6320BD743F55C690BF4D37BDBA7E2019196" + }, + { + "path": "docs/internal/extensions/bv1/commands/select-semantics-3.json", + "mode": "100644", + "gitBlob": "e94d5e77698eb2fb419f11afe53d92eeb7bac038", + "rawBytes": 19631, + "rawSHA256": "1D39B0F0E2581E036DCE49968818D3F65F7EE9988BA429D4C57D4E3D9074AA2A" + }, + { + "path": "docs/internal/extensions/bv1/commands/select-semantics-consumer.json", + "mode": "100644", + "gitBlob": "87d144c1ea65ed1458f3eb7df5747fce36ab2503", + "rawBytes": 10802, + "rawSHA256": "65D2D19B62700511D7953A7250759B85B4F0D9D63486DB7BF4486C920F20471F" + }, + { + "path": "docs/internal/extensions/bv1/commands/select-startup.json", + "mode": "100644", + "gitBlob": "f755bec316d90ac15f3aa198fdae3562bc514057", + "rawBytes": 2074, + "rawSHA256": "F4D75585761602DD84631EB71BE4C50EB7AEF43EFC12DD7EA5BDDD52DDF0ECDF" + }, + { + "path": "docs/internal/extensions/bv1/commands/selector-controls-main-v2-final.json", + "mode": "100644", + "gitBlob": "972d9bd6a56cc65e00705e346fb9cdba8ac7d3ae", + "rawBytes": 51445, + "rawSHA256": "9DEDD1345B46D867ED735419CF795B59CC3505BA5D3AF98D6E17D241C2543C9A" + }, + { + "path": "docs/internal/extensions/bv1/commands/selector-controls-v1.json", + "mode": "100644", + "gitBlob": "c8bb3e170085a28b2fa4dcf427f98b9ab82863e8", + "rawBytes": 21521, + "rawSHA256": "5D2A9F16E0C9FF1F85958943774D32207D0D69C8E637CEBDB5F2F382F9A2C3E4" + }, + { + "path": "docs/internal/extensions/bv1/commands/selector-controls-validation-v1-final.json", + "mode": "100644", + "gitBlob": "01737b36f214d59c191da9ee4198aecab3512159", + "rawBytes": 10909, + "rawSHA256": "E5E424E5121C5A3B809F29F45AE17636C381450E8EC685AD8CB6EA5C2B4C5018" + }, + { + "path": "docs/internal/extensions/bv1/commands/selector-omitted-main-v2-final.json", + "mode": "100644", + "gitBlob": "23b9288a4950ca41fce4afc58b815efac2917578", + "rawBytes": 48945, + "rawSHA256": "8BCDBE202527191FD84501C27E02C894D987CACF1F272DC4EE0A68C1E6E6D293" + }, + { + "path": "docs/internal/extensions/bv1/commands/selector-omitted-v1.json", + "mode": "100644", + "gitBlob": "31003b3d1a0dad3cfd0cf13480af319dd586b51f", + "rawBytes": 7081, + "rawSHA256": "8B98D984C817016B4F683FD4C047E3B431906F2FA92FD13104BB84C5B5DF39AE" + }, + { + "path": "docs/internal/extensions/bv1/commands/selector-valid-main-v2-final.json", + "mode": "100644", + "gitBlob": "10bbe1c0e967e238581a392d4c2b43eebd0191c7", + "rawBytes": 31182, + "rawSHA256": "1EB13D7156E15B5915B152ADCE2EF888417EEB774EB3B7D04A08785C7B0B64FE" + }, + { + "path": "docs/internal/extensions/bv1/commands/selector-valid-v1.json", + "mode": "100644", + "gitBlob": "a0e2ecb1faaea365ce77ead6520f7cba09feb529", + "rawBytes": 2814, + "rawSHA256": "203E389B086C46EAA2B11FF495CC9D6E15D3EE9F672525684B8623B9FF64EF46" + }, + { + "path": "docs/internal/extensions/bv1/commands/staged-whitespace-diagnostic-v1.json", + "mode": "100644", + "gitBlob": "2a41f2fa768f6941eb6b177fa066e3e4fd8833bc", + "rawBytes": 11126, + "rawSHA256": "1BB86B5D38173E8A4187E0EAC85FB876498414AA404D1E4197C85EEDCCBAE11B" + }, + { + "path": "docs/internal/extensions/bv1/commands/validation-controls-selector-omitted-validation-v1-final.json", + "mode": "100644", + "gitBlob": "dc60529314be2af96681ce3f2a2624415d08d7fa", + "rawBytes": 16207, + "rawSHA256": "83E9DEB9562CF9A9384DA68C55C8BE3175D84D34BEC02449F3CD2C2BD8317E7A" + }, + { + "path": "docs/internal/extensions/bv1/commands/validation-controls-selector-valid-validation-v1-final.json", + "mode": "100644", + "gitBlob": "191b9f009294d014317f3be09a9d8fb8f1d699a6", + "rawBytes": 8957, + "rawSHA256": "4C406A2572DFB0F857D454CEED5EB19E40D822C78542CE8A9965B057D5551188" + }, + { + "path": "docs/internal/extensions/bv1/commands/validation-crossing-v3-first.json", + "mode": "100644", + "gitBlob": "707b648b8c8077261689c0507344bede967cced8", + "rawBytes": 29084, + "rawSHA256": "361D4712D4C15BB91CE9A42E92781A7C506DE820BE8A2562C46096B3B36266EC" + }, + { + "path": "docs/internal/extensions/bv1/commands/validation-final-static.json", + "mode": "100644", + "gitBlob": "b411cd3c443a64e67375760a30bf80f4e0c0041b", + "rawBytes": 4534, + "rawSHA256": "C965BCB4060BE0E6E5787D61313568D5675E9BA6CE245FD89D4AE9C4F2EDCD36" + }, + { + "path": "docs/internal/extensions/bv1/commands/validation-v2-known.json", + "mode": "100644", + "gitBlob": "83929e134685b52726fd365b61a2e4297858e583", + "rawBytes": 28475, + "rawSHA256": "1B636540B73EB9CEFAC6AAE64E76241D2C4DC703366DA95E80989876AFF925BC" + }, + { + "path": "docs/internal/extensions/bv1/commands/validation-v2-startup.json", + "mode": "100644", + "gitBlob": "614d2743eb1db61dd267d190c65595f93ebee65c", + "rawBytes": 27935, + "rawSHA256": "7EB7FF55AC5337368EB207F67E9B5969769711997E2E7F2A6108CAC66231D0E6" + }, + { + "path": "docs/internal/extensions/bv1/commands/whitespace-attributes-v1.json", + "mode": "100644", + "gitBlob": "6faa7c2cf6713d0d1aec48addd5b695de813fedd", + "rawBytes": 44028, + "rawSHA256": "C7AA69ECDC79D64DE7698C0B142650954CA6FBA15C17C6B4003577705E9ED67F" + }, + { + "path": "docs/internal/extensions/bv1/controls/allocation_reader_expected_type.lean", + "mode": "100644", + "gitBlob": "b8d5b2048b4097587cc54be27e7060c66ce3c36d", + "rawBytes": 4290, + "rawSHA256": "DD09511ED00D8753C97164EEE06CC0E58C066CB0BFE33C0A37CA04D2C6D8F7ED" + }, + { + "path": "docs/internal/extensions/bv1/controls/controller_axioms.lean", + "mode": "100644", + "gitBlob": "d30198a229102f569172a4699f7a0f7d7fbd5a73", + "rawBytes": 10008, + "rawSHA256": "10705AE00918BFD709027B1DD3936867C8C0EF0502D5C84E630C7B9FC755B957" + }, + { + "path": "docs/internal/extensions/bv1/controls/crossing_v1_expected_fail.lean", + "mode": "100644", + "gitBlob": "ca27842b6cc81eefcbc73f123bb6689ee4e8019c", + "rawBytes": 1405, + "rawSHA256": "F9201FE1970244D968AF47EB884D42E6BC2055984ED4A853985AFB64351ED758" + }, + { + "path": "docs/internal/extensions/bv1/controls/leaf_consumers/bv1-canonical-select-safety-consumer.lean", + "mode": "100644", + "gitBlob": "1a1e8cfdc6d4e9d31ad637a068222acd69138bc8", + "rawBytes": 3741, + "rawSHA256": "6EB1741EC157B37904DCE556CDBC16BA9730DFD28269217C16FEEA0EE9B44C50" + }, + { + "path": "docs/internal/extensions/bv1/controls/leaf_consumers/bv1-generic-select-safety-consumer.lean", + "mode": "100644", + "gitBlob": "01c0de4061a9943662290e6b6aa1094ff3f01e58", + "rawBytes": 4382, + "rawSHA256": "297C96DB48830938A8236C5D02CDA3DE35E87AFD4CCD75E17785814B5F53D8B7" + }, + { + "path": "docs/internal/extensions/bv1/controls/leaf_consumers/bv1-rank-layout-consumer.lean", + "mode": "100644", + "gitBlob": "c796a04648b75c4a8dd76a331de1f2a72ebcaf41", + "rawBytes": 2044, + "rawSHA256": "283CE0B7E52E49F63108BBDBCBB66E916C6086C0E821F49C1F6B8B5D6A071E7F" + }, + { + "path": "docs/internal/extensions/bv1/controls/leaf_consumers/bv1-rank-semantics-consumer.lean", + "mode": "100644", + "gitBlob": "2367efceefca82d879bb3c6a1850a0f8e412cef6", + "rawBytes": 3117, + "rawSHA256": "2F4D7A5B4FF532C80CCD162519C8A989F5B78B44B249CD9A159F122E7EEEA2C0" + }, + { + "path": "docs/internal/extensions/bv1/controls/leaf_consumers/bv1-regular-layout-axiom-source.lean", + "mode": "100644", + "gitBlob": "e5b1344fd89fd497141c2a11b12eecfa7279d6dc", + "rawBytes": 363, + "rawSHA256": "67012CCC16E31764979ADED20BA08C462E1CC207DA389839737219CD98E7627D" + }, + { + "path": "docs/internal/extensions/bv1/controls/leaf_consumers/bv1-regular-layout-exact-types.lean", + "mode": "100644", + "gitBlob": "f4f08493067048bbc3ceee869b8561a079115ad9", + "rawBytes": 3415, + "rawSHA256": "F59CCBB23FD0074B8E769D98DC16ED263C16A7DBC3939E6F76FF20CC1586E337" + }, + { + "path": "docs/internal/extensions/bv1/controls/leaf_consumers/bv1-scratch-frame-consumer.lean", + "mode": "100644", + "gitBlob": "f190e7b03cb27d76edd7108c76bf1e3122c4334e", + "rawBytes": 1684, + "rawSHA256": "C40D8F1B3D776C84E2594FFC6605E51AD347F9ABBA1B5A83E1788CB214AC6712" + }, + { + "path": "docs/internal/extensions/bv1/controls/leaf_consumers/bv1-select-semantics-consumer.lean", + "mode": "100644", + "gitBlob": "b572118f9f808ee63248feb00705ae8755596516", + "rawBytes": 2874, + "rawSHA256": "35A9FEB285AA5CD883F9AB0FBECC693EE7DE9271242EB63E8F45EA07B27026A0" + }, + { + "path": "docs/internal/extensions/bv1/controls/leaf_consumers/replay-list-v1.json", + "mode": "100644", + "gitBlob": "e928d2382b1a1081c3494e5b77febffea332f248", + "rawBytes": 10079, + "rawSHA256": "FCA3D67AD0B3B13AE65416431F73A209FBE8CECDE1C08E790FA7DADB2DFBEDEC" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_expected_type.lean", + "mode": "100644", + "gitBlob": "77799af6f8a981de81e5e91e85929247d66013c8", + "rawBytes": 13417, + "rawSHA256": "FEA8D045EF0A9CB9679949ED8825F2E04A4542C01E8F056A778BB0B474BF7A9E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/capacity-without-code.constructor.lean", + "mode": "100644", + "gitBlob": "dcff956498a94d9e36ac789b581d5e334de287cd", + "rawBytes": 11829, + "rawSHA256": "648A6A344CFD1D95B1384AFF1D805A7F66D8A6ABF72C13A36C49B70F00B5B55F" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/capacity-without-code.consumer.lean", + "mode": "100644", + "gitBlob": "9f8c2d3f12b04a6c74443c4141155fb120dce4fc", + "rawBytes": 25204, + "rawSHA256": "0551357AB6FDECA16921CBC2E38131462338188C72BCF697886139A68B356ABD" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/capacity-without-scratch.constructor.lean", + "mode": "100644", + "gitBlob": "ce5f16c77e0e43beca7cb141e1e5bdcd0e8ffc82", + "rawBytes": 12171, + "rawSHA256": "7BF69AADCDD603D3DAE0FD3A4194C2151BB94F7B51E90D1ABC5CA0C81D446EA5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/capacity-without-scratch.consumer.lean", + "mode": "100644", + "gitBlob": "482507db97b824eb46600deeefd326d8c2f508e2", + "rawBytes": 25546, + "rawSHA256": "4854D99D124B5B7AB5E0C07AB4448499C8FF6E1A5D3CBA3B3CCD02797B1F0872" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/delete-accessCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "4e700258a22c22b183c3c94899b83b06f35ab634", + "rawBytes": 11313, + "rawSHA256": "E107CDBA1FD835C7CD236AA6EE5CB28B632B4BC79821A5607B4AE0070D24D0A9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/delete-accessCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "8e79188fde15e57d13709c5294cf6acb87b65d98", + "rawBytes": 24688, + "rawSHA256": "623C809616B6935F1AB462AFE46940F9DEF46BCFB105D4EFC002B4B05530A930" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/harmless-comment.constructor.lean", + "mode": "100644", + "gitBlob": "2d9c01574473366581c1683657f4c2e3e002d0c4", + "rawBytes": 11638, + "rawSHA256": "B98A0874F9314EEC8601EA885726D66F17847062A29F444F2F92309152B1E937" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/harmless-comment.consumer.lean", + "mode": "100644", + "gitBlob": "ffe24e322ebf7452d2b8b403ad483a38e185ea84", + "rawBytes": 25013, + "rawSHA256": "6B4D647B5CC0FB377CB4F2ACA1DE30AB1BB0D84E1C810AC5E1F8F3DE42A1ABA8" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/public-proposition-True.constructor.lean", + "mode": "100644", + "gitBlob": "6b97ac13a445ceeade28acd38230c89f8d8cf13f", + "rawBytes": 8464, + "rawSHA256": "C0795054B92747D206166B629DCB8AD43A25C0BAB8A289F8BD6FBA2EBB959F4E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/public-proposition-True.consumer.lean", + "mode": "100644", + "gitBlob": "131a1e6f871572821ae2bdbfe571ec171b0eabae", + "rawBytes": 21839, + "rawSHA256": "5FE7E7C2CD8F5EF82956B103C12CF1B1A28F88E43974BEA4AFE13E88F3CA0D61" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/sibling-completeCapacity.constructor.lean", + "mode": "100644", + "gitBlob": "dc30237ad3df8354203d66859211dc92e3879dc3", + "rawBytes": 12334, + "rawSHA256": "D7A40FD7F8CCA01DDAB064D1258459145CDB263207CCAB7E003A62463ED07438" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/sibling-completeCapacity.consumer.lean", + "mode": "100644", + "gitBlob": "36d0c84fc9d182e1b40f26dbaef522110b47a66d", + "rawBytes": 25709, + "rawSHA256": "B515C27BBC7C7445E64563C2E91C476813186742FBCBEF4B0C40F6DE9D7CC29F" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/sibling-readerCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "72172a15eda02c88eda38acda10de449f7163560", + "rawBytes": 11090, + "rawSHA256": "D5A0136709D05AE4DD09BF7033B1691370225221997DFA87F144F0BFB7C29236" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/sibling-readerCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "007a00bdd8503f1b9271a62399cea60532a4599f", + "rawBytes": 24465, + "rawSHA256": "5C359574D244E725DEE232E852C94516EA06AE455FB8C2659AA053789BF9B565" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/sibling-selectSafety.constructor.lean", + "mode": "100644", + "gitBlob": "673be9ec6c646a824895efc99fc03a5ae01fca6d", + "rawBytes": 11615, + "rawSHA256": "C25B0530845C1B02F0A01BAE596D5B7A8DFED8AF5337F9F8AC33664D8F1EA66A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/sibling-selectSafety.consumer.lean", + "mode": "100644", + "gitBlob": "11ee0e684491a3ea02ed557cf5b89be41117daa7", + "rawBytes": 24990, + "rawSHA256": "35924FBC0C83E6A97B0825490D9C97BBD650318CA84DE27C928C55D18D539E3A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/unchanged.constructor.lean", + "mode": "100644", + "gitBlob": "c52bf5ddd24b34224533f8090b12de44bab236fc", + "rawBytes": 11567, + "rawSHA256": "051E5472BB3AA2F8F22B6A1C392E68EF2CCE2F0744F2F1657B58CC45F18EAFAE" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/unchanged.consumer.lean", + "mode": "100644", + "gitBlob": "8d0d2b8d1b0f69a6f6b0868a2075736a8ae49dbd", + "rawBytes": 24942, + "rawSHA256": "07320BBA0DBFCE2862CF737CA2549371E50C85ED31062C2C73740EF03BEC8B32" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-accessCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "78098a5fe2d36fa36702a5423d4dbcbd4169ec38", + "rawBytes": 11502, + "rawSHA256": "BA8855F6A16EF8F8AE7216DA53AAE1C2F5F4A68571C98F9E8B0B31C816C1BF64" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-accessCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "6260bc3868c380f7cea8d5f87ab0e2fe6ed73f84", + "rawBytes": 24877, + "rawSHA256": "10E69147FB2A58BA4A63A6A949EBD72050866172D53F2227DBA829723670C7C4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-accessExecution.constructor.lean", + "mode": "100644", + "gitBlob": "c052a7f899a4aeb9753df979bb0f1510cdcd92a5", + "rawBytes": 11122, + "rawSHA256": "6582D802F511E7636F238DB3F91F51834625F31875D68D97480EB41B724DA79D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-accessExecution.consumer.lean", + "mode": "100644", + "gitBlob": "e2d88a57d841a00ea4979d84ba021b048b18b598", + "rawBytes": 24497, + "rawSHA256": "6C3A572FEE66F47158C9564BFFC4734FB1D6CFEE8EBD4FFBD071AD73EC2A58D9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-accessSafety.constructor.lean", + "mode": "100644", + "gitBlob": "b002788a5f9881c404fe347d129bb3c0b260b6f9", + "rawBytes": 11293, + "rawSHA256": "E91610F2212F81F1A3D09FE4727CA187CC24239EF1BB56565A39357A2B4DE554" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-accessSafety.consumer.lean", + "mode": "100644", + "gitBlob": "9078c5ddd5fb92b54955869232c3c7e80ff1f340", + "rawBytes": 24668, + "rawSHA256": "34C2327113E1356622DE8AB2DFF3CF42326EF2528A3BD40CD38FB74F93AD1C37" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-categoryBounds.constructor.lean", + "mode": "100644", + "gitBlob": "ba144a6d9753d0979c18d17c0d8b7ce3781f5724", + "rawBytes": 11352, + "rawSHA256": "6949E46511D90A5F2F4BECF310E5016B1E98A3B6B1BD7D67E349B86EB127F66A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-categoryBounds.consumer.lean", + "mode": "100644", + "gitBlob": "681a3f1ed6166242e01fb1dfcd7d64462d841cdf", + "rawBytes": 24727, + "rawSHA256": "0609F1C9021FAF43B3BC5A9A02E45D3CCF950B42C03A8476E249420FC0790AA4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-categoryPartition.constructor.lean", + "mode": "100644", + "gitBlob": "f5efbf2b0597a46fb9bbafd0255847f6e45fae34", + "rawBytes": 11186, + "rawSHA256": "7C19221F37F3FD07387C8999B5FD1D1EE683955F983C248951F489E5F3A9EA9B" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-categoryPartition.consumer.lean", + "mode": "100644", + "gitBlob": "72ab8829e9529368a519d793a0518fefdea10ebb", + "rawBytes": 24561, + "rawSHA256": "AA1E55E48F0A618C1B96DAB1937A0DD24F3005E51F163AB3D3227ED2AFEF0EB5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-completeCapacity.constructor.lean", + "mode": "100644", + "gitBlob": "25bb9b1c3dbae9bc3ffea1f8e9faf5c0fbf544de", + "rawBytes": 11203, + "rawSHA256": "F17A26D72B7C0A9A9CA79A0E9D99879C56FF0739CD5F5780349D77C7ACAEB4D9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-completeCapacity.consumer.lean", + "mode": "100644", + "gitBlob": "9c5eeae1da9a3b5a2fcd71e2fcb4833e56e32d3b", + "rawBytes": 24578, + "rawSHA256": "0D5C916242818400E43F59A1F7A59E415E84E9FCFBB57B36B83B9C9D9B2042C5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-finiteScratch.constructor.lean", + "mode": "100644", + "gitBlob": "4f3f765f217b3089983f6f411b53c65daa088855", + "rawBytes": 11359, + "rawSHA256": "1132BE4D82415B8E0EDED57F266A11BF296A081FECDF96B06F2CD587D5E69193" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-finiteScratch.consumer.lean", + "mode": "100644", + "gitBlob": "564ab30914cc3d7e7c2fbd6216c4966325366c6f", + "rawBytes": 24734, + "rawSHA256": "6430D5EE21F8F5B04DD6C427CF2C23CE2765C9F2474198D1A044344999E80875" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-memoryWordsFit.constructor.lean", + "mode": "100644", + "gitBlob": "fe027f44908da00299a0851bdb6afd0c1af4fe80", + "rawBytes": 11438, + "rawSHA256": "4309D769AA3B95540AB4BEE346CA264A51FB0E5B8E1B2E650A6048C3305D6728" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-memoryWordsFit.consumer.lean", + "mode": "100644", + "gitBlob": "635611625f4ed77ae6c3dbcb36246da1a16ad365", + "rawBytes": 24813, + "rawSHA256": "86F30A1E37EA8E53AAE7CAC29B5D2C1A5142E30D62F79EBCAEC9047807870D27" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-overheadLittleO.constructor.lean", + "mode": "100644", + "gitBlob": "fc06d1549b41e7801096c034b7b03ce0791b0266", + "rawBytes": 11537, + "rawSHA256": "35ED2361481CE3409F0F0200EB6B41D894B409DB8C1191325BA8BB1805EEF4A4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-overheadLittleO.consumer.lean", + "mode": "100644", + "gitBlob": "b30b8465e7cbb1caf91ce4469b1f549a1165b19d", + "rawBytes": 24912, + "rawSHA256": "F28B855D9AE3A3792462F4199EEDC6F164286479DD168CC6D790A952A1403937" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-programLengths.constructor.lean", + "mode": "100644", + "gitBlob": "2104f1c20ad96331c8b02f2897a228d4e032a8d2", + "rawBytes": 11394, + "rawSHA256": "73EDD80D3493862ACFAAC033C720F70DE216E2984C6E274B0FAC5E12444268C1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-programLengths.consumer.lean", + "mode": "100644", + "gitBlob": "f058f1a487c1e897b8eab2a1141ff31d1bb2448f", + "rawBytes": 24769, + "rawSHA256": "2D2EFB3ED01BA27749498A2A29208A7792A699F5988E3D2E009465DA6DC8EB6E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-rankCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "19a50698edc8b37de94f43771b41f3e34fc6449d", + "rawBytes": 11397, + "rawSHA256": "0B5EC9D0FDB6B003FA4A5E5129CB38ABF77E8FEF64717B0768F0D24C6B2E69AB" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-rankCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "6c05d2c293cdebd77eb0a8ec8cf8cded9e08448d", + "rawBytes": 24772, + "rawSHA256": "C918E25B84C82860F2F9A69AD33E27BA11981CE7E9AB7302E0C4300DA9EE0A46" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-rankExecution.constructor.lean", + "mode": "100644", + "gitBlob": "b8d6416c2e9835e4df68f8ef82df4eacec4d6c86", + "rawBytes": 11096, + "rawSHA256": "929124CB2D24A019614A6951E0F651F4AC8D88E1477E4F76D66A39835EF2602E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-rankExecution.consumer.lean", + "mode": "100644", + "gitBlob": "24d05da2a5ff95a47a4b96cb178d8c3a020b8692", + "rawBytes": 24471, + "rawSHA256": "A18E055613BE6B35AEF2D73124A3939A5E763A18F15685354751B7256E28B43E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-rankSafety.constructor.lean", + "mode": "100644", + "gitBlob": "99ec78f302d6ecde363464abcaf78d33ff00be5e", + "rawBytes": 11284, + "rawSHA256": "B4CF3EA1E6C9E9665495E8EFC3725C0D4828879242A0B4B0AE0DCC7B92CA1623" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-rankSafety.consumer.lean", + "mode": "100644", + "gitBlob": "9a1772c02264836346f77c58ae9959d6e6bbfca3", + "rawBytes": 24659, + "rawSHA256": "04E66EB52C517F09CB1B68152553C8D907EDF348CC110931E1E78BC9B1CB7C21" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-readerCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "1773ba48f0938a26591f3d7147c7e131264b6e95", + "rawBytes": 10894, + "rawSHA256": "EF9FD42A99BC7FC9E30EC36860547697FD1066DCEB5B2C8F037DF9C84C8E6442" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-readerCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "397f570cee1e92a37e8d04aeb7daeb2c92b77cc0", + "rawBytes": 24269, + "rawSHA256": "8FB7AB2DD365B1A2CF50EC646E9B8B20F254D16607FF8A82EB12AB46AF2CDC5C" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-readerGeometry.constructor.lean", + "mode": "100644", + "gitBlob": "aa377eb52f10c53a2f0eb8298e387c97ad5edd1d", + "rawBytes": 11268, + "rawSHA256": "A17C94536127915C823B65826C136ACEE50C7F09A8D67698604105B894496F22" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-readerGeometry.consumer.lean", + "mode": "100644", + "gitBlob": "33158e890193ce150c1ed68bc04f9fc554f251a4", + "rawBytes": 24643, + "rawSHA256": "FFE06E2491A7D86FCD28E5951C5697231F90A7DA7B4D8518DA94BED1AC72E13A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-selectCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "4ebb063d892d661bf6b09251c6f114f4d6d3ad33", + "rawBytes": 11439, + "rawSHA256": "C1AA1B79B631EA5943CDC4736C179B4E6041CCC574BE7F88E0917BF942511BC2" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-selectCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "e1c435b99150b16a82309ca14254682ebc8ddd75", + "rawBytes": 24814, + "rawSHA256": "10846343307642CEC627ED4C9FEA917F1112F358086579DED3353708A23EEF84" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-selectExecution.constructor.lean", + "mode": "100644", + "gitBlob": "6fb95585bd9b74b8fc4f2145c990410a36794d8b", + "rawBytes": 11066, + "rawSHA256": "2CB005B1D063B78C95AEE13E431F352156EE44F3F7AC08A49190253C04EEAB88" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-selectExecution.consumer.lean", + "mode": "100644", + "gitBlob": "60b71251d4195a13c0398eec4879bd6af7ebdbc2", + "rawBytes": 24441, + "rawSHA256": "5F0EF38FCC7FBF843612B39E0948429DEA7D76B34C01E5B26D426D75B4F9800E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-selectSafety.constructor.lean", + "mode": "100644", + "gitBlob": "05af4d81ac49a623222512a79db8024e135481df", + "rawBytes": 11276, + "rawSHA256": "9AC67AF9F57D88E5BE80A609F61A630CE67522CA0E3AEEA9453D7F51BF36A3AF" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-selectSafety.consumer.lean", + "mode": "100644", + "gitBlob": "5f6ac7d185f402c0e4c940c5869b5015e30d9fa8", + "rawBytes": 24651, + "rawSHA256": "886CE818099F531C25B1D7D59DA8E82E04027D0731048948D6FDB2C4D5CEB2E8" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-sourceBudgets.constructor.lean", + "mode": "100644", + "gitBlob": "1c09abeea72531de4a339f2809c62ec6d7598423", + "rawBytes": 11394, + "rawSHA256": "826D9211D0AE37384D09E5C931341577B3DC2E23A091CA10E049505DF9EA7A74" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-sourceBudgets.consumer.lean", + "mode": "100644", + "gitBlob": "1a212c7045ae7378a85cfcbad1470ed6ebeccc01", + "rawBytes": 24769, + "rawSHA256": "3B1B57A79FA8AE065AAB959B78864BF2617D8ED74079BC96A53BC2EE7425319E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-stepsBound.constructor.lean", + "mode": "100644", + "gitBlob": "afcb0b556d8fe5126db2bc1a3d56e5c870f429a4", + "rawBytes": 11400, + "rawSHA256": "D9F4B4C9791037A3C5760B743CE3C4606E126B59FC63C5EE47E37513F55E5F73" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-stepsBound.consumer.lean", + "mode": "100644", + "gitBlob": "8fa556cdee818cfbaa122c151d5e5f79edfb3d33", + "rawBytes": 24775, + "rawSHA256": "16421CDA6CB337FDBA04DE4727CF19744DCBD5350246EBFE32761517CAFBA63E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-suppliedMemoryAgreement.constructor.lean", + "mode": "100644", + "gitBlob": "e7043541fa1e13a9a757c268e68311d4cabf16a8", + "rawBytes": 11152, + "rawSHA256": "61BFA2E0E489D2BAB4A64D155B1F0B224388E1578EC7DEC01A59509B636858DA" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-suppliedMemoryAgreement.consumer.lean", + "mode": "100644", + "gitBlob": "8d2d4db56cf811f71d517122d76dafb9c4e99178", + "rawBytes": 24527, + "rawSHA256": "813CFDF046C30C83FA2506747BE016DE1E9699760BFA3B76A3F2FE40A7E85767" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-validArgumentFits.constructor.lean", + "mode": "100644", + "gitBlob": "3478c531356f46808333b9a545e7e2b14aada19e", + "rawBytes": 11486, + "rawSHA256": "4E70B1E0541ECD469F9FD28E4D4A0FF9BBC1712D9960000701745EA7DAA89E65" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-validArgumentFits.consumer.lean", + "mode": "100644", + "gitBlob": "b02eea3df85b222cf7dbbb7bb7f5b21f48672a0f", + "rawBytes": 24861, + "rawSHA256": "7816DB0F5B2BE3B00746DE43AF9DE3A2894DC0118176C9D5479834172B5B91A8" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-widthBounds.constructor.lean", + "mode": "100644", + "gitBlob": "9d1e010b095eb94779ad664881baad06a0d557a7", + "rawBytes": 11448, + "rawSHA256": "8C77D786737FAD5EFD287AD46B889BC72CFE6A2D74B6A4BE2BDD0098AADC9FB3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-widthBounds.consumer.lean", + "mode": "100644", + "gitBlob": "e4cbb00d512f907823054f15d3c75a2aa9665fcb", + "rawBytes": 24823, + "rawSHA256": "879657296DC3615A02661B33A7913920F6EF7E2BEFA199093D465F12BB377D41" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/capacity-without-code.constructor.lean", + "mode": "100644", + "gitBlob": "650fdb6c82509ea5f282ab3e79ebbcf4b0acfb81", + "rawBytes": 11904, + "rawSHA256": "7C09B74D503BF7F673A834D9B1CB2F092BBA8A17B41F5160BEE3C10679C1AC04" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/capacity-without-code.consumer.lean", + "mode": "100644", + "gitBlob": "62cf44bfb72b6240679b5af65035d4350574d056", + "rawBytes": 25279, + "rawSHA256": "7849671DA72D77E6ECF49F4ADEC7CC0608CD4DC6F9054B9823FBFBD09715735F" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/capacity-without-scratch.constructor.lean", + "mode": "100644", + "gitBlob": "6ad1c635ee7e84334333ac773db46aa43f479cfa", + "rawBytes": 12246, + "rawSHA256": "904825C2C5A5F96040BFFB84135D504A417174EF5D7A2D46B9691DC9F73B75EB" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/capacity-without-scratch.consumer.lean", + "mode": "100644", + "gitBlob": "ad28d7ff656ef44fef14c56fa7e1af99bc0fe399", + "rawBytes": 25621, + "rawSHA256": "B679C671E706C9F9F3FB042E9913C900A3388752186D28DD016962F343E411D1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/delete-accessCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "e49773659d34d7ad4e74a3a1c1428007e4d123fd", + "rawBytes": 11388, + "rawSHA256": "0F0406739EF1C369E2CFC38541A4FB51B22A4E3C6D0259E538061AC58A6AC3AF" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/delete-accessCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "78fb908f580e744119e62135cbecb718aafcdada", + "rawBytes": 24763, + "rawSHA256": "0F0D99598825D9946B77913AA886E69C4648AF272F46B90EBCFB0071E9F80A5A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/harmless-comment.constructor.lean", + "mode": "100644", + "gitBlob": "c8f5f25dc5bec852f867009b448a28d435b7ffc5", + "rawBytes": 11713, + "rawSHA256": "A4AB5E4587BCD8F59FB11CEB44EFB47BE70C216BC864AAD1794F8FC24FA96A87" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/harmless-comment.consumer.lean", + "mode": "100644", + "gitBlob": "857410a8f3cdec32c8ce203e2bf2bbbc347cd108", + "rawBytes": 25088, + "rawSHA256": "B4E84042625F412B9A5EC0EE94172EA685F43390FA7D1686CF171E198A31A874" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/public-proposition-True.constructor.lean", + "mode": "100644", + "gitBlob": "d8519f2571453cbc71d22b62508640e07d9cc8c3", + "rawBytes": 8539, + "rawSHA256": "32E8C382C78FADE4CA06BF78228FE1B8A7E59D5F8D929C5F61B1F0DC81FCD3EF" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/public-proposition-True.consumer.lean", + "mode": "100644", + "gitBlob": "0356a311fbeb986e295b4ded1c2774c4d5b8f013", + "rawBytes": 21914, + "rawSHA256": "CC86C2519BC28F797AFA57832A4A480DE69D814AD747F4FA62DF3BD72C34CF58" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/sibling-completeCapacity.constructor.lean", + "mode": "100644", + "gitBlob": "c3b2862d4ebd3844724a7c28054879154d84a895", + "rawBytes": 12409, + "rawSHA256": "E97FC11F28A067D0FC4CA0B2BFAB0B68FE6889ACD89FB08E589C25E523D45B3A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/sibling-completeCapacity.consumer.lean", + "mode": "100644", + "gitBlob": "34ae8110584f219d4a4a0023f30c2659870d0e0f", + "rawBytes": 25784, + "rawSHA256": "277C6FFDC862520B9BD3C16D95622A727338363154530122E1464727B1F65606" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/sibling-readerCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "5b2c7a1ed3d2076ab2e767ef65cd35a4959c1ca3", + "rawBytes": 11165, + "rawSHA256": "2AD7E7C62D2346D57A9ECB9D415C67ED6D4C5BDDC4236A840F193F2FB7D59BD1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/sibling-readerCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "3ee17763ed0a649ebf5a34d96423f2789f207c04", + "rawBytes": 24540, + "rawSHA256": "731B15131915CF739754C250405F1F897FBDCE48CFD3D5C9853295AB9FD7290A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/sibling-selectSafety.constructor.lean", + "mode": "100644", + "gitBlob": "20bc459a1e4fe32babb434e271c29b8b1eb260a3", + "rawBytes": 11690, + "rawSHA256": "1CC63491001F357B5C76799177A79C1AED57B3D7FD79CB18DFAB80EDF028B74D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/sibling-selectSafety.consumer.lean", + "mode": "100644", + "gitBlob": "ea9b95634a17d299afd967f839cc264e347a8917", + "rawBytes": 25065, + "rawSHA256": "040BCE96780FB16A9FE681CE8A5B9AEC1CC099B467E1203E42B894A0F29A6B58" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/unchanged.constructor.lean", + "mode": "100644", + "gitBlob": "dcab715171e9e3414a8ecffe3a50e73ca1e16764", + "rawBytes": 11642, + "rawSHA256": "7F7B7EC00BFA68887243AD12B3D0D87147D37EC457E2025AE99359B8A47E2C12" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/unchanged.consumer.lean", + "mode": "100644", + "gitBlob": "98dbb8532c03342401e1f721014cdfda273ed5ed", + "rawBytes": 25017, + "rawSHA256": "BB8983EA0A13E5B50163522EFFD007F2AF98E563C3D0681F2E0C3DB941E9B6A3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-accessCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "beaf3608671da3dfc23f9d380bddde81536e1d8b", + "rawBytes": 11577, + "rawSHA256": "03446601C88A0F8D4EE1E69EC635FF62995F9A1EFBC5923165783510B80FABAE" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-accessCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "ef6779b38f15dac71abab7ee0475fec118fbccce", + "rawBytes": 24952, + "rawSHA256": "A9122CCF5714FD08D5DFCF813995DAE0C2E37FFFDCFDAC078B8C6AAAEF2D613D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-accessExecution.constructor.lean", + "mode": "100644", + "gitBlob": "8235da8f7b07d293edb687f7fa030ef71a92ce67", + "rawBytes": 11197, + "rawSHA256": "4EBDB3F8FE1DD35D563FB0315380292BDC9BFF48DEE55DCC45E4FDEB0166ECCE" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-accessExecution.consumer.lean", + "mode": "100644", + "gitBlob": "346dd1ee2b3a2c99f5ca720d538d7234ae8419bf", + "rawBytes": 24572, + "rawSHA256": "A6EC15E8BF0B17E4DA01E968CE8F3DF496F191FAE3D207E89C9850EC9E3EADE9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-accessSafety.constructor.lean", + "mode": "100644", + "gitBlob": "998cfd32c4124c6ed7c8168407ade71d1991577a", + "rawBytes": 11368, + "rawSHA256": "D4236DB17F212D0BAD7778440138FB61954163905FA0E2797E03D779C0BA1B1C" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-accessSafety.consumer.lean", + "mode": "100644", + "gitBlob": "492ac5bbf07883c7dd02b9aa48287387a278dda2", + "rawBytes": 24743, + "rawSHA256": "47FC99AD80104B2A3AAE5DA7BC471E85F81EB884D7A91A7830F5CAAEDA0497C6" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-categoryBounds.constructor.lean", + "mode": "100644", + "gitBlob": "7e6882c326deec45a4af0db4d2722dc06f0da0dc", + "rawBytes": 11427, + "rawSHA256": "F09305959C7BE02EB358D1DF577F7F0DF2B59E776AD41FBE1283B98643759781" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-categoryBounds.consumer.lean", + "mode": "100644", + "gitBlob": "50479bc32abab4ab0835b12dd138dd73e807ce73", + "rawBytes": 24802, + "rawSHA256": "A996C5DA62ACB6F95BEF10B5E950AB6FC2A9123FDC6EFFA15A4C63851130BB48" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-categoryPartition.constructor.lean", + "mode": "100644", + "gitBlob": "b6096adffc84868b405f490f194a6db792e67445", + "rawBytes": 11261, + "rawSHA256": "01E8DCD4F40FB210DC78BD3B2CCCEB8BA08252F82E27B02BA22407DA8438F41B" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-categoryPartition.consumer.lean", + "mode": "100644", + "gitBlob": "04f593d2be17f2a5c21edc3c632ae198ee8c717f", + "rawBytes": 24636, + "rawSHA256": "38676DBAF807CFE09EF8B6474DC67EA5FC560521E8944F6D828096E964EA4EB0" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-completeCapacity.constructor.lean", + "mode": "100644", + "gitBlob": "27e9711bc8ca5714d0660c53ff975aab177b6822", + "rawBytes": 11278, + "rawSHA256": "C2CC22B5A53391CF69C3D68BDE36B8B9A096CF9E88B57CD91B81FC5E80FDD661" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-completeCapacity.consumer.lean", + "mode": "100644", + "gitBlob": "b2ddea77b83e66663e6ef573bb4a515543040361", + "rawBytes": 24653, + "rawSHA256": "FF5F485929E3AEF036422E1CE658C7FEBDFEB59D2DFD24D91BF43D917FD994E4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-finiteScratch.constructor.lean", + "mode": "100644", + "gitBlob": "a6cb7603dd41057f96f5013083ab7c61f0d40d0c", + "rawBytes": 11434, + "rawSHA256": "D21A76992F4EE54F58AEA7B9E6332B44268F1E4349F682918EEFD57191F5A080" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-finiteScratch.consumer.lean", + "mode": "100644", + "gitBlob": "29a038946035f29e94c39afc9a6032dcbe569bc4", + "rawBytes": 24809, + "rawSHA256": "F6532543B8B0444DCB13F6ACB46ED30E05D83ECFA0BFA56953079E9D848E88C1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-memoryWordsFit.constructor.lean", + "mode": "100644", + "gitBlob": "9afb789d8902e7d054dcfc212ccb0771e92ad479", + "rawBytes": 11513, + "rawSHA256": "328063870767754D95EE7B2192D4263AE37335289C5A90C81F413E3E0F8FA99C" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-memoryWordsFit.consumer.lean", + "mode": "100644", + "gitBlob": "ee77b1673b18cc6b41bf1f2a892d0d3c2d03572e", + "rawBytes": 24888, + "rawSHA256": "E4C525AA498BF0F609182BA82D0D4AAF661B4EF2A79CBF929D286A96B45C101D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-overheadLittleO.constructor.lean", + "mode": "100644", + "gitBlob": "26546cd85a407f868198cabf6a3ae1b7fdec200b", + "rawBytes": 11612, + "rawSHA256": "DFB67100F9E512F9EAA7270D650949491193CCE5D504AEBA5E54DC46AA9C5D95" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-overheadLittleO.consumer.lean", + "mode": "100644", + "gitBlob": "1a1ca7c7ace49beed6c79b5046486e4cbf73ee19", + "rawBytes": 24987, + "rawSHA256": "8517D6B5F604E384AC9CE2FF68908C028A06DF5BA0174F40A0879F663965F405" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-programLengths.constructor.lean", + "mode": "100644", + "gitBlob": "b9446ad827a93f33a9c14387e01227019ea2c657", + "rawBytes": 11469, + "rawSHA256": "284691291D50277EB8AB79F917CDF6691939CD5E2940D1BC61756DB3ACFF8F61" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-programLengths.consumer.lean", + "mode": "100644", + "gitBlob": "3f70eb7c86a344a8707d6d407696d8a53ba36aba", + "rawBytes": 24844, + "rawSHA256": "F02584E3B4FDE6E7F8D0BE7C11240E2DACC8436EA627F4FCC2F45B8DA57E4A27" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-rankCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "fe16fad50765acdd31e3cdb83cf7a2040a99cafe", + "rawBytes": 11472, + "rawSHA256": "04C3F219060F67B66423AB9CC9A73DC0F114521655187419F1C865D4FA559446" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-rankCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "0f3e16210a2c6254b768ba4a79059a21df72dac7", + "rawBytes": 24847, + "rawSHA256": "7BD0479E0FE44FC476753FD1578C27C25C7B4286DD5BB2E87D0BD3BA2137D537" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-rankExecution.constructor.lean", + "mode": "100644", + "gitBlob": "9c70a510ee7ec140d37d62c1b6359a8ca4fcba30", + "rawBytes": 11171, + "rawSHA256": "483F2074D1ABE6A72364AFB6654300A0D2AE7038363BC46A440865ADC004F9D9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-rankExecution.consumer.lean", + "mode": "100644", + "gitBlob": "8901dcaa2cb240f140c04c8dba1f454d696a39a7", + "rawBytes": 24546, + "rawSHA256": "FDAC29ABBF3A0DEE84EB673BFC9CCE83049C0147D619D92B10D288ABD94E65BF" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-rankSafety.constructor.lean", + "mode": "100644", + "gitBlob": "e23ac973c2e54860595b2a1fdbe730c64ef2d2f8", + "rawBytes": 11359, + "rawSHA256": "FA0E57B48FFC2B3EE1AA02EBBAFAD39A81FDC6ADD2D8899B831AE05D41291654" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-rankSafety.consumer.lean", + "mode": "100644", + "gitBlob": "ebbd07e33170a896440bf6e3dd9e941b4405e3ae", + "rawBytes": 24734, + "rawSHA256": "EDF9308C83EB831EC444C5E8393F263E845396D583715692F6F43030AA13FD95" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-readerCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "b9d2dfe94a0bcda7c117c2faa943168f6135b09a", + "rawBytes": 10969, + "rawSHA256": "70F29691A7A81238D8287AD1204CB42580B3BDE1DEF21C11B43BBCEC91769D21" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-readerCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "4640a5dcf616d71cb3451bf7d1d74fdfdf88e722", + "rawBytes": 24344, + "rawSHA256": "A686E61143D39E595C3544B523FA06086ACC6E5B5D0623096B90B9989853C522" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-readerGeometry.constructor.lean", + "mode": "100644", + "gitBlob": "4010f6f99838441aa26d04f245f1ceeedec2a5f3", + "rawBytes": 11343, + "rawSHA256": "7EC5D47EB0C8D6260FD30ECF2F2791333CAADE175E7283C52008DA24A5986663" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-readerGeometry.consumer.lean", + "mode": "100644", + "gitBlob": "fb8df43159baba23b466d17cef00d5720ba6e093", + "rawBytes": 24718, + "rawSHA256": "9EF134D70A370C8F5E6C63CF239A3621AF529D6E4EC2D0488DB8518B0F73ED55" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-selectCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "58cbdb875cae56c3fe638e7d25f5b7ee6e0fc908", + "rawBytes": 11514, + "rawSHA256": "129467D512207044D15388AE05FC3CC0EDAFA81B50EC98C071924AEBDF1C0ADB" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-selectCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "bfdf5c998a503ceff1cd9b877e7457fcfb0ea9a9", + "rawBytes": 24889, + "rawSHA256": "0131FD5B04E6194DF51FA1E04C447254AC43698761B7C4A563635DE8C0AFBE04" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-selectExecution.constructor.lean", + "mode": "100644", + "gitBlob": "6aadeb5a8414a87b5a0da931ed31b625f64a4d44", + "rawBytes": 11141, + "rawSHA256": "256145ADDFCB7A2B746C28D61F2001AA200CB7F1BFF24EB21C8A22762D5D001D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-selectExecution.consumer.lean", + "mode": "100644", + "gitBlob": "0f3498f5646f136b78f52bcf79462e014b8a3053", + "rawBytes": 24516, + "rawSHA256": "6C6DFAC4D59C02176F2883C103261EDB0A549EA3B2BD460918CCACD2BDAC6626" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-selectSafety.constructor.lean", + "mode": "100644", + "gitBlob": "cba231e230c468700f5016166a1e9a7f5b09c040", + "rawBytes": 11351, + "rawSHA256": "1A2E66C5AF4AD393CCCAD4E9C087C51410C9785DDFCB25F2B36D382157BA3F91" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-selectSafety.consumer.lean", + "mode": "100644", + "gitBlob": "e65cd6d0aa3dbbf3be13c0c3c827e5260a3e229a", + "rawBytes": 24726, + "rawSHA256": "31D27BD8C8B62F39B4BBF24445E0869A71A9EEA01A07E8DD032106F4DCACC1BD" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-sourceBudgets.constructor.lean", + "mode": "100644", + "gitBlob": "0ac22a00b23fe5f123bf1908ac24872c64df17a5", + "rawBytes": 11469, + "rawSHA256": "C0ABBB5591BA2198028DFC2C3306B78EBA3BB50B0C35957DF850A87EED198A9D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-sourceBudgets.consumer.lean", + "mode": "100644", + "gitBlob": "8ebcf380ba46fdfa2383d950a44113a2e47c05be", + "rawBytes": 24844, + "rawSHA256": "637AABF5E10408764016D9D972CBDD3F74D2A56A9A96C932B0D80D717495DC32" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-stepsBound.constructor.lean", + "mode": "100644", + "gitBlob": "7a19a9b09769e13388889e85b7f8b9e4d8987d71", + "rawBytes": 11475, + "rawSHA256": "9CAE3C200B773EA6A3A9E6DF07B1E1678C3536C365FC90AC504F5441E65D1E70" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-stepsBound.consumer.lean", + "mode": "100644", + "gitBlob": "e9d39d29a3aefc9dcc09e6fdaf917c05863dd3d2", + "rawBytes": 24850, + "rawSHA256": "A8041A49032744E7AAD19A522BDB826264BCE7129E7002B912CDAEB99E9578E1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-suppliedMemoryAgreement.constructor.lean", + "mode": "100644", + "gitBlob": "caba8e0eecda659baf87bae8ebd28f7c4d758488", + "rawBytes": 11227, + "rawSHA256": "3B57BE9502209F2E102938C3914B8E6E2071C78D7803EEAEC6A9F1D181AA665B" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-suppliedMemoryAgreement.consumer.lean", + "mode": "100644", + "gitBlob": "eea90d0e57135df9c25ecfa3029804155f9f9fa5", + "rawBytes": 24602, + "rawSHA256": "3EC6F253E26664AB9BD7542514ECD75AE2C63250F483B940D6E36D2091BF4824" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-validArgumentFits.constructor.lean", + "mode": "100644", + "gitBlob": "98bacbd30fcd7a17be2d69a55eefac4ff1ef90b3", + "rawBytes": 11561, + "rawSHA256": "6312C19E40DAEECB8166E82F6D609F0D0F94A04F5CFDF7FB5AAAE129500B2C44" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-validArgumentFits.consumer.lean", + "mode": "100644", + "gitBlob": "e06e4a8830a652e59876dda41f17c79df29b332a", + "rawBytes": 24936, + "rawSHA256": "472F158CE31D7C0F1AA63E1F00506005E19EBD11E2651B1F2CB311BB61A5FD91" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-widthBounds.constructor.lean", + "mode": "100644", + "gitBlob": "15dfa1443eef6538c14e53f3f66b2dfc3c618d17", + "rawBytes": 11523, + "rawSHA256": "7A76E88C776843C55677298B903B0CB051580D56EEF772981987A4F47FFC778C" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-widthBounds.consumer.lean", + "mode": "100644", + "gitBlob": "97414c714081d0c1d549dc34881a8290a14c427e", + "rawBytes": 24898, + "rawSHA256": "3B2DFFF51A9959F39C12F25C50B6AAB67F6FF74B721A70A28070468066808EC5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/capacity-without-code.constructor.lean", + "mode": "100644", + "gitBlob": "515b663f92b6833ae30a68ad22e6cef3f4d94015", + "rawBytes": 11823, + "rawSHA256": "B1498ED33EC8656803133CCC32F6560A3EF2D9A345E6F8C2FB70DDDAC670FEC9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/capacity-without-code.consumer.lean", + "mode": "100644", + "gitBlob": "4f75bc2e2bcc97a81ca986573a5185219cb43a18", + "rawBytes": 25198, + "rawSHA256": "3C92A1A989EEE049BB61A36CD138B6D834E622EA4706C96EA428CF955D3ACA51" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/capacity-without-scratch.constructor.lean", + "mode": "100644", + "gitBlob": "b8645a5b221a47202280b0fdd4a1eef917426c2c", + "rawBytes": 12165, + "rawSHA256": "9BD68C775DD930400A88A320855BE4D66C3A91DABA162F8B556745F53061CB16" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/capacity-without-scratch.consumer.lean", + "mode": "100644", + "gitBlob": "79afbbe4e723e6f8835eff5fbbc2bbe23363be39", + "rawBytes": 25540, + "rawSHA256": "A3AB73E68543F636B03EFCD85E345B43C0537AC0754ED0609F92D0A64F5EE9E1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/delete-accessCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "d501900856a222f63ebcef52caa1b431e77f7c79", + "rawBytes": 11307, + "rawSHA256": "D5A999CFDB2FEA2598EFC0999D10D15002D67B6D2090CF8EA1117CDF8BEEB343" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/delete-accessCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "e3bd6e4aa10e552ba48943ebe7dbc952bffd1d5c", + "rawBytes": 24682, + "rawSHA256": "50CE522DB5671B9DA3FA9BCEEF71D38A05D4F2A8BE41C9B5F7C182CE4329B25C" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/harmless-comment.constructor.lean", + "mode": "100644", + "gitBlob": "58dff7038e0ab087dca4a2bd0850ed8b4952f839", + "rawBytes": 11632, + "rawSHA256": "FEC9E7C7BA1299C60E8D3EB6E3DCF06BB51029D9CF66509F2049CB4C55D900C9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/harmless-comment.consumer.lean", + "mode": "100644", + "gitBlob": "e51ed9b2437b8aad0e2fd1a5198ab6fffe32551e", + "rawBytes": 25007, + "rawSHA256": "2D37F54478DDBAD26E5EA0132323739A6B5D33CA4EBACB4CD45BA920E468CDD3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/public-proposition-True.constructor.lean", + "mode": "100644", + "gitBlob": "5f70b6920e9c57f1c32e5b1f54e4183291133cd7", + "rawBytes": 8458, + "rawSHA256": "67676F9278028407C5D50E0B0DB3858FD63526659468285912F27C09A29FD155" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/public-proposition-True.consumer.lean", + "mode": "100644", + "gitBlob": "b7da322ba2a93b49714f5fad9774268302e23c09", + "rawBytes": 21833, + "rawSHA256": "18C8D76BDF639FEF1B55C052A30CA6BEB80980A7B5AA9EDEE421C6C4CA47A62D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/sibling-completeCapacity.constructor.lean", + "mode": "100644", + "gitBlob": "9a06c60f325da387900ad316512610689efaab74", + "rawBytes": 12328, + "rawSHA256": "12E410D3F19C1BA5288D506549F8BA4A1FD5142D4FE776DB7FB11D1ED4FD3E40" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/sibling-completeCapacity.consumer.lean", + "mode": "100644", + "gitBlob": "2e14e749704d99bd1fef73396b2674b4d49e337a", + "rawBytes": 25703, + "rawSHA256": "E3619A833E72A70B5030D0043B4E4963DAFBAF78D40BC3690195D56BB8DE7BFC" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/sibling-readerCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "da2b175bfb46284ad94bf79785737b4ac171189b", + "rawBytes": 11084, + "rawSHA256": "61D16C948DDBB3825BA19C7F780AF94C108AEA700CF4330548EC2BB5953EBAAB" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/sibling-readerCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "eb574d4c9080473160a7d868b2c2885df6c804b4", + "rawBytes": 24459, + "rawSHA256": "9AC0FE972CFE6825F48781B502086434F421DA86255AAA04FC978BBCF2EFECED" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/sibling-selectSafety.constructor.lean", + "mode": "100644", + "gitBlob": "d4e0416fbd11df6deac3aefeb7e0599c1f2c2e3b", + "rawBytes": 11609, + "rawSHA256": "FEB06585E104DA3C4B665B4AF9B1BAEBE0642F39CD15AE472FDDD0AAD0F49809" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/sibling-selectSafety.consumer.lean", + "mode": "100644", + "gitBlob": "20cc96dea023dc04ec142900afac47eb277d401d", + "rawBytes": 24984, + "rawSHA256": "2AC4C251760BF877E382109D55996EAA1387881C3E4D6E90D0C7BCC8D5B65EC2" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/unchanged.constructor.lean", + "mode": "100644", + "gitBlob": "52e9cc5c2e2352a99b7d6a6345131f4734294d27", + "rawBytes": 11561, + "rawSHA256": "3E6163098F25F0A698A33A9E3CC9F5BF230A56451DD1570CC571D5DF4510ED77" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/unchanged.consumer.lean", + "mode": "100644", + "gitBlob": "91924d7091871bf4773b0dc1d647090bfd291941", + "rawBytes": 24936, + "rawSHA256": "0214F8540456AD97CDD60A19431CB9EA14DD162370C2CD63902A4F916C6C868D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-accessCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "09d9abd90fe91d005611ff27a1e2b65514466e5d", + "rawBytes": 11496, + "rawSHA256": "A91B8EC7BF919DE89E97D36030AA10A45A1C260ECE541520F20B0A6901B4A61F" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-accessCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "a96606fed7422fbc3e4d50bdea26ee9b15e48b08", + "rawBytes": 24871, + "rawSHA256": "3EDADE56CADB4067C7467710B3FD61BA5D2C6537E0FE414611F04057DC9850A4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-accessExecution.constructor.lean", + "mode": "100644", + "gitBlob": "72c4e00479ecd92130a70c869e55789f2505f824", + "rawBytes": 11116, + "rawSHA256": "8CA893FA74512AAC3E84E6825524A1140A90198C09D8CD02242DD1BDDA78A2BF" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-accessExecution.consumer.lean", + "mode": "100644", + "gitBlob": "3922ba3699912d7a69def89eed1673f3b8754b26", + "rawBytes": 24491, + "rawSHA256": "D5C5545945AB8540BB5F05B72634C3BE1B30B8C05E339D2FA8AC55327B127C53" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-accessSafety.constructor.lean", + "mode": "100644", + "gitBlob": "5910a7d5bccef71fc0072355a0de5d7679f12256", + "rawBytes": 11287, + "rawSHA256": "AC2F6B6FF76FFD51B8B37F2B738ACA1049B78F07C4E1C10B38DD2A6380C7E33E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-accessSafety.consumer.lean", + "mode": "100644", + "gitBlob": "dc63eec5ea441834743bd378b6b29de423f09332", + "rawBytes": 24662, + "rawSHA256": "A1556436823BB967CE0CF5A30CB1AC530C542F323DD9C3CD7287D25A111DC3D1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-categoryBounds.constructor.lean", + "mode": "100644", + "gitBlob": "69cf1c5ae32e10a36068750f9b28bf33e5510b46", + "rawBytes": 11346, + "rawSHA256": "C869FA9C5559F6365BF73B2D6B2AD3C0395BE79E8D6CAD015FA3913829E63DC3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-categoryBounds.consumer.lean", + "mode": "100644", + "gitBlob": "c26e9bb04c357988cae6d711599c7a50eb0629d3", + "rawBytes": 24721, + "rawSHA256": "DD1C80FB12A567C40177BB26AC88AAA7159864D45C565E5A5792F79816D1B37C" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-categoryPartition.constructor.lean", + "mode": "100644", + "gitBlob": "17b66c31de1454102ca74d7748d1f811b1000024", + "rawBytes": 11180, + "rawSHA256": "4BC1E2E56BD83331C1F0073E805FB1ED9F4F68E9E52EB590A72EBCB6AFEBC691" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-categoryPartition.consumer.lean", + "mode": "100644", + "gitBlob": "f4e3b77596a7e1cdfc688c386331c1f39c59bb41", + "rawBytes": 24555, + "rawSHA256": "05B77E9A4682110852E02330EAE35008F33689FFAB0C95E1C57F379B91CE9AAB" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-completeCapacity.constructor.lean", + "mode": "100644", + "gitBlob": "b8aadd31b47e8d6076b0364d4c3eda127ff9d0b6", + "rawBytes": 11197, + "rawSHA256": "A2A79B31028DCBAA990C354CCB6EAC4F15E69C015776FA99F5133F09FC120108" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-completeCapacity.consumer.lean", + "mode": "100644", + "gitBlob": "a958edb1b1c58a406fc707c89b413b3ef14438a2", + "rawBytes": 24572, + "rawSHA256": "7974FEABD9C67765DC3D10AC6C4AA507645268B47647F42E757BBE167151C25C" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-finiteScratch.constructor.lean", + "mode": "100644", + "gitBlob": "f8754e09c77cbd961e6647b68883b874cc477bb3", + "rawBytes": 11353, + "rawSHA256": "9A14F8D9BA315A63E2794CD9ACC62066B09A8CD6EC24F3B4E538F6B352029F66" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-finiteScratch.consumer.lean", + "mode": "100644", + "gitBlob": "3a80ce4867e71c9fabfb518d1c35fe14279e627c", + "rawBytes": 24728, + "rawSHA256": "342682DAF21A7C0B94A4E59041084960E09B16110B094C295F3BE1D7891777B4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-memoryWordsFit.constructor.lean", + "mode": "100644", + "gitBlob": "97ad82add7d98c3c519596eef8974cf37457e800", + "rawBytes": 11432, + "rawSHA256": "C1D3730D6AAC0A1128C823821F17A4A7BCE6B20BD88B4785789F9EB232933C1F" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-memoryWordsFit.consumer.lean", + "mode": "100644", + "gitBlob": "20a252518297f672231818d4a3b2e2091857bbc6", + "rawBytes": 24807, + "rawSHA256": "0E1FA937E9D1BF2739AB2BE64F15EE0477E0D1F6C578D7CC0E2DF5A6B08D42B2" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-overheadLittleO.constructor.lean", + "mode": "100644", + "gitBlob": "691fa976294e420a64b79067318cbdb0c41c5bc5", + "rawBytes": 11531, + "rawSHA256": "C9CA06D84EA8AD65B10C87EC9C2285C70EFDAB2EA33DAD354195E972BC237142" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-overheadLittleO.consumer.lean", + "mode": "100644", + "gitBlob": "507011bfe03ecc82a30739cff384055de9a7782f", + "rawBytes": 24906, + "rawSHA256": "FB1F0EF5ACC97B9DB6E08B3B39759B2EE0ADBD358748AB803BC1E2535CF6FD12" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-programLengths.constructor.lean", + "mode": "100644", + "gitBlob": "55f896818bd82e2d345322f952559ea8b7d33ff9", + "rawBytes": 11388, + "rawSHA256": "0C61E1D4CB45C8147D736B11C33FBD4703FD266AF833429D31A3E1F5B5C210A3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-programLengths.consumer.lean", + "mode": "100644", + "gitBlob": "e37318ec4320bd485584a6ba58ef1d35aa663455", + "rawBytes": 24763, + "rawSHA256": "301A49EC9AD804E7DC9E2D3AA2D782F93ECDC30901147DA5DB42CFE2DCD274D2" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-rankCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "2dc827fe66b158f8ba609fa0b55aceca720dec37", + "rawBytes": 11391, + "rawSHA256": "5E5852B5B5216E9762BF204C9BE8BC0F43CED3E9610247665D4F9ECBB081952B" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-rankCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "f557ce56dcaff8f3a35a4ab40fa70fc555a18810", + "rawBytes": 24766, + "rawSHA256": "5060AE513318AC89BBA83BAC95E4D3D3B62B38388DBE04DF4BE0A95C7F96BAE5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-rankExecution.constructor.lean", + "mode": "100644", + "gitBlob": "f295d8dda841f4f11f8bf1c09c382dc1b58b2d70", + "rawBytes": 11090, + "rawSHA256": "DB3C462314D91A669D9EE1D9FFB80F3D4A4ED36C781E9A139E35081A897E9BD9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-rankExecution.consumer.lean", + "mode": "100644", + "gitBlob": "f562ce9d3efecbd4b671a99785475b57daed1f34", + "rawBytes": 24465, + "rawSHA256": "4357F0DFA0DFA23EFA153D502B4E960FAA7C531329BAB18915912E7DC48F754A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-rankSafety.constructor.lean", + "mode": "100644", + "gitBlob": "2cee78c55ce6c2a745ffe9603c3599b80a0e7395", + "rawBytes": 11278, + "rawSHA256": "A8697E1E9553C7A0CAB78B0EFE5BE5FCF6217C401BA11E781DEE489BB214A03A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-rankSafety.consumer.lean", + "mode": "100644", + "gitBlob": "280b2879f924d6dc2aa67e2bfb7a9cb399f95606", + "rawBytes": 24653, + "rawSHA256": "22F88A61AF30638089BCF15B71900C137056C1F8A434CD4ECA61746C4DBF30DD" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-readerCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "ae6f258afa82c6f2335da4f71b230e1692054324", + "rawBytes": 10888, + "rawSHA256": "BA1FDBF0ABA815C0CFAECCCA117AC46C36C0D4BC2EFACE02AAC969FB53385381" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-readerCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "7fd7e0075c31d601fcb2d6ed4159c2ce4a55d5d1", + "rawBytes": 24263, + "rawSHA256": "BEF27C49C398627DEAAD4490F5DAC22E4C9DBB55A8E4D0C1F772FD54B83275B6" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-readerGeometry.constructor.lean", + "mode": "100644", + "gitBlob": "b1bfccca365a17ae30ea7742057b4a738478dcdb", + "rawBytes": 11262, + "rawSHA256": "CEFE12EB9AD045B3109C60D4E4A839B22588F07ED71C34002766FB0516005962" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-readerGeometry.consumer.lean", + "mode": "100644", + "gitBlob": "bce078189acb11566ce6a73040e370a51b1ef393", + "rawBytes": 24637, + "rawSHA256": "B459C912FA63A869F0353B8E6D1BDECA91D2D61B4A0DF4FF6EB1B2DC965AA046" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-selectCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "b4c9d373b78ef027b7cc26e7051cea241f52508e", + "rawBytes": 11433, + "rawSHA256": "5A8B507444F96A5FCD981AC792EC98B1828D68BC9178257846A1C04D6414D24E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-selectCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "ebdcd922a10abe403ae70b9a1754b5a90bf69301", + "rawBytes": 24808, + "rawSHA256": "7BA9F6E3635B6CF6EACE442F5629C8157B562006E6B50118B66D4CBF0F520573" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-selectExecution.constructor.lean", + "mode": "100644", + "gitBlob": "75a116f29d984dd6e0b764db7a15ec882e99c23b", + "rawBytes": 11060, + "rawSHA256": "E2257A7AD3B756E144E142F2B0097CA03A63423307E2D4A0FC24CF92B830968C" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-selectExecution.consumer.lean", + "mode": "100644", + "gitBlob": "f7702035b48c282ad09578d9e6c0b3c3e6079c21", + "rawBytes": 24435, + "rawSHA256": "D6164A4C8B8765EB193BB335E9F4F3CC2A41DA4EA924D9C1087BC2A49B526EA4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-selectSafety.constructor.lean", + "mode": "100644", + "gitBlob": "4f4c7b5d9c3ebdb7930012294b64c96b72c32793", + "rawBytes": 11270, + "rawSHA256": "087312E4EABDBCE8868FA93B0489BEB3129CA756B8F27855BACF4EAF62182E0D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-selectSafety.consumer.lean", + "mode": "100644", + "gitBlob": "ccc615f20e91256dd2d3de883f7e470d5a8574b5", + "rawBytes": 24645, + "rawSHA256": "C3F5DF9AF70E24D549D6BAFEAAE7FC8293BC44C3CEF55351210F5BDBB06C7738" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-sourceBudgets.constructor.lean", + "mode": "100644", + "gitBlob": "17a044876c0784059e0540e680dbeb61038bdc18", + "rawBytes": 11388, + "rawSHA256": "5630B8D3EEB6EFEDBEB00609A9B29E4A5FFCBDB190B133CB88F7E1F7C8D411A4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-sourceBudgets.consumer.lean", + "mode": "100644", + "gitBlob": "086eeaf32be4b9216b2aaff0c86a1df0dc4ff69d", + "rawBytes": 24763, + "rawSHA256": "9DFA351D725D4D6BFBFF387FF3CC7E556D433EC0AECBFF3F88BBE601520FD7A5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-stepsBound.constructor.lean", + "mode": "100644", + "gitBlob": "3f4af7cf06e35e0847a86f4f537e8161446f748f", + "rawBytes": 11394, + "rawSHA256": "287279111614FA86ACE3BFA7B6B0D34EF1D23CC8D4DDDD5CB0FA728C6B1C3075" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-stepsBound.consumer.lean", + "mode": "100644", + "gitBlob": "3468e33ad53bfe2bc18c066f0d4d17ed9a0ffdfc", + "rawBytes": 24769, + "rawSHA256": "57E53CA68683C31D4D71F34A8504C4F14C92F09F4FF097B9F7BE9973E34E1488" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-suppliedMemoryAgreement.constructor.lean", + "mode": "100644", + "gitBlob": "4ad093d673a1b096cfc2b97039a6e01c0bafea27", + "rawBytes": 11146, + "rawSHA256": "D37D398A33627168DBFA19CD30487F4E6E4F3B7A8FA48F5A1649FD971A99A7E6" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-suppliedMemoryAgreement.consumer.lean", + "mode": "100644", + "gitBlob": "5848525126b6a62946ece6c3b47403ca2ba2025b", + "rawBytes": 24521, + "rawSHA256": "979C4975E4484D66DAE9864380269BB37FEE0926695DCB61D37FE1A3865593FE" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-validArgumentFits.constructor.lean", + "mode": "100644", + "gitBlob": "bf29c02c26476cecac082dd2a043963f0145e070", + "rawBytes": 11480, + "rawSHA256": "3ED0A28AA01AF37DC29A2170ACBB0EB14CFEC27686EFBF156CC9E2E53E1A5F21" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-validArgumentFits.consumer.lean", + "mode": "100644", + "gitBlob": "1fd0b65abe837a19d45fd812584409240a1e677e", + "rawBytes": 24855, + "rawSHA256": "5B2AF2EC240642F0CD03C38FE51EC6E51C810E519C9DE28BFA6D93EF4FF71B54" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-widthBounds.constructor.lean", + "mode": "100644", + "gitBlob": "1c76722e5df313e661da7ff4d36ce697fcbdcf6a", + "rawBytes": 11442, + "rawSHA256": "E5B7627E6BEBE4733ADBCEF700C3976B6081924FC230D98797B68D085B39BC05" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-widthBounds.consumer.lean", + "mode": "100644", + "gitBlob": "04fe4f7190bdfcc9d1c96d4bb31f1d907b4e5fbf", + "rawBytes": 24817, + "rawSHA256": "D9287C6F1E8402A30A66F79D76FD65A05902D67ABCEEDF66CE1F90DA6840B10A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/capacity-without-code.constructor.lean", + "mode": "100644", + "gitBlob": "a09ac4fef7ce4b45f2f3ff9b3c74cd718a55c8d9", + "rawBytes": 11674, + "rawSHA256": "3B8F2B138D8688E6135B810B4DFE542D2E6A541CD0228EE11F3EDF7A7A7BC4FB" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/capacity-without-code.consumer.lean", + "mode": "100644", + "gitBlob": "77211266476610042602cf0018555ab8841da42e", + "rawBytes": 25049, + "rawSHA256": "51441D1D50D5306585FB86A5B6E7878A40227EF4496E567482675373B6F55A80" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/capacity-without-scratch.constructor.lean", + "mode": "100644", + "gitBlob": "d96fdb2f0732fbd87f561640c451c26617ff9fee", + "rawBytes": 12016, + "rawSHA256": "A753103B1A5ACF77E6C1E99AE347C5737CE5F430BE46AC37FF0A6F5FCC33A6C9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/capacity-without-scratch.consumer.lean", + "mode": "100644", + "gitBlob": "cfdb4c8b554b3ab363ae805637de53eea9a57298", + "rawBytes": 25391, + "rawSHA256": "C4F7C8FD7424E1E114FA44146C8264A73DB4979B726735DC43C6D7A5F2CA338C" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/delete-accessCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "2476fca2abe7dbaa66da65680a665301d3a5d5c3", + "rawBytes": 11158, + "rawSHA256": "651791C2BACE987748195F70EAE64B2B7456DAD1B64F76D39959113EDEFFC6E7" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/delete-accessCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "a2e585992498bc3b6be2a163851887449e0fee3b", + "rawBytes": 24533, + "rawSHA256": "1D448F39649BE5CA08713BA75E8B198063819BC1DE619488DE32A3D06145DCEA" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/harmless-comment.constructor.lean", + "mode": "100644", + "gitBlob": "ae0a57829e7dcc813a86aa375c821691b2ea3f46", + "rawBytes": 11483, + "rawSHA256": "72FB34AEFDD6DD4C5D58160F954FF6F6A251B957438528E4BFE9FE86CCDA4DAA" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/harmless-comment.consumer.lean", + "mode": "100644", + "gitBlob": "570516f92f378ae3df0ab4d691fb122f3c8b9081", + "rawBytes": 24858, + "rawSHA256": "FD5635974A1AB26F392D5AD314220BC219019ACBC066C38D8B4BB1275A3917A8" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/public-proposition-True.constructor.lean", + "mode": "100644", + "gitBlob": "5fd81410e22ed0c9adbc8e8b304fd971e33e1edc", + "rawBytes": 8309, + "rawSHA256": "25F7DFA212CA726BFA0B94D53514F418F636334834E611683C107DDB500198F5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/public-proposition-True.consumer.lean", + "mode": "100644", + "gitBlob": "2b40da833cc40572f755deed688ff3b5ce0752c5", + "rawBytes": 21684, + "rawSHA256": "CD318D4A01D7EB7D85734777D2DE9793DF29C799AF2DBBC66E6E39521CFB8E2A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/sibling-completeCapacity.constructor.lean", + "mode": "100644", + "gitBlob": "830663d296b3c0671ec8b200e37367e1562b61a9", + "rawBytes": 12178, + "rawSHA256": "383AC71E84D35B513E61FB2D6922511EC707A66D73906EDBE059F110BB4CA583" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/sibling-completeCapacity.consumer.lean", + "mode": "100644", + "gitBlob": "7f3fb3d33027495d529f4719e60c1b99c00acb4d", + "rawBytes": 25553, + "rawSHA256": "3D897DBE47103BB5DBAB786B2EFC7DBB6320EDCFEDAA5E5F050AF8C9B6A321A5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/sibling-readerCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "b9e942b8ac95e8582bd01c2c19e7de3391931f23", + "rawBytes": 10935, + "rawSHA256": "09DD0A40D2E4AA6100F2FCD52327F3F1A899DFD7C18CFA8AA6025D02A56D8A93" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/sibling-readerCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "f8e64748eace4d1a60bcdcdf3df979f9a05ded95", + "rawBytes": 24310, + "rawSHA256": "8BF63B05D98C8F0785AC0684B7F1D960757C792A0A81CEF5B98445B5845DA11F" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/sibling-selectSafety.constructor.lean", + "mode": "100644", + "gitBlob": "0fe2b2a154a94bc3c6e9c73b75140d1d694b83b1", + "rawBytes": 11460, + "rawSHA256": "E7EC2C585E24141BF454AC9B116F824ACBA24EDE85D58D5CFD33B9670BF7E2A0" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/sibling-selectSafety.consumer.lean", + "mode": "100644", + "gitBlob": "8783cc147547d65d482021fa38f1ef5c4c31848d", + "rawBytes": 24835, + "rawSHA256": "E6C6E5F62FEB8B9A903A40606A2FCE0C84E467480595BC097B9DB2F2949DBF0E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/unchanged.constructor.lean", + "mode": "100644", + "gitBlob": "8184759bbac7eb8b54cfe5acea62c9b86cb8211b", + "rawBytes": 11412, + "rawSHA256": "1C6CD0A85B77FBA7706C77DA87DE358808A24FA661D5635A3C4B3BBF96005D69" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/unchanged.consumer.lean", + "mode": "100644", + "gitBlob": "333c7f7b9185d5f19e703855126e300f0630b0da", + "rawBytes": 24787, + "rawSHA256": "34030EC06C9424F6692A02E49352D7B58CB67A6F1A874BCF07D980DEA0FCB3FB" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-accessCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "1d1566db6c748a2005e9e61c18d92df996201130", + "rawBytes": 11347, + "rawSHA256": "BE09F4706F3D5A0B82A0B7A2B3C2F7EC974F39181B7FF6EB82A3C2F0D0905839" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-accessCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "4d2d4efffff52f03062ed28e0d0ce3d1f703fbf2", + "rawBytes": 24722, + "rawSHA256": "3E46A4250093F07453FDDD3077B0CD86D24E4F0C7DA68E0B7A36614937D1EB8F" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-accessExecution.constructor.lean", + "mode": "100644", + "gitBlob": "3daad8f272f9a29156236becf0a9fe9b8b94c106", + "rawBytes": 10967, + "rawSHA256": "D08CBAFF37A5A3CF762A697B7C0B041D91612DB39CED86481A29F11D80A9A4F5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-accessExecution.consumer.lean", + "mode": "100644", + "gitBlob": "811a8bbb0b624dc28ccf54f044b142bcd23e3fd4", + "rawBytes": 24342, + "rawSHA256": "233BC572F5947A66BFB47857CA8629E696B691E3399AE6DDB7BEF3814129EF9E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-accessSafety.constructor.lean", + "mode": "100644", + "gitBlob": "8b63d87d332133a7d6cab2b046a4bf1070f7b60e", + "rawBytes": 11138, + "rawSHA256": "89BD8C1D125D764AB8538610A7986B71B4639107B89DE60C3B00B012F89127E2" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-accessSafety.consumer.lean", + "mode": "100644", + "gitBlob": "aec90e1e7fe49ab2530abe5e301daf058331420e", + "rawBytes": 24513, + "rawSHA256": "5433D05760D65D9F969D3433834EEDABAB1A6274F65F951EFA5FD0AF339E901F" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-categoryBounds.constructor.lean", + "mode": "100644", + "gitBlob": "2b7a998ee82242c228d9e5e4e41a7202f673780e", + "rawBytes": 11197, + "rawSHA256": "7716C9062519F437B242E46328219893B7C9DA9FDB4F56C7F7CAB92E96A899F5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-categoryBounds.consumer.lean", + "mode": "100644", + "gitBlob": "f73dc29a882e258ffaafe9981bec1f894f9b4da5", + "rawBytes": 24572, + "rawSHA256": "E4311923FFF5ADB3787056D750814B35477E68419265D522BF46FCA8D7FF79A8" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-categoryPartition.constructor.lean", + "mode": "100644", + "gitBlob": "51a91f75c783f1a07a9057b7eefe75d4f02d7255", + "rawBytes": 11031, + "rawSHA256": "04863CC2F81C1F9DE7E69F8A8E551AF2DC69AE39DD7327ACE348FDC7314C0719" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-categoryPartition.consumer.lean", + "mode": "100644", + "gitBlob": "0ad1aff421088743802d92beaaf57937487d1446", + "rawBytes": 24406, + "rawSHA256": "A87CC95187DDEB2E09FB08D0834036C10F434318E32B1631581E80CBDB05106A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-completeCapacity.constructor.lean", + "mode": "100644", + "gitBlob": "6b9a4ebb43ffb4f9c18513ae7d179d2984737fd0", + "rawBytes": 11048, + "rawSHA256": "4B0706831969C019A3D2783BA58FB40FCF6314ABA0324A8FA664F5F8E1486FA7" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-completeCapacity.consumer.lean", + "mode": "100644", + "gitBlob": "9f37df32e743f745c3f3f9eeec94350a16aec239", + "rawBytes": 24423, + "rawSHA256": "6EEAC100AD379A0CCF6D0AE1DF62AED680DB286B4A3ACA11A204C23ECFFA28E4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-finiteScratch.constructor.lean", + "mode": "100644", + "gitBlob": "6039b399f77492b63f72fe0bcc983203ffa7a6fd", + "rawBytes": 11204, + "rawSHA256": "B152A554E610CD1B71AF4FEBE48EF7DE76A07AD1E552BBBB369329F73E753D95" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-finiteScratch.consumer.lean", + "mode": "100644", + "gitBlob": "73d618a553f1bdcf6da6eec731b92e47101e5806", + "rawBytes": 24579, + "rawSHA256": "45A0F90170383AEBCC6A26B1F805930C9EDD1C7AC7712A4572CB05413B124C07" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-memoryWordsFit.constructor.lean", + "mode": "100644", + "gitBlob": "a281320d581f1d5d54df90d3713b0d8f3245680a", + "rawBytes": 11283, + "rawSHA256": "357895F2A939A21AD32072C92496E332A6A7C0D19B11ACD6460BB4777F1365BE" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-memoryWordsFit.consumer.lean", + "mode": "100644", + "gitBlob": "5734d69446f18daf6c7e8d5bd85a7acfeb01041a", + "rawBytes": 24658, + "rawSHA256": "7C694AF7B9DCB60A38645BEF898AF307E331504B9234F03C727782CE119FB382" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-overheadLittleO.constructor.lean", + "mode": "100644", + "gitBlob": "8ed06564d248876239944cb3abbb19084b1394bb", + "rawBytes": 11382, + "rawSHA256": "81B4ED9073C48C982CD353D2FC5AEA6DB93312EAF20E1A5F3B1E59B0F57AF1EC" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-overheadLittleO.consumer.lean", + "mode": "100644", + "gitBlob": "b85064500f53df05e1704ed05308611255c7dda5", + "rawBytes": 24757, + "rawSHA256": "4B929237A0A552FB5C0452ADC7C67645CC48145DF3136145429E914DE25A39E3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-programLengths.constructor.lean", + "mode": "100644", + "gitBlob": "550bb409b7ff387703fac09747804da606320944", + "rawBytes": 11239, + "rawSHA256": "218B2E0E75ADA30FF7CC020751D13604192493D43BF9DEA4A8A38720A1BEC884" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-programLengths.consumer.lean", + "mode": "100644", + "gitBlob": "1f345bd3b0750d52ad62a951e9daa2dc34367738", + "rawBytes": 24614, + "rawSHA256": "6504D0887EBEABC94D26FF26EC79CFBB9BE8E44E192D1179A9B9A872799E425D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-rankCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "68d19f16af2b8fd83a3f89e78e4e22c1108511f7", + "rawBytes": 11242, + "rawSHA256": "CB537E5BDF53729456D4CC64D8ED0C587EB0DCB02FC71B0890E0FEACFFF08AED" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-rankCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "7a8ff28d0acb1cae1b605f33babefa41913aacdd", + "rawBytes": 24617, + "rawSHA256": "70DC8889FB84878BE1F28130F289EFEE45D4A993A1B41AF79F989B1B637468E9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-rankExecution.constructor.lean", + "mode": "100644", + "gitBlob": "9454db01084751433eb6831e392789a8801f70bd", + "rawBytes": 10941, + "rawSHA256": "94001D672071D489778FA49426B372FBFBC332370182A6281D7548F5702CA367" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-rankExecution.consumer.lean", + "mode": "100644", + "gitBlob": "1f4be86560bee62a285e994f11d1075e4c3e4ef8", + "rawBytes": 24316, + "rawSHA256": "8560837AA178EAF503503DD786C74EA68E3AD4CA57822877611C460FC5762AFF" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-rankSafety.constructor.lean", + "mode": "100644", + "gitBlob": "6697061bf711bb009d330e0f4d95b9107204ea47", + "rawBytes": 11129, + "rawSHA256": "507059533A947EBAF1CEDF8BF78F68A90E76904793922602F4EFB1BCCDBD8641" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-rankSafety.consumer.lean", + "mode": "100644", + "gitBlob": "f96d5476f508ad71411580b2be4c20cec8966025", + "rawBytes": 24504, + "rawSHA256": "5CA82990A028513E0955CFD0D3BB20E97D6B7109A30BF36A3FC8305CA6ADC937" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-readerCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "28b673e42454f8a92bac1035abeccbdb9cc8e238", + "rawBytes": 10739, + "rawSHA256": "93E5ED046477366087D233485968F19B015170505D15C2E7745C1EBC54F5C1DC" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-readerCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "1da9913307f9082269bdda156622f96c35e90f8c", + "rawBytes": 24114, + "rawSHA256": "ED39EA38FA85B96952E8C5442E95D3F60BB16147A4995C5CD2256C0F8B6EE0B7" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-readerGeometry.constructor.lean", + "mode": "100644", + "gitBlob": "152181f03342c990eb0b2d862bb00ce5bddd2397", + "rawBytes": 11113, + "rawSHA256": "B83749B6812A69E42E75C286F433BDEC4F07B8297B50EC220313C8EDACAB1029" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-readerGeometry.consumer.lean", + "mode": "100644", + "gitBlob": "13b5db7ea87fe732e5ff633ffaef111f0f18fb01", + "rawBytes": 24488, + "rawSHA256": "94B58CD1D753928B54BE64BF9341E3F01AD2ED48EF6FFC1ED915D28D7B18F7EA" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-selectCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "dda8a9e04b53ebabb62afd2318cf1f7824e105da", + "rawBytes": 11284, + "rawSHA256": "CF4D7AF5EFA1270F66619985DA7A42453826FEC680C932BF3CD562DEDA1D4820" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-selectCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "59b4310658fd9852090d5ae1997a7c6a8762a561", + "rawBytes": 24659, + "rawSHA256": "EC2BC5463D39D9511A08403449B9818356DB57309E3D0BA6CADC6875B831BB81" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-selectExecution.constructor.lean", + "mode": "100644", + "gitBlob": "895abd72751b7c334c3d5d24e418cd0b1a88b763", + "rawBytes": 10911, + "rawSHA256": "6F840AFC5BA6467310E7DB225FC8A8D1396F3B01339A8463CCC3AB60716BF122" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-selectExecution.consumer.lean", + "mode": "100644", + "gitBlob": "c19e3fcd6b0eca01d803d05515c82f3dd77450d7", + "rawBytes": 24286, + "rawSHA256": "0507FAB74975C9FFA4094FC2644580900A2AE77FD74013F6131E0666D7A326F6" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-selectSafety.constructor.lean", + "mode": "100644", + "gitBlob": "94edf5c2043e7eae01f2ecc634430e2f9f7b7cd6", + "rawBytes": 11121, + "rawSHA256": "2B7D753EC6DFBF5848B7F3E14BD0C6C4AE0E98D0D04876EFFBE316ED497C5BE1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-selectSafety.consumer.lean", + "mode": "100644", + "gitBlob": "eb0a28141277ce7dff35c304f5a5d4d25f872ce4", + "rawBytes": 24496, + "rawSHA256": "A61094FE7ECF898D423E14830D6845942F59E93C24DFA49F10B3559D8CD1B588" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-sourceBudgets.constructor.lean", + "mode": "100644", + "gitBlob": "5649fcbc908b923e244fae25768a16468aada7fe", + "rawBytes": 11239, + "rawSHA256": "005BB35670B2C32FBE85E30EF1718DC644B1234AED677F8754C5659BA5AC2331" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-sourceBudgets.consumer.lean", + "mode": "100644", + "gitBlob": "290f1355401845c41fd468cac840736f6fc758bb", + "rawBytes": 24614, + "rawSHA256": "6C7C268A1034C947B8F8E922E17B4DCA6E675F1B40F2FC6962B8227D3DB1631E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-stepsBound.constructor.lean", + "mode": "100644", + "gitBlob": "95d47280ef6088fe846f34b6021d835e9ff9d053", + "rawBytes": 11245, + "rawSHA256": "01046965F0DB6E44EB0701DC4D8E77BE3A61037132270B41D24B76324384E193" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-stepsBound.consumer.lean", + "mode": "100644", + "gitBlob": "218635533e9b447f5067cfa7ee0866176c6e1da0", + "rawBytes": 24620, + "rawSHA256": "BBDFC89E87897BEC6F8CDFE092134FF9D8AA413F0BBED409D832DD7077DE9765" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-suppliedMemoryAgreement.constructor.lean", + "mode": "100644", + "gitBlob": "59b8303f4a08710869d4d5ec53edbbe6d8e10cf1", + "rawBytes": 10997, + "rawSHA256": "46B67E7A43110C142844548F3C12F71C6A261E216105A7E98EE0511E909F96FE" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-suppliedMemoryAgreement.consumer.lean", + "mode": "100644", + "gitBlob": "a7f23e23244d36e27c5b68da21a210c5069c5863", + "rawBytes": 24372, + "rawSHA256": "BC23BD30C1C415D25127455ED9C75E7158BAB19325CB69F93797032FD9F3E195" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-validArgumentFits.constructor.lean", + "mode": "100644", + "gitBlob": "ca3d46df660efdf67521f9145f327e4db0dfd1cc", + "rawBytes": 11331, + "rawSHA256": "6B9A8F0B135126F6A20839D0AC2E1EDA63FAE2ADDB068C2E40CA3FAC14C89C35" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-validArgumentFits.consumer.lean", + "mode": "100644", + "gitBlob": "e16b0775c56df82ff5fb46abf8b8a7b9f4547054", + "rawBytes": 24706, + "rawSHA256": "FE300CD5BE7A660467EA4C06DD91B6CDDE02C5BAD63490A5A6C9EEE56226AF69" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-widthBounds.constructor.lean", + "mode": "100644", + "gitBlob": "acb6e5fc9dc8ea55830cf10d1f648424313aab01", + "rawBytes": 11293, + "rawSHA256": "DCAC8F2FE924655589D8A5436CB92A1288A0BDD797F3A20A8E15C2B0BD0F4689" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-widthBounds.consumer.lean", + "mode": "100644", + "gitBlob": "eacfe7b1c1aff9543d2d38d9fe2561ab48c9b2c8", + "rawBytes": 24668, + "rawSHA256": "2ECB9D416095DC8ADFF4067438A5D2FD17D57D5EC63EF29B747C6FE0108380CF" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/diagnostics/capacity-without-code-r10.consumer.lean", + "mode": "100644", + "gitBlob": "f714f0ebcafd2f667c93281db823014577b054ab", + "rawBytes": 25232, + "rawSHA256": "46FA2E22E169F04DA3348E33986EC96BDDDA9441F385079F019CE390B91E25EF" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/manifests/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A.json", + "mode": "100644", + "gitBlob": "40df2724ffdc8ee04f59de7f69cf3b1af11251bf", + "rawBytes": 76712, + "rawSHA256": "177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/manifests/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821.json", + "mode": "100644", + "gitBlob": "138a358f42fbdab9cfdc7a06a3e50b27c9086976", + "rawBytes": 76787, + "rawSHA256": "55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/manifests/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2.json", + "mode": "100644", + "gitBlob": "8ca13d336f77a2c1eba785344f0b3a3f1afbc971", + "rawBytes": 76706, + "rawSHA256": "6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/manifests/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618.json", + "mode": "100644", + "gitBlob": "8ebe97ae0ad7f70c92e219cf9b3352bc7665d2e6", + "rawBytes": 73041, + "rawSHA256": "B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/capacity-without-code.json", + "mode": "100644", + "gitBlob": "94f90d2c75b7a26ef5e4652f71b46b4b44671a78", + "rawBytes": 11745, + "rawSHA256": "218B564248CFC043ED72DAD7712900703B7FCB3E50526F3F80C2447AB34FF030" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/capacity-without-scratch.json", + "mode": "100644", + "gitBlob": "ace528ae29ec17b4181e7a4ab5be6d6563f3302b", + "rawBytes": 12297, + "rawSHA256": "D9D63CA9D840280C0421FBCAAB91C2D22C2D6A3BB9782FC69DC5E782ED7BA54D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/delete-accessCorrect.json", + "mode": "100644", + "gitBlob": "de3bcf320a1762cc35cb4be51032ee694e89085b", + "rawBytes": 10782, + "rawSHA256": "C63667ECBCBF93AD2B97340459C09C525686CA5F6D771AE0321F3F24670EF9F9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/harmless-comment.json", + "mode": "100644", + "gitBlob": "510fd62159933b170d1cc1d838cc8cd0307911d2", + "rawBytes": 9318, + "rawSHA256": "542EBCD8671A0D75E1A584EE17E7F38DC859862CF5F52BC544C9DB758803451A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/public-proposition-True.json", + "mode": "100644", + "gitBlob": "557cc01b96c9f0fd3635eb4c11577bd437591254", + "rawBytes": 10575, + "rawSHA256": "2D01C5558EE5D5AEB9F469200D079472CC33405090C4ABB81A40843D8256722B" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/sibling-completeCapacity.json", + "mode": "100644", + "gitBlob": "eeb031df10e4f2782360c8c00f5969f5b07dc4db", + "rawBytes": 12433, + "rawSHA256": "807CACE1B1BA4530E66DD6AF6F91F1F42133796BE6AFD4F460F09EFB15128C1D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/sibling-readerCorrect.json", + "mode": "100644", + "gitBlob": "658fa676ad804416961be0701dac6d6c397dd501", + "rawBytes": 12071, + "rawSHA256": "21C344C900687FCC7685CFD9F0307DAF90C5D6C1623B61C439B5E5E24E032498" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/sibling-selectSafety.json", + "mode": "100644", + "gitBlob": "b1a0db5efdedeb10e9cd1ed69bc74558e5433878", + "rawBytes": 15310, + "rawSHA256": "4DD630756B4A4024415BF8A91350A12B7E72E26C408F7738875A26C198E970C9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/summary.json", + "mode": "100644", + "gitBlob": "f20f507aa95f9f8ae4306e00b3d811fb6f63685d", + "rawBytes": 500628, + "rawSHA256": "DC190DE58D493133D28D800E73A1CE58FD474D674BF5A9D8F61017987A5016C1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/unchanged.json", + "mode": "100644", + "gitBlob": "69469b1573a2732ff6368a65cbf9106abbc6cf24", + "rawBytes": 9298, + "rawSHA256": "38F7F634E83E047C78DB2AB86305B9775C4AD7A41E4435532F399F2AFAA3A799" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-accessCorrect.json", + "mode": "100644", + "gitBlob": "f41a320212fd30d11f3adad8d1fd115634f8ae3f", + "rawBytes": 10733, + "rawSHA256": "65AFA75BA0FCC50063446D66E15647A713363C86D05BC3AC5B4BC50C68F2CAA3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-accessExecution.json", + "mode": "100644", + "gitBlob": "798524091ae9b64ec7ec6521fb36e73fb0dda475", + "rawBytes": 10749, + "rawSHA256": "1E51557748066F4355BC771B9C657A1147527B406E75B1D34ED533954134734F" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-accessSafety.json", + "mode": "100644", + "gitBlob": "04f3c63bbe496b4920747f466bbc183f7b38839d", + "rawBytes": 10722, + "rawSHA256": "68160FDDB776B184889AF48B76AA4B33EEAB4CBA8AF1DEED47599D39DE28D597" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-categoryBounds.json", + "mode": "100644", + "gitBlob": "0999ff7643e2ce1642d4e6d337bea4336b290e71", + "rawBytes": 10738, + "rawSHA256": "48C7EAC3C35F1A141F800D5CDAA83E022211D1F7A4CBCE909141C2869D6A7498" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-categoryPartition.json", + "mode": "100644", + "gitBlob": "2eec79f6e5ea7fe73cfbf15cb47f657e3c13d91b", + "rawBytes": 10762, + "rawSHA256": "4CF07693F65CAD28FA3E0F365B592B7679ABD414CB2ADAAF3D19DDB67E151216" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-completeCapacity.json", + "mode": "100644", + "gitBlob": "723f22b8d1549d688c7f097d25b7c2953faf3019", + "rawBytes": 10753, + "rawSHA256": "794E04DFBADB5742E01D979F9BCF81CC331FB3F8B31B2DE061F62311331E710E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-finiteScratch.json", + "mode": "100644", + "gitBlob": "2f40a4e11f7d1472056e80902025544f4c2852d5", + "rawBytes": 10734, + "rawSHA256": "9A415A1A199E2B557FB73D89313F0ED183D86F3D26DBEA6DADA25CF374716396" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-memoryWordsFit.json", + "mode": "100644", + "gitBlob": "d0306ef35d9e35d279444295f5eccf93caaae4f7", + "rawBytes": 10738, + "rawSHA256": "73C5B67F305F6832828D5D56AE5AA7AFF7222E6CD682D737650FE7F1C9A98916" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-overheadLittleO.json", + "mode": "100644", + "gitBlob": "f85589dea0b5997be9cc2cfadbe716f3761f842e", + "rawBytes": 10669, + "rawSHA256": "CD012E14F23863D28D98CBA4D37B0280151415D2F95C6BEFDAD9DC81F9DBBDDD" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-programLengths.json", + "mode": "100644", + "gitBlob": "eae71c5737b2a18e670b4a481529e165951dd32c", + "rawBytes": 10923, + "rawSHA256": "77746BC59DD7B5C83C44F4F644146CD339C2F380DB080919A7E2302757536E82" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-rankCorrect.json", + "mode": "100644", + "gitBlob": "32ee40a91a50be367557794f029db3edef33ce1c", + "rawBytes": 10714, + "rawSHA256": "88679530B7E56C31E45F03B4F41C07B46A087A9464AEE8236DB8FF8E600AB015" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-rankExecution.json", + "mode": "100644", + "gitBlob": "e99f3ee1317a9c9ce26665823b58e5ab1b7a3909", + "rawBytes": 10733, + "rawSHA256": "08E32AC6411DCE2831C1D8FD1239FBBCB9682101DAE866F79409D5464F0C7E87" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-rankSafety.json", + "mode": "100644", + "gitBlob": "4bed602459efb3c22a68e22424e7ea5045d1a250", + "rawBytes": 10706, + "rawSHA256": "7E7C4D7DB8CD26F3144A7D1D2D8AE5A649EDECC4BD78725F597AAD77B2989A8D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-readerCorrect.json", + "mode": "100644", + "gitBlob": "1137453ade2929421fbb726bc9550b1b3dae2e65", + "rawBytes": 10730, + "rawSHA256": "8AE24729CBB9893B28DAA455C5C251DB4F0A7FDE48C722C302360B1D2243504B" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-readerGeometry.json", + "mode": "100644", + "gitBlob": "6f56ee397d0b78c876c2068280c350df4792e819", + "rawBytes": 10738, + "rawSHA256": "90B282F678A9CE46CCAC42807BDF1D6C987C0AC9941C1E3C28C49B503507B75A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-selectCorrect.json", + "mode": "100644", + "gitBlob": "cbe820781ca4bd64fd0da3d88f299e0a7708f760", + "rawBytes": 10733, + "rawSHA256": "463D8217DD8B67AC7745F09AB30F07DB365372C692EF4F714D87FEB29D40F510" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-selectExecution.json", + "mode": "100644", + "gitBlob": "c7a6e70ece3761f755886a16ef9e45530e04cd80", + "rawBytes": 12034, + "rawSHA256": "FF92B9B1CC91937758A49E7439F2F3FEC5C81438BA8329D084786C0FB6BD0A1F" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-selectSafety.json", + "mode": "100644", + "gitBlob": "597b5956306c25618ea9fdb1e362b6d38ee79adb", + "rawBytes": 10721, + "rawSHA256": "F664D534DC90C38D2DB50BEAB2E245153C9712A8680C0EEB0957E8BF8BA98B2E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-sourceBudgets.json", + "mode": "100644", + "gitBlob": "a673d2fc87b35ebf18f5646bbfb11c4770f5d866", + "rawBytes": 10891, + "rawSHA256": "EC89931815B8C56F1664A23A1633D9A9E6D527858135A28C3E34384AD8D7AE5C" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-stepsBound.json", + "mode": "100644", + "gitBlob": "2ca9ce8af60e6087a42f33ed9cf00f012f263b94", + "rawBytes": 10706, + "rawSHA256": "CD04B1D72BCEED20F8091F9CCAEA3F84A845D05D9443913EF29B66C1291E28A5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-suppliedMemoryAgreement.json", + "mode": "100644", + "gitBlob": "97049f434b95813624a57df9b030501217aec459", + "rawBytes": 10810, + "rawSHA256": "E98F669BBBAD677C3D64DF121410A14AD3354E86D07C86B6473FD0F2FD0FD5BB" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-validArgumentFits.json", + "mode": "100644", + "gitBlob": "106a9729a721ae6041c38cff6e35995eb09b4a08", + "rawBytes": 10756, + "rawSHA256": "6EDA749FE36ECA43ECD022D178F23DAB20CC7BB8951C7CC3ADF7B7FBA4D055D3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-widthBounds.json", + "mode": "100644", + "gitBlob": "64e5936b29664ae5c8bbfc4c5b503b6aadbbecf7", + "rawBytes": 10711, + "rawSHA256": "A1170C4BD6DA3C75AC9CFEDBC866FCFE15C35BC5B5400E64B32C82590FC2C46B" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-valid/summary.json", + "mode": "100644", + "gitBlob": "b731e304e9b9b9e68e89c3df908bc3a44a4173a6", + "rawBytes": 129729, + "rawSHA256": "94D5C1E8678D63E7F3B1FAD31AA829E8DA55B1D70BE433B04A655B32F5470185" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-valid/weaken-accessCorrect.json", + "mode": "100644", + "gitBlob": "e44c1d9d7a9c787dd8424ea5102ac36bec42ebbb", + "rawBytes": 10729, + "rawSHA256": "9B2BAA4802CA6B2138DECEE73043265D5267E37EB83D2FD1CCF420C8CF460654" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507/summary.json", + "mode": "100644", + "gitBlob": "92fbd7ec61c689fa0389690f6b8e2448d35224c9", + "rawBytes": 133847, + "rawSHA256": "176C5D9D041B2791D10F4E635D51DD664367B8A3AC2FA59DAF0D6BD95777420D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/capacity-without-code.json", + "mode": "100644", + "gitBlob": "cbbde7260b2829b8795d5c24e239e4bf459942a8", + "rawBytes": 11174, + "rawSHA256": "789C5A54E7AAF6B957A4A4F76C8AE5637A5F28CAB4EDB49A7016E30459C2D4AA" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/capacity-without-scratch-consumer-campaign-v1-20260912120258157-2c2c1792-omitted-24a73644b0e14a389023d3d989968e6b.bootstrap.ps1", + "mode": "100644", + "gitBlob": "65cd30d465ee4dbd8dbfac2dc91f5273f49fece5", + "rawBytes": 542, + "rawSHA256": "E66C4BE027DE2BFDBE634A0AF46B0CC346B514788014246CA6482BD416F7DFBA" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/capacity-without-scratch-consumer-campaign-v1-20260912120258157-2c2c1792-omitted-24a73644b0e14a389023d3d989968e6b.launch.json", + "mode": "100644", + "gitBlob": "ea4323ee1df72b9ceb4000b057c6ecbe6441fb2e", + "rawBytes": 3478, + "rawSHA256": "6FEEF544985AE20C47FE3AF8B731BA567C0B6FBA825CD47502D287396E7828E8" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/capacity-without-scratch-consumer-campaign-v1-20260912120258157-2c2c1792-omitted-24a73644b0e14a389023d3d989968e6b.release", + "mode": "100644", + "gitBlob": "f73a879c57b3b06728c6e7abdf61ad40308199ee", + "rawBytes": 5, + "rawSHA256": "F5E6D024C05C9CC2746A3E127408B91A8B7A7F2A30DA0C259BC54265502DDEF4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/capacity-without-scratch-consumer-campaign-v1-20260912120258157-2c2c1792-omitted-24a73644b0e14a389023d3d989968e6b.stderr.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/capacity-without-scratch-consumer-campaign-v1-20260912120258157-2c2c1792-omitted-24a73644b0e14a389023d3d989968e6b.stdout.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/delete-accessCorrect.json", + "mode": "100644", + "gitBlob": "1a2ca4f52ba2ce6c472716cd791386a2882f666c", + "rawBytes": 10770, + "rawSHA256": "8AF49B1A6F73CCA7DD9FE7A25AA5016B0382F3C9C577EABE182F60CF2D0645FC" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/harmless-comment.json", + "mode": "100644", + "gitBlob": "81bc342e99dd56652b3bdd7eaeb447a608e3d119", + "rawBytes": 9306, + "rawSHA256": "7744F7B3D1706DDEDB49A5E0A4FEB775CC13F68138CA306F943F1FE80B30F6C5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/public-proposition-True.json", + "mode": "100644", + "gitBlob": "f3f2650747031c8f83f68835582f8237f6e260ae", + "rawBytes": 10564, + "rawSHA256": "3C36B10B05DB79B8AA7B356647D32B926701D57BBF3DE07AC16D06BAE8BCCA18" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/sibling-completeCapacity.json", + "mode": "100644", + "gitBlob": "227673fe279fb4b37ccdd862ba34b975120018e7", + "rawBytes": 2328, + "rawSHA256": "20F74544602ACC3C307D92328B6E4AEA04AABD19A2463660144D7E0397E83E98" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/sibling-readerCorrect.json", + "mode": "100644", + "gitBlob": "a3ee8c754f6468a2a30f9e8a47f61f6e4e285845", + "rawBytes": 12060, + "rawSHA256": "1CBA0C3D18735BC4782E8808A4D072FFAD26B1CDA269D6CC6D570299A6707F71" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/sibling-selectSafety.json", + "mode": "100644", + "gitBlob": "4b62c3701e785bb68a5e5590c368feba321042f5", + "rawBytes": 15300, + "rawSHA256": "680BBE2DEF3A5C5372030BC53DDF1B4C251374B45BB895552202199A323460FF" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/unchanged.json", + "mode": "100644", + "gitBlob": "388c21f7f456c0230c248ddf97e483f5dbab901f", + "rawBytes": 9286, + "rawSHA256": "79C71F7421481F6C61F68AFA5100E737DA6E65D55E92F655C70E21CE7A090802" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-accessCorrect.json", + "mode": "100644", + "gitBlob": "a00abc70f2d25f41850389c86b1b9c3ae9c8bbb9", + "rawBytes": 10721, + "rawSHA256": "13025C57DD6EE46504D49A0A2283367AD4F304C610FFD49016BA2E16B970317B" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-accessExecution.json", + "mode": "100644", + "gitBlob": "a058c6244868520a6916822692ae06187b496a9d", + "rawBytes": 10738, + "rawSHA256": "B25E70B2E168089CCABF71F04757A049A7019209F06A9126A8426D0BB7C9EA94" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-accessSafety.json", + "mode": "100644", + "gitBlob": "9c3540c2019b0c658d78fa2ae3f2ae9c9143a6e0", + "rawBytes": 10711, + "rawSHA256": "258010DCB6CE2F2D8D983B642B51A41D6DA2986AAEE12F5C535FF2C30C3957CF" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-categoryBounds.json", + "mode": "100644", + "gitBlob": "48cba7ccb6e57856bbf7449352868f0a8d650f39", + "rawBytes": 10727, + "rawSHA256": "FD90787AE8D0DE8E9B1C836AC210CFC2DD7EAB82EFE5188B3B88D4F836593C6F" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-categoryPartition.json", + "mode": "100644", + "gitBlob": "0d13effc909e2196b6394214ebec3a6b4445cdcd", + "rawBytes": 10751, + "rawSHA256": "129CFB8C2344698E73CD40935F5C931F183FA336301E4BD033149C83A0E67336" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-completeCapacity.json", + "mode": "100644", + "gitBlob": "787d8e82812e81d788fbe7d15bfeb3d2e275dc2b", + "rawBytes": 10742, + "rawSHA256": "02CACF411343EE091F420E0E931568418AD0DB2519725AA172B2223392181826" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-finiteScratch.json", + "mode": "100644", + "gitBlob": "fdbd4ac263667cd522462cd96ca7d04b0f283940", + "rawBytes": 10723, + "rawSHA256": "3332311A14A2EF97437D73CDAB65B5EAC3A1CD07A3DB30DDB624EFD248324D9D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-memoryWordsFit.json", + "mode": "100644", + "gitBlob": "d4e74782793f0fbf310a7576d1f9c677d1b82f73", + "rawBytes": 10725, + "rawSHA256": "B9AE7DD4117F19804AD90558AAE64698D7369EA78EFA13E10B4F9506965A6E09" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-overheadLittleO.json", + "mode": "100644", + "gitBlob": "2586967d1fbe6c78507d5f2b9862644fe85d96d0", + "rawBytes": 10659, + "rawSHA256": "3004A5A5CC8D091C9247C9DB9ED1B715DC5C8ABC029BBE0B51B2A11E4D7347BE" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-programLengths.json", + "mode": "100644", + "gitBlob": "5dbf80d439ab7eb312a9796fc6e37869df318722", + "rawBytes": 10910, + "rawSHA256": "C1BDC511045C38BCAE793AD44ABAB09A81B27AE8B9C4F63E6DA07F5BE735768B" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-rankCorrect.json", + "mode": "100644", + "gitBlob": "f3756c6e61fb994bc205c0a6f6cc22e4558f9905", + "rawBytes": 10703, + "rawSHA256": "24DE8525CBFC2D2117DA6CD3D0D26E71C66BA7A160655C8ABAFC43BAF62189D3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-rankExecution.json", + "mode": "100644", + "gitBlob": "639e20cd1778014d5a3469d3b1c24c8a494b4428", + "rawBytes": 10722, + "rawSHA256": "0BC449A586B4D0D522D67BFC732C5A7C71954709E6E9D82201DB2D1F86396542" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-rankSafety.json", + "mode": "100644", + "gitBlob": "8f04c2f9033b8a8fc419bbaf3ebca677f3908638", + "rawBytes": 10695, + "rawSHA256": "52A8B89B236A96AF2843501D72E9BE2D8B6733FFA2F68CECFA384B0229359DC2" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-readerCorrect.json", + "mode": "100644", + "gitBlob": "f1dd91808320a4cc1fe9d74f4d282ab2c0430ed3", + "rawBytes": 10718, + "rawSHA256": "21C099880974B57EAE5F2394B1C633FB2309284EB101E7E7B9B1222AE59DA390" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-readerGeometry.json", + "mode": "100644", + "gitBlob": "2ea64297448ef7ad08aff09ee6f6d94a35b8cf4d", + "rawBytes": 10727, + "rawSHA256": "16F295E4F066B2F7B94FB5227359E028FE008769550A0FC94D69CCB885D7B1F9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-selectCorrect.json", + "mode": "100644", + "gitBlob": "8ea8525625944015792eb859fca125ee583c079f", + "rawBytes": 10721, + "rawSHA256": "96B5B4C1BFF269CB3ABC64E5B2519393D3E63FDC82575CCFBB95D63F0551FAAE" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-selectExecution.json", + "mode": "100644", + "gitBlob": "98f5951fd20e7c8c93dbed8a8b74e7f83603a02e", + "rawBytes": 12022, + "rawSHA256": "275A26EF8ABC4F81EB2C8A50FFA9C0599E830AA3F0B3CC2D616E001E7AEED482" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-selectSafety.json", + "mode": "100644", + "gitBlob": "33cd18ee693ad0852769e062f945687d69b20083", + "rawBytes": 10710, + "rawSHA256": "13BD295EF3584CCE4128DDADB803DECE9773C1B900C7AB35C332FBDA12C1B50D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-sourceBudgets.json", + "mode": "100644", + "gitBlob": "18193e7e32db1879245df40d8aea036b23fba010", + "rawBytes": 10880, + "rawSHA256": "58FED9ED5E1A7BF453E0EBCB9B9CED144ADD0AAED0D04E28416FC6EB8E7D7B8E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-stepsBound.json", + "mode": "100644", + "gitBlob": "c31455461e1281ffca216d55a324a8d64bd05f00", + "rawBytes": 10695, + "rawSHA256": "0CCAA2071E9A6F35E5A9CEE0329CAF8A0B89151C3FE66B3EDEFCB6ABF0B89A55" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-suppliedMemoryAgreement.json", + "mode": "100644", + "gitBlob": "2f16341d6636e6302820e48452461c1419e69329", + "rawBytes": 10799, + "rawSHA256": "081D4D07D9D824E88A7397A41386E077DCCB4D7680D269701542E31686FCABC1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-validArgumentFits.json", + "mode": "100644", + "gitBlob": "eaea1f9510c3a73f271ed4cb7dbdb66f92294ef5", + "rawBytes": 10745, + "rawSHA256": "E5EA6A139E8E65CF1443ACF518620FC3261BD5BB5CADB6BF644BDAE29D452DC0" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-widthBounds.json", + "mode": "100644", + "gitBlob": "f45f4e678b1b9206e378cd4866b5db1b54f6701c", + "rawBytes": 10700, + "rawSHA256": "DF2C85E9847FB837581B75F8C21BA0A5D8833CC1F8DEF8EE310E9409454D0B95" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-valid/summary.json", + "mode": "100644", + "gitBlob": "2ffb0e12a2ca0341f36b47594355260fdd9cb973", + "rawBytes": 127528, + "rawSHA256": "1991B66202A780E3ABBC9D448CFEEBA73044EFAA90D380260C30249BECE3C4F5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-valid/weaken-accessCorrect.json", + "mode": "100644", + "gitBlob": "0538e72c7e07398a77c2eeebbf8a3a529cfba522", + "rawBytes": 10718, + "rawSHA256": "D4A15477F5272D8BC8EBCB448A5BC8F20A1B423BEE4ECFD8CCBDEF20EB856C27" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792/summary.json", + "mode": "100644", + "gitBlob": "379ffb578e61622ae49c527c0e1febdcfaed9898", + "rawBytes": 129539, + "rawSHA256": "65546AE004A15E5B09DB583E169803A5C22C5E83A5C927AC5217A9CA6F40C1EC" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-known-r2.json", + "mode": "100644", + "gitBlob": "d9ed7f55ec062eb95e127b8904c7a3d5b79dfdda", + "rawBytes": 2603, + "rawSHA256": "9ED285C82152C828016BF095A9DD4A70C1B2BF7DAC2AC64CA28F8EC4311514A0" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-selectors-r15.json", + "mode": "100644", + "gitBlob": "8511e12e527776d5e307b7801a3008664f1d5ca2", + "rawBytes": 3143, + "rawSHA256": "648BFEF62D26C2F97765785319F28DB321CB289FA5F31F4E9613BDEE81035695" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-selectors-r3.json", + "mode": "100644", + "gitBlob": "8e43515ee8d64797e97494a14c1d8bdfdd55be16", + "rawBytes": 3134, + "rawSHA256": "15E9CCEAA5BD9B7A6B7A69678C9012DA4B9E57CC5779108DCD376EDFBBE9C46F" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-sibling-capacity-r14.json", + "mode": "100644", + "gitBlob": "6f67aa1383cec65624ac2dec8e2fd72e0730b47b", + "rawBytes": 2640, + "rawSHA256": "88405A9141EDF748F43D970A1828E85B206799DE80DB95763D6DB20788A86D3D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-startup-r1.json", + "mode": "100644", + "gitBlob": "fe77d19cf780fec4b8996c69163a517f28ea88d3", + "rawBytes": 2665, + "rawSHA256": "68937007517CF24122EA01B03B750A4F324D05AF256C426432BB6167AE856FE9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-startup-r11.json", + "mode": "100644", + "gitBlob": "d1fca654e1690313398791263ad1db20d6e485d8", + "rawBytes": 2646, + "rawSHA256": "08CD3BA113D91285C3326B0A3406ECE175C590FAC6353EFA58064F044A8E2C60" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-startup-r7.json", + "mode": "100644", + "gitBlob": "9610db1cade9d6e7f5ec5eb7a34bf145f0eb7afb", + "rawBytes": 2627, + "rawSHA256": "E6630325A65107E4C596406E25E09691137BE3D5F7FC7EA49AD2E949A2BDB56E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-startup-r8.json", + "mode": "100644", + "gitBlob": "1ba1c152eeb132e52b0cacec19cb15ff4dbce833", + "rawBytes": 2723, + "rawSHA256": "45327F4CE0E73A92E505994CD11B5151A9915B8F407EBC4EB84F9D45480EB309" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-without-code-r12.json", + "mode": "100644", + "gitBlob": "a49d079340ee622610b48a5f5a3b4de3a40f4278", + "rawBytes": 2615, + "rawSHA256": "1AF88927E2370B4ABC688E7E90E95E6F2D7703289AFEB66B601F594796EAD6CD" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-without-code-r9.json", + "mode": "100644", + "gitBlob": "b4d9a71d670b98d1626cd51c374db51a5d78b930", + "rawBytes": 2601, + "rawSHA256": "871C0C21BEF28913B224439C83F4719AF7F0DF23892B7C2C4050806C0A40194F" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-without-scratch-r13.json", + "mode": "100644", + "gitBlob": "fa4c7a4375e5f5b893d8a5d3e0597c1363bc55de", + "rawBytes": 2636, + "rawSHA256": "78AC9D40B1ED9D1EF03303914EA60E7095DBE6D030E2DED4E0F4369598E56D98" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/final-static-r16.json", + "mode": "100644", + "gitBlob": "33e20f4d8d406825b27320e11161799f8b3135bf", + "rawBytes": 118993, + "rawSHA256": "3A6B5CADD17A7F4FE7BB7D0D263C33D34A4B8BA10C79290BFB54E2DC902B6180" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/first-campaign-multiline-axioms-r6.json", + "mode": "100644", + "gitBlob": "b0b6d550022c52c22f1ea6e5169266be9b4b65e9", + "rawBytes": 23080, + "rawSHA256": "027B1C9613213338E7F53E55A20B5DDCC6626E0D1A1BB3D2D1DACAED8C92D06F" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/known-v1-20260912120122614-27f1d4e3/summary.json", + "mode": "100644", + "gitBlob": "31c650ab7fc0e9684dd6649ef46b5ef9d26dae66", + "rawBytes": 126194, + "rawSHA256": "9DB603032EE96EE9C5D97C6B18DA8A36A9D364E7E896148466D3794D1CF64494" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/known-v1-20260912120122614-27f1d4e3/weaken-accessCorrect.json", + "mode": "100644", + "gitBlob": "76e1b0ee799eb8310b045ea3feca468312e32cff", + "rawBytes": 10699, + "rawSHA256": "9803BD6D4745FB61BA011FB59E20AD4DD83292EADF65F2BDBF7A7D5667B8397D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/preparation-r11-allocation-boundary.json", + "mode": "100644", + "gitBlob": "3ab6d6bad926948de1f8dc971f88ffd1f519f9ce", + "rawBytes": 21268, + "rawSHA256": "B116B00C7E8D02CA6C7750D0B0388CE1EF81353CDD6AB9466AD316BBAC864300" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/preparation-r5-amendments.json", + "mode": "100644", + "gitBlob": "c2ef2cf5dab6035ca8d3d28536cf15b0357e3d69", + "rawBytes": 28070, + "rawSHA256": "9684D50BF35829AA05FFCA39B9DB919CAAAB7E6BCDB7B863C5B847F1829CC856" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/preparation-r8-local-scope.json", + "mode": "100644", + "gitBlob": "f8a7c4d54cf21c7e16356ee885fc7893df24e81c", + "rawBytes": 21010, + "rawSHA256": "EE178EA4B25ED69052CF5E02211EE90054F2E02BBE42347E71DB8D11B44C29A3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/reduction-diagnostic-r10.json", + "mode": "100644", + "gitBlob": "1fe752a4e85fc95da288bc5a1c5175c15969971b", + "rawBytes": 40618, + "rawSHA256": "3ABCCBF66562F75B0649B86519353ACC317CC4405051B269A6DFDF09CBD23FEB" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/sibling-capacity-bounded-v1-20260912131232993-0dae1d73/sibling-completeCapacity.json", + "mode": "100644", + "gitBlob": "3017fed25154289a0805b5d52415c0933bb9f987", + "rawBytes": 12437, + "rawSHA256": "7FA9ED78DAF87DBFA065AA82F089CFBF2563FE90F1EEF664D3301E3425F2C7DE" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/sibling-capacity-bounded-v1-20260912131232993-0dae1d73/summary.json", + "mode": "100644", + "gitBlob": "815a2d74e4a4e2fbea66fafa9c3f6cc23a5894b3", + "rawBytes": 131425, + "rawSHA256": "9AF7A77855DF07179D3A9899388EECACDA58DCEE1F78DDF193EF9B3ED6F97FD3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/startup-bounded-v1-20260912131112382-16de550c/summary.json", + "mode": "100644", + "gitBlob": "1ed4dfdb3311da946164df0d379c7e08952b540a", + "rawBytes": 128047, + "rawSHA256": "C34A27BB72B9FE87D646CC539FCC75140392CFD64EDFAB6852C7E778957437EC" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/startup-bounded-v1-20260912131112382-16de550c/unchanged.json", + "mode": "100644", + "gitBlob": "0057136fe38fe983785e13a7f29150f2fef32360", + "rawBytes": 9284, + "rawSHA256": "CFD77BACBCB8304D1F814C8E4D3C61749737619EDF706F539E48537CE933D94A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/startup-fixed-v1-20260912130326593-5ae12815/summary.json", + "mode": "100644", + "gitBlob": "e484502dccb4ff6891d04488c9cb61f6d1b81ead", + "rawBytes": 120137, + "rawSHA256": "140A2DCEAC22BE786F125B87BDA9C5DDB5FC70E808735394568F1F1FC4DAC964" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/startup-fixed-v1-20260912130326593-5ae12815/unchanged.json", + "mode": "100644", + "gitBlob": "2e0071e1b17f0bfe76c0dfeb3149ad844274d30e", + "rawBytes": 1999, + "rawSHA256": "7A384C2680324D69C5F8BAFD967BF878B9812216710C5059FC21451E02E99B6E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/startup-local-v1-20260912130542938-da84d62a/summary.json", + "mode": "100644", + "gitBlob": "0e7dce1534075b00ece9923ffe495056f2205036", + "rawBytes": 128041, + "rawSHA256": "9CB2EC431BFE07917529597F2A951CB612D4ACEB1507E9EC245EFC1AFC895EC5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/startup-local-v1-20260912130542938-da84d62a/unchanged.json", + "mode": "100644", + "gitBlob": "d33d971baa69029797936ab5e49144f0593cfb9b", + "rawBytes": 9280, + "rawSHA256": "AFAB159AC4C59F2F9A31715C5762BB7EAE420E9B0F0941263FEAA71DF49090E1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/startup-v1-20260912115946824-c5633795/summary.json", + "mode": "100644", + "gitBlob": "2c860e6280e1151731e21bffb48620a24759900a", + "rawBytes": 124581, + "rawSHA256": "31F1115F7ED0F4AE460ACED3DC3E7D12D46D0D24060361B33B612BF1E5AED027" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/startup-v1-20260912115946824-c5633795/unchanged.json", + "mode": "100644", + "gitBlob": "a0236bcce9afedd6b6148c7aec5390de9e416c08", + "rawBytes": 9268, + "rawSHA256": "E8BBAFE43C54802F8564204AE1186A615BBBE00ACA39498FEBD2325461782BF6" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/without-code-bounded-v1-20260912131141013-c315be77/capacity-without-code.json", + "mode": "100644", + "gitBlob": "0b4f3a341de5b514131b4ed111ed2ecc00fa063f", + "rawBytes": 11741, + "rawSHA256": "CEA9E5FE376C2A5C79699FADA5A17BA54AB8DF89652B0A71A02638064AC30CA5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/without-code-bounded-v1-20260912131141013-c315be77/summary.json", + "mode": "100644", + "gitBlob": "3dda8fe68487ea6f32fa99665d772a9e8128e87d", + "rawBytes": 130679, + "rawSHA256": "4BBF4D3C1E7E863574691CEC3A8031034C01D4C642E1AFD09EF0B32746874E2E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/without-code-v1-20260912130638654-f62ec813/capacity-without-code.json", + "mode": "100644", + "gitBlob": "3a7b97ddc2961100ccd73a47d6e027df86745e6f", + "rawBytes": 11164, + "rawSHA256": "776C35AFD301F51C3F46641E0ADB319EA220D4F9F42DF2625EF8DF219D2C9630" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/without-code-v1-20260912130638654-f62ec813/summary.json", + "mode": "100644", + "gitBlob": "fda7e3f0f49661dcce22566ff9739a350d6b33b5", + "rawBytes": 130011, + "rawSHA256": "4A5B4F30C3E2B83F71395407B5D962E87F3F181DD2F69E9D13F72AA80B794035" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/without-scratch-bounded-v1-20260912131205253-a3c06263/capacity-without-scratch.json", + "mode": "100644", + "gitBlob": "dcf1ea6c6512a0b3b76b49ad00f2ff1ffcdb1eb8", + "rawBytes": 12299, + "rawSHA256": "897C3B948E05A28EACDE75F7FD7EC9B4336321A51651752583B317586A5E0032" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/without-scratch-bounded-v1-20260912131205253-a3c06263/summary.json", + "mode": "100644", + "gitBlob": "04269d84a46491eb63dcd9a095fe7e6e27cb41e7", + "rawBytes": 131270, + "rawSHA256": "D4490C8903753A59FE1FBB54E2E0F25B7A932BA26C43623D34DB135B40F106B5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/write-scope-freeze-r17.json", + "mode": "100644", + "gitBlob": "ee478c7c27cf9996a4d67bda7eefb508b1c1cc86", + "rawBytes": 103609, + "rawSHA256": "D9100B6EE635781917FA551189F764FA66D999664E33A134FF19B0560E8F5D73" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/registry-v1.json", + "mode": "100644", + "gitBlob": "60b2170865b060b909e44fdad0c18975e71c3c71", + "rawBytes": 194, + "rawSHA256": "546ED02ED97227C269C4649C0B75C5A7337B9D40DE6ADA14CBBE2546AD79FEEB" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/snapshots/97405C70ED3B60CED72874D6DF622D2E9BBA0BD8F04808A3F98ED34EE1CEB770/Capstone.lean", + "mode": "100644", + "gitBlob": "8184759bbac7eb8b54cfe5acea62c9b86cb8211b", + "rawBytes": 11412, + "rawSHA256": "1C6CD0A85B77FBA7706C77DA87DE358808A24FA661D5635A3C4B3BBF96005D69" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/snapshots/97405C70ED3B60CED72874D6DF622D2E9BBA0BD8F04808A3F98ED34EE1CEB770/public_expected_type.lean", + "mode": "100644", + "gitBlob": "77799af6f8a981de81e5e91e85929247d66013c8", + "rawBytes": 13417, + "rawSHA256": "FEA8D045EF0A9CB9679949ED8825F2E04A4542C01E8F056A778BB0B474BF7A9E" + }, + { + "path": "docs/internal/extensions/bv1/controls/route_v1_probe.ps1", + "mode": "100644", + "gitBlob": "56b10b0c192073009fd4a98c265e4fb3cc340568", + "rawBytes": 1693, + "rawSHA256": "8C3D92D057026636386BCD075886C54E9D034C6E2322F8C7290244B1934F4D38" + }, + { + "path": "docs/internal/extensions/bv1/controls/route_v1_selector_controls.ps1", + "mode": "100644", + "gitBlob": "33778f78952730c95cc0148f81a8fc070652b431", + "rawBytes": 3190, + "rawSHA256": "D676AC5F587F3EECC0A15B75CCBB0E76B729DD531E7E6A72EAF1FFCB3F0E1228" + }, + { + "path": "docs/internal/extensions/bv1/controls/route_v1_validator.lean", + "mode": "100644", + "gitBlob": "727ff397c3c56a97e4235322fffa310ec3fbe177", + "rawBytes": 4441, + "rawSHA256": "A36ACF5EDF0750D2F5F01BCCE931B2104310E68AEFEB4F7A6BBE6CEBEA30ACA3" + }, + { + "path": "docs/internal/extensions/bv1/controls/validation_v2/baseline.lean", + "mode": "100644", + "gitBlob": "702061d81a8595ad940019bb5ec572e768eb78e7", + "rawBytes": 9387, + "rawSHA256": "333B0A6BD8FB3082051845D2F1BD333668B9D33758A9030A68B25695CFEE068E" + }, + { + "path": "docs/internal/extensions/bv1/controls/validation_v2/registry.json", + "mode": "100644", + "gitBlob": "eb7884ee4e29c206f40644ecea1c336e565ef92f", + "rawBytes": 3204, + "rawSHA256": "BA82633FC1D6647A294C150DC20A21159C64635A08FFD5CBA5B3C16464B64CDF" + }, + { + "path": "docs/internal/extensions/bv1/controls/validation_v2/removed_fixture.lean", + "mode": "100644", + "gitBlob": "36bc541d427a58eefc583cf2c029bb7caad7d16c", + "rawBytes": 9306, + "rawSHA256": "1F2241088DD172B38673AA376F291400C5B68DB319545A3C465B78E971875BB2" + }, + { + "path": "docs/internal/extensions/bv1/controls/validation_v2/restored.lean", + "mode": "100644", + "gitBlob": "702061d81a8595ad940019bb5ec572e768eb78e7", + "rawBytes": 9387, + "rawSHA256": "333B0A6BD8FB3082051845D2F1BD333668B9D33758A9030A68B25695CFEE068E" + }, + { + "path": "docs/internal/extensions/bv1/controls/validation_v2/wrong_crossing.lean", + "mode": "100644", + "gitBlob": "6eb488621eac8ac4e5306b30c8b08fae9af443c0", + "rawBytes": 9387, + "rawSHA256": "6B9484013683BFA4E6C0F46800582BFEDE057BA8661273DCACA5BB8453D06D14" + }, + { + "path": "docs/internal/extensions/bv1/controls/validation_v2/wrong_packet.lean", + "mode": "100644", + "gitBlob": "1d0478d02f82624fd652cb8664ba32a339980e1a", + "rawBytes": 9391, + "rawSHA256": "4895B39F548A5C434D173288346A59D812D996F5A2A1D31D1CC0E7FBACF478A1" + }, + { + "path": "docs/internal/extensions/bv1/freeze_contract.ps1", + "mode": "100644", + "gitBlob": "4c5f2997143f1746d914ba3f12c29f8b4ad2019f", + "rawBytes": 11973, + "rawSHA256": "930F16AF7C38DAC2198F9F894F6BA96AAD4B9153FDC02205F2196CC646EA9F45" + }, + { + "path": "docs/internal/extensions/bv1/run_command.ps1", + "mode": "100644", + "gitBlob": "f2b6b69b8339224d2b8787df23bbf404a2686248", + "rawBytes": 2193, + "rawSHA256": "BD1B93838AAFFDF67BF06BF5E613B208E0944F55027DEDD223B36CCE483099F7" + }, + { + "path": "docs/internal/extensions/bv1/run_final_gate.ps1", + "mode": "100644", + "gitBlob": "d87947b32f3b08432f06afc221fc9c22ea14ddfe", + "rawBytes": 6837, + "rawSHA256": "3C7B8F56F96406CC170FE80E135B0CBBD8C6109F0A6EB27D5A9D24F6BEF34EA3" + }, + { + "path": "docs/internal/extensions/bv1/verify_phase.ps1", + "mode": "100644", + "gitBlob": "c688d094e5f873da2cd73c7f8b389ea3c7d9ecc9", + "rawBytes": 3629, + "rawSHA256": "0727C072E20B50CDDCD983D7CAAB56ECA84B906A5EDEA2EB242835A88FAA4AFE" + }, + { + "path": "docs/internal/extensions/lb1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "0ef956c9d6922a94e55b5afed2d2b3e8e768aeb5", + "rawBytes": 18465, + "rawSHA256": "21D7970E80844C07B6E87AB0CA78B3A792B624B11E1F0EE1D975DDF8C5578C95" + }, + { + "path": "docs/internal/extensions/lb1/AUDIT_D6_INCONCLUSIVE.md", + "mode": "100644", + "gitBlob": "7d843c28c6796e6b288cdb3d3ae501330a264375", + "rawBytes": 997, + "rawSHA256": "45C5125FF020E050E05496B3BC061C2F8C0C92228BFF4A80BECDDC894470A773" + }, + { + "path": "docs/internal/extensions/lb1/AUDIT_PROMPT_DRAFT.md", + "mode": "100644", + "gitBlob": "1b5253bffe86d67bd3a0af2f1cdef3f76d1d9630", + "rawBytes": 30280, + "rawSHA256": "C747B0B3D423EBA89FA80416627F8DAC31F4B03DC690D9AFB29B7986E6943547" + }, + { + "path": "docs/internal/extensions/lb1/CONTRACT.md", + "mode": "100644", + "gitBlob": "49c4763d142d277a282aebd510f8ba55b9ecf912", + "rawBytes": 6963, + "rawSHA256": "C37A1604C4D9A73B4E8B9BA336ED7F8138BDA9DCC14C9CE4709EBCD51F253DC1" + }, + { + "path": "docs/internal/extensions/lb1/CONTRACT_REVIEW.md", + "mode": "100644", + "gitBlob": "cad3efd2edaf3cbe1c9b432913e9b2cf48148c18", + "rawBytes": 14550, + "rawSHA256": "4521F23D2295ABC87CF7DC4735C486C8AAFF125F064CD07A973F0BC9C02AFDA2" + }, + { + "path": "docs/internal/extensions/lb1/COUNT_PROOF_NOTES.md", + "mode": "100644", + "gitBlob": "4f5e5c140d9b76ed6f942dde039931a041b8ed26", + "rawBytes": 22524, + "rawSHA256": "1684DD3DAD857808BA959E74FDA1F607B55D287069B3D094BEB05E6EFF794452" + }, + { + "path": "docs/internal/extensions/lb1/EVIDENCE_PLAN.md", + "mode": "100644", + "gitBlob": "1d1553ef9d3ac463fca963d0a4e46555777577da", + "rawBytes": 13426, + "rawSHA256": "BB85EBC1AFFCE213A3AEC70695E64D6B27C3D62BFAC5B79AE29F7CA67167A8F9" + }, + { + "path": "docs/internal/extensions/lb1/FINAL_AUDIT.md", + "mode": "100644", + "gitBlob": "ecccf970b8ef207dafa9982f73251254cf1069fd", + "rawBytes": 60590, + "rawSHA256": "7F26751CB14DFB9C345BC13DC374C1F4D6AA8CC0E8677D3B7FECD236A6726778" + }, + { + "path": "docs/internal/extensions/lb1/FINAL_DISPOSITION.md", + "mode": "100644", + "gitBlob": "05f0547a0acf7f9bef43538dafc8cde77d07d0e8", + "rawBytes": 9723, + "rawSHA256": "307BEF03AA8179AE71CC2C79F7CC4EF211C902BE34FFA369DE16FBB49D52D967" + }, + { + "path": "docs/internal/extensions/lb1/FROZEN_INVARIANTS.md", + "mode": "100644", + "gitBlob": "bccbdf3e2b7663f219e67f7aae50ed7404c012fb", + "rawBytes": 5172, + "rawSHA256": "DBA3E9A832430B6B77AF233694591E3F3351B8D0F8F0E1089A742E069983AF8C" + }, + { + "path": "docs/internal/extensions/lb1/FROZEN_REQUIREMENTS.md", + "mode": "100644", + "gitBlob": "a13021ea8fca97b96179bad0f42536bb3952d91f", + "rawBytes": 2903, + "rawSHA256": "C6973439FB2F915F47CC0D641F33FA1F4F9844260B3D2A42DC4C5D41BAF9A7D1" + }, + { + "path": "docs/internal/extensions/lb1/FROZEN_ROW_EVIDENCE.md", + "mode": "100644", + "gitBlob": "28b9090a802856577550ffbc225837a78380e36c", + "rawBytes": 9483, + "rawSHA256": "AD164B668CBEB805019C4368F3564D5FF5E182B2B09ECE89DCD84200FD527F71" + }, + { + "path": "docs/internal/extensions/lb1/PACKED_PROOF_NOTES.md", + "mode": "100644", + "gitBlob": "c5e0c4ad01837b420881a75837b8f6d22e3a4e25", + "rawBytes": 9778, + "rawSHA256": "87699ACC658F305232E9ED45054A203BE4CAA80EB18B20736EC28AA8628358A3" + }, + { + "path": "docs/internal/extensions/lb1/REPLAY_REGISTRY.json", + "mode": "100644", + "gitBlob": "16adc302887bb2d13b8388af8463b6328a604acf", + "rawBytes": 10844, + "rawSHA256": "9015398F8F1AEE8AF69C21294B2437B68FC77DF70006B69EDD2A593878D07E8B" + }, + { + "path": "docs/internal/extensions/lb1/REPLAY_REVIEW.md", + "mode": "100644", + "gitBlob": "92c165edc90b806d0115204616408d514836e8eb", + "rawBytes": 7818, + "rawSHA256": "97C9E31D32B6BD801166EE4DD340BFDE62CEB7CDF622655D2D5C92BBB0D71212" + }, + { + "path": "docs/internal/extensions/lb1/REPORT.md", + "mode": "100644", + "gitBlob": "8b939ff059a658aef8742b97322ffdf21f954a1d", + "rawBytes": 15415, + "rawSHA256": "0669030286C33C1C2C272A6D3E02313F41BC0F0A0B18E39FD108FB10468460D9" + }, + { + "path": "docs/internal/extensions/lb1/SOURCE_RISK_REVIEW.md", + "mode": "100644", + "gitBlob": "fa24eaf9364f3770d5ff463aa43c042f396e5d5e", + "rawBytes": 25192, + "rawSHA256": "EBD0EF82D236FE465EB246B5835F8DF117B76EB43227D17F5CE5A0398B4460D5" + }, + { + "path": "docs/internal/extensions/lb1/VERIFICATION_LEDGER.md", + "mode": "100644", + "gitBlob": "9833d8aa5a5c5a732880a64b19ffda35944bac55", + "rawBytes": 12914, + "rawSHA256": "672F419DA9469F6A88528CE56B262F9DB2DC43C8EDDB057C397B1851F1E9B4B3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/REPLAY_REGISTRY_v1.json", + "mode": "100644", + "gitBlob": "6f97ed70ae35fd0cc49a9cead0425172e6055b30", + "rawBytes": 9654, + "rawSHA256": "C8228678C188C14BF579EE1DB2876A0D511010EDA539D1404CDFDCAF38BBF0B8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/REPLAY_REGISTRY_v2.json", + "mode": "100644", + "gitBlob": "4257558f7bd807148fb87a4a56aa94ba68e493f8", + "rawBytes": 10691, + "rawSHA256": "C31CF089904CF1B377C53F19109CB756DBBC969DCDD6A95B7D92ABB4899B86CE" + }, + { + "path": "docs/internal/extensions/lb1/evidence/S03SamePredicateDiagnostic.json", + "mode": "100644", + "gitBlob": "f3f65cfa14d97b561c89d90b84954bbc3bec2082", + "rawBytes": 1198, + "rawSHA256": "DBB395EDF0E0413EC63FEC7C91F8E0AEE3CD2BB7B8020712B15A88D408AED04A" + }, + { + "path": "docs/internal/extensions/lb1/evidence/S03SamePredicateDiagnostic.lean", + "mode": "100644", + "gitBlob": "47bc35beaed406ecdadfa427e531f3511ed88e1e", + "rawBytes": 885, + "rawSHA256": "3748714FC508B7DB57FB97F95DD871AC218E70B1EA7150CCAF29FE8C3D778C72" + }, + { + "path": "docs/internal/extensions/lb1/evidence/audit-launch-5033/AUDIT_PROMPT_READY.md", + "mode": "100644", + "gitBlob": "70514bf71f0262d096e3d6686bccf946234c731a", + "rawBytes": 32925, + "rawSHA256": "63B4119CBA8797D2CD8B8A319ABBE14FA9FEC9F157311C634A52682A9BF91767" + }, + { + "path": "docs/internal/extensions/lb1/evidence/audit-launch-5033/baseline-runtime-manifest.json", + "mode": "100644", + "gitBlob": "1ca9fac057d5fe8ef47a64e9cb9adf368139617e", + "rawBytes": 5761, + "rawSHA256": "4FF2AD65D48A36B95C6BF5B419FBE18C555E2E4FB055101F8A56CE62CAA77B10" + }, + { + "path": "docs/internal/extensions/lb1/evidence/audit-launch-5033/delivered-evidence-manifest.json", + "mode": "100644", + "gitBlob": "f58c2bae496148fc5a4cbb855079fd3a9fe87cd7", + "rawBytes": 6369, + "rawSHA256": "3C8459BED9B99A4DEF74CB8970F4C5038629F46B1A9B79922A6F902423BDEE7D" + }, + { + "path": "docs/internal/extensions/lb1/evidence/audit-launch-5033/full-replay-manifest.json", + "mode": "100644", + "gitBlob": "906031c67dcb62eb907a24c238cea76ea784db61", + "rawBytes": 59582, + "rawSHA256": "BC23837A1B04C1714FB8CEF1E09BE14F456306419687EBCED8CA49728048AE30" + }, + { + "path": "docs/internal/extensions/lb1/evidence/audit-launch-5033/immutable-source-manifest.json", + "mode": "100644", + "gitBlob": "0804feb17143180d33dace91ad70d3d8216081bc", + "rawBytes": 283557, + "rawSHA256": "046E16AA91D82722BAA39AF0F5BF3CF949811757430E85A5372289176E366549" + }, + { + "path": "docs/internal/extensions/lb1/evidence/audit-launch-5033/launch-receipt.json", + "mode": "100644", + "gitBlob": "cebd0f6b667ca07fe1346c041bc1db9d850e77ba", + "rawBytes": 2386, + "rawSHA256": "6AE98C59D886E70E825EDFF8019FDC54297443D5A5FF2FD463730460847732E0" + }, + { + "path": "docs/internal/extensions/lb1/evidence/audit-report-receipt.json", + "mode": "100644", + "gitBlob": "fdc5c0201a26b7907765d291a774ecab949a5e0f", + "rawBytes": 725, + "rawSHA256": "211FB39287488676C2564E48F8A0FBD7048AEC31BC42E5E81A2B3B6C105902FB" + }, + { + "path": "docs/internal/extensions/lb1/evidence/axiom-inventory-development.json", + "mode": "100644", + "gitBlob": "07c09497629f93241a82bc1aaabdc1946c048ed3", + "rawBytes": 6151, + "rawSHA256": "67A7BA044588C45401562D8FC31BA72DDCBB592A3C95D2373C5CE16B305F8149" + }, + { + "path": "docs/internal/extensions/lb1/evidence/axiom-summary.json", + "mode": "100644", + "gitBlob": "c3153265b5161b1b786be806ea0001261e73e61c", + "rawBytes": 1595, + "rawSHA256": "190DDF0CFA10A211D7B519DD621C153A5272E6880F86302CC5863F63D4781CE8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/build-20260912T071459461.jsonl", + "mode": "100644", + "gitBlob": "e6347117261eaf0885e5e8acd65b34b23766c3a4", + "rawBytes": 11228, + "rawSHA256": "AAAF13F1C08E1B64DB60BEC42C2D92A031DEEB2EFB411AA4891F64E43D5C67C0" + }, + { + "path": "docs/internal/extensions/lb1/evidence/build-20260912T071953550.jsonl", + "mode": "100644", + "gitBlob": "7ad5569c7acb0e26f5f6f0baa722cfdc4c2e3761", + "rawBytes": 872, + "rawSHA256": "B1FEA60DA6F066F541ABE008C17CAA7805BEABC6B77FCA3EA6DF15924EBD80FA" + }, + { + "path": "docs/internal/extensions/lb1/evidence/build-20260912T072455472.jsonl", + "mode": "100644", + "gitBlob": "b3d0ce7bbf257f4ea6ebace50036b5b5c9158147", + "rawBytes": 426422, + "rawSHA256": "3DEA96F33F468F166526179324A7D41CA91007C0C6536DD787A477DE1EAE1BBB" + }, + { + "path": "docs/internal/extensions/lb1/evidence/build-20260912T084142579.jsonl", + "mode": "100644", + "gitBlob": "3c5fb2e6f3f56bfe38284341230687bf5c66dafb", + "rawBytes": 912, + "rawSHA256": "C6BF421628F29BDD09DACC771B9E55D0C990E90AB7169DDAC5564CF3BD69878F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/build-20260912T084243070.jsonl", + "mode": "100644", + "gitBlob": "cdb4e39c572186441827e3bb219412d435c71a4c", + "rawBytes": 1427, + "rawSHA256": "C38D36ADA3480909082EAEA53A5912F23E14C410BB29B7E4DD270F15F3841270" + }, + { + "path": "docs/internal/extensions/lb1/evidence/build-20260912T084355841.jsonl", + "mode": "100644", + "gitBlob": "f9bfac05e3f1bb84441627a081af2d14236962d2", + "rawBytes": 892, + "rawSHA256": "488654F212715A4711625E1FB64F1FE232B8B8E156943F1F0F3C3E41DBCA71CB" + }, + { + "path": "docs/internal/extensions/lb1/evidence/build-20260912T100805553.jsonl", + "mode": "100644", + "gitBlob": "adbd6c7d28f2b8130f8e173ffd89e8b0938d2750", + "rawBytes": 892, + "rawSHA256": "BE805F42763FEFAF78EFFBB7503797EEE36B3851DA66EF257A5CDABD07239598" + }, + { + "path": "docs/internal/extensions/lb1/evidence/development-checks.json", + "mode": "100644", + "gitBlob": "bb22f02a1c4a05b270e5e92b8bd71e3adc11da92", + "rawBytes": 2653, + "rawSHA256": "B7AD3379491473351D00E8790C616DD8F2A95CA105F7AE89EC8FD827E132E433" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-evidence-manifest.json", + "mode": "100644", + "gitBlob": "ccff4a28c37009d6041369112e314b84e51e387b", + "rawBytes": 71281, + "rawSHA256": "9EAC10B7DB0D08A860887145B1E62F2853D7E369095712EF9C3F4006002248E7" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/audit-d6-inconclusive.md.gz", + "mode": "100644", + "gitBlob": "96fef014611389e30b9d0d034273211199e1e75e", + "rawBytes": 22013, + "rawSHA256": "2C3248E96D1804EE2BE82CCD46426111FA58B7E794B56AEC5EE15E064ADD782C" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/final-frozen-rows.json", + "mode": "100644", + "gitBlob": "0fc16f19ce945ba4efc7a1a6510eb1c3ba378fca", + "rawBytes": 12424, + "rawSHA256": "785AA40020B248D50F409F53D60DD9AA5EFF37B5A775267F86AF45705E91A46E" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/final-replay-verification.json", + "mode": "100644", + "gitBlob": "1f55611f91b8b14771e97588522cb06f4cb3f915", + "rawBytes": 338835, + "rawSHA256": "9E12B8D8C2148F38F253E0BCBC8955C89CE371E1A641FE96D12740C3ADD12494" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/full-terminal-receipt.json", + "mode": "100644", + "gitBlob": "02d7a97efc8d884d245b97fd3818caa28d066a73", + "rawBytes": 2215, + "rawSHA256": "00846AA0F1D3320DDC3EF207286E0110C42382609189008E946CDDC999FA86E2" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/historical-audit-claim.log.gz", + "mode": "100644", + "gitBlob": "0e22ab18c1e80077f1caab06255d4af096b629fb", + "rawBytes": 585, + "rawSHA256": "58516BE0BF581E826356E33E8B30DE65F5CE20FA5D79F75A334746A3BC096DDD" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/report-certified-claim.log.gz", + "mode": "100644", + "gitBlob": "e6066d900344957c8260c6f6f7d643fb86a38dec", + "rawBytes": 604618, + "rawSHA256": "A750C8419ABBC29B136282394546A46BB2F07EA22259D6ACAA6C5A6D0A980D27" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/report-certified-design.log", + "mode": "100644", + "gitBlob": "07d0a0374e8cb9b21b77987fefe49edd60956bad", + "rawBytes": 76, + "rawSHA256": "CB70C605B01AC3BB88B012B3BCB073900DBC7801060EC0ED0DCF218A86C82B0F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/report-claim-discovery.log.gz", + "mode": "100644", + "gitBlob": "93a7db9b2819b1a6aba27915f82a8210c2cee65e", + "rawBytes": 3214773, + "rawSHA256": "FE035CF19490C87AEB9A51FCED1B86719E4575B69F7FDCF821094D9463883E99" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/report-whitespace-discovery.log.gz", + "mode": "100644", + "gitBlob": "09efc1d151b596ec8738acc243df07260e3711a4", + "rawBytes": 304, + "rawSHA256": "C8754E96A4CC6A627D51C9E3021194BAC484130BDE04F046C467C9B6B45E64F6" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/run-conflicts.ps1", + "mode": "100644", + "gitBlob": "2272d16533e2b0b05f2eb9efcbf83d343e68a9dc", + "rawBytes": 4906, + "rawSHA256": "DD5DA56B8A1DBC34FC659E1E0B88400BC11CDAFA2BCAD121D967865D999AA466" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/run-final-trust.ps1", + "mode": "100644", + "gitBlob": "affb1c44cc5f02633fd59abfe4de6a093a06b37d", + "rawBytes": 5984, + "rawSHA256": "FE19DF3C0D5C562FD01AE7D5918EBBA0BCD092CABA30D02BDF56275770A55F97" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/run-focused.ps1", + "mode": "100644", + "gitBlob": "a1537b410159d37e2714ad48fa978527a9f12168", + "rawBytes": 4295, + "rawSHA256": "898238CD16BD54A0901B06F2B6A1DAAACAB761B7A52A3F6AA0E517FBA2023539" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/source-5033-claim.log.gz", + "mode": "100644", + "gitBlob": "2a5e9682835181469cd8949cd4226ba0da124950", + "rawBytes": 604156, + "rawSHA256": "83CC10ED0F4C1D64720C15607AF0374791F1BE40263695BC95FBCD69EC6153A8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/source-5033-design.log", + "mode": "100644", + "gitBlob": "1663957322b0dfe1eb2359c26c93de4446c02e56", + "rawBytes": 75, + "rawSHA256": "B8C6F527AFCEB3E87AAE310E208AA97CAAAA1EF4EA72D91D5F4235B55FA828CC" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/source-5033-policy.json", + "mode": "100644", + "gitBlob": "66b602a0fe90abf7ed5ace7ee0783fc1f4087a90", + "rawBytes": 1066, + "rawSHA256": "AC5752D0902FCA77F56F5C64DA022E9343453DAAF7A4A0E4AD4FB2F3466606A2" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/stopped-audit-2.json", + "mode": "100644", + "gitBlob": "96041d9fd10af35b1e31a47022ec19465e8d9a28", + "rawBytes": 721, + "rawSHA256": "64D83970DCC0344B6A7C560756E4001475B5A6AB521017719494D8D1941FD4E6" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/verifier-discovery-001-bytes-property.json", + "mode": "100644", + "gitBlob": "b9fd380af33b911a323661e1e010102f7772eaf9", + "rawBytes": 2334, + "rawSHA256": "000738B4DAAA67BB2D262677BA5A093BE33CF8A12AFCA8849487274846F94177" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/verifier-discovery-001-pipeline.json", + "mode": "100644", + "gitBlob": "9a62a8f36455c7bbe29ea04c8d0017fe413a4299", + "rawBytes": 315, + "rawSHA256": "56C0C9E656DBD26DACD0C50FFBF348CC0820D9979348E80A67E3063876AEB36C" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/verifier-discovery-002-nul-excludes.json", + "mode": "100644", + "gitBlob": "170f5cab2d1fa62c7b0724615670834263558cd9", + "rawBytes": 2310, + "rawSHA256": "384D4E5C751D24316F3AED4556008CC9D3DD35C6C7D93DAA1799C864F58187D2" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/verifier-discovery-003-local-ignore-pass.json", + "mode": "100644", + "gitBlob": "36390f47e954eea1fa515f855f9dd48c7a776af7", + "rawBytes": 338835, + "rawSHA256": "3A2D74AE62305053853CFB166AA8BE7039153429405B4FF6931A9CF022DF3722" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/verify-final-replay.ps1", + "mode": "100644", + "gitBlob": "6265a990614b87686c5b031326c42e44300c84d7", + "rawBytes": 34122, + "rawSHA256": "B0F56D591E67B67DF2C5E24F43E8564EEA993D579EBA15DAABC4CF1CE15D7BBB" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/DeadlineOnly.json", + "mode": "100644", + "gitBlob": "11fdbe69941afd303cf18b0b34e55316996fd8c7", + "rawBytes": 3459, + "rawSHA256": "4353B059D6FFCA82E65130C6B4CF296BBECE4CE42CB95641FD649ABD839D48FB" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/DiagnosticOnly.json", + "mode": "100644", + "gitBlob": "e57cd0424a5d837e371c91d12ec45afa1314f6eb", + "rawBytes": 2742, + "rawSHA256": "1D8D9EBAB95BE41760797F19A189DA2559CA0C17404237B1E87B70B6E630248A" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/RegistryOnly.json", + "mode": "100644", + "gitBlob": "b6ea83b2b355941b6a5a110a516511f02f819c1d", + "rawBytes": 2718, + "rawSHA256": "2FAD915984F617B7EC55815C63884D68A7357E6709FC59FFD03CC2BE5F08C969" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/RuntimeOnly.json", + "mode": "100644", + "gitBlob": "d655b426cacb397b62a629223053c8b4315c0b17", + "rawBytes": 3493, + "rawSHA256": "7EA5DF824E0A62032D3D28F914110FC53681E27BE8CB9E43061AF43645334F1F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/SelectorBoundaryOnly.json", + "mode": "100644", + "gitBlob": "cfb1c03d05342475dcbcbdd13822b7d9876317ae", + "rawBytes": 3388, + "rawSHA256": "9F89761636147579B8D22FCD45DC8574187875CC6FC58D1C36EED64D2F3EC808" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/DeadlineOnly-0/deadline-fixture.ps1", + "mode": "100644", + "gitBlob": "f26738b0309cb5949e09ed4bcb6b5bf6087ed4c2", + "rawBytes": 431, + "rawSHA256": "4E890249F8D3222EE32D0174E1ED8F886E98EF11642B222F85F67A1317A919E8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/DeadlineOnly-0/deadline-result.json", + "mode": "100644", + "gitBlob": "ab090c44876af83015bcc3e53b44dcc42d97511b", + "rawBytes": 343, + "rawSHA256": "FB778481933E195FCC8630D0A49FCAB74F2F2BA697D3EB2A427CFDBB42038744" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/DeadlineOnly-0/descendant.pid", + "mode": "100644", + "gitBlob": "c05bef18ed18cf0cf210446be47381acf4b4eafb", + "rawBytes": 4, + "rawSHA256": "BB4895391BDDAADEAD1C9015D8C4DF4806458CD7901F221B5C6B92B8CFA9297A" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/DiagnosticOnly-0/diagnostic-boundary.lean", + "mode": "100644", + "gitBlob": "8dfb0224f2a771d50e00d47e79f440cb1b8bfded", + "rawBytes": 82, + "rawSHA256": "095AA29925219A82EE935057C12CE34296AD318BA3415B2EDE6B51A1E3101343" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/RuntimeOnly-0/runtime-full.json", + "mode": "100644", + "gitBlob": "96a2eee91d007ef320d1fb5d9c2f31cda4ae6baa", + "rawBytes": 1135, + "rawSHA256": "526FB4A54D572F9CBB1F38A8573E35B7FBCBA651E0963201B4C695F6D0C554AC" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/RuntimeOnly-0/runtime-known-selector.json", + "mode": "100644", + "gitBlob": "81c79328e5fd7c4b3706c397eb78489fd86fe2b4", + "rawBytes": 576, + "rawSHA256": "E95A55307426F3950C42511F860019105428C4047989649EF0E518296F6516A8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/RuntimeOnly-0/runtime-selector-empty.json", + "mode": "100644", + "gitBlob": "b2cb87a292f5fb3ffbc76fa1c37012f7516ad2bc", + "rawBytes": 413, + "rawSHA256": "5943B041FC62558A9894F3E26C267A5315602D1F7FF32DFC69D2622E8C50E7AD" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/RuntimeOnly-0/runtime-selector-malformed.json", + "mode": "100644", + "gitBlob": "077c2cd1e4c74e7b34eedc1d2b3e928086bf8bf0", + "rawBytes": 440, + "rawSHA256": "30C7BE856E171A4E692B901D18E35553DFF3A993BB34B565218920BBB559D340" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/RuntimeOnly-0/runtime-selector-unknown.json", + "mode": "100644", + "gitBlob": "e358cc0e862d00c4c39681c65a8c9d9d742d43bc", + "rawBytes": 446, + "rawSHA256": "C425152E89C44CCEF3A6478B917EAD72F71D1E92B10E8EB556BC3AF64591AE8D" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/RuntimeOnly-0/runtime-selector-whitespace.json", + "mode": "100644", + "gitBlob": "2d94ed68f3b1aa7b4496a1f33806bf3df682c3df", + "rawBytes": 429, + "rawSHA256": "A957511191D26677E07BA2F86C89443B4276D5B6CF975D944DD7EBA677416A34" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/RuntimeOnly-0/runtime-startup.json", + "mode": "100644", + "gitBlob": "1afc54e9702686e392f41f9f5cbd8aab2feeb534", + "rawBytes": 704, + "rawSHA256": "8CFF41191A00812CBEB4AD6CB6C2B0304048F25D5146C4BE4C4B9C510819EFC7" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/SelectorBoundaryOnly-0/selector-empty.json", + "mode": "100644", + "gitBlob": "1fe21ca75323fcb7270e6df47d577af3ef928b18", + "rawBytes": 1002, + "rawSHA256": "C0C4F89ED1C3CF19B7DE13D042BCA633C8FCC7E7925A29720FFD2B1628D7BB4B" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/SelectorBoundaryOnly-0/selector-malformed.json", + "mode": "100644", + "gitBlob": "34d1cda170d2353054d67ed6bab4e1810b5b7b2a", + "rawBytes": 988, + "rawSHA256": "BDFDC7518F60CCCDEDC6B5B17BFBF2D0FAC8B9B1B2598D66300987EB4E3DA2B1" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/SelectorBoundaryOnly-0/selector-omitted.json", + "mode": "100644", + "gitBlob": "0bdf06241e8769275116070af2ac72cf7c9ef2fc", + "rawBytes": 2882, + "rawSHA256": "21EDCD4956F58A7603B72EF957B7D68096BF596F9A35AB89695A3F49C4C022B0" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/SelectorBoundaryOnly-0/selector-unknown.json", + "mode": "100644", + "gitBlob": "90feab8f18741e2462aaa6739581fb7cae386d20", + "rawBytes": 979, + "rawSHA256": "4F805DEA975D7A07656A90AADBC5AF35A827EF5B9CA1B2726F598EE2FF41C664" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/SelectorBoundaryOnly-0/selector-valid.json", + "mode": "100644", + "gitBlob": "97d70c0602cc5e23a99a3d6a53cff30f4abf4896", + "rawBytes": 402, + "rawSHA256": "C9D8E36DA4B135B5F5B862D2E24F19A609CC691159754C5436D7D803A21CF231" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/SelectorBoundaryOnly-0/selector-whitespace.json", + "mode": "100644", + "gitBlob": "b81fb8b6b1463c19998c565e56e6c67d9f0a3108", + "rawBytes": 1007, + "rawSHA256": "D40CB998A07AC96491C569077BCFEE77A5F7D6FBCE9A4096310799159DDB2883" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/summary.json", + "mode": "100644", + "gitBlob": "4e8245ecf78250baa3edef49157b0eeacb1b1e4b", + "rawBytes": 18074, + "rawSHA256": "AE6C9ABCF27BCBD059AD40D011BEC743932B6B31C781039DD4ADC769F36FBDAF" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/S03-SIBLING-BUDGET-consumer.json", + "mode": "100644", + "gitBlob": "de749dca468fd290a08685c9e76cf2a5c352df0b", + "rawBytes": 1243, + "rawSHA256": "58E28F29A2494E82314E91B303CFFF45ED9CBC71970C8C77F7811D038406B439" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/S03-SIBLING-BUDGET-producer.json", + "mode": "100644", + "gitBlob": "f65794e4d96734e8ddf54124a3005d8cdf98fd95", + "rawBytes": 300, + "rawSHA256": "8105A064EF2C9A4C53E9519FFB999D6CDBD8F864BD829E77DC86FCD0B7C6206D" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/baseline-consumer.json", + "mode": "100644", + "gitBlob": "f96846af6d869aa965898f8ca869dcabfb3f3041", + "rawBytes": 293, + "rawSHA256": "95F31DF092195B0153A5DDA7E7C2AE3C14594DF3EC2F3816D6E7EB068CAD1616" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/baseline-generic-consumer.json", + "mode": "100644", + "gitBlob": "ca5712403a40f0d4d90f2c30aa25ad7c136d02e9", + "rawBytes": 300, + "rawSHA256": "96A7EA7DD24B07BEAD3AB14838C1475FC11EB9707E36CD15243BED27623F8786" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/baseline-generic-producer.json", + "mode": "100644", + "gitBlob": "913ffab5bf21197ff1fec5ad433b009322446d7a", + "rawBytes": 300, + "rawSHA256": "F7698694F62D758CAE495B429B00E647B42D956F672D4821E2681281286F2B45" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/baseline-inventory.json", + "mode": "100644", + "gitBlob": "6dcba452a5917a50d6318fb12f2c6bfbd8ec0357", + "rawBytes": 696, + "rawSHA256": "C72559E98DD6854A89F1CE567A2D7D12CA5F921EEE17C658848C5BDD0A4DC21E" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/baseline-packed-producer.json", + "mode": "100644", + "gitBlob": "bfe3403f4d7b0f19552b43cb38bbca6e1abe2c6e", + "rawBytes": 299, + "rawSHA256": "233BD9D05B14BCDCBB190913850673B454547EFE8308CDE36D098A0C06C6B7A9" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/candidate.txt", + "mode": "100644", + "gitBlob": "aea86e28aaca292bc0d7ddbc17018da7072b3f64", + "rawBytes": 40, + "rawSHA256": "38E9F2BE4EE79EDFA800B36A3E1C3945EA26D0A4B3F9298D014293A2116E3586" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/diagnostic-boundary.lean", + "mode": "100644", + "gitBlob": "8dfb0224f2a771d50e00d47e79f440cb1b8bfded", + "rawBytes": 82, + "rawSHA256": "095AA29925219A82EE935057C12CE34296AD318BA3415B2EDE6B51A1E3101343" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/summary.json", + "mode": "100644", + "gitBlob": "4f06615480cfa3dc20b36834efa82032dc8d65d6", + "rawBytes": 4162, + "rawSHA256": "76A94106857CF44762EFE51ED3C805EFA5FAE0215C7C9180A5673F45C099FC29" + }, + { + "path": "docs/internal/extensions/lb1/evidence/frozen-rows-5033/binary-git-result.json", + "mode": "100644", + "gitBlob": "37e82f1e2ab6c6f4769e87f172265d5cae406426", + "rawBytes": 398, + "rawSHA256": "12C017570AFBF1678E5747B82839B0271EE9CF011D83204F016935B4BED17D3B" + }, + { + "path": "docs/internal/extensions/lb1/evidence/frozen-rows-5033/binary-git.json", + "mode": "100644", + "gitBlob": "e2255a13c499fae39d17e5fa4804400d1763bb37", + "rawBytes": 352, + "rawSHA256": "A4EC1484EF04A42D5A28105480D131AD48F27F897BB09AA5DACA2C5F2A454BEE" + }, + { + "path": "docs/internal/extensions/lb1/evidence/frozen-rows-5033/evidence.json", + "mode": "100644", + "gitBlob": "06321cef6b1ea909f0a0475b3d290f9f151c1c33", + "rawBytes": 12423, + "rawSHA256": "ADD641EE29784166FD20F1FF972B1C6242A246E8F82770BB9D6577465FDF8D4D" + }, + { + "path": "docs/internal/extensions/lb1/evidence/inventory-repaired-20260912T084829575.json", + "mode": "100644", + "gitBlob": "d989b47897104ff104ba9224ae4bc7219a9c977f", + "rawBytes": 2973, + "rawSHA256": "7829D223AFEA1A1933B3009EF1E41585E2E581A2B8ED8BE9E732A263E01FD533" + }, + { + "path": "docs/internal/extensions/lb1/evidence/process-controls-development.json", + "mode": "100644", + "gitBlob": "073e0c8c7186927ba8149cfe4804c2c0417555fb", + "rawBytes": 11936, + "rawSHA256": "55980C87B8D7B190F76637809ECF2F2D2E18A4C3863C85E7219965232BCAD5B3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/A01-BASELINE.json", + "mode": "100644", + "gitBlob": "56ef52a53841c2d04ea8b94947db2a2504d5effc", + "rawBytes": 288, + "rawSHA256": "FDEC8BA62747A85A7D1B3738293AA4C0F28D4365437AC16CB95D18BB0ECCEEE7" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/A02-PROOF-ONLY-WRAPPER-consumer.json", + "mode": "100644", + "gitBlob": "75e213aba34c37e07d64edba3b5495499aaac128", + "rawBytes": 307, + "rawSHA256": "37B454D8592D08958F89A75A712CBAC5AF64E4D50579C3736E34C98444BF06EC" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/A02-PROOF-ONLY-WRAPPER-inventory.json", + "mode": "100644", + "gitBlob": "3a4fb21462271dfa897cd02da7a9be7ec86f6a03", + "rawBytes": 711, + "rawSHA256": "01D5F17320D325CF6F7E8CE259372865B5B592612C5BC62E7D1089DBDBCB8BBB" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/A02-PROOF-ONLY-WRAPPER-producer.json", + "mode": "100644", + "gitBlob": "9194d711a00991b0fcdac87ae90f274610f383d5", + "rawBytes": 306, + "rawSHA256": "AFEE235AC7D1AA045F6A4600ACE28B9AB4E466403540BA5CA83B327073D21085" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/D01-NULL-DECODER-producer.json", + "mode": "100644", + "gitBlob": "2e276415d0f4999569b8509b1cd08301b5bdd8d1", + "rawBytes": 3803, + "rawSHA256": "FA7C6D71E4E02BAA1DBC4AA987034DF930B74C7327EB17883C7BE98C095D2B35" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/D02-WRONG-DECODER-producer.json", + "mode": "100644", + "gitBlob": "a93ac9bf7d9069b65b991e0704e8a6720e895393", + "rawBytes": 3802, + "rawSHA256": "D1C575A32A7C9AA61545BCCC1F7ED0707C988E7E32ECB953762922D07780B8CE" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/D03-ZERO-SERIALIZER-producer.json", + "mode": "100644", + "gitBlob": "97adb4ef9f73e43210344d81570bce00a27c96d7", + "rawBytes": 2850, + "rawSHA256": "E8A1EF2169A8F95D61979694D6FEF263B8A062CEFED80B55DDA9A32145E399EE" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/F01-DELETE-MEMORY-RECOVERY-consumer.json", + "mode": "100644", + "gitBlob": "10e45c2a3d6ac814113a524d1772c76c0d83e695", + "rawBytes": 1735, + "rawSHA256": "ED099960C4E0BCEBCE883256F526641142FCF3792B997B2279011786582872AE" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/F01-DELETE-MEMORY-RECOVERY-producer.json", + "mode": "100644", + "gitBlob": "0e9aac910006b5b03d9a34d9256f6a7356718611", + "rawBytes": 310, + "rawSHA256": "BBF32A1FDB4AA435EE98B339A322C94C4AE61EB67630D4DC7E4624156165216F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/F02-DELETE-READ-BACKING-consumer.json", + "mode": "100644", + "gitBlob": "a9e60617a6c3d7bc3305fea2cbd8401a967eb3d7", + "rawBytes": 1092, + "rawSHA256": "8A83B47FB5C3F77A179FFB52065A0B7B38E5EC91181F00760710C3C027E022C0" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/F02-DELETE-READ-BACKING-producer.json", + "mode": "100644", + "gitBlob": "9757773f41d56af26d9720faa64b0cc5509a569f", + "rawBytes": 307, + "rawSHA256": "DBB7F035489CF8C430D263EBFA7C95840603B0C90476D476427DAFF1C9EE6FFC" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/G01-LOWER-PROPOSITION-consumer.json", + "mode": "100644", + "gitBlob": "b3f34e5f3f64327e72a00582856401258b57a254", + "rawBytes": 991, + "rawSHA256": "2A76C30F2F32DD5B92E7491F64313AC6A2BD4D393EB485B2D2034EF623C2AF38" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/G01-LOWER-PROPOSITION-producer.json", + "mode": "100644", + "gitBlob": "356eba7ebf9ba14c4b7d2125e4938657a1bc59a6", + "rawBytes": 759, + "rawSHA256": "E68D8C9B463E63D8C0ED3BBE51321F7FA76C3D5EE0BF6A4E4D4CCA8ECBEA1FC6" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/G02-DELETED-EXACTNESS-producer.json", + "mode": "100644", + "gitBlob": "62b7bdc89d904844607780281a3ec7b8a2ce6153", + "rawBytes": 6763, + "rawSHA256": "95002AA2FDBAEF374667DF66226AC619A2E09924B85AD16932AF4D9A4BE12EA5" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/H01-EMPTY-ONLY-DECODER-consumer.json", + "mode": "100644", + "gitBlob": "8cbb8d52d19636e61145fce4af9aa8f20a0503ae", + "rawBytes": 3589, + "rawSHA256": "64D45F3FA10261FCE5CC8400E50401C0F2214115E41569F492BF45F908FC019E" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/H01-EMPTY-ONLY-DECODER-producer.json", + "mode": "100644", + "gitBlob": "a0a215f0b62997127391f5ef278836a36953735f", + "rawBytes": 306, + "rawSHA256": "CBF16DB8FA922BD48B83D2F6AE5E4E36ADD2F9CE63F5880E5B08D69256795232" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M01-allocationResidualLittleO-consumer.json", + "mode": "100644", + "gitBlob": "6514661b6300e59d43e73510180a75ff5e777a82", + "rawBytes": 976, + "rawSHA256": "52A1CDF91D1D6A4DF1B0A61483D0E7FAB982401B76FD1DBDBB119B64377F6872" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M01-allocationResidualLittleO-producer.json", + "mode": "100644", + "gitBlob": "dd76685103bbe63543a1123221e71b5915501c13", + "rawBytes": 312, + "rawSHA256": "E2BC4CC288A601B55EEC2ED31D867CB7A13890591FF2054DE3DAD12DF8BD2C79" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M02-completeResidualLittleO-consumer.json", + "mode": "100644", + "gitBlob": "fec3dd4f3411d06e6113144a04912887cabf1a0f", + "rawBytes": 976, + "rawSHA256": "71FD5B8BAB1717EC19C26D63F63E7AF399FE32AC7E9542136BC92863C1AE6430" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M02-completeResidualLittleO-producer.json", + "mode": "100644", + "gitBlob": "26ff2e1f956bf0901d3a708d4b55126af89a9e8b", + "rawBytes": 311, + "rawSHA256": "8FC192D27E487BB714CDF98C19D3CD59BD50BED4C1F7756432E5983E7F3E9C0B" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M03-widthBounds-consumer.json", + "mode": "100644", + "gitBlob": "c058b1a64c91fb2e2c2f10a1e991c276e0b39a9a", + "rawBytes": 1064, + "rawSHA256": "F588F79302DAACAE86ACC4F67859123D34532B38B353E2D6E3E69181DF119C89" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M03-widthBounds-producer.json", + "mode": "100644", + "gitBlob": "74624a36195277ceb3fcf616d5214d39576ed01c", + "rawBytes": 299, + "rawSHA256": "36948CA1A254269254682D08FB33E579F0AA40BC8E440C628F25E0CCE73CE0EF" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M04-dataCapacity-consumer.json", + "mode": "100644", + "gitBlob": "265032d42a1ef9f5e1d62bb07d6dbf225ac7541d", + "rawBytes": 1155, + "rawSHA256": "76A605143A73753983FCB907D3B52AF595F55E7ACBBC5F416A05700513FF394F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M04-dataCapacity-producer.json", + "mode": "100644", + "gitBlob": "a6b9961d1ea3636e02980e2e2b61fca65e9a9196", + "rawBytes": 300, + "rawSHA256": "2FF22457B637E44A4FD57469DC959B6B470B05DF1EAD7497E998517E6FDA25CC" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M05-completeCapacity-consumer.json", + "mode": "100644", + "gitBlob": "ad7c9ee87b2bec6f945209d44d2a56a73c28c8d1", + "rawBytes": 1451, + "rawSHA256": "BF4DE5914472DC5399B8F44E381E222E20E11E7F67F10C003FD5E1E2CBCB08F8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M05-completeCapacity-producer.json", + "mode": "100644", + "gitBlob": "9c3f812f06247283cfe44675be20263997d0f734", + "rawBytes": 304, + "rawSHA256": "535722F321BBFBF3F658F63BB35335B2C0BFACB5B690D455047A69C183D64CA7" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M06-memoryWordsFit-consumer.json", + "mode": "100644", + "gitBlob": "a530841acd2c96fbbd9b3a83c4c0b76c36aa390d", + "rawBytes": 1090, + "rawSHA256": "AF9A390AA081AEFEA479238955F8F368616464463D471F8D21469753A9A80857" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M06-memoryWordsFit-producer.json", + "mode": "100644", + "gitBlob": "05aff58b43b4a9ec3749a02a530bcf0ce0f39adf", + "rawBytes": 302, + "rawSHA256": "131ED87169DC670BD4A9A77F5979E3237FEE5413F85BBE2C777397A058192398" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M07-allocationAddressesFit-consumer.json", + "mode": "100644", + "gitBlob": "7bbed25891809277ce0d5e270d998d513a1da568", + "rawBytes": 1185, + "rawSHA256": "49C33E5A2D6EEE7F94E70715802B4F6B71938F5D95EEA5856BB21CB505CD1BB9" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M07-allocationAddressesFit-producer.json", + "mode": "100644", + "gitBlob": "d580f0a44e7b350441e5434e9df9c4a2728f7161", + "rawBytes": 310, + "rawSHA256": "D776D706BB1DD2071E3AFF7CE36EB678120C2F23928EAD8DB6C08B7BA962385D" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M08-programFieldsFit-consumer.json", + "mode": "100644", + "gitBlob": "007e402faec986d225490f1b4ccdfa02b0eba0b1", + "rawBytes": 1157, + "rawSHA256": "DB166373A5ABA11B0CC688A4F21F552CFD643F25A1B51EFB2172EAB327F491A3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M08-programFieldsFit-producer.json", + "mode": "100644", + "gitBlob": "083aa484a03cee6deb3ff3b915b0d0237c021548", + "rawBytes": 304, + "rawSHA256": "8CD6DE85898AD52882B1CC4C7EFAA73B619F5865FE499D9C06AAB3E18A0E66CF" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M09-budgetExact-consumer.json", + "mode": "100644", + "gitBlob": "0de884d39664be61f60af50e9392ba4b03c96e4b", + "rawBytes": 922, + "rawSHA256": "3FCF31D0CE5228DE3583639784F8AA2C4A8C6CEC593924B43955F4A4E924108E" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M09-budgetExact-producer.json", + "mode": "100644", + "gitBlob": "007e22d18b9037c2c2a9cfb8dded7739e24937de", + "rawBytes": 299, + "rawSHA256": "3081B1CEBD0D71533F9E7A1BBE63BB7128C91D868372043E6ACBAFCA50BB8A84" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M10-programLength-consumer.json", + "mode": "100644", + "gitBlob": "c3814abb6a6f342aa5358590dcf7be9c8a18cf6b", + "rawBytes": 964, + "rawSHA256": "97601D4ADFC9A07A0121F4179541092ACB1407ED18284FC2BC9FB5135067F1BC" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M10-programLength-producer.json", + "mode": "100644", + "gitBlob": "8cd0202941aa38a7484c18ea79ae2a2db70a932f", + "rawBytes": 301, + "rawSHA256": "7111E52D9A19792D0870DECD6450ED36CB99C1F74BAC27DCF6BA5BA83E5A4EF5" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M11-encodedProgramBound-consumer.json", + "mode": "100644", + "gitBlob": "842b812a27427fde87ad2f09cc478d21815188bf", + "rawBytes": 1064, + "rawSHA256": "89918415A3049B7D3C68FF1543072E76B423A03DA4483F3172E5D4920C27EEDB" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M11-encodedProgramBound-producer.json", + "mode": "100644", + "gitBlob": "c6c99ba041b6bf199f7e53e1d8cca19a862d539d", + "rawBytes": 307, + "rawSHA256": "2F018FE65A7BA0942676C55EC01319D210E394C0519B5A397C90E5D6BF8D6E80" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M12-registerCount-consumer.json", + "mode": "100644", + "gitBlob": "c3d054f96c5349ee9255b89ad9ac78ca10868cfd", + "rawBytes": 938, + "rawSHA256": "9E65F0B76B24299C21E18275508C611D5DE70DFE6D101F2F0F7421679F4F2867" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M12-registerCount-producer.json", + "mode": "100644", + "gitBlob": "b0c75f6ff474f26affce28ccfaa426322f0f04fd", + "rawBytes": 300, + "rawSHA256": "393C4BD4BED0B333C6425718BA0527D0B60EB392BA3339888EDBBC53F498E0FF" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M13-scratchCount-consumer.json", + "mode": "100644", + "gitBlob": "7f18a117571be6b44f73931d5256f042b5650853", + "rawBytes": 933, + "rawSHA256": "E59C7CC5FA748D6F9C4900B179677C1ACA3A44717C0DC8AED1402460962FFB5E" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M13-scratchCount-producer.json", + "mode": "100644", + "gitBlob": "0c003e002d2ad03d9c78478400fa2a071946c61f", + "rawBytes": 299, + "rawSHA256": "536CC66928D9FFEC54124B060B0C7F9F530E50A8E816775967CB02C22F9A8E19" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M14-unusedRegisters-consumer.json", + "mode": "100644", + "gitBlob": "7e786181392193b9083728265c30fe3f0ca92fda", + "rawBytes": 1300, + "rawSHA256": "4E3DE7B9C684D3864A2933D4485FFE0AD5012F15A5DC84543D3A3571EDFE0E36" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M14-unusedRegisters-producer.json", + "mode": "100644", + "gitBlob": "0ec2bf329cee2667841a60b305948318af1d0a79", + "rawBytes": 303, + "rawSHA256": "D7306D7F46E6BCF9097DD7BA1C11F8DD71A52801045388706141BF8098420E55" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M15-validInputs-consumer.json", + "mode": "100644", + "gitBlob": "9041ae5b55daba9b77fd70c7c3ed0ecc03aa879c", + "rawBytes": 1398, + "rawSHA256": "49E61ED2F08FDDC5C311B4D93127E885D75E2D5C6BD649C2780DE8FACBDDD06C" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M15-validInputs-producer.json", + "mode": "100644", + "gitBlob": "855860217fecf8ab143bb345234ad637d7e9298a", + "rawBytes": 299, + "rawSHA256": "A3E716A012EAF003E39D62CD01A46593B18A22202E9219AE816D467CF22AF13F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M16-natContract-consumer.json", + "mode": "100644", + "gitBlob": "ca18b04a5d4c2bdb326fd27a6a7bb5e7f33ff8d5", + "rawBytes": 1293, + "rawSHA256": "B252B57EC53D35EE71E10EEF5B3A787B781BD95CE2B6A14ABDD337CED758B7EF" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M16-natContract-producer.json", + "mode": "100644", + "gitBlob": "0b8882039b329432ca7f7e03d3f7f86dfa125ada", + "rawBytes": 299, + "rawSHA256": "5F0FFBFE7A7DF333B5981691D4F0BA069ACF65464B39738F67F30FDE4C381B4D" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M17-leftmost-consumer.json", + "mode": "100644", + "gitBlob": "2588b61ee7f21f506648d3dd5d9d59f5a62c7e70", + "rawBytes": 1200, + "rawSHA256": "BD9B154A72DF1EDDA22F6A96595F0B3D348611153E99EBFA8D856926DC737A1E" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M17-leftmost-producer.json", + "mode": "100644", + "gitBlob": "fdf2413cef995d20445b24ae7e9e8ca183e10c6e", + "rawBytes": 296, + "rawSHA256": "1CFB0698AD63D6BB3825852C97FCE98D9826474AA871A5F6753EC91AB3844B86" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M18-result-consumer.json", + "mode": "100644", + "gitBlob": "1b066be755d18486732065264a46a3f371b70836", + "rawBytes": 1564, + "rawSHA256": "CE88185082C6AB4C80443907C5FFBD01FE8F05FA2E72D03CB96A8BAF15C31A8D" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M18-result-producer.json", + "mode": "100644", + "gitBlob": "ebeaa250baf277203c4b2432244883ccf0bd9783", + "rawBytes": 294, + "rawSHA256": "2A34D51D2949DC77A8143E800D91124A821F6E6110724005C46E262211D45D86" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M19-halt-consumer.json", + "mode": "100644", + "gitBlob": "65179872ad931a2da9027822397fd8f8c9378963", + "rawBytes": 1589, + "rawSHA256": "F760ABE8E8D28C9ACD5B428CA64DBDC6A4D09AD0DCAF86C15F70498E3BF18DD4" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M19-halt-producer.json", + "mode": "100644", + "gitBlob": "a96c7a72645e14c559b49d86f5332d172a6ab6ec", + "rawBytes": 292, + "rawSHA256": "BEC9CFB8C418EE47A86E4EFE478CA1CF43A7B4879F74CDA7CFB786727ECAD97F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M20-invalidGuard-consumer.json", + "mode": "100644", + "gitBlob": "854b62a4cc3dd53947ae284b7ffcbc472c48982f", + "rawBytes": 1801, + "rawSHA256": "9C7EC7724EDB8B8A172B379E0A01D8B00B3043D6B206A3B5376225E2D46FE8C3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M20-invalidGuard-producer.json", + "mode": "100644", + "gitBlob": "065f4803838288247c6c2def4046705cfe87f36b", + "rawBytes": 300, + "rawSHA256": "ACF764D1EFB6BE7ED31966B7BBFDD577A215043C1A604D92FCB1BF77E09A1F29" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M21-stepBound-consumer.json", + "mode": "100644", + "gitBlob": "1fc5a4dcd0739959e4988cee7f68d1e7545cd1a3", + "rawBytes": 1234, + "rawSHA256": "9E3930281094149CAA088B4CC37BA49CA06A9B21AC1A5787657BA1046AB57C86" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M21-stepBound-producer.json", + "mode": "100644", + "gitBlob": "8bd4fc3b12567027da6ba2e447ab8a535be94f4a", + "rawBytes": 297, + "rawSHA256": "99613F3A5FB34CCF1FD8B9B2EDEC6EAE23E60E2353E26C2AE83797EF8AD1FB19" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M22-categoryPartition-consumer.json", + "mode": "100644", + "gitBlob": "03191e0839e9981c547c58eff2d0ba8cd143269b", + "rawBytes": 1950, + "rawSHA256": "45D66191A6C91CDF1740997169D7BB310920F323DCB36520979CF5565A7D1784" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M22-categoryPartition-producer.json", + "mode": "100644", + "gitBlob": "19c15cdceee1cab89fc29402ef2271b9b6406e6b", + "rawBytes": 305, + "rawSHA256": "BDE10CB28BE505DF32D5AF3CEDB317424BC595022B88B1B6A454C30893506F16" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M23-finalStateFit-consumer.json", + "mode": "100644", + "gitBlob": "bd415f09e6613f5888968b132830b1cf5d8cb0e1", + "rawBytes": 1490, + "rawSHA256": "99DD41497861FDF086890C56EB1CA462FB2B0CC45D342AE380CED91C8FC783F6" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M23-finalStateFit-producer.json", + "mode": "100644", + "gitBlob": "b1d138155a94740501151b611366e31abdc5b256", + "rawBytes": 301, + "rawSHA256": "607A9AB6C008818ED506F47F4F13BBA5A91E97C16F07F366A54DE4C1448F05C8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M24-transitionSafety-consumer.json", + "mode": "100644", + "gitBlob": "12c79979d6f04f72b62d9cd8a28d289de167b739", + "rawBytes": 1957, + "rawSHA256": "EDBCAAF3CEE1AC9ED99FA7D999224C121C81C5780EDF5C1CFB386ACD2CE731EB" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M24-transitionSafety-producer.json", + "mode": "100644", + "gitBlob": "93cdcc08199c25ae488d4841b66401a4c21d58d1", + "rawBytes": 304, + "rawSHA256": "1C0F49CF32F11C6CEC8EE6B3CCDE5998E51863ADCA41504B817AEF126CE0181B" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M25-prefixSafety-consumer.json", + "mode": "100644", + "gitBlob": "ea4024437f0a64ca3a659a5c0b73ee02ca092efd", + "rawBytes": 1643, + "rawSHA256": "EF13C51C519F1E5632B47263E19B8263D83DB34848742B8F196070FF643E4FEB" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M25-prefixSafety-producer.json", + "mode": "100644", + "gitBlob": "a4e1e7afcc8b50fedab8a0adb83d41eb7a52aabf", + "rawBytes": 300, + "rawSHA256": "A30A8E9CEA206571C7C7FC51CDBCE64472DE710F5692C2BC1C14757928A26A05" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M26-readWidth-consumer.json", + "mode": "100644", + "gitBlob": "9e347e1488fc0a26ce7427cd36c0ab2a7bf79c4f", + "rawBytes": 2302, + "rawSHA256": "01722EB97709DF2E351DC8C149CC70AE5E4D3AC7E61B53DA1209C7BFAE2DCBF1" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M26-readWidth-producer.json", + "mode": "100644", + "gitBlob": "b5247842ee988473db28c07b3e0ff64eebf3394c", + "rawBytes": 297, + "rawSHA256": "405B0F1811CA1B3FCE0086411E06DB0E1E4343EA14B4EDA337A3381049B16965" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M27-positionalReadBacking-consumer.json", + "mode": "100644", + "gitBlob": "0f984c0cd4bb8bb1af3e53698dd5f935c28242ff", + "rawBytes": 2732, + "rawSHA256": "15016E3DBD054B4F506B3FA70D81F126A82DAC94E5BA8DD2BE27DDFF16713921" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M27-positionalReadBacking-producer.json", + "mode": "100644", + "gitBlob": "f16ebcbbd5432ec1e6453c1310be05433452131b", + "rawBytes": 309, + "rawSHA256": "8AF81870F5235AF53F18CE1A8C519305BCBDEB4AF1F3998EEFD3DEED7A55336D" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M28-orderedLogicalRefinement-consumer.json", + "mode": "100644", + "gitBlob": "ee4bc0abf775e8b41cf5d497a5445a514d4489d1", + "rawBytes": 2013, + "rawSHA256": "055A404E3A38D482BF3746846C8B04778B18AFB99AC15E779E118151FB71FFFA" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M28-orderedLogicalRefinement-producer.json", + "mode": "100644", + "gitBlob": "3b7fab1cee89305fd1c6ad38383a2b15b76aac29", + "rawBytes": 312, + "rawSHA256": "F765FCB1B9B61F86C584B9024264D49D53CC233A592AC6F530B44F3919877996" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M29-logicalReadOnly-consumer.json", + "mode": "100644", + "gitBlob": "acbbf4a6099003a3eb6e13fda6f3e4ef0e43242f", + "rawBytes": 1109, + "rawSHA256": "12E89D09EA556ED3FA6434A0F5A00F34028A5B0231E9E20FAA44BBBB2E746472" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M29-logicalReadOnly-producer.json", + "mode": "100644", + "gitBlob": "7f699065dad4dcd1554e4eb24cbda11681984bae", + "rawBytes": 303, + "rawSHA256": "06F93A1D4D01B1CD6F463FADFFE687208D76E04B3359A04EAB8A91450023C272" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M30-suppliedMemoryAgreement-consumer.json", + "mode": "100644", + "gitBlob": "40c4353c46b79cfbc110ef4bb0173132e3111279", + "rawBytes": 1942, + "rawSHA256": "DCBF711C0AC19CC7DF19BFA79ED2A310755B16AA85775A8D58E56D195C7C55CE" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M30-suppliedMemoryAgreement-producer.json", + "mode": "100644", + "gitBlob": "56992ae098ddf9b6903297d26ae5107c4cf4247d", + "rawBytes": 311, + "rawSHA256": "655CB1BD01A97F21A09F0F7A4DDB989679BD38EAB32E6E4F83E24E3D6EB78227" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M31-specResult-consumer.json", + "mode": "100644", + "gitBlob": "514f1328b97efa78136e92666e055f3907dae7c1", + "rawBytes": 1391, + "rawSHA256": "0A4CBF278F37A8BC62D81E383798419B754E97F1758469197C280AAC7D566ADA" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M31-specResult-producer.json", + "mode": "100644", + "gitBlob": "b614949cb8189e60463a353d56eb15178f065780", + "rawBytes": 298, + "rawSHA256": "BC0C669284A5C9619C3FFC27D6DA225F5E1179FC7A505A5BAC468BDCE306BD1F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M32-noFailedLoads-consumer.json", + "mode": "100644", + "gitBlob": "c9b992ffb04b7e579a98e72d3fa8c39d08159ca9", + "rawBytes": 1498, + "rawSHA256": "CF55C28E9549C75643414E61D9A175BD3D57BCDFFAE6026F5F42F6B55953D6FD" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M32-noFailedLoads-producer.json", + "mode": "100644", + "gitBlob": "7fbfa176a32d7a0cb5b96739d1225c22c143332c", + "rawBytes": 301, + "rawSHA256": "68C540BB4D1AB09FBCCBB7F81CCB929682B60048C9252F75175B3A57389341B4" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M33-invalidGuardSteps-consumer.json", + "mode": "100644", + "gitBlob": "e2b45d1b80c866c6c39dd42fcd2b0b11316da4a4", + "rawBytes": 1299, + "rawSHA256": "D30D71FB88972E36181B9FE2B137FE1E4F5B7067ADB0381715906018954F149B" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M33-invalidGuardSteps-producer.json", + "mode": "100644", + "gitBlob": "c1b1ad088a3748afcb48d053020af0a6b62580e2", + "rawBytes": 305, + "rawSHA256": "3521F57F8A8D1DB9217576D3C645C8402F6E8309BDBC2AF906C18332D3C78F5E" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O01-wordRoundTrip-consumer.json", + "mode": "100644", + "gitBlob": "1bab1dbca70495331c3006f0da184984e2b3f472", + "rawBytes": 1296, + "rawSHA256": "B88E4CAD4EB53110BC7CB35A6738E06976191627AC149DCCF3BB644CD089C679" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O01-wordRoundTrip-producer.json", + "mode": "100644", + "gitBlob": "f3e8649c72cb6aaec6590b6a9b9fd92c5ea56229", + "rawBytes": 301, + "rawSHA256": "3A25A97B9F9E68576A4521F2AB8BE51CD08A2CB4BB6E680BAD45F1745B25DE0B" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O02-wordSerializationInjective-consumer.json", + "mode": "100644", + "gitBlob": "a79eb6dfdfe7b4bd7715ca72cabab918aad2b798", + "rawBytes": 1538, + "rawSHA256": "E2AA4C5B24E5CA8C4077AE22D98816D8D9A5637EC656DB69F9AE9D87C7ED191C" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O02-wordSerializationInjective-producer.json", + "mode": "100644", + "gitBlob": "1ff54acda8bcca8f6d2d6fa29bc5ac8d352e23bc", + "rawBytes": 314, + "rawSHA256": "BD8279494C42C350FB0307F1416FEDE55CF7D2B56994A4F140BBE814FE41BD41" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O03-serializedLength-consumer.json", + "mode": "100644", + "gitBlob": "8b604537e056f81ccc83e4bbc60593bbb753527a", + "rawBytes": 2075, + "rawSHA256": "29462EC22B6BC7FD2691AA34F4D4A04BF903908926457A1FD678AB63B7DE37B7" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O03-serializedLength-producer.json", + "mode": "100644", + "gitBlob": "f310904b8838e322e77f6794df55696e2e33b0f2", + "rawBytes": 305, + "rawSHA256": "F0538068CC287A6B9CEB91A533AB3324CCB59D00AB156B0935579E47554150F8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O04-memoryRecovery-consumer.json", + "mode": "100644", + "gitBlob": "43d64d5bbb66f87412d1a649246f0b1a58f01df3", + "rawBytes": 1921, + "rawSHA256": "A24AF19845A9BC4E522ED1990941D7E36C64F2B57DBA41EA1884903CC60D8A11" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O04-memoryRecovery-producer.json", + "mode": "100644", + "gitBlob": "ad8ffce03fa81e69657c847a7cdcdbc43415179a", + "rawBytes": 302, + "rawSHA256": "1F9924AE7DF6209BAD84EF5063A6E5C34CBFAEC4AC4ADA5235E4C89B19CDE095" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O05-decoderExact-consumer.json", + "mode": "100644", + "gitBlob": "bfa7107d42c5acdfea4b1818a9a0751847b49867", + "rawBytes": 2531, + "rawSHA256": "AD3127612ABB183992512DAD9612B44AF9E53AF75AE70B107E725297A0325AA3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O05-decoderExact-producer.json", + "mode": "100644", + "gitBlob": "c49a7b4eb2bfb65604572c3189cc84c3577aa9a6", + "rawBytes": 300, + "rawSHA256": "64D1DA3997EC21E6D02D285B1735125DC813D6C166A2DC74C1C69A83821918C4" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O06-decoderLeftmost-consumer.json", + "mode": "100644", + "gitBlob": "5cb1ef899e7a56147832036d198efb6c8d7a3e8f", + "rawBytes": 1212, + "rawSHA256": "CAA1439E8F5D2EADC3719749BBACDAAC980D87B789AE7E40D6E9EBF622D266B9" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O06-decoderLeftmost-producer.json", + "mode": "100644", + "gitBlob": "33a8d1823042af5dc8b6c29a9e363a4cb53469fb", + "rawBytes": 303, + "rawSHA256": "6ABD864AFEE661E2498EFA46C13C71E2E336E82FEE39562ED3D1E8FD2210C54F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O07-sameShapeMemory-consumer.json", + "mode": "100644", + "gitBlob": "b66c7d394d357a54bfb807f57e493c1ce2619712", + "rawBytes": 1033, + "rawSHA256": "AD04875D8635910CCFA45E9859D78E0B4DDA0A23B8D028C6F28DB1E16E8CE317" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O07-sameShapeMemory-producer.json", + "mode": "100644", + "gitBlob": "7d2422837d2bc19e4ce9838525f426de6b235cc1", + "rawBytes": 303, + "rawSHA256": "5C94EFE53F608ECBD3D258DAAA3D250A6046A0CBD1EF58502892DD7E591E6015" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O08-shapeInjectivity-consumer.json", + "mode": "100644", + "gitBlob": "55db0fcca6d4805fa676d4ee5f4ac6d7063a544f", + "rawBytes": 1361, + "rawSHA256": "8BB9BFC0E09D59ACCECD0EF617407F558C5C7F8DE1DEB9C8AF981D44B8BAE661" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O08-shapeInjectivity-producer.json", + "mode": "100644", + "gitBlob": "37bbe00215b2b27675e6a755da30d010cf4a0e95", + "rawBytes": 305, + "rawSHA256": "75687DA036F7F044E9EB127C698E09ED53A931DB39FF0958E1B2752D364CD091" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O09-uniformBudgetCount-consumer.json", + "mode": "100644", + "gitBlob": "bbeff7859c152d15c72ba6db1b27cd2ee8cf3482", + "rawBytes": 1048, + "rawSHA256": "9F0F25849CC2BF121484A25C4E4A88A0E5F61CBD45869763FCA27FD0A37E78D2" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O09-uniformBudgetCount-producer.json", + "mode": "100644", + "gitBlob": "254de8fb3868443d46f1f4d9cf1bcfc08ee438eb", + "rawBytes": 307, + "rawSHA256": "FE000646C2D162664379354FB6C088935C293DBA9B5EFF63E01AA820883797BC" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O10-uniformBudgetLower-consumer.json", + "mode": "100644", + "gitBlob": "7f051c1f72ff7954e4eac87a9c273d515667fdd7", + "rawBytes": 2299, + "rawSHA256": "B5200300879E69B213E200FF1C3332102C976FCE314A8EADF97DCD329E759CC2" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O10-uniformBudgetLower-producer.json", + "mode": "100644", + "gitBlob": "5dd8453723c4002d34ce1142be665034f7d0ae1d", + "rawBytes": 306, + "rawSHA256": "3E4AA26FA2D51C1EB3220F2F0EF324B84FD9574B072E5EB02FD637CEB019E16B" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O11-canonicalCount-consumer.json", + "mode": "100644", + "gitBlob": "f845ec431e329719bd10d347553ff9149955f155", + "rawBytes": 1011, + "rawSHA256": "01366D1A1F4432B84D55AA21CC2F189D60C7EDFDCEDD1432DB4B20400A0A5297" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O11-canonicalCount-producer.json", + "mode": "100644", + "gitBlob": "c84867cd53a9519ba6c8cb2dc981dfd9bc3dd119", + "rawBytes": 303, + "rawSHA256": "34F34C9AB9C0F7DDD863655082F815921C1F67E71B10974447B9770C300CDE84" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O12-canonicalLower-consumer.json", + "mode": "100644", + "gitBlob": "52750275d72a822f86123d447c97e54f451909a0", + "rawBytes": 1061, + "rawSHA256": "053F00E967B181705ECEE68C49136ADCA110AD8DCC995FD6E4E3A5502CDBB72A" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O12-canonicalLower-producer.json", + "mode": "100644", + "gitBlob": "d79bfee9675230641ac695951ecbc0f6d204f8c4", + "rawBytes": 303, + "rawSHA256": "F0601F18441C8B93A79B465149FDBFFD0750CCCC0FBA3AB9AF2774F1EEEC06C6" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O13-upperCapacity-consumer.json", + "mode": "100644", + "gitBlob": "7c0ba3d100cb3e41c9b99eeb5d445cb0245639a6", + "rawBytes": 2128, + "rawSHA256": "B31525630541FE48BEB949F174D1701A8277B183FC28CF97BB1199AFC10ED419" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O13-upperCapacity-producer.json", + "mode": "100644", + "gitBlob": "4ce8209dc749af8a9b9042920c8e81a23b0325f8", + "rawBytes": 301, + "rawSHA256": "43F0E95E59C5CFC4461F7C8B95A1FEECC3D1B2C126FFDCCBB32B2B22467FEA56" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O14-allocationResidualLittleO-consumer.json", + "mode": "100644", + "gitBlob": "1a788667d16f5d00cc20987afd20b313f5a3df39", + "rawBytes": 960, + "rawSHA256": "62CCEDA85F1D17358E1A68BFD28630F20F9AC682E0D239942298EDDD8FE6A6B6" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O14-allocationResidualLittleO-producer.json", + "mode": "100644", + "gitBlob": "10fd4f212a99be14f6a459e71c8b4cb40b6c4f34", + "rawBytes": 314, + "rawSHA256": "3EEC155180DA431AD9FADFCA46F38A9384070D14DAB7677A810586E3C694F4EF" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O15-runIdentity-consumer.json", + "mode": "100644", + "gitBlob": "e25c6d2bc55ed7380644230520f6e10ffedddba8", + "rawBytes": 1323, + "rawSHA256": "754F2ADD08B6DE3D6BFDE035795C64DEB6A7FC48BA4243CFF8855D0D8AF47101" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O15-runIdentity-producer.json", + "mode": "100644", + "gitBlob": "a340cbff7c46fecdd39fac4d46237f478bb64180", + "rawBytes": 299, + "rawSHA256": "F86C15C3FB7D658C423C39576AEC4171D640F222EC58D51E7E804EEE635E9A1E" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O16-machine-consumer.json", + "mode": "100644", + "gitBlob": "803dadcbfc1f1f6e1d6226e931994ed5932e7d51", + "rawBytes": 19896, + "rawSHA256": "ED92801E3B7293F66F444845EF4D7C252A0EE539BC5C8A12BAD3E9525513E167" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O16-machine-producer.json", + "mode": "100644", + "gitBlob": "97d6250b106eb1505c29d920363fd738b3bfdb95", + "rawBytes": 296, + "rawSHA256": "B22AE9CD403B27FAE432FCA588CD28452C04C66ED950388318CF269ABE453DA4" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/P01-PUBLIC-PROPOSITION-consumer.json", + "mode": "100644", + "gitBlob": "0c34e72101a611d2a86053164a75bac871d1b099", + "rawBytes": 30175, + "rawSHA256": "32D024A563F60B2FF986BFA4662D7D034DC5204FA2C0C5966EAB18C9353E27DE" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/P01-PUBLIC-PROPOSITION-producer.json", + "mode": "100644", + "gitBlob": "3dd259d113ec9d6df0d4722aea52e0deb02f0696", + "rawBytes": 306, + "rawSHA256": "6A6D90D0B22EFD5D20371C5384BFFC8219672E5B7B146AA5B57555D8F677E9F9" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/S01-SIBLING-MEMORY-consumer.json", + "mode": "100644", + "gitBlob": "c4f4aa3db1783831d3ac0e2ed181697680084310", + "rawBytes": 2177, + "rawSHA256": "330F0D21F39A19A002DC9E11928CFB6453F811FB2FEBE3AF29B0A8D13C658624" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/S01-SIBLING-MEMORY-producer.json", + "mode": "100644", + "gitBlob": "50095f5ceb6ed9ce3f8be41123381a51a14afee0", + "rawBytes": 301, + "rawSHA256": "CDCC4AF58A601DBDEA128C7AE5DFC039003576427C154FDDFA27526AA119E936" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/S02-SIBLING-RUN-consumer.json", + "mode": "100644", + "gitBlob": "2d5c1097f25f74207a407c4a228b46ab68498709", + "rawBytes": 1792, + "rawSHA256": "4669E67F5F8963200D277714498C47C55CFA599C6B9474F9CB2A01168F9C607B" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/S02-SIBLING-RUN-producer.json", + "mode": "100644", + "gitBlob": "db82028865b978603b19276456a246574061e288", + "rawBytes": 299, + "rawSHA256": "1A26EB830A0D8CF283AC07DDE73474CE84E331E114279D887CC3E949B31281A0" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/S03-SIBLING-BUDGET-consumer.json", + "mode": "100644", + "gitBlob": "67eba3584b20d46070585b9c49535dae657bfa2c", + "rawBytes": 1243, + "rawSHA256": "1BDC90E51DA8A87C8D84C009F7721E13D3915B959A02E600B62F151D65E36341" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/S03-SIBLING-BUDGET-producer.json", + "mode": "100644", + "gitBlob": "6bc580d324162c033abfb9d113c9ed1af0fc3d9c", + "rawBytes": 302, + "rawSHA256": "DF2C6C01C04982DEE338C7D751EA6AC6F650D41FAF27CF09459BB4346C9CF7BD" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/baseline-consumer.json", + "mode": "100644", + "gitBlob": "c7f612106958cca8486f63b163476414bc282fc4", + "rawBytes": 293, + "rawSHA256": "4C8F7DFD1B77A0738AF57CAED1C5BCCA7A2E2EED4DEF70F5A77D07D78686B31A" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/baseline-generic-consumer.json", + "mode": "100644", + "gitBlob": "a34c8d6ec4090628d77663399f6d17ca9e690d4c", + "rawBytes": 300, + "rawSHA256": "764B25FB42F66405B8E8F04C6D09744D276C674ABA2E8D933F6B5E70201C437E" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/baseline-generic-producer.json", + "mode": "100644", + "gitBlob": "7fcd74c778ef62cb9832a9a06c2e7e1da13c9114", + "rawBytes": 301, + "rawSHA256": "83F1E0BBD236626DC287DF8A8F57B6248E1F184FF807C853AA7FF082E8C9213F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/baseline-inventory.json", + "mode": "100644", + "gitBlob": "b4c6b3d1e8e081922b67b7acf3f5749fb9a26328", + "rawBytes": 697, + "rawSHA256": "212879380044D9DA954945EED5C8C31B8395A76B41AE9C4E50C65EFB35B0A4B6" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/baseline-packed-producer.json", + "mode": "100644", + "gitBlob": "9cc86fd9c870c02cf33c08a6c62b480d7297c49d", + "rawBytes": 299, + "rawSHA256": "FFA658F03EA44E6974A36FB7CB7A8EF5CCCA7B42A6EE1EB34455092615F5F588" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/candidate.txt", + "mode": "100644", + "gitBlob": "aea86e28aaca292bc0d7ddbc17018da7072b3f64", + "rawBytes": 40, + "rawSHA256": "38E9F2BE4EE79EDFA800B36A3E1C3945EA26D0A4B3F9298D014293A2116E3586" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/diagnostic-boundary.lean", + "mode": "100644", + "gitBlob": "8dfb0224f2a771d50e00d47e79f440cb1b8bfded", + "rawBytes": 82, + "rawSHA256": "095AA29925219A82EE935057C12CE34296AD318BA3415B2EDE6B51A1E3101343" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/runtime-full.json", + "mode": "100644", + "gitBlob": "c124c26226a575438add25bf00cf79335dbbdc4d", + "rawBytes": 1135, + "rawSHA256": "274DA194CF15E0062FF89A8C775DF1EC8FD68C236AD074D9F345DF1E9D3AD7F4" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/runtime-known-selector.json", + "mode": "100644", + "gitBlob": "c26c7bcb5290b280e9dc9b1b7f26dc251a50de21", + "rawBytes": 576, + "rawSHA256": "017FBF50FB9F0409528FC1B5B41FDCA73AA365798CDB7A51AFF0E2E9FC216B16" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/runtime-selector-empty.json", + "mode": "100644", + "gitBlob": "b29e2a075a96d6639ed93a3dc41e3cafc4699f95", + "rawBytes": 414, + "rawSHA256": "A9EA3F0527D05F4EB2D28E45686E32EC1F77CD6018837A11AA78A5839D2CD846" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/runtime-selector-malformed.json", + "mode": "100644", + "gitBlob": "8c6714bb883df4e0e28d932d85c18ef0f6ed1e77", + "rawBytes": 442, + "rawSHA256": "1847FC1A4475A6E45F16C952F51AE441B81030F50B6A3430A13ABE0FCDC4D6FA" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/runtime-selector-unknown.json", + "mode": "100644", + "gitBlob": "bff55d182d299409b1e9cd84c1b9933883ebdac9", + "rawBytes": 446, + "rawSHA256": "CC840553F920161CBCA7B1F17E1F35EA0FDC19841776F6528DDAA38CCF6A51A0" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/runtime-selector-whitespace.json", + "mode": "100644", + "gitBlob": "c1300f6572c0b9f999abb6de473b173a2c3483d7", + "rawBytes": 429, + "rawSHA256": "4381CF8D5E38BD91674675EBE77F8A42DBE379AB4347D866B277FFB2D531F86F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/runtime-startup.json", + "mode": "100644", + "gitBlob": "f38e5bd3613fca560d8f27e12ea520ecaadf7a5a", + "rawBytes": 705, + "rawSHA256": "166FE6CD3838E2675E1FFBA69B0091F07AE5F161706B3B1375D09037D61D6B35" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/summary.json", + "mode": "100644", + "gitBlob": "4f1fd4b962b9ffc70031fb6282cefffa530e6a37", + "rawBytes": 194336, + "rawSHA256": "2747EF8ED6285B345B683D53B42A58D527B644D183DA85EBCCBCBA53B4C6062A" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/A01-BASELINE.json", + "mode": "100644", + "gitBlob": "b36e50c5d49e3b4639dc21acab3fe74df6a2e0d7", + "rawBytes": 288, + "rawSHA256": "712EC65DFCC9569BA355F40318911D3E7716E0F0B035FE9BA12A29A32F10A3DA" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/D01-NULL-DECODER-producer.json", + "mode": "100644", + "gitBlob": "42e764977304594739f9ec4cf5703269628b3f9f", + "rawBytes": 3803, + "rawSHA256": "9AB0DE276BA6F9B361462386451A6E25B6F334A45C6856F50DDBB703E78DCE1F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/D02-WRONG-DECODER-producer.json", + "mode": "100644", + "gitBlob": "d722d226522b00e14445f509c2f8f81e92ac941a", + "rawBytes": 3804, + "rawSHA256": "2891CC04C8D8C88C7FB2955549D40405CD995BFA4C1043AE744565F54437D6CE" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/D03-ZERO-SERIALIZER-producer.json", + "mode": "100644", + "gitBlob": "70a0284a157e35280ad0d22009c4c7c7a54f6cd1", + "rawBytes": 2851, + "rawSHA256": "3AAE58F5D38E558322255AA1420B437E9231D791CC05DAE73CDF25294BFFDB76" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/F01-DELETE-MEMORY-RECOVERY-consumer.json", + "mode": "100644", + "gitBlob": "0fe507d577b99e17d9bf611bb7186338ee3f8c88", + "rawBytes": 1735, + "rawSHA256": "1673359A432881002EDD754B19577266633995324429C539424BFF62E8329D8A" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/F01-DELETE-MEMORY-RECOVERY-producer.json", + "mode": "100644", + "gitBlob": "e184a8aba0d735ae126b9c275b7562e57ee7bbea", + "rawBytes": 310, + "rawSHA256": "41322BC61E93A76F80C7E231B91AC4304C0BD6AE47BB2FE88C28EF5F17524B32" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/F02-DELETE-READ-BACKING-consumer.json", + "mode": "100644", + "gitBlob": "ca7a30075d0adcb19175113ffb2f8e2dfdaa9fa7", + "rawBytes": 1092, + "rawSHA256": "23DF298F07E41EE2C0C63202ABA114DD792280AF2378040011FD9B2EA950D141" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/F02-DELETE-READ-BACKING-producer.json", + "mode": "100644", + "gitBlob": "667c60e8e5cef693288efbf0d487a8668961c0be", + "rawBytes": 307, + "rawSHA256": "5F09BF44698BD1F050EFB94264B4AC717EE4F8EF67E270D8F71DA962CDC610A8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/G01-LOWER-PROPOSITION-consumer.json", + "mode": "100644", + "gitBlob": "5fcceb46cc62cad390414281b7da700e3c8e38af", + "rawBytes": 991, + "rawSHA256": "F7EB104EAA1ECD664F10C46079E31E701D07A703F21FD9C01384E75FCE540B67" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/G01-LOWER-PROPOSITION-producer.json", + "mode": "100644", + "gitBlob": "a54a8e7fc010039cc5a51da7d35b041f5a795a60", + "rawBytes": 759, + "rawSHA256": "BAC840040065F8AC81BFDF2AF1A6F3FAE90B41030FD0B8D07E9B497D373523B9" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/G02-DELETED-EXACTNESS-producer.json", + "mode": "100644", + "gitBlob": "9d4b34aba9fefa6323d303dd0d6c5703634288cd", + "rawBytes": 6763, + "rawSHA256": "91068AF99B4E751E80E58AC3E72CB2172EF5F431886938A1C4FB6EF09C81873E" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M01-allocationResidualLittleO-consumer.json", + "mode": "100644", + "gitBlob": "5fdc54b384a5f1b998fe1d8fbd9ae2f9162a8243", + "rawBytes": 976, + "rawSHA256": "71D1DF5C907A87CE2BD5C035F73CB52F0FFEE526485345D36445DD0044A04C83" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M01-allocationResidualLittleO-producer.json", + "mode": "100644", + "gitBlob": "c7db240d3ce4c39108e43c7d663fbdcf6eac11a8", + "rawBytes": 313, + "rawSHA256": "8A1E7844ABAA65AA30027679BABCD13FC4EA299F78A92ABDFB2D4657EFD0106C" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M02-completeResidualLittleO-consumer.json", + "mode": "100644", + "gitBlob": "3ea4379fee98232b3d9208596b74fa926c215430", + "rawBytes": 976, + "rawSHA256": "CDC3E8A2EB0F138D8979E89AC9CDE1C31E7E9BBBF5F33CDAA65D360BEC167DE3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M02-completeResidualLittleO-producer.json", + "mode": "100644", + "gitBlob": "80db857dc1c1a8d5ef493b96b2a7e487c6eb7923", + "rawBytes": 311, + "rawSHA256": "B6F6E90CAE01D2C07F0FFA1F8D666719754D47886D3AACA1351E66D24D68FAF8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M03-widthBounds-consumer.json", + "mode": "100644", + "gitBlob": "dfa76663878f669419fb14ec7a80bd075d32e74f", + "rawBytes": 1064, + "rawSHA256": "4F5E49899FA2032FAF31C3A7791AD76431B8B23776A99AB607628437B20DA43A" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M03-widthBounds-producer.json", + "mode": "100644", + "gitBlob": "39b173eb0ab453ce658d1adaa1ac5f980b0dfc49", + "rawBytes": 298, + "rawSHA256": "8AD876E242FDC2DC288CE55FB93098A2B588CB27293DEDAB9C9A08DFF1DF13CC" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M04-dataCapacity-consumer.json", + "mode": "100644", + "gitBlob": "d8379c99b44e21a564d49bd87f83b03706a025d0", + "rawBytes": 1155, + "rawSHA256": "C98593CCE714DA7DB49813A7BBE861231A4C3908462928DC48CA2F773EA76C64" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M04-dataCapacity-producer.json", + "mode": "100644", + "gitBlob": "c156b356eb9462cbe6ce5fa8d09e8fcb1b31a751", + "rawBytes": 301, + "rawSHA256": "AD2BF81422144C5141EB5616D7D2D569AFB8DB9893137CDA832B2369756253DA" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M05-completeCapacity-consumer.json", + "mode": "100644", + "gitBlob": "0d2baa119663bf189d7a9cbf7af3ebcddc0b85ad", + "rawBytes": 1451, + "rawSHA256": "0141C4C7630F710B312F1C10454700C2B28AD9EAD50C669574FD39370E63BAFC" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M05-completeCapacity-producer.json", + "mode": "100644", + "gitBlob": "4981b35b9bcf919770e760cda93e0c9f33d7c4c1", + "rawBytes": 303, + "rawSHA256": "62559803035BA720A2349E4DBA44ECA652C1E5E04918429319B9AB7B4BFF6EA0" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M06-memoryWordsFit-consumer.json", + "mode": "100644", + "gitBlob": "43043e5030245bdad72735ccc5e1daca1fef6d19", + "rawBytes": 1091, + "rawSHA256": "7D6BBD1F3A2C31294E7A7249EBE684EF30A1E5B25E454E33550D9C6246959BBB" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M06-memoryWordsFit-producer.json", + "mode": "100644", + "gitBlob": "268ae7e9823c42f70c11225081c8ba8ad1c7845a", + "rawBytes": 303, + "rawSHA256": "C178B8606B69C1D5B6DB73FC6F39E1935257B191D54C1DFC9985C3746544EEBC" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M07-allocationAddressesFit-consumer.json", + "mode": "100644", + "gitBlob": "57e472d05d20b5c2175c3c708c15608165c2e4f4", + "rawBytes": 1185, + "rawSHA256": "88190A83300B391CA22CA9C7D998015AC4ECF4D9366BFDAE8A841DBC626CDF7D" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M07-allocationAddressesFit-producer.json", + "mode": "100644", + "gitBlob": "82fd86ff2830a0ee1822d5517ff2ec58b952d11b", + "rawBytes": 311, + "rawSHA256": "5019DC44AF5577D78C81211E45FEAC432F16309F446FD3F41EDBF1181C0E0B26" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M08-programFieldsFit-consumer.json", + "mode": "100644", + "gitBlob": "441b74d0546e7e3c131c78dc8c0582b51dea840d", + "rawBytes": 1156, + "rawSHA256": "EF16F170F686A289146B145C4075AF7119F6AA57674E2F4A2319C35EB4FB8C80" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M08-programFieldsFit-producer.json", + "mode": "100644", + "gitBlob": "885dc50550c0b89961162d18aaba36b24eedcc86", + "rawBytes": 305, + "rawSHA256": "9219BCC7A15020D2B10AC6C348A1BBB72AB810692617FB3444C7AAC69D495641" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M09-budgetExact-consumer.json", + "mode": "100644", + "gitBlob": "0bd6fefd7f17fa369f8c41041fd49d0af12d83b6", + "rawBytes": 922, + "rawSHA256": "C9DF567E6DD0CB566EE9FF40F60E7B48911236F85459778698B9E4DB3B2A0252" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M09-budgetExact-producer.json", + "mode": "100644", + "gitBlob": "b1aae881588c0b1760a32954a8ba9aebca5bfc7b", + "rawBytes": 300, + "rawSHA256": "1608E531132669D2AC53F2449BE94CC9B4CC47ADCAD3A31C224BAC4E08289631" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M10-programLength-consumer.json", + "mode": "100644", + "gitBlob": "68f6be23e09d4118f723c7b31a9ad1f8e822f4c9", + "rawBytes": 964, + "rawSHA256": "7271E232BF50F718DE1DEEF4BE06540D9442D4B366C93C894F9F371C8F5108EF" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M10-programLength-producer.json", + "mode": "100644", + "gitBlob": "0a67f656668449aa7d0b4323873f4fc3457efcd7", + "rawBytes": 301, + "rawSHA256": "25C1C950197E3CE1A468588BA4457D07501A1AF31B9AE20E680FCEAE576C97BD" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M11-encodedProgramBound-consumer.json", + "mode": "100644", + "gitBlob": "df1cbb5f4e14d868d445c169ea064d68a6e5b7ff", + "rawBytes": 1064, + "rawSHA256": "2328C18A6588ADAE098EADCD03B267D7ECBFD165C1D31278BCCD4E2C367E08E9" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M11-encodedProgramBound-producer.json", + "mode": "100644", + "gitBlob": "53110ef54fc1edbed50f76cb7dee386bfffde072", + "rawBytes": 308, + "rawSHA256": "C0921B3DA0680FBB7C441B5DAFE3B46DF160AD012424FD1422E28BE652E7EFB4" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M12-registerCount-consumer.json", + "mode": "100644", + "gitBlob": "1db13c308f3220b6a529098a13d1fc5f99d16515", + "rawBytes": 938, + "rawSHA256": "9FA45E657D51185E552067A412722AFB19AEF6AFB4E7128B8BB4462121EAAF7F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M12-registerCount-producer.json", + "mode": "100644", + "gitBlob": "c1c862b994a49cf198fa0aae5ebaa139f69cf95a", + "rawBytes": 301, + "rawSHA256": "D51903240B74DD58AF076986B53B0D0C23B9ADBF3FAFE9D6C1ACA27EE3FDD39A" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M13-scratchCount-consumer.json", + "mode": "100644", + "gitBlob": "bde1711ab097b93c1f8ee93c5b9f9c35f6b1b7d4", + "rawBytes": 932, + "rawSHA256": "54875D7954BD56C99B6B4D9358C28302D367A8F77380A47E3F05346D8B49B26F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M13-scratchCount-producer.json", + "mode": "100644", + "gitBlob": "5723049e23e9a155624dfa5ff49b64a0663bd476", + "rawBytes": 301, + "rawSHA256": "7601DA52430A58E68DFDDF10DA7E625E7B58BA1C0554AD2BCC8C241F13430685" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M14-unusedRegisters-consumer.json", + "mode": "100644", + "gitBlob": "6e8635bd36347f1428ec7a09a0f20462bd649f73", + "rawBytes": 1300, + "rawSHA256": "A374D680402D2B51C320CBA41BD609302936944174185957A4EAF42FBE846B0F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M14-unusedRegisters-producer.json", + "mode": "100644", + "gitBlob": "26f8d4c77c94d1235e9a143616e4f7c1ba9a4f43", + "rawBytes": 303, + "rawSHA256": "9EB1FA04C3583E90A646D59CAEED4F785029CB354F8C4854897A60C4F28AB181" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M15-validInputs-consumer.json", + "mode": "100644", + "gitBlob": "ce1392a09de6d1864837d31a5c41d96f5d7fa7de", + "rawBytes": 1398, + "rawSHA256": "2B56336F19D9FA6D09801359CA6C9D5E7F1B3A1C1FC12651B708DEE20E0F2469" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M15-validInputs-producer.json", + "mode": "100644", + "gitBlob": "3841bc888d610c5f1738af2eb0ccbfa85e683141", + "rawBytes": 300, + "rawSHA256": "78948C45E83E7714E0647673C8F168A773E61EFA5EF7DB693DE9572F4CD13070" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M16-natContract-consumer.json", + "mode": "100644", + "gitBlob": "c7ebb3c7d67b64de614a6ec3f13608eea168e5a0", + "rawBytes": 1294, + "rawSHA256": "A409BE6FEE756F258E69D03FAB2D37A14363A0ED9AB8571B6F01CFC31936A1CD" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M16-natContract-producer.json", + "mode": "100644", + "gitBlob": "23379a1093d0c9ba5d6765b97753bd883371c281", + "rawBytes": 299, + "rawSHA256": "807AB71CD7525D9330DC28E5CC4EF52157D5CCD0A5D309A763F96DBC8C48D980" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M17-leftmost-consumer.json", + "mode": "100644", + "gitBlob": "4afadb315e40a78c50a6467568167afff13ee833", + "rawBytes": 1201, + "rawSHA256": "603F8250B18880A96864A5AFD657C1140DE8F8B065384D576AB7449B06D94EBC" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M17-leftmost-producer.json", + "mode": "100644", + "gitBlob": "9178b679a9b0d9b89820bc763bf120ecd6972b69", + "rawBytes": 297, + "rawSHA256": "82380974EF079759BBE7E75B78DE2FAD505B6CD82FD40BF3407CB2E9F645072F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M18-result-consumer.json", + "mode": "100644", + "gitBlob": "715a27e818a8454507356ba9c78e0dcb83da4925", + "rawBytes": 1565, + "rawSHA256": "F91C22365E11068BE111F7B312299A562F502206EE995759A38AD915322C9CE9" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M18-result-producer.json", + "mode": "100644", + "gitBlob": "e46fb1ac92fa19dcc4be414b5e18a7a3cd924a87", + "rawBytes": 294, + "rawSHA256": "D480BC8FA9EAFF0A5AC0D37C52EF89347D7A22149626299E617CA2283DFF06DF" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M19-halt-consumer.json", + "mode": "100644", + "gitBlob": "b7d8aa589dbd8c6d015ef51ed4b09743ef22ce1c", + "rawBytes": 1589, + "rawSHA256": "0F795C0F1C0074FE2DB742BB107D38120F66E63DD155503B482EF2D9C9E556B2" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M19-halt-producer.json", + "mode": "100644", + "gitBlob": "3e771895ae91d98cbebd3bb308a22fbddde44db0", + "rawBytes": 293, + "rawSHA256": "982E151CFB0712D76CF4EF7A083475F0AC5E341895EBF0838CEBB18815DEF607" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M20-invalidGuard-consumer.json", + "mode": "100644", + "gitBlob": "a654ba5a34a25ac57327437cdd1b8f6d0cef5d91", + "rawBytes": 1801, + "rawSHA256": "4CDA65EF745B83CDB5BAF0CD9611DC0D94D74BE02B3625D72190153282A5E080" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M20-invalidGuard-producer.json", + "mode": "100644", + "gitBlob": "a41fc7386ea1803d4a5e18464eeb45094b94cf5f", + "rawBytes": 300, + "rawSHA256": "CAAE67214F6189A14E432147723496217BDDB6E6C8FA3BC493355EB5B0512F49" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M21-stepBound-consumer.json", + "mode": "100644", + "gitBlob": "42d41221b3b98d31f9ee8b459582cf7031e56b22", + "rawBytes": 1234, + "rawSHA256": "6EFA500C947041200A3CF7AD25657C54E12447FBFD2F5443CE415D19B192688C" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M21-stepBound-producer.json", + "mode": "100644", + "gitBlob": "41414ceadb3bd635a6f1414e54baaa8bee66f7c1", + "rawBytes": 297, + "rawSHA256": "57C034CA68EEB4826B1A2BAFE068D8CF9AA3A7107B5763BFED47066B0FE33829" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M22-categoryPartition-consumer.json", + "mode": "100644", + "gitBlob": "125ffedeef6786fe7a5205c64faab7105fb69547", + "rawBytes": 1950, + "rawSHA256": "A2119990B30012AFA64671101109F8CCE30D6FDEB5A7746ECEA5D1FF3E68B535" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M22-categoryPartition-producer.json", + "mode": "100644", + "gitBlob": "709c692dec1355e8a12471f2a5e2328bfc1c51e2", + "rawBytes": 305, + "rawSHA256": "981040FADBECBA59A70B959DBA4A058E42644FAE3AF11EFCF88ED6FBBCC37451" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M23-finalStateFit-consumer.json", + "mode": "100644", + "gitBlob": "95276423d9b9884463ba8757e41c20fe47ae0f5c", + "rawBytes": 1490, + "rawSHA256": "610693694F50EA05FA91F4AE101FDECAE13E925D9EBAD83F2D5E434B00D3AB11" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M23-finalStateFit-producer.json", + "mode": "100644", + "gitBlob": "13b195af966076d4a4c0ad97fc913b381b0ac7c6", + "rawBytes": 302, + "rawSHA256": "1C87A51CC9A7CAE61A62C747B987859096A785D6672D6CE82A95A67944FBE75E" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M24-transitionSafety-consumer.json", + "mode": "100644", + "gitBlob": "04e5e010781b81de0c7a56b126b49e7426d7c8c2", + "rawBytes": 1957, + "rawSHA256": "7D78E556A32D4446C8B29E444EAB5F66F123F090A30F4ADE1F5F96D77002DD98" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M24-transitionSafety-producer.json", + "mode": "100644", + "gitBlob": "c0241b261d7301268f4c3fee7bda7def50857890", + "rawBytes": 305, + "rawSHA256": "6B79612CBC2D452146DF208F23EBC465DA0081493D4BA6F2EC09EBB2D66C2EEC" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M25-prefixSafety-consumer.json", + "mode": "100644", + "gitBlob": "823206cab90b0305696dbff191120f89f20d855c", + "rawBytes": 1643, + "rawSHA256": "35444C870AA75B7EB8E3BA7E26C1D6B6028B6051E2E20B96F299C530A1A85F63" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M25-prefixSafety-producer.json", + "mode": "100644", + "gitBlob": "9547770cd87e21688eb2c550b119d289677adae3", + "rawBytes": 300, + "rawSHA256": "B95451295B9B85456A668553A59D03B82100078D5D66EFB49B7A67CCF4414656" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M26-readWidth-consumer.json", + "mode": "100644", + "gitBlob": "27f445d4fcb58e61b896f2c431ceb7d89d4550bc", + "rawBytes": 2302, + "rawSHA256": "016FB0EF469E88BAC1018FA6344695ED137BAAE1440C579B6E9CB9A6E6F037DD" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M26-readWidth-producer.json", + "mode": "100644", + "gitBlob": "c70e227168370b7273d81ac2ca412faeca71f13b", + "rawBytes": 298, + "rawSHA256": "55AF6B836CCA2AA24E9E5B8023078FD6E4C1B09355D415DBE1EBC9D08346966B" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M27-positionalReadBacking-consumer.json", + "mode": "100644", + "gitBlob": "f6628d222bb5f4b3eaa16f100aa8d30452d318f0", + "rawBytes": 2732, + "rawSHA256": "6C1FF48B31C44A8CBAF504AE600D0115583858E2A1A0028EBD85439D2897104B" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M27-positionalReadBacking-producer.json", + "mode": "100644", + "gitBlob": "64a5753982131fb587c4f523479589873113295a", + "rawBytes": 308, + "rawSHA256": "080AF5351A2CD5037B743D790D805826D03DEAFF01E8B7270ACEF43980D9E984" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M28-orderedLogicalRefinement-consumer.json", + "mode": "100644", + "gitBlob": "d7c8ce16126e3489080313ff526c226b4727059f", + "rawBytes": 2013, + "rawSHA256": "66E4B7A182D7793914F095E2C9041895E1B26BBBBFA4570B92C943A0898B6A5F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M28-orderedLogicalRefinement-producer.json", + "mode": "100644", + "gitBlob": "e6a003f4b64f816246e1d87ca55e87b51a44ab43", + "rawBytes": 312, + "rawSHA256": "9671362FFEC26BA86AE3F71E2176B07AAEB07D6C8330220980F687E5B0EA1709" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M29-logicalReadOnly-consumer.json", + "mode": "100644", + "gitBlob": "a4120726256164023548761592303f047b0262af", + "rawBytes": 1110, + "rawSHA256": "3A1011B6A80B914704A35357173B08311EA0578323E54DEBC6009E3FDD255AA1" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M29-logicalReadOnly-producer.json", + "mode": "100644", + "gitBlob": "3dc3c065a9c78a79c0ad6ad3fad5ec1797f91427", + "rawBytes": 303, + "rawSHA256": "3BD1A2488A0B1D856BF01D55FE49022C2B0A6B324E127CE7AF774FAE49F335B1" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M30-suppliedMemoryAgreement-consumer.json", + "mode": "100644", + "gitBlob": "52b9aa22ea1e2432aad05b10d0ecafff3e344d99", + "rawBytes": 1942, + "rawSHA256": "1C2BBAB15A8244915CA2C0DC82F3CF11A9392004792950B4444BF39CB87CE7A2" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M30-suppliedMemoryAgreement-producer.json", + "mode": "100644", + "gitBlob": "51608ee269331c156d358de25801e3624def894e", + "rawBytes": 311, + "rawSHA256": "2684AA2C25E2FC9DA94A4A237440369C66C02EC749EC46A85B2F52D96C0D6A24" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M31-specResult-consumer.json", + "mode": "100644", + "gitBlob": "51e67c3e1ba32d0351cce3a2d8e5ff9cbb672265", + "rawBytes": 1391, + "rawSHA256": "F69DB00C6D3314EF11A66FC7A02DF07C47C245A25163CEA3A33A421CADC94317" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M31-specResult-producer.json", + "mode": "100644", + "gitBlob": "c3bfb7ffa03fe20b9c72507876a87c47353475ab", + "rawBytes": 298, + "rawSHA256": "6296098DE870D6751744BBD682A9F2A8DEB0C681566F5001955104B50A1B0B5E" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M32-noFailedLoads-consumer.json", + "mode": "100644", + "gitBlob": "3c9e870173dd38dd34851e01c78b16601128e819", + "rawBytes": 1498, + "rawSHA256": "26EE8963319C82618845E90CD5D0DF747AF1A8E8CD735A4CB56E1787DEC2862F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M32-noFailedLoads-producer.json", + "mode": "100644", + "gitBlob": "e2ec911c0f913ba52b846c6539336024c2a0c771", + "rawBytes": 300, + "rawSHA256": "B1B9E0E5825029A2C5B359C8F9B22D32A4A1578816F63B5596A7D6FD4E52CFAB" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M33-invalidGuardSteps-consumer.json", + "mode": "100644", + "gitBlob": "8cc3a292cb6d36d823f2b2f81ad8c976ce134dd3", + "rawBytes": 1300, + "rawSHA256": "DFD47A5BE28BB4BD05589E3CB1DDA6C61F255B77CEAB2623CB45D710966ADF44" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M33-invalidGuardSteps-producer.json", + "mode": "100644", + "gitBlob": "3115df21a7faca671e2f7cd962e7c898b33a81ac", + "rawBytes": 305, + "rawSHA256": "D4467AA385CDB38C4772EA0BB5DA34BD1E65EAC3879F074FB1B06249730FD109" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O01-wordRoundTrip-consumer.json", + "mode": "100644", + "gitBlob": "e16045deb02e18c3ed46d4f16b79a07fbaa14f2b", + "rawBytes": 1296, + "rawSHA256": "25436D389FB8ABFFB4AA8EA39996882A1B812E9873059B8569F0AD2E77B91FAF" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O01-wordRoundTrip-producer.json", + "mode": "100644", + "gitBlob": "9365c1b52f7a42f53b024b3d38c04d0fa37397c5", + "rawBytes": 302, + "rawSHA256": "D6283CFBD841A7939C4ACBA52C828CBCEF540D4144DB87D58BD332B05362B133" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O02-wordSerializationInjective-consumer.json", + "mode": "100644", + "gitBlob": "4b7e74523bcca1ffc0ebadd7aac4fc1b5b7549dd", + "rawBytes": 1539, + "rawSHA256": "D4204EBE59276DB3FDA625575C3BA4393468C7A5409C9E988340994A780EEA7B" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O02-wordSerializationInjective-producer.json", + "mode": "100644", + "gitBlob": "b55bd4e4a1cf5e91efcb69dd167339ca6b2dad89", + "rawBytes": 315, + "rawSHA256": "AAB4C9363098F58D0CCED354122432B317D6154C77D89817BEF8D0776080EC94" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O03-serializedLength-consumer.json", + "mode": "100644", + "gitBlob": "b888736b968fc7510fa3b7de889094488e8b74cf", + "rawBytes": 2075, + "rawSHA256": "EFE0D627007D44F095AADB0AD8784235D99946D5A08FA943440DAC9EEB7CA6E3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O03-serializedLength-producer.json", + "mode": "100644", + "gitBlob": "86ef2d9cb4618a008bdcb659ef77b72e5b52c7e3", + "rawBytes": 305, + "rawSHA256": "76E0286104BD383586A629E70652485DA75A295FAEA743F886906B5E7F17430F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O04-memoryRecovery-consumer.json", + "mode": "100644", + "gitBlob": "2d3271b9911eb842c0127eef653f16e589b32a7e", + "rawBytes": 1921, + "rawSHA256": "E396D838D8FC9BE31E8C840AFB0C60D6FBE5913AF8C66FFE4A2A747A08F556BE" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O04-memoryRecovery-producer.json", + "mode": "100644", + "gitBlob": "e4378daeeb11603280e18971ca8f06c15838898e", + "rawBytes": 303, + "rawSHA256": "9651BA49EE2714497B8D5E549A449D26E0EDA7569AEB0610F1B3213FCF210A3F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O05-decoderExact-consumer.json", + "mode": "100644", + "gitBlob": "b5950d003b664f0abf13d39fe0660c1ab31e5ea7", + "rawBytes": 2531, + "rawSHA256": "C3309947ADFD7C38903B5C0D95375C19BDEF58981125C59265C2764509000C29" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O05-decoderExact-producer.json", + "mode": "100644", + "gitBlob": "5a0f3095248c56d5dacc34cb04bb8eac75d6e80c", + "rawBytes": 300, + "rawSHA256": "DA2573AAF016390BCFF800D081A8BF51DF4A56E375E5A644368FC96FA7C07498" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O06-decoderLeftmost-consumer.json", + "mode": "100644", + "gitBlob": "bf1200287b64483870daeeede375e87d99058993", + "rawBytes": 1212, + "rawSHA256": "0149BE9EB0BA4697A51BE013641188BF9CE982787034FAD8CCF9A321443A918E" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O06-decoderLeftmost-producer.json", + "mode": "100644", + "gitBlob": "45ddb98b882a82225494d9b6143bc9da7393524b", + "rawBytes": 303, + "rawSHA256": "B4EAF72D6E4C0F52253C5183B444B4467BA0A5C056EBC8B5E1308AC2F7399BC0" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O07-sameShapeMemory-consumer.json", + "mode": "100644", + "gitBlob": "2934cd287c527ee0374ed65e921ce13bffd12849", + "rawBytes": 1032, + "rawSHA256": "53FCA2AE56727669E398D3DDBED813DDCFDEEC90A1E923D1ACE40EB62650C6D6" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O07-sameShapeMemory-producer.json", + "mode": "100644", + "gitBlob": "f7a9754ab7b4bbe90b28d8aaed275b50d465c729", + "rawBytes": 303, + "rawSHA256": "57FD1836D25FF7DE7873C77A4AE79C565C95D5A6678501915B42A9727A9A4F4C" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O08-shapeInjectivity-consumer.json", + "mode": "100644", + "gitBlob": "16d5092d45d2519dcf8e26603dac008d9124c09b", + "rawBytes": 1361, + "rawSHA256": "DF53E542B880729EC6AEBDF07A3BD8CFEC7EC4C71E477B936979A8076E6535EA" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O08-shapeInjectivity-producer.json", + "mode": "100644", + "gitBlob": "5265fee757b9431b226db9a3baf163707a740d56", + "rawBytes": 304, + "rawSHA256": "F68612AC0380FA702AA6C2EE27456EFB7D0AC02C532BED36136E88D43137CD23" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O09-uniformBudgetCount-consumer.json", + "mode": "100644", + "gitBlob": "0e4abfcebbc003b854237369faced71116a99927", + "rawBytes": 1047, + "rawSHA256": "DA7AFB39C9AF4945126CBBD139F5DF244B2AC1F9C3A2B4F5801A5A3A3DB35E44" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O09-uniformBudgetCount-producer.json", + "mode": "100644", + "gitBlob": "913815a8ec799082c081155c4ef2aab99e74a3b6", + "rawBytes": 306, + "rawSHA256": "117B32A6CAAB0E48F647122EEC6CD8BB6D92549AFE763EDBDBCD68FD173E7575" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O10-uniformBudgetLower-consumer.json", + "mode": "100644", + "gitBlob": "5456d8004a1ed8365cfed40b5fd1ef30530a80b1", + "rawBytes": 2299, + "rawSHA256": "636C6393AEEA1A6B457DCB93F2CD35310CC351996A71D9E575C5E467E9731BC3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O10-uniformBudgetLower-producer.json", + "mode": "100644", + "gitBlob": "7414f705eed3d593e58a5a32722d16c3639d15d3", + "rawBytes": 306, + "rawSHA256": "33AF7F49FBCC886F4973D09C6E2846BF484335C8E4175F472CA498B74DE6325E" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O11-canonicalCount-consumer.json", + "mode": "100644", + "gitBlob": "7e4843e8d9e4fa0f99e0f3707cc1acd8729bff60", + "rawBytes": 1011, + "rawSHA256": "0BF6F0ECE3E66F670E380334BAAC904137B9B7DCDB19A52126F15D0F689AD18F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O11-canonicalCount-producer.json", + "mode": "100644", + "gitBlob": "b3d6b22413dab64521c382ef340b57cf010e3a74", + "rawBytes": 302, + "rawSHA256": "21713190071EA86D0EB9F75D0A85AEAF90079225D8DBEA863EE22F43985C9824" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O12-canonicalLower-consumer.json", + "mode": "100644", + "gitBlob": "dac62a2263fec74870fd1e4b01703a7102c60e95", + "rawBytes": 1061, + "rawSHA256": "908E54E31102B54F2ED731CB7439B88F2899BE7FE510F971812220745C474529" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O12-canonicalLower-producer.json", + "mode": "100644", + "gitBlob": "5bb0612a8ed31d08e6fdbad70860216bafc05b86", + "rawBytes": 302, + "rawSHA256": "31E97A7FC737852FF89F336CA237CE7DEE72B84CF8BA8709938DD7EC2BCBE8BA" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O13-upperCapacity-consumer.json", + "mode": "100644", + "gitBlob": "e169b6636c5419d6592c4188202a410a480e617a", + "rawBytes": 2128, + "rawSHA256": "29D8799807CA8E2C82D58599BC34FC697B4D6264D8AB4A82D43307572E54F83A" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O13-upperCapacity-producer.json", + "mode": "100644", + "gitBlob": "b3303e4d14c6002ea9d1b13a2e1fef6977ebfb10", + "rawBytes": 301, + "rawSHA256": "E8560D7501B44A5EFAE7D734AA706BD57FB2AF84E54E2191BB308B0446DD5760" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O14-allocationResidualLittleO-consumer.json", + "mode": "100644", + "gitBlob": "879fbde25fe62cf7fccaf0d7ba75dc4cc9476c0a", + "rawBytes": 959, + "rawSHA256": "4ED269205BE7D8AD960B0577C33D4462147EA16DE19345BAF25D25585396480D" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O14-allocationResidualLittleO-producer.json", + "mode": "100644", + "gitBlob": "9c2a7af08e1e437093bd363dbbed2af9201d8b53", + "rawBytes": 313, + "rawSHA256": "F636C9083DEC9423B7069074B8E7B2DAED40C4038C0E5DD7F58D9A16708C283A" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O15-runIdentity-consumer.json", + "mode": "100644", + "gitBlob": "a4ae87b8ac57e8ef08ed05c4b41e25eb69deee50", + "rawBytes": 1324, + "rawSHA256": "D8762ED56920649DD49EF8EA0B1912B853392F0174C61CC7A0A088EA2A0F0291" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O15-runIdentity-producer.json", + "mode": "100644", + "gitBlob": "cf2b040241c5a03cbd0469286e9b60d7bacef3dd", + "rawBytes": 298, + "rawSHA256": "1C1153403D51501E95AFE2BCC85AE00CBD3BC5F77D6C621305616616A680315B" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O16-machine-consumer.json", + "mode": "100644", + "gitBlob": "e428d1c078b91272f455427cb7288aedad8991ed", + "rawBytes": 19896, + "rawSHA256": "8DA50654B60E400FBFD53DC36DC0C2C54C3957094060D65D80B553809449429C" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O16-machine-producer.json", + "mode": "100644", + "gitBlob": "12997512a98507be7356179306504bc3bae9c781", + "rawBytes": 295, + "rawSHA256": "23118787B5DB8807E2DCE020CABC3AAA90237618FA4DA0E03A057888F0FDD1E3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/P01-PUBLIC-PROPOSITION-consumer.json", + "mode": "100644", + "gitBlob": "494d00ec08d7fa14256cbadbf34f9ae19fb0338f", + "rawBytes": 30173, + "rawSHA256": "C0DA99ECD914A8295528E3E63566EBB448D70651FD56E74B77ADB2C0E592F150" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/P01-PUBLIC-PROPOSITION-producer.json", + "mode": "100644", + "gitBlob": "06f0e3eb9674cf9c1354cad05e62dcfac0e257e3", + "rawBytes": 306, + "rawSHA256": "FDE7593ADA182FC3A19A22FBF5445AA0A1D4A314244DCDE79B6FC32405DBD34A" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/S01-SIBLING-MEMORY-consumer.json", + "mode": "100644", + "gitBlob": "1a474022340165ddb13a351dfa933b6e76ef221e", + "rawBytes": 2177, + "rawSHA256": "D38E762FA6D8AEEFC2565C43EB1E8A479AA4556FEE7FDC640475C422DB423C80" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/S01-SIBLING-MEMORY-producer.json", + "mode": "100644", + "gitBlob": "27726bcc57cccf604907ef8e3b740d92405fccc0", + "rawBytes": 302, + "rawSHA256": "F1557AD5988031F6598CB9B2EFBCC4A4DBFDAFBB5519C8246E020632A836AB03" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/S02-SIBLING-RUN-consumer.json", + "mode": "100644", + "gitBlob": "6a4fdc8b2ac79a4d6cc0ceec109a0019db84ba43", + "rawBytes": 1792, + "rawSHA256": "A746652C8E0A4F2BF0E02F9365945B13E70311DD5F7467DD961C28337F7AE856" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/S02-SIBLING-RUN-producer.json", + "mode": "100644", + "gitBlob": "03566145ef28a07025ec16b44ead4b0fb20bbf73", + "rawBytes": 299, + "rawSHA256": "02F78268B1133836FE2C87333A79A12E46A8308880D6648EF9D086074A4FE336" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/S03-SIBLING-BUDGET-consumer.json", + "mode": "100644", + "gitBlob": "d8b59b4420c91f991cbfd2f94f770b33c468953c", + "rawBytes": 889, + "rawSHA256": "85DDAFF9947135F7DEB02C69B99698A78F9ED2003D4FA17863F0408C42D4FE00" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/S03-SIBLING-BUDGET-producer.json", + "mode": "100644", + "gitBlob": "315cb225ccbd4f023f1575152879146aa2c34f76", + "rawBytes": 302, + "rawSHA256": "0C640F319F08F91E74398D6F77048B4A04D987CB8FA9457C6B2E2FFF67ABF19F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/baseline-consumer.json", + "mode": "100644", + "gitBlob": "377e01237906cacafd980185d7ee47b9bd4aa4e8", + "rawBytes": 293, + "rawSHA256": "4655295D1086E0AD8DC862CDC1EDF7512B577C1CC3E1C8668F7698BA5B93ED86" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/baseline-generic-consumer.json", + "mode": "100644", + "gitBlob": "7cc6d049b667ad6d4662249848ff6b37063499ed", + "rawBytes": 299, + "rawSHA256": "A3BC0FB07665C1D64444F12F942029C63D1F9F99C71E37C8B37C6A9BECD19C88" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/baseline-generic-producer.json", + "mode": "100644", + "gitBlob": "0d454b9429f04b1eb41fcd4f6a10126b1b476903", + "rawBytes": 300, + "rawSHA256": "E93155EBA9DC93E41F07759DD9D2EFD883FD9E630BC009336FA28201CD1D3B48" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/baseline-inventory.json", + "mode": "100644", + "gitBlob": "4218a40b84214145749c9e907352dd1eb2f2a912", + "rawBytes": 698, + "rawSHA256": "D67E6FCE332574D05C0EBC425117D842B90BCEB17B102E7C289B257D081235FE" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/baseline-packed-producer.json", + "mode": "100644", + "gitBlob": "bdd5e229b5b11a0135b302458b7b63b08553d5b0", + "rawBytes": 299, + "rawSHA256": "414F7F7D67E510BA2E48F069BCD80038AC58D3622988A2D397C6A92A01D817C0" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/candidate.txt", + "mode": "100644", + "gitBlob": "98de6cff20ed9739418d9fdbb549d8d137912f36", + "rawBytes": 40, + "rawSHA256": "DA3E11358B1CC9538B488DD85B61FDD57C44FB43641201CC68443BB56E377777" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/manifest.json", + "mode": "100644", + "gitBlob": "6f1731fb81a8be5d6169a107060dea1fb99558db", + "rawBytes": 41823, + "rawSHA256": "F2AE19631427F321E1E7878F17007A75DA916C4A555AA342AC00A1C5142A7D09" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/runtime-full.json", + "mode": "100644", + "gitBlob": "fa7892e018d86d7d457c2786e99008356a091c37", + "rawBytes": 1135, + "rawSHA256": "559F8A0C3ACC4CAA060A94A25DBF0D62B43D5ED3BE95ADBA327773152FF5A306" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/runtime-known-selector.json", + "mode": "100644", + "gitBlob": "5a6ef1280e13a0847e642016969d058e1a58d078", + "rawBytes": 576, + "rawSHA256": "E097E7ABF6891F6D04B581CABAA24537F3EA451DDB0DF74D56F94A8A643F3083" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/runtime-selector-empty.json", + "mode": "100644", + "gitBlob": "a5087e468bc4d73c17dbb73eb2535cce6c2b5620", + "rawBytes": 414, + "rawSHA256": "99B58979B5805894DCFC5B5A4614AF30950B986DB59018D598B467854F6434EF" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/runtime-selector-malformed.json", + "mode": "100644", + "gitBlob": "a6964d25774cfc79227833d24adabb122c236f9e", + "rawBytes": 442, + "rawSHA256": "15C77E77B560B2C3CFFC96A4C79FC70E3CE14A36B91DC4CFD0C00E4D31451E4D" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/runtime-selector-unknown.json", + "mode": "100644", + "gitBlob": "c94e6eb6f56a59fbb2087274a10d70438437bd73", + "rawBytes": 446, + "rawSHA256": "C15CF894B9B9BD4F24F0915BA81F2F5801937252EF6F0C291BF7D38A8FD9DABB" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/runtime-selector-whitespace.json", + "mode": "100644", + "gitBlob": "ff95bfeaab19ae74d737100b1095c5af2a4d48d1", + "rawBytes": 429, + "rawSHA256": "F11C1C023CBFB717B43353F3B2F3C30D29D821ECA20FBA5CE35B261DF0418B53" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/runtime-startup.json", + "mode": "100644", + "gitBlob": "e20df29d7483908806ff4255eddaa87a6a16335a", + "rawBytes": 705, + "rawSHA256": "ECB45140B2EE7E49C007E68FC36C63D80524417EA5FD54590A0C2FE2E3612FF6" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/terminal-receipt.json", + "mode": "100644", + "gitBlob": "6e205d103a39324845f4498f3a82030203672857", + "rawBytes": 848, + "rawSHA256": "19A0B34B0EC4E7AC5682B37F81D221EF3525573A6659ADBDCF7AC2CCDFA50D3F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/report-check-discovery.json", + "mode": "100644", + "gitBlob": "0deb8f140e24233cad9d31c8349418f31992206c", + "rawBytes": 907, + "rawSHA256": "F04AA797EB9B7E5CBE2F599291D5141F372981179615F27F942BA3F636924D11" + }, + { + "path": "docs/internal/extensions/lb1/evidence/report-checks.json", + "mode": "100644", + "gitBlob": "d137c85f81c3c22f8461d2d8a8dec507e6dbce45", + "rawBytes": 3703, + "rawSHA256": "26B8BE7E1F206C890F3F2212D24A2B60031FEAD2309EC807BE938442EC41C7D4" + }, + { + "path": "docs/internal/extensions/lb1/evidence/selector-controls-v2.json", + "mode": "100644", + "gitBlob": "bd0a3b0bbfdaf3e327cac7834e6aab0f5461a165", + "rawBytes": 8594, + "rawSHA256": "3A0636A0995AD0B132A9488309595B4ED23284896D477CC89E500E150C93C82F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/selector-controls-v3.json", + "mode": "100644", + "gitBlob": "f83e78c3fa9770e9d73b383a0ced5cc87f340250", + "rawBytes": 8643, + "rawSHA256": "26C73B74BAF4EC5B56A9F8071EAA906594E1717C5D3AA972E2DA25D0BD814234" + }, + { + "path": "docs/internal/extensions/lb1/evidence/selector-extra-5033/REPLAY-CLI-ENV-CONFLICT.json", + "mode": "100644", + "gitBlob": "173e7e729b124707d64b710a8fc99e4592fad8d8", + "rawBytes": 2944, + "rawSHA256": "CB8D97B487D4BF17E375B1678603B3EB9A8DB2D50510231F63802E939B5B7B09" + }, + { + "path": "docs/internal/extensions/lb1/evidence/selector-extra-5033/RUNTIME-CLI-ENV-CONFLICT.json", + "mode": "100644", + "gitBlob": "7ec2bb4c9c6b3d0ad21c7a7134f8e736124f4b2a", + "rawBytes": 2484, + "rawSHA256": "492C4796A504E51A65EF1F97A0834742A0D354DC89B2EB4AE31004815520D345" + }, + { + "path": "docs/internal/extensions/lb1/evidence/selector-extra-5033/RUNTIME-MALFORMED-ID.json", + "mode": "100644", + "gitBlob": "1c3fd9f521e05bd9d03e6cca6a55f9bd2e0fe564", + "rawBytes": 2415, + "rawSHA256": "D788DD531D1AB304A0A7D999726513E21207E23D744993D4364B30306E7C665D" + }, + { + "path": "docs/internal/extensions/lb1/evidence/selector-extra-5033/summary.json", + "mode": "100644", + "gitBlob": "6cfdf835abd6d733bf82ed4f4fdf7d4c0748109f", + "rawBytes": 9276, + "rawSHA256": "61B0AE5B51BEA3FDDF89C998CE4F0E32D88315FA002A5A1518B87D4840E4A5A8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/startup-development.json", + "mode": "100644", + "gitBlob": "b542a4c4ad6fa1c9c8428cb782f523bb7fdd4a39", + "rawBytes": 2010, + "rawSHA256": "B430C3F819E0BC17C72D6D9186ECFF393E4D603A9FBAD4BB905C81FEE2CE062B" + }, + { + "path": "docs/internal/extensions/lb1/evidence/startup-preflight.txt", + "mode": "100644", + "gitBlob": "eb5bbe671fd725be5acbd57b43efb76d2aa3f610", + "rawBytes": 819, + "rawSHA256": "5F6D25B0E4B8CCC9D133EA718BCCD1044CC22A1DF380E8FD56C57FDFB840B0CA" + }, + { + "path": "docs/internal/extensions/lb1/evidence/trust-5033/axiom-inventory.json", + "mode": "100644", + "gitBlob": "fde873811886f8d46353b11ed14f5400f58ff2ba", + "rawBytes": 7453, + "rawSHA256": "C8F1257B67B481F8CCADEDD9073C96F550EF21AB683909E1F361477DDDC0DE70" + }, + { + "path": "docs/internal/extensions/lb1/evidence/trust-5033/summary.json", + "mode": "100644", + "gitBlob": "b73c763570f7286f7a02ffd152d383a906b21361", + "rawBytes": 5963, + "rawSHA256": "B3231DA95191829471F5D1110F2F4545E3B4D29EB56F05B145A5A2BEABDF5641" + }, + { + "path": "docs/internal/extensions/lb1/evidence/version-20260912T084142579.json", + "mode": "100644", + "gitBlob": "3ef45fe92b0ac9ef0eb7bf4cac5d389ae8df1434", + "rawBytes": 516, + "rawSHA256": "D5446F92B7C94981E647FED1649D3998EF199D61E0E6ED9C42AA8CB3CC2AE8AB" + }, + { + "path": "docs/internal/extensions/lb1/evidence/version-20260912T084243070.json", + "mode": "100644", + "gitBlob": "e02d64674b20315fb72ee5d23224eba5f9c99a44", + "rawBytes": 516, + "rawSHA256": "B17F4335522E25A27EA0698C699FC68B8B805B7DF8A76A6FD973EBAD83CFA0F3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/version-20260912T084355841.json", + "mode": "100644", + "gitBlob": "f236f7e8a6ac3f3d867710718bd1ae8d0703458f", + "rawBytes": 516, + "rawSHA256": "BFD6BE406D367887D822BF5DAFEE4160CE799A37ED9DAA36670EFF966F565574" + }, + { + "path": "docs/internal/extensions/lb1/evidence/version-20260912T100805553.json", + "mode": "100644", + "gitBlob": "43f2bfc477dc043484349663d3497205f8e631df", + "rawBytes": 516, + "rawSHA256": "0810B4E5EA75A3BF2299D0B16FD847D885319B647049CE155023F7797DAF558A" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/.gitattributes", + "mode": "100644", + "gitBlob": "32c5ed886b694aef66c38c0624568b9a0eb1b6cf", + "rawBytes": 94, + "rawSHA256": "452DE0B852AB4578105E47480AB75D7CFC9195F3619DDF189BA73AE2884DE295" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "9b07c65cd0250e29faa95ddc7d2fd7781b45e867", + "rawBytes": 18447, + "rawSHA256": "AEB07F3DF8638ED47705800B2F00DAB42695F35CE6678B95050DFDFB1F0FCA03" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/ACCEPTANCE_ROWS.txt", + "mode": "100644", + "gitBlob": "fe30a2239762f3a16070a093c759d471eee1ec3e", + "rawBytes": 8534, + "rawSHA256": "F45113AE6BF3F769105A748B3D0A61EA99532A05A715410F11EF29E7E518EC29" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/BASELINE.json", + "mode": "100644", + "gitBlob": "9cbf9adaa47ce7b79b4e534befc6c64d2de9d8ba", + "rawBytes": 5699, + "rawSHA256": "DA869E0C2AC50C3CC042C6C44ECCEF4E3DE9C59BF205AD8DBA888B9410C67238" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/BOUNDARY.md", + "mode": "100644", + "gitBlob": "f51cf6c0ea28f8476e953716e9755b3c2015133c", + "rawBytes": 10306, + "rawSHA256": "DA0F91F7DF36708936EF31E6C17F382FCB7A928E74D57A4B68AAE9B96B189F87" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/CERTIFICATION.json", + "mode": "100644", + "gitBlob": "00a9d01cbc85027ed88831617ccb6cb27025dae5", + "rawBytes": 9683, + "rawSHA256": "757F8EC4491F65A6D931B1D7E2F03C53F360FA6BE5A34F228BB43A6519E78B72" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/REGISTRY.json", + "mode": "100644", + "gitBlob": "79c348f3218c96576b58d9b37f68ba726fe92c30", + "rawBytes": 5899, + "rawSHA256": "6CD97F40E7C39D2212A8C8705D264D4832DCF2542815B72CD927906A01DC8B20" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/REPORT.md", + "mode": "100644", + "gitBlob": "1d81ea295c38e447102190c05afa08aad4f32a82", + "rawBytes": 25211, + "rawSHA256": "658652FEB62B1A5DCEEC2BCC030C3DF3A24B19B8D34933A8FA4561142C8CFD98" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/REQUIREMENTS.json", + "mode": "100644", + "gitBlob": "934885ad0379893486695c78dfcfe6ebf1773677", + "rawBytes": 4361, + "rawSHA256": "0983881A85F9A3B42ECD54C0BFB18170C3BE3E5A65602CDE66547042CA5421C9" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/RESULTS.json", + "mode": "100644", + "gitBlob": "bca831965f01334670c774b2a08b4a5191bef3f6", + "rawBytes": 63804, + "rawSHA256": "6440A963BE7A0E65222F86AFE3CFB89E4BEE1B6BDCD0226DC0D5CDA88D296FDD" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/RUNTIME_SOURCE.json", + "mode": "100644", + "gitBlob": "93989d23e91a6493da487e9f0ad29be9baefcc60", + "rawBytes": 1398, + "rawSHA256": "F32AA70D04AA8FE2A14873DA0E6B22501781187544B5335918A7925221C7E9A6" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/START.json", + "mode": "100644", + "gitBlob": "dd481854de39bee665b40c93320c33f1af90e5a4", + "rawBytes": 1174, + "rawSHA256": "1718F02C23F770AA00E288E27C355CA2D78D2CEC6AEBD4CC017C2300D6DA0F90" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/VERIFY_CONTRACT.ps1", + "mode": "100644", + "gitBlob": "67f044f96d61fad65566542e580d1196f558ed24", + "rawBytes": 2236, + "rawSHA256": "00D16569E407149CFAEA1A8C34CB81F72CFF6FBA02FF45841F67C91EEB2AB957" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "80a023437613d52c6b2bd30da914c49a0764b1e9", + "rawBytes": 13436, + "rawSHA256": "236480A9AB5A68AEF83824D3AA31DDEE8C170203F53C5F6C61CB8ED0AEF76925" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/ACCEPTANCE_ROWS.txt", + "mode": "100644", + "gitBlob": "64ba642be3e814192975653c6ab11de3bc5ad375", + "rawBytes": 10983, + "rawSHA256": "74982691E40EB56A10365F66E74877F6518C0A13E959F559E267047BDAC7130E" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/REPORT.md", + "mode": "100644", + "gitBlob": "24aa7738d5a920d2e0c2d9b8e23a1ce6044cdddd", + "rawBytes": 25981, + "rawSHA256": "2C260FA9AD51034B1684ED011FDF1CC7CE5E0B485CF3950061E7FD5CFAAC34FE" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/RESULTS.json", + "mode": "100644", + "gitBlob": "ff80bb068f63d4c7007bf503bfae5e8548beafdf", + "rawBytes": 98423, + "rawSHA256": "9313E4C20C4326B62F5CF4174BD5D57B54E300480AE48EB97D4AA74F8EBFF8A1" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/SOURCE_REVIEW.md", + "mode": "100644", + "gitBlob": "2ee84e9c7095f899e4ea47ae81dfb363db827320", + "rawBytes": 5495, + "rawSHA256": "2B865AB9AACB43A5BBA2FB7C5C7AF9D5A98FF005CCFE01937689DF6D49C2377E" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/START.json", + "mode": "100644", + "gitBlob": "4201934432978b7e31fe19811e8be4889e260586", + "rawBytes": 1004, + "rawSHA256": "9D6A31B3847994C4058625F5AEEE2014F222266BF91359610BD8B64E5A2594B0" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/dependency_controls.ps1", + "mode": "100644", + "gitBlob": "ba23024d2167bde1da22c7c018436be7030404b6", + "rawBytes": 5705, + "rawSHA256": "6BC73AD9F00C72A4E2A2D3EB4C38E8EFB33A2983A530AD70E5E9C4E6A10C38ED" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/final_checks.ps1", + "mode": "100644", + "gitBlob": "1454af7b0e52f13439a11302859a17ef4a2b8173", + "rawBytes": 2483, + "rawSHA256": "EEE489C244B35FAF8E1E480F439EB637937A4CCD33B64F889599C0B87A70DCBD" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/freeze_contract.py", + "mode": "100644", + "gitBlob": "94751a0515e077170217cffcebca381dcf0fc277", + "rawBytes": 5677, + "rawSHA256": "83FF711B0D2774690BBA99A6EC92C9E8D9C1AB5D3479716EBA78D3BEB62CFDB7" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/integrity_controls.ps1", + "mode": "100644", + "gitBlob": "2b3907ec07041d16f9f7130b337d670615121c6c", + "rawBytes": 16062, + "rawSHA256": "7D3C787D00E41C5639102FD9F4EDAD42CEAB621C7637DF36D8834A505192BF77" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/run_owned.ps1", + "mode": "100644", + "gitBlob": "248d2fdd07bf7282c76dd236ccf6989c07001ecb", + "rawBytes": 4728, + "rawSHA256": "7269C6500F6D04904A14F5C32E2AB000F702577BACFCC039DF5E4A24EAE5F3EA" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/verify_contract.py", + "mode": "100644", + "gitBlob": "d11ac3b94cb61384aff87608c79fdd961d258d37", + "rawBytes": 8376, + "rawSHA256": "6BF80F6082076BC6048C54B744C73E928657B5BEAF9A8CEDCE82F6EFF6771EF9" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "da57544cd45c79ab3f3ddd582a747ae205931f4b", + "rawBytes": 17755, + "rawSHA256": "35FC6D35710BED02B021A46A32C0682E9DEF2FB442B19263DCEC07E191CB677C" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/ACCEPTANCE_ROWS.txt", + "mode": "100644", + "gitBlob": "9bb864eb558401ced42b6d540546fbd597cf3041", + "rawBytes": 13600, + "rawSHA256": "7DBC035076EA9CACE20AC735B1AA85B099AEF3D5B5B1AFE514ABA2C0C63E237E" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/HARNESS_STREAM_REGISTRY.json", + "mode": "100644", + "gitBlob": "2838bb471f344dee355363663dfb053c9a257e18", + "rawBytes": 3395, + "rawSHA256": "227BE213E795A6FF037ABB1F67BEF328992D6284C56E0E427243EDE63C41428B" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/REPORT.md", + "mode": "100644", + "gitBlob": "cab207d14dae45ce91cee4d7fc0bcdebc85503ff", + "rawBytes": 27374, + "rawSHA256": "527CDE985093EE77F6EC02A5750D0A7943740C9D3D47D2A0359C4C739285F91D" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/RESULTS.json", + "mode": "100644", + "gitBlob": "07452a5a52c6f153a16519bed81e827f3bc1b533", + "rawBytes": 45177, + "rawSHA256": "6F73111913D67788775FDDC6D632D8DE34A38C3FDB56E88A6FA94D8ACF9D7B21" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/SOURCE_REVIEW.md", + "mode": "100644", + "gitBlob": "ed9226dc1fd88c4c9d5caf3efae5422753bb57d2", + "rawBytes": 14323, + "rawSHA256": "B57511DDC74FEE0CF37C9AB81496820D31F24BA537C42BEC9BD6834F26C5097B" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/START.json", + "mode": "100644", + "gitBlob": "6137e4772fbebdc88d73f7c6858d5f7f79bc1f46", + "rawBytes": 1008, + "rawSHA256": "A8190551F7523F5F9729B2331D64F8CA174EC99DEF7FD950814C3152C7CA75DC" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/WRAPPER_STREAM_REGISTRY.json", + "mode": "100644", + "gitBlob": "abbf7db1fec288b68505d13306bf7368f2b67b4e", + "rawBytes": 36673, + "rawSHA256": "39D047A36C138E34787BAB33731EF77BB29558233D218A1D76BE5ECC8E2B6DDC" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/certify_profiles.ps1", + "mode": "100644", + "gitBlob": "a3479c56bf51768109ffa342f36b5665a269323b", + "rawBytes": 2266, + "rawSHA256": "154BFE41DA5D9644EB01B2464E1FF1D2B98418694353922A97E633919008C06E" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/claim_expectations.ps1", + "mode": "100644", + "gitBlob": "f7e6ea23ffbac4f7ac0ce1830603a95125efca74", + "rawBytes": 13914, + "rawSHA256": "DDAF90D70F60C4E339AC4381A279FD0C1E430B2C7FC19C78186A74209371FCE9" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/freeze_contract.py", + "mode": "100644", + "gitBlob": "ff9aac13ad220cf2141bf94d9458634af678fcae", + "rawBytes": 5338, + "rawSHA256": "A29909E89320FA2E0F4627E84E0574F30CA0C4DBB882909548AEC6043DD39A92" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/harness_stream_controls.ps1", + "mode": "100644", + "gitBlob": "38cd26fdb0616b3f165ef5c556829461be2fb22f", + "rawBytes": 12082, + "rawSHA256": "FBF570C3F191AD6043CBDDB71223020166AFD842112E41C4709457BBF035249F" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/reproduce_old.py", + "mode": "100644", + "gitBlob": "3b5335044bab8702505b9c70fa673904d656636b", + "rawBytes": 3091, + "rawSHA256": "73949FCA39324FD9771F8F22A6F15B4B477D65613DD30EE77D5CC8F9CC74A787" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/verify_contract.py", + "mode": "100644", + "gitBlob": "3bbb81aaabdf71b7fd9103633e3e89281e2998ab", + "rawBytes": 27998, + "rawSHA256": "6F1CFB871656215513FA91F617EA563BC9B2EE4EBFBE04D77A7F2E7C30A69871" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/verify_results.py", + "mode": "100644", + "gitBlob": "586ca7815c343a0e398b8d1219e9bf7ab379ec22", + "rawBytes": 41462, + "rawSHA256": "CE931FD260A5FDA818E06BEEF1C66C6152189B46984FC4510EB445376244CAD2" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/wrapper_stream_controls.ps1", + "mode": "100644", + "gitBlob": "2590b0bb4da3f461a8edcb40b2a19fb6385a4907", + "rawBytes": 30059, + "rawSHA256": "1B8C9B2F95FA3AA9C88D8228D645B9A6C4A9A2B991DB81DE7A3A577EAA5B02C3" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "bb0e1811f3351876e93a5e13a4daa32f6c119ed4", + "rawBytes": 24776, + "rawSHA256": "7E8DE1B68D4F742FF59D6B39679875E6B59FEF9CDC543836BC041E5CE5B92858" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/ACCEPTANCE_ROWS.txt", + "mode": "100644", + "gitBlob": "57979fcf621af11fc2e9f6382b08ea80abee168d", + "rawBytes": 16030, + "rawSHA256": "D567FF2B9F861A6A910CC94A9E7ABB44D2D559893CBBC7293CEFBE798CE01ABF" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/CONTROL_REGISTRY.json", + "mode": "100644", + "gitBlob": "af6ac29ee4401fb3d82d8ac6fe97dfa6347be1bc", + "rawBytes": 14326, + "rawSHA256": "16E26C5B131BBE258B3813BCDB252414E8BED454EF6286EB2ED7F7EF3496261D" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/FREEZE.json", + "mode": "100644", + "gitBlob": "eb128030283818f71516c271f6d6100734557205", + "rawBytes": 851, + "rawSHA256": "8A78737CEC55BEA8E45BED9785E892CFB8691659BCA0CD958F7F12E1E93CA50F" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/REPORT.md", + "mode": "100644", + "gitBlob": "d3ab6bac49ca10dc54b76653c64e8d9c17087434", + "rawBytes": 25656, + "rawSHA256": "AC08AE4DC421C66012E645FD513034CF361B5CF09221C5D8D665F1815B5536CB" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/RESULTS.json", + "mode": "100644", + "gitBlob": "724d20cb7c7af15af36b2d48b2a98584342b4a81", + "rawBytes": 10377, + "rawSHA256": "12A080909522843A1826B9AA0A80D2B3C512996F6B63098B21B4BAC0AF9A9C8C" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/START.json", + "mode": "100644", + "gitBlob": "dec3323fcc0324529cf06aaff562f6337c712205", + "rawBytes": 1530, + "rawSHA256": "65F8E6A80C875A675C1FE893329351557D7BE41A99A7EDF53FD2D5554E1BDE78" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/certify_current.ps1", + "mode": "100644", + "gitBlob": "1d6412375943407c44742677c1fdc604606fb9ca", + "rawBytes": 6195, + "rawSHA256": "25CB6B0C49A82DFD57DE3ED605D7ABC32D2CA4520E4ADE16873DD17ECFBAFA6B" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/freeze_contract.py", + "mode": "100644", + "gitBlob": "d71d10df92f5af163f6050d201016030a616b102", + "rawBytes": 5932, + "rawSHA256": "4288C680F322509F330283347CC9EEE76200EE7FE7C3E83C776230AE3255F0C5" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/literal_selector_controls.ps1", + "mode": "100644", + "gitBlob": "a5272f8159f8374a1e56e6e5b8ec27f7508bcf55", + "rawBytes": 12112, + "rawSHA256": "1E4F1BED4FB59DA2B39A21B9D52B083651F499F6CFA59EC1310C95CF6D396E61" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/make_registry.py", + "mode": "100644", + "gitBlob": "33d142a544efde258f19feb6e41cb0bf672c7dd9", + "rawBytes": 3828, + "rawSHA256": "89DB0D436BD473B3651DD49611CD8F3F2A55888BA5BF322EC6208CF0397708F1" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/retained_registry.json", + "mode": "100644", + "gitBlob": "e92c8369c564f00655400591e455577151b0458e", + "rawBytes": 3340, + "rawSHA256": "521BFA0CD6DEE84383AB41F8B7D6CC0F226EEFABFC96113EF5EBE835A48A20EB" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/revalidate_retained.ps1", + "mode": "100644", + "gitBlob": "6726c86767028a16b156479db94949bf731a0d67", + "rawBytes": 16744, + "rawSHA256": "E5165926E21EC7E337A71902796D94A98B13E4AC99AA281FB2E813A517642B27" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/verify_contract.py", + "mode": "100644", + "gitBlob": "59e676b3221b665be192ccf84b925839991e27f0", + "rawBytes": 29089, + "rawSHA256": "E364EE4B4B4B867D231E9461260E1DD2FE44D2FB99A32B7A2A5D949B078E2D9C" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/verify_results.py", + "mode": "100644", + "gitBlob": "fb2b6138bef802b38eb4de9fdbae441e53c79ad4", + "rawBytes": 35096, + "rawSHA256": "A660CF4344A71FFB3E8E62E936836755598BA37FD483098C42E1733C4A61ADD4" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/ACCEPTANCE_MATRIX.frozen.md", + "mode": "100644", + "gitBlob": "95f3ade90e80e1c19fa2666fc2803ffa9b5bb261", + "rawBytes": 80759, + "rawSHA256": "05B3435261D9B531837E5879B8C6390EB7B298CE4B61DC34E425AC48F5607EA3" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "2097bfe2a372e9d451f5fe30477fe8360192506a", + "rawBytes": 88209, + "rawSHA256": "A0EE8433BB68B5A50A8213386ED73F57EC65A575FD86DD9B1713B613F1625B08" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/AXIOMS.json", + "mode": "100644", + "gitBlob": "3a0a09a2649982bc34e40f95d292e738b5bfc61d", + "rawBytes": 17615, + "rawSHA256": "A9B0FFCD5C9527D18936D2F76A6AFC4964D517C47743E895F86A1C6A59D78895" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/BASE_IDENTITY.json", + "mode": "100644", + "gitBlob": "7906711ffe9b407857cab89cfead42424b190418", + "rawBytes": 1178777, + "rawSHA256": "CFEB23F578E9EC014F2302220DE4C08960F2C96892F8BE5C60608FF8C4CB6997" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/CHANGED_FILES.md", + "mode": "100644", + "gitBlob": "c722f8e8a8801df4c46b2f7c4d43714871b12242", + "rawBytes": 6755, + "rawSHA256": "E4BC58E076AA5CB99A61993358CA8CFA59CD053A58B0F0BB3299F5207843BCC6" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/COMMANDS.md", + "mode": "100644", + "gitBlob": "6269c65f7b8d925434e5c82f956fc6291cea447d", + "rawBytes": 16508, + "rawSHA256": "1D2E4EC1A410F64C8565EC82F78636D6FED583772078400395E56CDF66165948" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/COMPILED_ROUTE_EVIDENCE.md", + "mode": "100644", + "gitBlob": "8dc00b88f4a9c95e71210115bc268ae3b3efb5c1", + "rawBytes": 26238, + "rawSHA256": "77F0142676E68A1D39C02C687F4E7E10570C1A1858296C122B3EAFA7FD079B36" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/CONTINUITY.md", + "mode": "100644", + "gitBlob": "b438a37d0d71257c819d51bb8ad6732ddcf2dca5", + "rawBytes": 35045, + "rawSHA256": "274ABBCA846A760BB7051B55ACF4FC5DB7A55BD197AC0EB4AC3B1FD52BD775EC" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/CONTRACT_AMENDMENT_01.json", + "mode": "100644", + "gitBlob": "6214ba37e119dc2056f9a7120ba18ae336f68aac", + "rawBytes": 1406, + "rawSHA256": "2F88861685FFAC7ECE3EC03812C6FD7738140B9A1949DB7BD728E60BCBF899DA" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/CONTRACT_REQUIREMENTS.json", + "mode": "100644", + "gitBlob": "fe5750d192de2b7de6616984aed790da926e8323", + "rawBytes": 371381, + "rawSHA256": "736FF55B84516D1B0C7E45F5DBF8193DF98846EA259F0EF5B3CAEFBE7CD6BC5F" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/EXPORT_DIAGNOSTICS.json", + "mode": "100644", + "gitBlob": "07cc3e4b23c2a53924a02f3a477e50a4d9ccee7f", + "rawBytes": 55943, + "rawSHA256": "8688E2089FF225DE19B741327AF451EEF2C019F0997E4652DFCCECD181B0C542" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/EXPORT_MUTATIONS.json", + "mode": "100644", + "gitBlob": "761e1a4e49116e124a196f2cb6a06792153f4313", + "rawBytes": 62705, + "rawSHA256": "15034DC9CE6E6077D27487BC4DDDD7990CEF6B39C66DE39DFF2D9BE8A6825660" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/FINAL_STREAM_CONTROL_MAP.json", + "mode": "100644", + "gitBlob": "4462fa13b745a53d454083e0e68c451a02998f89", + "rawBytes": 2384, + "rawSHA256": "92A0CDA169F378EBA27A9884E5ED4A9E147845EF80ED0D528A02E95BEB115813" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/FINAL_STREAM_MAPPING_EVIDENCE.md", + "mode": "100644", + "gitBlob": "8a13f776a02c5fb41eb4d319abc1d6d279b98731", + "rawBytes": 3946, + "rawSHA256": "E5D983271F8E55E3B11D4124485861F4DFB25DF57E717B52F2874C8090BE3C21" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/GUIDE.md", + "mode": "100644", + "gitBlob": "4ea2ca326c09042814bf0adb9b8af1a7f5b87f18", + "rawBytes": 9119, + "rawSHA256": "3BA8B5D79109BE7A2686693537E814AD6F5135EF59CE3FC79A729AE99B74AD5C" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/NATIVE_CLIENT_SELECTOR_EVIDENCE.md", + "mode": "100644", + "gitBlob": "28bb274cf70e714b321697bdddf60e0a2f9b325b", + "rawBytes": 8513, + "rawSHA256": "C71BC5B694E146397E4E905E8CAEE3DDEF82F6A20324A36BDF8BA8CC60E542EC" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/NATIVE_COMMENT_AMENDMENT.json", + "mode": "100644", + "gitBlob": "fda381623e8c4d34b85c052766b6c92c65150df4", + "rawBytes": 4534, + "rawSHA256": "B69C06945A7B13843F5E78176F21624D856C318D7C4B9D0F2DABAC8816BF4E18" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/NATIVE_CONTROL_EVIDENCE.md", + "mode": "100644", + "gitBlob": "3c340ca82f8736fc4a4cfc84b9fe09b9c0f70aff", + "rawBytes": 28104, + "rawSHA256": "778C62F2190FAB0FF32F462FD8C5E53EDD50D990BFAFEC0D9683304784A1DD33" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/NATIVE_EXECUTION_EVIDENCE.md", + "mode": "100644", + "gitBlob": "6a896b595ee8f134148a7af4f590db57a7bf2ba3", + "rawBytes": 22610, + "rawSHA256": "81EDB2EF1D061DBCD97034CC5CA4855A57C4F5691722A95B9B91135F34C79E7E" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/NATIVE_EXPECTATIONS.json", + "mode": "100644", + "gitBlob": "949c6ca197ca1eb26958db19c3a6ed911c11e1d4", + "rawBytes": 622132, + "rawSHA256": "E67348C7E631FB7FACBD9B580A44D1B42729E9DB0526A5AC09A2B804143E5466" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/NATIVE_REFRESH_EVIDENCE.md", + "mode": "100644", + "gitBlob": "a6c278b1dc13dcbb30f75c4b188b2ad9d4d689d8", + "rawBytes": 13294, + "rawSHA256": "E0AF13A847642C36789C67D3FB84BC6A35106C23F263CB44F420E14957809A17" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/NATIVE_REFRESH_PLAN.md", + "mode": "100644", + "gitBlob": "8259d0231dbb7abdebb02af0e16f2e15a61bcc0e", + "rawBytes": 13835, + "rawSHA256": "6059FD976D76BD596CBF291318AD94965B3669317876F810D933869BDD946E4C" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/NATIVE_SELECTOR_CONTROL_EVIDENCE.md", + "mode": "100644", + "gitBlob": "a0f1731e82d185621db60165b30a85d6ed78c1ef", + "rawBytes": 4913, + "rawSHA256": "B89D7E2110B462759B93F818E4D17708FD4881907D5F0F3DB5A35FB3E6E4074F" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/OWNED_DESCENDANT_CONTROL_EVIDENCE.md", + "mode": "100644", + "gitBlob": "57351676bb8bd8a2dffe0d54fe3f602a0ba72173", + "rawBytes": 2891, + "rawSHA256": "AFC7B599B0FE0591C5EE22A374B8C9B2C774DE1CD3402D09C341B714E4526ADB" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/PAUSE_CHECKPOINT.md", + "mode": "100644", + "gitBlob": "ee7b173b5c85676e2e9dfe1d5a83495dc4d22bfe", + "rawBytes": 7099, + "rawSHA256": "70E6783B028ED5B0AE864351E9704112768FDB138A9C04F689B617F16B977A2C" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/PREDECESSOR_DLL_REUSE.md", + "mode": "100644", + "gitBlob": "cd1196b952657aeab0eb8585f1b485749f57db92", + "rawBytes": 3210, + "rawSHA256": "805360E807C77AA72CC018DE593886D4C1E0179124638369B94A47647E7AF3D2" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/PROOF_EVIDENCE.md", + "mode": "100644", + "gitBlob": "f582f31fc9d10e5e7cff0d2fb994e948264007e1", + "rawBytes": 67710, + "rawSHA256": "CD2EBC07FDD58003A112534DEA6F159D43539C2579DE5FD2F4F9B88BB82081DB" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/REPORT.md", + "mode": "100644", + "gitBlob": "a4e4589ecc1fd6bf01431734ca6290f9e5aa7dd8", + "rawBytes": 27754, + "rawSHA256": "883843F1510555D2DE6C1DC7105C2745ADBDC58C4B96578B5926468AF18E431A" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/ROUTE_COVERAGE_EVIDENCE.md", + "mode": "100644", + "gitBlob": "cfdb43463fc7a3baf90f01889c93b64d40feeef6", + "rawBytes": 18424, + "rawSHA256": "89EBE5B45AAA4E96A4725EB0B7867302691014C95F60B4B988ABDCCC0BEB037D" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/RUNTIME_LAYOUT_SOURCES.json", + "mode": "100644", + "gitBlob": "9059738f1ffcdb9edba2a4ff5b1356939b887324", + "rawBytes": 1651, + "rawSHA256": "C8A716182A13ED8F15E40CA87C94A7FD0686A592D071CCB8532AEDB5F439171F" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/RUNTIME_LAYOUT_SOURCES.md", + "mode": "100644", + "gitBlob": "ed538b4f8c60211e74e6ab33bde3814b7502f7ea", + "rawBytes": 4161, + "rawSHA256": "C30FBDCAF2150DDDEA58AF6C77CF36A9927A4865B9CE280032728EE73F2F9834" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/RUST_DIAGNOSTICS.json", + "mode": "100644", + "gitBlob": "c7534e977ceb3d2d30350f2c3f5e07f7e10fc333", + "rawBytes": 35435, + "rawSHA256": "985835ED2AC39483DAE006C327F656A0FD92546D60C91EF97122F67B6D795141" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/RUST_MISUSE_EVIDENCE.md", + "mode": "100644", + "gitBlob": "cc6033833437d0d4bec98dd48e9fba83a1411452", + "rawBytes": 6359, + "rawSHA256": "4923C88A57F79BF49C0FED2F6F7A8A2943515BD7E3B579574FD8455BC0262697" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/START.json", + "mode": "100644", + "gitBlob": "b88ec0051e94567ef05cfd32728063dd4f32058e", + "rawBytes": 2898, + "rawSHA256": "674312B1B4F16247BA8A2F757931AB0F34950A5A7560F00EAFDDB37EFE9213FB" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/STARTUP_AMENDMENT.md", + "mode": "100644", + "gitBlob": "2ce4c33452fc745b8dc26bf282457ed1e28901ae", + "rawBytes": 11928, + "rawSHA256": "2C4A5C7B4E837B61649A495690A75269EB355FB41D4F9366E568DA634E1A9779" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/STARTUP_AMENDMENT.patch", + "mode": "100644", + "gitBlob": "95a985f2f856685ae8860be343f5b4e9d7e91ac3", + "rawBytes": 1881, + "rawSHA256": "3A4600648173001ECF52CBE18A63454E8B1F99E09FCB3C2C39A210BEB6C6142F" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/STARTUP_AMENDMENT_RESULT.json", + "mode": "100644", + "gitBlob": "7716a0ee77af760effd4c3f6b867e88d2fb3a5dc", + "rawBytes": 2022, + "rawSHA256": "A302312C58B93000724C6DA4C7925BB17EDD3A53762F21FFF0EF98FC81229D82" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/VALIDATION_APPLICABILITY.md", + "mode": "100644", + "gitBlob": "75623a0975bc11d91b6b21e3fda0974a3e3d8d22", + "rawBytes": 7951, + "rawSHA256": "CB25D532631D99DDFEB96BC53B28554093A3DF1F28728603A2BEABAA4A7B896C" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/VERIFICATION_PLAN.md", + "mode": "100644", + "gitBlob": "a5b7cbc97c37a891bd168c1ed0f7b6b7faabfb03", + "rawBytes": 14217, + "rawSHA256": "54A0F27AEC6CFD9B3356562DD6E4A12AE3BF6CBBEEA350F65050F4DC1C8173A8" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/axiom_inventory.ps1", + "mode": "100644", + "gitBlob": "201fc2db187690b9e7d70cd233bf71a0ce30cac3", + "rawBytes": 14552, + "rawSHA256": "501F6F804F7B0183EE87AABDDAB34DDE14D10C353E9AEE24A7FB8BC253F331EF" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/default_build.ps1", + "mode": "100644", + "gitBlob": "ca6ddd75750a373d9d7e819af01b83b92c2933d6", + "rawBytes": 6295, + "rawSHA256": "561D47DB21A87233CD9F1164F117F43B34E616EA0161E1310EE6E8709FBBC19A" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/export_mutation_replay.ps1", + "mode": "100644", + "gitBlob": "f0d4f7086e3b8fa28e95c12ea4161c111f891518", + "rawBytes": 36826, + "rawSHA256": "435A20F61F5C226BF291E6EA114E5FCB2EE8A59B76E3E957697CAC9F03E6B2EA" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/final_checks.ps1", + "mode": "100644", + "gitBlob": "0ad1e4fc143a4600945c92e162e8e6479358364e", + "rawBytes": 8646, + "rawSHA256": "561C20D85A559BEF42326760A53D198380330C1937AB7A89794291382C9422A6" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/final_stream_controls.ps1", + "mode": "100644", + "gitBlob": "fb054f1494ef0ad47a6fb49b2d92af850f6967f7", + "rawBytes": 19751, + "rawSHA256": "369721C793B9EAE79CD0022A7F4AF3D6501B3E196C56AFBFBF67664E75476366" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/final_stream_controls.scope_seed.json", + "mode": "100644", + "gitBlob": "b0af2dbf919a22245b2ba89126d14a98de40bca0", + "rawBytes": 927, + "rawSHA256": "65819DA0654FA9BB96FEBA91685E40197BA1CEEEBD433D0189EE34B70B5CCC39" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/final_stream_mapping_controls.ps1", + "mode": "100644", + "gitBlob": "8ebd6fb4f1c2d38c156c9a019147a57d3c9a990a", + "rawBytes": 7989, + "rawSHA256": "0072AE081E7D0465F0AAA92A601A30693E8D531C7243AF9E8AB3EE15568ED132" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/final_streams.ps1", + "mode": "100644", + "gitBlob": "075a3bb840f555b4ab34476c90120b3a831bd7a5", + "rawBytes": 18056, + "rawSHA256": "75A5389F5187F9F48691B04CBE43BDE28E5B5F5197095D62CA91B52DB3D74CC5" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/init_probe.c", + "mode": "100644", + "gitBlob": "1e5d6bfa6be395b0c3a889bd2b668994ec48b015", + "rawBytes": 2430, + "rawSHA256": "F1470E6A78F7219D1336C97E93FF554345E881E3C27D2A621EDFD8479036A959" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/loader_probe.c", + "mode": "100644", + "gitBlob": "601fcd6bf8b7931570aa8dcd8f79c5f2b684da1c", + "rawBytes": 834, + "rawSHA256": "F2C2A71E0B1D89E83195A92457A8B1AEF0322EECC4637C3492A574FCA4BAE13E" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/native_client_selector_controls.ps1", + "mode": "100644", + "gitBlob": "b55d86aac426edad55ab68e1e9455335bb910c86", + "rawBytes": 11714, + "rawSHA256": "FA96E34698745E189EBFFE34EE1BEFD471A1AE32EC97C2CA7BFBBB5AACD5B92A" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/native_clients.json", + "mode": "100644", + "gitBlob": "0011c981ffbbeb1b48918b48ff193f3413dd4236", + "rawBytes": 3074, + "rawSHA256": "5A8B5E6A30482209EA7F75D1733DCAAC5199B5468BAB3D36000F364284AFE3B2" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/native_clients.ps1", + "mode": "100644", + "gitBlob": "a8ed719fa5b731cb1466bb361d2e8844064edfe4", + "rawBytes": 17164, + "rawSHA256": "FA8EC7976BBD744636BB530C609BB229044F58FC6CEAA5F3FA825B3E039125EC" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/native_control_selector_controls.ps1", + "mode": "100644", + "gitBlob": "bbb06ac10825a5e79e72950d1c1f7ca404e56b67", + "rawBytes": 14131, + "rawSHA256": "621D82E2B4B1845AB3EB6BDADFE1A813672543DA9F5B84BDFEEE4FF13A2A9C6E" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/native_controls.json", + "mode": "100644", + "gitBlob": "1cd95f6eaa2fbc6053145fa9a9b9cc404c431466", + "rawBytes": 13973, + "rawSHA256": "1F7476824F518B33790DA70E922E64E1985E07F4AAC50D74ABD35773F5CA8F34" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/native_controls.ps1", + "mode": "100644", + "gitBlob": "2fb2899382d5297e01ca6bdf30dbaf153b8aab28", + "rawBytes": 30910, + "rawSHA256": "6F3D2138160618E33333A3368CF6F3D38A709F71AB5B847957FDFE3238495E00" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/native_recipe_controls.ps1", + "mode": "100644", + "gitBlob": "83cca98fb35a894ceeb2d49a844b19c6cb1ee10f", + "rawBytes": 10677, + "rawSHA256": "AF0FAEA135BDC4031D50A5E5D0541F64B9BDA3AE75C997849F0FE69B5C343614" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/native_selector_controls.json", + "mode": "100644", + "gitBlob": "428dea971b372b6eed85d1790b06cfefc379a10a", + "rawBytes": 7236, + "rawSHA256": "FB9D38AFD5CA8B8FF1313C355E7C649CB6E3E44777EEF9A1915B818585EF67B5" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/native_selector_controls.ps1", + "mode": "100644", + "gitBlob": "1473f334138be7d09e876e0e0590851044a96e07", + "rawBytes": 16502, + "rawSHA256": "6A4B734F964182A994457D6A2D3B85E1A78482512C576DAC6B69F214D5F73317" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/owned_descendant_control.ps1", + "mode": "100644", + "gitBlob": "2d37d483aa714acf546b50ced8b7d2470c77f12a", + "rawBytes": 13098, + "rawSHA256": "94F446F6F64D96E8D34C0FCDC619895B6247EFF487B03413CA7F3D1FC8F8CFAE" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/rust_misuse_replay.ps1", + "mode": "100644", + "gitBlob": "f75d7315831dbba0dc796098390e6b97d0085b58", + "rawBytes": 11329, + "rawSHA256": "155C773040EFEB88A0DEDBCDC292E83D4E4BE1F1747E1853D14F9620E372B1EE" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/rust_misuse_selector_controls.ps1", + "mode": "100644", + "gitBlob": "2d8a105328198ddf17bfd9aa968709a9d01cb54d", + "rawBytes": 10873, + "rawSHA256": "DCA966B0FDC50C7815E0AB5593C8332E69769F1553B254B41266B6DE3D1E60F5" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/scope_check.ps1", + "mode": "100644", + "gitBlob": "1f9511d4fb76a24a99729aebd55e10ae9623859f", + "rawBytes": 7365, + "rawSHA256": "314FFD9A70498E1D2E01ABE36B0746987E75BA16335D0F7FAFC722BE2ED36608" + }, + { + "path": "docs/internal/extensions/lifecycle1/ACCEPTANCE_EVIDENCE.md", + "mode": "100644", + "gitBlob": "79ef9dcea341dd5906b0aa3b1f4fe864deeea1b6", + "rawBytes": 33319, + "rawSHA256": "F996EB73D4ACC9020B093E568521D7413B232ABA9D0D642376B564439CB22FAB" + }, + { + "path": "docs/internal/extensions/lifecycle1/ACCEPTANCE_MATRIX.frozen.md", + "mode": "100644", + "gitBlob": "1aa9b2139c05574b6256fff28aa8c3035e105e04", + "rawBytes": 43514, + "rawSHA256": "BC596CD8A4866CF8DB7BD06360D1C2E797E389C92237C9AC3A0B5E4145CD22AB" + }, + { + "path": "docs/internal/extensions/lifecycle1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "c6b2388371d564b24d9441f2a3489531012460c1", + "rawBytes": 73177, + "rawSHA256": "63B7EB6B7C01FCF9CA109BE9CDCBF67141BB83C3927C2D7F707B06E2DC482CF1" + }, + { + "path": "docs/internal/extensions/lifecycle1/CACHE_PROVENANCE.json", + "mode": "100644", + "gitBlob": "6b77739dedaa51dea5538caaac601ed77d4a0477", + "rawBytes": 669, + "rawSHA256": "6F803BE4FEDB148D054DCE987CD78146BB10687CC81EF6581B412D36F8FA0CAA" + }, + { + "path": "docs/internal/extensions/lifecycle1/CONTRACT_REQUIREMENTS.json", + "mode": "100644", + "gitBlob": "d8271d9a796dbbd5fec02b4169dee3098357e9a8", + "rawBytes": 54250, + "rawSHA256": "E47AB45ACAD51FE508CE9B8BE9983A136F8C9267D4D8FDD7888195BD0419E488" + }, + { + "path": "docs/internal/extensions/lifecycle1/CONTROL_PREDICATES.md", + "mode": "100644", + "gitBlob": "d41df3a79b34cb4adda997027e5f157030450462", + "rawBytes": 19654, + "rawSHA256": "8528F0ABE9FBBEA11077F02B6303C772400FC895575B0792A349C7769A13C2F6" + }, + { + "path": "docs/internal/extensions/lifecycle1/DEPENDENCY_VERIFICATION.md", + "mode": "100644", + "gitBlob": "4eadae2fe0e46eee875331a598c758c3dca685ad", + "rawBytes": 15665, + "rawSHA256": "C5A5805B520A5503C70D18A390F8011109381F3D16B2347E9801047B649ED4DD" + }, + { + "path": "docs/internal/extensions/lifecycle1/FINAL_RECEIPTS.json", + "mode": "100644", + "gitBlob": "b5573b9babc6083516bfabd1758e069c54b1dd1b", + "rawBytes": 80207, + "rawSHA256": "697397C8B6B06930393898099E226B576477CA1B1890CF9E5404093548139A5D" + }, + { + "path": "docs/internal/extensions/lifecycle1/NATIVE_VERIFICATION.md", + "mode": "100644", + "gitBlob": "29a4c789ee598f727bce1e0eeb6b8bc597e9020b", + "rawBytes": 14741, + "rawSHA256": "4CC702230F0D16839FA2B5087569D8E27E61FA3C154DB5231E52FE75260FFAE0" + }, + { + "path": "docs/internal/extensions/lifecycle1/PROOF_INVENTORY.md", + "mode": "100644", + "gitBlob": "2fec2352d7a2057cf147a5fadf487ab9cf66e810", + "rawBytes": 40258, + "rawSHA256": "CACD0C5A9A96F767AA9AAD585C0B19A7A98AD2583AC821966AF2A8AE384F5C88" + }, + { + "path": "docs/internal/extensions/lifecycle1/REPORT.md", + "mode": "100644", + "gitBlob": "996833fda5424ed6fac4e8b623b05ecb429be01c", + "rawBytes": 25629, + "rawSHA256": "F0A21EF6EB0F5992E5A9584877C65AFDB206F52679F40D98344F68C652371850" + }, + { + "path": "docs/internal/extensions/lifecycle1/RUNNER_REVIEW.md", + "mode": "100644", + "gitBlob": "7742b7998d2fe4b1db769629bdd54f8e1bc8ba23", + "rawBytes": 4980, + "rawSHA256": "B2E697FFB04183E56E10354C1CD34A28E67723101A129F21B8ADDE36E978F722" + }, + { + "path": "docs/internal/extensions/lifecycle1/SOURCE_MANIFEST.json", + "mode": "100644", + "gitBlob": "70ed6bbe243bab060987e8c3f3d4cde854abaf71", + "rawBytes": 16870, + "rawSHA256": "2B8500DBF3573BD4F2F7E6A27BFB7DC46A682ED4E59DE5411405A6BC60952CA0" + }, + { + "path": "docs/internal/extensions/lifecycle1/START.json", + "mode": "100644", + "gitBlob": "86b6ff30e72578b97d6664ddcf8ebcee6761272a", + "rawBytes": 1853, + "rawSHA256": "59F47921F87FE08FA92065257CC9A5230D96B8F299D0E9E207BDD6D2A8137ACE" + }, + { + "path": "docs/internal/extensions/lifecycle1/VERIFICATION_PLAN.md", + "mode": "100644", + "gitBlob": "c14d285ee06bc44a46d5f5e78623d3129e2eeb96", + "rawBytes": 17841, + "rawSHA256": "60A70BA7EAFA7A11584F23809A726D137A4A7538A18C823683B6E5D245A29A5D" + }, + { + "path": "docs/internal/extensions/lifecycle1/contract_integrity.json", + "mode": "100644", + "gitBlob": "7b80274dc93c9d3ec02c7180403ad03abcbdeef4", + "rawBytes": 22548, + "rawSHA256": "5E883A58C09DD23BB21713FE5ACF97A2697567BC693264AB1F46B58835389330" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/ACCEPTANCE_MATRIX.frozen.md", + "mode": "100644", + "gitBlob": "d1a682acd99207d855745d016d85eae0cdbda8ff", + "rawBytes": 46274, + "rawSHA256": "20B1DB9B99FB730E7075B4B6A4ABC0992E40DE29336AFE8375773EA062E8BFEC" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "07386b6f1e6fafd9b856a821f071d34bd722ffaa", + "rawBytes": 86187, + "rawSHA256": "3C2401957389BDFE894574A13AD9C626F038D2873975F61890D6942E3912AAC0" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/CACHE_PROVENANCE.json", + "mode": "100644", + "gitBlob": "58ebd6e210f206173ccb797adb33034f890b9aa8", + "rawBytes": 578, + "rawSHA256": "DD303F0F93E929651BB57BC3A3F66294624DCDB8C6FA15CBA594C1635C12408C" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/CONTRACT.json", + "mode": "100644", + "gitBlob": "4a7f4f984557cf7d391ba24952570ac2abe6dd09", + "rawBytes": 19993, + "rawSHA256": "3365D6D013EEE347385DEB2CB4DAB042700E7EC259F0CBD62FFBA3081F4520E0" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/CONTROL_REGISTRY.frozen.json", + "mode": "100644", + "gitBlob": "204d6c1d48268fdec3a3d369d9b3dacd38ecb8e1", + "rawBytes": 76654, + "rawSHA256": "68AB24530878BE76E030313AE4B3A17610B5BEC6F70AE3FE83351E67435F1619" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/CONTROL_REGISTRY.json", + "mode": "100644", + "gitBlob": "204d6c1d48268fdec3a3d369d9b3dacd38ecb8e1", + "rawBytes": 76654, + "rawSHA256": "68AB24530878BE76E030313AE4B3A17610B5BEC6F70AE3FE83351E67435F1619" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/EVIDENCE_INDEX.json", + "mode": "100644", + "gitBlob": "83a62a24f1a6a12c745e1a0e5c2e935c80a8e980", + "rawBytes": 2136062, + "rawSHA256": "AF8A32126DA5F24CE5D43ADFA2E4E8593BD2F6941480172C20A4FE62D9CF1CE6" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/INITIAL_WORKING_FILES.json", + "mode": "100644", + "gitBlob": "52501ead077dbe569e9676338ba569e0afc3b86a", + "rawBytes": 707591, + "rawSHA256": "BBE8B6278795FA2E29D4F68CFF348C483E6E44DC4004025C739A78090CFAEF0C" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/PROMPT.md", + "mode": "100644", + "gitBlob": "8c218b9b03b7b60753b0dd5b6c155d6fae241a35", + "rawBytes": 46818, + "rawSHA256": "2971CA834F06A62EB33B8589E718246938D8C703AB2211F83BE8DBCCC80BC895" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/REPORT.md", + "mode": "100644", + "gitBlob": "38ba7debc57f1452c02bfd705ab9bf62313bd87e", + "rawBytes": 23036, + "rawSHA256": "1C30FCF76880E4D275B2881F4074EC29C31C51E4BC80930D3D01D7CDB5A58892" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/ROW_DISPOSITIONS.md", + "mode": "100644", + "gitBlob": "4d6036cc9f01f6141cf8bb73f54a8a52092f459e", + "rawBytes": 39911, + "rawSHA256": "BC74804E65B18A2A08CD0ECA008BD763E85945B75111CE380647E91A892ACA9E" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/SCOPE_VERIFICATION.json", + "mode": "100644", + "gitBlob": "b823a4e6fed43598bbf4d97e51d8c7012abd263a", + "rawBytes": 33283, + "rawSHA256": "83002220AE3132A424A36E910A50D9C351F1A854D4BCD3E5938684454AE68392" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/SOURCE_FREEZE.json", + "mode": "100644", + "gitBlob": "6b883ce07a59c068a318f82b096085a2b1cd4afc", + "rawBytes": 347686, + "rawSHA256": "4527E51E7E9E5CEF2759957F7A1942A6BB6FAB89B784D572FA0AF3130A81606D" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/START.json", + "mode": "100644", + "gitBlob": "166a5b92fe16c8722237e995bea6f8c4a5522025", + "rawBytes": 2635, + "rawSHA256": "073AECAAE06126BF0E4F6EF1CA68450BE68A2C685515AF1359A43B711D121AF5" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/VERIFICATION_PLAN.md", + "mode": "100644", + "gitBlob": "87f0e01f8f3c92d6ae30f5004af7b3aacc04df1e", + "rawBytes": 4563, + "rawSHA256": "228E1AA0EEECA213CDE272E0F37AE2ED7A8DEC31DBFD94DF5BEEFD2BCFC5CB5E" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/build_row_dispositions.py", + "mode": "100644", + "gitBlob": "36c0bcdb41590781ed1d9b600ea4216b84b8164a", + "rawBytes": 37341, + "rawSHA256": "3202F14F3DCFEE4002B1EDD3170A8CE944C465B539B5D654141A380BDEDBD2C3" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/collect_evidence.py", + "mode": "100644", + "gitBlob": "94e8ac24a23e2b7edeffa898b1425eaf8d528967", + "rawBytes": 4350, + "rawSHA256": "D95377B9657E45226F3B894785411803051D43EB5169C9675E7208DF09EC4E6D" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/contract_verification.json", + "mode": "100644", + "gitBlob": "c985666c30fa9c5eafcc3aa4b91162df4010ec6f", + "rawBytes": 15966, + "rawSHA256": "1143B16F9ABCCBB5ABB4D0415B16248FDA5F730C66D82D55130088AF61462362" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/deadline_control.ps1", + "mode": "100644", + "gitBlob": "e985da4bb21ba3cb6646623fdc0efd0808fde264", + "rawBytes": 3226, + "rawSHA256": "4831CEF50CE6043F4AFB9F3E2971A34D53E2E0947D4C25B311E2B3B4C1A1E1FD" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/dependency_boundary_cases.json", + "mode": "100644", + "gitBlob": "c5e63fc9f4ce0f7ae97c41a5570e74019ad7cced", + "rawBytes": 28695, + "rawSHA256": "D9E56DC40888CFDB937F0ACBD9EC945846A5CAC585C99341D21DAA9B793D9ECF" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/dependency_child.ps1", + "mode": "100644", + "gitBlob": "b16c812db3acb30043ec470237b86833b9b62b56", + "rawBytes": 7959, + "rawSHA256": "5640AE40E34B05760F9E0FE71779291B8F23A4B053DA62408A12F8499454C67D" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/finalizer_cases.json", + "mode": "100644", + "gitBlob": "84c8df0b0339a48a60af93ad446532d2a186cb58", + "rawBytes": 4731, + "rawSHA256": "0F03F2EBEF9EFE9B8F305DB58E8E8636DAACCB063A3D87E6872CB0F88A939767" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/finalizer_control.ps1", + "mode": "100644", + "gitBlob": "76165bc0c27e07a7c9aa6874492a140cbb4c5195", + "rawBytes": 27003, + "rawSHA256": "91DF97E2042A6C3293632AF3DE6E0FEF4C61CA24C4FE9A34F07182E01134E098" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/finish_report.py", + "mode": "100644", + "gitBlob": "2e3c2ea92ed013b9768bdc21cd3e32976c83bc99", + "rawBytes": 6728, + "rawSHA256": "3EB0B4F946FE5665B87F3F54E09FAB8D4B9605B4891825CEB0E681637360DAA8" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/freeze_controls.py", + "mode": "100644", + "gitBlob": "b385c8f2f32d8d903c2c712771c272fc5ca2c457", + "rawBytes": 1779, + "rawSHA256": "58AA36C561F27F0B940308E6ADFA14AE01887BB0498811DC3B613980EF647C9B" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/initialize_contract.py", + "mode": "100644", + "gitBlob": "648be366f7ce6dec0636f00ee4238ccede69b2b1", + "rawBytes": 5497, + "rawSHA256": "5C6D2CA690E8CDFCAC247AA57353C17AFB8E18F9C3B4C9A978D365F8A1421209" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/make_dependency_registry.py", + "mode": "100644", + "gitBlob": "3992bc4ce288246c858771067667d37fa2a25041", + "rawBytes": 3747, + "rawSHA256": "A769606EC40F89A07884B255541864629491FD17A9A5C7D3225661F0C2368A24" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/make_selector_registry.py", + "mode": "100644", + "gitBlob": "1150b33fe1b2fca49f84159864dcdce8d8d0ded7", + "rawBytes": 5166, + "rawSHA256": "D46E862F6F3B408AE07A433AE1D54C6365DA6A5DD2CC2EB30422CF4805C49B21" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/old_environment_control.ps1", + "mode": "100644", + "gitBlob": "253b002ea3e9928a827e45430b2b63772dfd68c5", + "rawBytes": 2816, + "rawSHA256": "61AC0A6CCBA2BB25F2911418CE470BD5791DFE8DE21CB2DEA030F7C4DAD0047D" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/preflight.txt", + "mode": "100644", + "gitBlob": "79701ff2fbd7f1734c51fe124460577e9dc7c90e", + "rawBytes": 819, + "rawSHA256": "C64D1C2760F6BC3CEA8A5953F45078AD994EEDBF4E6D726FA344006140E8D3EB" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/prepare_cache.py", + "mode": "100644", + "gitBlob": "ba174899fc48bd9ad8e5c2b8c94036d54351c710", + "rawBytes": 3027, + "rawSHA256": "BD06BD2ED9AF5EAD748655AF6EBF805D18D89F98F8784598F80A0294A77732BA" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/prepare_old_root.py", + "mode": "100644", + "gitBlob": "172e0a3cd5bc49e103513f7c93919b6f606cb78b", + "rawBytes": 1698, + "rawSHA256": "B5C456E20BC975A12F5AA5A10E67B9475891C19898130C79E4CC0609728609AD" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/registry_control_cases.json", + "mode": "100644", + "gitBlob": "694154da863eddcb7823dd400c92eb4d4b6bb9ab", + "rawBytes": 12683, + "rawSHA256": "1B8627573B7B8E39944BC8B8F5E87E2595E055AF1D04B7CED7B53D2C6229A9E7" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/registry_controls.ps1", + "mode": "100644", + "gitBlob": "1615a4676738c90178f545a47904ffaee1978c09", + "rawBytes": 16273, + "rawSHA256": "833662925BC1986A650A4440FBC2A0031FD0D8DB7EDC27C0BFBCAD944145D13E" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/run_check.ps1", + "mode": "100644", + "gitBlob": "f21505428701c77abd2b6390b64cf127b9a267aa", + "rawBytes": 2583, + "rawSHA256": "70C86A6C07803D19F1092E182A35CC2B266DA94E6790E431D84BC53D7CA32F36" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/run_controls.ps1", + "mode": "100644", + "gitBlob": "288a0f4e70adfc3d613f2893e0cb293a2e12a667", + "rawBytes": 7672, + "rawSHA256": "885BBC7C8A5D356CDFC82920D208F7D2DE4CE3972ABF705B3F02BB518159B42E" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/runtime_profile.ps1", + "mode": "100644", + "gitBlob": "4f26065b241fc676c12249f56d0ea3025590101e", + "rawBytes": 1482, + "rawSHA256": "4F296DAD60179A23BA2D049487E29E02E4C78A873A02C8542C84B8FB918F94C8" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/selector_cases.json", + "mode": "100644", + "gitBlob": "0f14678abfb13f44af973d4a2f349b87da7e7bd0", + "rawBytes": 26312, + "rawSHA256": "407E9F8455AEC21EF6ECAD8098C0FD0FEBAF557D7BE423ECCAA0AF32F08FBE3B" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/selector_child.ps1", + "mode": "100644", + "gitBlob": "58ff6de108feb2389868e73bff49a32c788a4f39", + "rawBytes": 10856, + "rawSHA256": "F2A6663EBE067A9AB0F2FFD241DE92AAB0C57DB7CA0D8DFA73EF1A36A9D2DDCB" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/source_manifest.py", + "mode": "100644", + "gitBlob": "151d7031b30e62bbb0151c421676c4b0c2a43411", + "rawBytes": 23409, + "rawSHA256": "D3B173D5D74929DA4388476095A22F88BE71E0751A9B539DBAEA0636D092ABC1" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/verify_contract.py", + "mode": "100644", + "gitBlob": "2b353beb90079032a8a444a864664b1892265c59", + "rawBytes": 21547, + "rawSHA256": "FCCB2933DBB5C498D2CE57E52604DD9C958FA59E9235D8737CAAA5C505B5BD76" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/verify_scope.py", + "mode": "100644", + "gitBlob": "400f55963696731fb2874a4f348f840ebc890f50", + "rawBytes": 20768, + "rawSHA256": "A91052F6E4E49D78E7E2B7EE935C1871C67194440C6D5207A1AA62D86393E6F1" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/ACCEPTANCE_MATRIX.frozen.md", + "mode": "100644", + "gitBlob": "edf51bdd84f398ceac473075018fdc8ab4bc9dee", + "rawBytes": 49094, + "rawSHA256": "CF11930DED662D07714A5D024FF5B6A3D54923F8951EBE0338CC9A5A92464BF7" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "7ef99baff08d0dbeec2841f8ea9a9e93f321c32e", + "rawBytes": 136520, + "rawSHA256": "25B610B2568F76586C70605AE2009067901B1F653C7F148A1FDEFD80226F4927" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/CONTRACT.json", + "mode": "100644", + "gitBlob": "1b41a4f7c0de6a061443700a4b0732eb81f3b4d7", + "rawBytes": 23818, + "rawSHA256": "28FCE1D275A6A7D1E48A710173E8D3C7FDB182A819DC8BDC62DAA7694AFEBB01" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/CONTRACT_VERIFICATION.json", + "mode": "100644", + "gitBlob": "3ffcab6a83c00728c053cbea73b24d51119dd8d7", + "rawBytes": 28405, + "rawSHA256": "78F63515019858AFE8B4E030B064CE1386FED5CF9759487EFF9FC3248E76C783" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/EVIDENCE_INDEX.json", + "mode": "100644", + "gitBlob": "f94875756d11565d7392d4629f8a639a815edfe1", + "rawBytes": 808355, + "rawSHA256": "50F0B1329E91F542EE822CEE2955EBA136456DA9BDD4D4B2192D69C62BD736AB" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/FINAL_CONTRACT_VERIFICATION.json", + "mode": "100644", + "gitBlob": "550d2a36153857c9affbbcb0f537f9fca0ea63d7", + "rawBytes": 28423, + "rawSHA256": "BCB5C9AF80775193F48CEED3CCCD6BE6DEE5E97B15CDE12F39C0E5E293058047" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/HASH_CHANGE.json", + "mode": "100644", + "gitBlob": "266ecb432e6371b648895f186c94ec24b0d8574d", + "rawBytes": 641, + "rawSHA256": "B5459AA84F31D8263DA9EE3540312A09C07308F879BD46D5FC79533E75B76C71" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/HASH_VECTORS.json", + "mode": "100644", + "gitBlob": "1105b0851ce4cfec9203ee22cc5faa0f863f930c", + "rawBytes": 1755, + "rawSHA256": "1F8978A6C12865127C68244DA50CF434761A315405BA366F5282000DCC664DB6" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/HISTORY_APPLICABILITY.json", + "mode": "100644", + "gitBlob": "5c56e445a847530ea5d19be098435050f60ec47e", + "rawBytes": 73770, + "rawSHA256": "B74D30A4866E4723C02B2986433B21AA50493F496C35A42734ECBBDBF5036ABB" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/INITIAL_FILES.json", + "mode": "100644", + "gitBlob": "c1bbd17cda85a6fd054405cf88588b9f3e787962", + "rawBytes": 1860160, + "rawSHA256": "0B7ADC9EDF480BCA8E84D8FB2BB9BA3190827FC044D828AFB99DA3BFC25A9507" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/MATERIALIZATION.json", + "mode": "100644", + "gitBlob": "d6f0e1b6f8f6cd5ced82c3cf926fc2a7100f51e7", + "rawBytes": 8638, + "rawSHA256": "64F1082AFCCC82EC98952E94618CB0A52FF6F8E56AAD7A830B4B2EE363AFD1E9" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/PREFLIGHT.json", + "mode": "100644", + "gitBlob": "4024982fde5e08b3f7d9da31672c1c7efb908651", + "rawBytes": 1407, + "rawSHA256": "A12390EE2FCA59D5DBDF69C123DC44D4FC81F123E8CF5FCE9BCE5DF19AC46D96" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/PROMPT.md", + "mode": "100644", + "gitBlob": "88c4332107732eaf72257a90b23cc2dee67b1345", + "rawBytes": 42671, + "rawSHA256": "D265FBB7B634E9CD5DAD41EE817A51C32EC14E98CC57400C83E712140795E3E0" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/PROTECTED_BASELINE.json", + "mode": "100644", + "gitBlob": "b719f02e73bf7689d955874d15ce9b34cfcb10a0", + "rawBytes": 715453, + "rawSHA256": "EE37179CE6B3330A278CC43B044202151626A0AEC3E8DE49FEA46D177650CDAB" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/REPORT.md", + "mode": "100644", + "gitBlob": "ec46526b0209fa4d4409cfd50a4cede4dac0ae89", + "rawBytes": 25314, + "rawSHA256": "E56720F96B7A77B95D98A6A6E665BA433E0D89541DB2F370D49D6E44B7CC4684" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/RESULTS.json", + "mode": "100644", + "gitBlob": "695d2ccefaba960a568a901786d57488621936a1", + "rawBytes": 303999, + "rawSHA256": "827BC69B864B71CB49C26350890BD29E8D744A97E675177AD7D89DE59821DBA1" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/ROW_DISPOSITIONS.md", + "mode": "100644", + "gitBlob": "adfe856a75dc02bd9ab94d9b30356cb75e05c442", + "rawBytes": 87424, + "rawSHA256": "243CA8FC3E12F0A44E936055E340160F52280F7711CE6833084E65CE2F3FA17C" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/SOURCE_FREEZE.json", + "mode": "100644", + "gitBlob": "4cd65468038a78584195eb64018eb7cbdc232fb4", + "rawBytes": 51722, + "rawSHA256": "ED86CC527ED10E10164DDEEF437D4E8AFDB44C19CFAF59615670EF0975C8527F" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/START.json", + "mode": "100644", + "gitBlob": "e621a05e2a021300a9f3101504cb5ccf51765af6", + "rawBytes": 6623, + "rawSHA256": "EBD653A8108470D2BD735850D4E788052EF8E939424761F3EE556F6885855428" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/VERIFICATION_PLAN.md", + "mode": "100644", + "gitBlob": "c845f62d150d44a40b444776ee962183a60e8e98", + "rawBytes": 3312, + "rawSHA256": "105D7FA4C41700A1CEB1B8000156835C5076EA47868CCF62D361F4767688B79C" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/bootstrap.py", + "mode": "100644", + "gitBlob": "8cfa05738f6b9bd1f0257398ff1348d24c400666", + "rawBytes": 6784, + "rawSHA256": "8F9C9AEDEE035111B93D1285283C10EB213C3556781B435DF34641C23E9E2FB1" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/build_rows.py", + "mode": "100644", + "gitBlob": "cd0266a1d09b5f14db68bcb0c388304793dcedb8", + "rawBytes": 30931, + "rawSHA256": "73D72AA7051E9848152A81B516E4FFFEE2AFC21AD1228034179211F4EF27CA9D" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/hash_control.ps1", + "mode": "100644", + "gitBlob": "a8b24591062123e7977e1ed79f1da2e5cabfe0d7", + "rawBytes": 4695, + "rawSHA256": "633E6CD248567468CF7755EC7937802E698EAC25D84BDDC73B48F43427B2F4FC" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/materialize_contract.py", + "mode": "100644", + "gitBlob": "706fcc51dbb5d0e7523c53764daac7201160066c", + "rawBytes": 6584, + "rawSHA256": "881E0946ABFE4DE07664A67572E3C9FEF84DAC0C200CDA9EFD83A31A7FAAACD2" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/package_results.py", + "mode": "100644", + "gitBlob": "96c44881fbfe06ffb6b875b83b8afdd43d90613b", + "rawBytes": 1570, + "rawSHA256": "C2603BCE25D305AF2C46ACCA5931AE856AC71174D117AA2649476449322FB8A3" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/prepare_runs.py", + "mode": "100644", + "gitBlob": "72785f46b35e2aa37a661a6fdc6341cb3b3d9fe4", + "rawBytes": 3155, + "rawSHA256": "2FF59106EDFED101A68926F15A1301AE2E8D3B6B5EEA368DDB70D2E2488E9EB6" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/render_report.py", + "mode": "100644", + "gitBlob": "394b67a629e69e71035f9d548dc07e3ebb120f2d", + "rawBytes": 21128, + "rawSHA256": "943B4DCE27443E155472DCD6267848BF185DC4645A9D46D56AA053CBFAB03047" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/run_check.ps1", + "mode": "100644", + "gitBlob": "1377712ad2e86e8ea3ed0ab497c25960cdebb045", + "rawBytes": 3376, + "rawSHA256": "444EF5BEDABFBD29495A0556408A7C3FFA85F937F6857E99127760291E85DEEB" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/source_freeze.py", + "mode": "100644", + "gitBlob": "a68ca0066eea5c04af01e42b8c29a76236ea8165", + "rawBytes": 4562, + "rawSHA256": "F2391D3F5DCEAEBBF79E6B6BB4DDAE6A7DD60CD4EE5B907F1D8B0AFACCB5D719" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/verify_contract.py", + "mode": "100644", + "gitBlob": "aae2c76ea3d3f670b102cbdbeb33c350a14d8dbc", + "rawBytes": 25567, + "rawSHA256": "92FDA271B84D5286B7CCCD3277DB7B13B4DE5D0196FE26E6148DA864EB9321DA" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/verify_evidence.py", + "mode": "100644", + "gitBlob": "c6436243788fc270d2f5d7c34287182cdf4c5d6e", + "rawBytes": 30668, + "rawSHA256": "614081CB05F073121D02309A2F249DA8D27C6535D9B069776C45A57239656CDF" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/verify_history.py", + "mode": "100644", + "gitBlob": "9aa64b4988de69ecfb5a0dd0bcb08237b91c1b24", + "rawBytes": 41578, + "rawSHA256": "64E66A04A1E35486BF1CF35481B8B3FCA8D20B00B88DC46292D808211D2E47CF" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/verify_scope.py", + "mode": "100644", + "gitBlob": "d1e937a09cad712d6c9370560da77ea2e2ccde07", + "rawBytes": 4819, + "rawSHA256": "315751A3CF257382B104D7D7471AA2C9FD9BCD0E22C09E6DB6E62E96A6B2961C" + }, + { + "path": "docs/internal/extensions/native1/.gitattributes", + "mode": "100644", + "gitBlob": "0d06cba3191946218cf405cac707d12f0e0c0662", + "rawBytes": 1508, + "rawSHA256": "CCF135C40AADB273A2366D0E9DCDA2D80A792E246F77ECEC5DA894D32956B98A" + }, + { + "path": "docs/internal/extensions/native1/ACCEPTANCE_FREEZE.json", + "mode": "100644", + "gitBlob": "e9099d54833f90abd4660e85243e3ad1f526f816", + "rawBytes": 354, + "rawSHA256": "C049A24B55FD35BDF3EE33EB208B0D6016D332864409F9ACE4CD488119B49E0A" + }, + { + "path": "docs/internal/extensions/native1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "42c5ce5ade2640d21cf459520f3cb19fed7312db", + "rawBytes": 74021, + "rawSHA256": "F216C6F8DC13343807E126CE29F33333144306B59B60B270ABFDC5224AE80AF9" + }, + { + "path": "docs/internal/extensions/native1/AUDIT_PACKET_INDEX.json", + "mode": "100644", + "gitBlob": "453e2448c3f7881718908032e0dd98f402b03281", + "rawBytes": 36713, + "rawSHA256": "81B89157942D4C67A24E3E9885D4A6C51FAD0E39B1A0A95C4A5E7275D9C31807" + }, + { + "path": "docs/internal/extensions/native1/AUDIT_PUBLIC_CLAIM_PATHS.json", + "mode": "100644", + "gitBlob": "fcab64d73deea73405f41fe9df0cd88cc386dea1", + "rawBytes": 16613, + "rawSHA256": "6AC9F2B344D1B49C1D0432384BB78E6ED9EA6C04D017C811FA8B5A38517FD57A" + }, + { + "path": "docs/internal/extensions/native1/AUDIT_REQUIREMENTS.md", + "mode": "100644", + "gitBlob": "31c4785e33d5eab258a969bf0a0f96dc8bfdfd72", + "rawBytes": 11035, + "rawSHA256": "2EEB860936F15D1C189D23C67960B1679DFFF1FF6FEB2DBFE53D018C624CBA60" + }, + { + "path": "docs/internal/extensions/native1/BINARY_BUILD_MANIFEST.json", + "mode": "100644", + "gitBlob": "fdf336a77a930da0918b3bbff3e3c01ce6ca5223", + "rawBytes": 5601986, + "rawSHA256": "8ACF20E470E6247E3E415FE283F909C7BDE2F968518F76F0CDA0ED7F988954FD" + }, + { + "path": "docs/internal/extensions/native1/BINARY_LEAF.md", + "mode": "100644", + "gitBlob": "906e2a024425992b1539a005defa668d808e9669", + "rawBytes": 28485, + "rawSHA256": "91D2E40E3FE5B4F39C715F4B519AA59FBBBB32B4958DAA3448E8F7231C2C7132" + }, + { + "path": "docs/internal/extensions/native1/BINARY_V3_BUILD_MANIFEST.json", + "mode": "100644", + "gitBlob": "d63988821bd58840a9c2c2848a78ee034e599aed", + "rawBytes": 2779460, + "rawSHA256": "A4C20BCAA5E35402293DB522CE8736A81BD84FBC67FC2648693475504E5E1069" + }, + { + "path": "docs/internal/extensions/native1/BINARY_VALIDATION.md", + "mode": "100644", + "gitBlob": "df6b7c855d910159f5901fcef5f073bef32f9a20", + "rawBytes": 47551, + "rawSHA256": "B3CAF562182BCAE69162D9F00B9563D5AB14DFB8B2320A62BF8A620F1CF19B63" + }, + { + "path": "docs/internal/extensions/native1/CLAUDE_ASSISTANCE.md", + "mode": "100644", + "gitBlob": "f42799175956bfcd92fd01aa3aa5f7b07238f8af", + "rawBytes": 3830, + "rawSHA256": "3570F033F75FE6C181E561616C45C184930B867E165305484FDE817969A12CDA" + }, + { + "path": "docs/internal/extensions/native1/COMMANDS.md", + "mode": "100644", + "gitBlob": "ba3d2bc55c2bd429a6683017e91f85cc76fc70ef", + "rawBytes": 19228, + "rawSHA256": "DC6A7DDAAC59AC4CCB2581175400F08813AD41BC577A81CCCB661E72C0354B31" + }, + { + "path": "docs/internal/extensions/native1/CONTINUATION_CONTRACT.md", + "mode": "100644", + "gitBlob": "77e254fdd06d9dc0ad05943adc523486acf7bddd", + "rawBytes": 6940, + "rawSHA256": "41D73E461D330DE2306879AC9B30CA6E455832D039C1E9FFBC57942608465ECF" + }, + { + "path": "docs/internal/extensions/native1/CONTRACT_AUDIT.md", + "mode": "100644", + "gitBlob": "925ec8558db396a78dc27b509289eeed0269e095", + "rawBytes": 6559, + "rawSHA256": "8478BF15BE3EC6E9B9FBF1EC411B4E6DAEA98830271E0C8AA63E5925C79294C0" + }, + { + "path": "docs/internal/extensions/native1/CONTRACT_VALIDATION.md", + "mode": "100644", + "gitBlob": "cd3e5d2a00095a22706ab9fc93fbe38e6d663b68", + "rawBytes": 12138, + "rawSHA256": "7C22845D4FF64AA27D2D849B7DDD0A646A1E16F15F83CBA452DD8474577025A4" + }, + { + "path": "docs/internal/extensions/native1/CURSOR_LEAF.md", + "mode": "100644", + "gitBlob": "67447ee823e85bb016d4099f87abdf2d3769fd92", + "rawBytes": 14440, + "rawSHA256": "C50BA238172C0148705B86FFEE7155DFD7E97B71FE2F017351E9DA0113A78932" + }, + { + "path": "docs/internal/extensions/native1/DEFAULT_CACHE_PREPARATION.md", + "mode": "100644", + "gitBlob": "32cdf20bc2676f7e91279f30d3894c25b174158d", + "rawBytes": 6732, + "rawSHA256": "42CD1EE4543E267F2173DC66827B7D3A1917BA2396A85C85365080C0C9154D32" + }, + { + "path": "docs/internal/extensions/native1/FINAL_SOURCE_MATRIX.md", + "mode": "100644", + "gitBlob": "577c669e14fa5e5e66a61a7b5357765a08740165", + "rawBytes": 43376, + "rawSHA256": "AC9259FB49DC6E0CBCDD83760AFE61FD2E76AC27979B8E2ACCDC17782C9395B5" + }, + { + "path": "docs/internal/extensions/native1/FINITE_LEAF.md", + "mode": "100644", + "gitBlob": "41841889fe74394a0cec52bc91e7ddfa9c4d5b1d", + "rawBytes": 14613, + "rawSHA256": "621881F7683AE6F0DE9D8CCEA6AB9B08373F77F832F6AB0CF738F170DE47D325" + }, + { + "path": "docs/internal/extensions/native1/FRESH_AUDIT_PROMPT.md", + "mode": "100644", + "gitBlob": "2af3f1e9c2987ec4e1dd9d32a8c1794e7e021809", + "rawBytes": 15782, + "rawSHA256": "FB993699B9E2CB96C1732251DA874038C1CE62872622DF2543952349A6DC36DE" + }, + { + "path": "docs/internal/extensions/native1/GENERATED_SOURCE_PINS.json", + "mode": "100644", + "gitBlob": "8d42156a171f2bde876868bd715dc54613e9fa8b", + "rawBytes": 7756, + "rawSHA256": "2B577ED972455CEE40096A1A7BED5BCA2E7805631A159D4F239EFF332F06A56F" + }, + { + "path": "docs/internal/extensions/native1/LIMB_WORDS.md", + "mode": "100644", + "gitBlob": "45ee7501d48f5099c29ed1ac1e1842fcdaa87d95", + "rawBytes": 13338, + "rawSHA256": "B6764E1D0F6543756D19B8DD663944193C2FF4BA9571ED2D0B61F76A39A0718A" + }, + { + "path": "docs/internal/extensions/native1/MACHINE_LEAF.md", + "mode": "100644", + "gitBlob": "229f9e7dccb6ede588d1e5ce09c6c0e1531a4b73", + "rawBytes": 20405, + "rawSHA256": "C47A57211500F386E61AA8F5DF67D8DAD101AFDB48EE0746B14F8E2526AB884B" + }, + { + "path": "docs/internal/extensions/native1/NATIVE_BUILD_MANIFEST.json", + "mode": "100644", + "gitBlob": "b40c37c7374b19eca80683b6a23ede34c224086c", + "rawBytes": 2637, + "rawSHA256": "2F2C3FB554CA57D8A1C086460B55817940FC2B238DC6CF00813BA59D54D3F162" + }, + { + "path": "docs/internal/extensions/native1/NATIVE_WITNESSES.md", + "mode": "100644", + "gitBlob": "f107832be50704f9a15dbf5a30238d82adba4b90", + "rawBytes": 17296, + "rawSHA256": "35D66A3ECCD53E5F9015222E72B23E0061C9C61D4789AA93FF7253832D4965F4" + }, + { + "path": "docs/internal/extensions/native1/PHASE_RESULTS.json", + "mode": "100644", + "gitBlob": "4004049e42a5c9a650da2753c1f0657f65c883d1", + "rawBytes": 702, + "rawSHA256": "AD6EE54D2D7190DCFEF8E352C2F657129664CC712AF3F2C58B63F2B6BE8358F4" + }, + { + "path": "docs/internal/extensions/native1/POLICY_REPAIR.md", + "mode": "100644", + "gitBlob": "d3418e6ad186d99301fd33ca91038c128f919a44", + "rawBytes": 22255, + "rawSHA256": "5587FC0CDC6E76F136316791FA41B8534BFD30E134B633A8554F9C23C7DAB4E9" + }, + { + "path": "docs/internal/extensions/native1/REGISTRY_REPAIR.md", + "mode": "100644", + "gitBlob": "7fff40370c66141aaaa5801e099d2277cd7d3c0e", + "rawBytes": 21980, + "rawSHA256": "7065D9B248D8B1131F4F8446BFC29A58BB7984366228B15989662D61948943D9" + }, + { + "path": "docs/internal/extensions/native1/REPAIRED_BUILD_MANIFEST.json", + "mode": "100644", + "gitBlob": "0cb4b6d21fd8ee965a2ac2a90c2804863ecb5008", + "rawBytes": 954536, + "rawSHA256": "B07F660A24BA5966D7CD5BDA3D2C7C7D90ECF6FDD4192DE0B709C486D5F006F9" + }, + { + "path": "docs/internal/extensions/native1/REPORT.md", + "mode": "100644", + "gitBlob": "15952d1a5fb792c7acdcbe04cb3aa9a25f1f90e4", + "rawBytes": 14049, + "rawSHA256": "2FB3D34A27414A796CCCBA0C4483B25A0435C8A8ED03643A60BFA1880D2877CF" + }, + { + "path": "docs/internal/extensions/native1/REPORT_ROUTE_HISTORY.md", + "mode": "100644", + "gitBlob": "98b3e5b65fe1414bd2071200a1d17ee648ede257", + "rawBytes": 21192, + "rawSHA256": "D6C362528D5FF2DAE2FA929C1C9A3A05B5E681F2C2E4EDF72451CB7D3F5FDC00" + }, + { + "path": "docs/internal/extensions/native1/ROUTE_EVIDENCE.md", + "mode": "100644", + "gitBlob": "57a292527d926f9290ee17c8c0d08cb9ee1c0fe4", + "rawBytes": 12810, + "rawSHA256": "94E4F0C210B219C251188174BC0A0D34B7716BDFC551A9D87C22429E5C300405" + }, + { + "path": "docs/internal/extensions/native1/SOURCE_CONTRACT.md", + "mode": "100644", + "gitBlob": "5ecea9aa6d125a7b3ba6dfb9544d37a257382c5e", + "rawBytes": 18526, + "rawSHA256": "8D9833471C76FD84E7C93E1387A755B063EB3307CD6ABE4B604564FAB6ABE94D" + }, + { + "path": "docs/internal/extensions/native1/VALIDATOR.md", + "mode": "100644", + "gitBlob": "7447bffb343045e1d80629d3a9bd6af3c4b0927c", + "rawBytes": 16963, + "rawSHA256": "A67D9F80ED923B4B87D6A3ECE5223FB6277D0E0BC8BA0B58F56407637F0AB6FF" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-controls-20260912T130603847.json", + "mode": "100644", + "gitBlob": "326e720be96cf37a5eb8d6c9f7e455a6d2f1a782", + "rawBytes": 1045014, + "rawSHA256": "2BEAD2557D7CD8EA6056265636B45F05E0AF68F4E39F848441EF51F9226C06ED" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-early-guards-after-v3.json", + "mode": "100644", + "gitBlob": "bca4d41da9036fbde6e1aabff0cdd5fd6ed3958e", + "rawBytes": 9893, + "rawSHA256": "E9F857F0D2C190F5DAAC6FBAE58353745344388C1258CDC90B8CB5160E06E432" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-final-extraction.json", + "mode": "100644", + "gitBlob": "d5fd40c383d3a7445ce6e56899dcfc469d6659d3", + "rawBytes": 37882, + "rawSHA256": "82DE67D23A1D730CE1C42B434EE5C9EFFAA87B543A8D7982FC6B251AAF461EC2" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-final-static-checks.json", + "mode": "100644", + "gitBlob": "661c7af52d71464325f41b4a17e058e85e1945e1", + "rawBytes": 1490, + "rawSHA256": "6CEC80BED0022446D33BA641AB88FAF11A9D369A3E275B74ABE6EAA5D511B00A" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-first-selector-v1.json", + "mode": "100644", + "gitBlob": "b4ace9c6762a54b0ce5fe2b3fb62e5ba82ffe097", + "rawBytes": 1503, + "rawSHA256": "B97BC00109328A43F2AA70C27C147B9C2EFC95C043FEC4000EBD4D92633F78E1" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-replay-20260912T114513436.json", + "mode": "100644", + "gitBlob": "9393bd83f0dd5dd2f66232883d4cfffeb2f14f3e", + "rawBytes": 2936, + "rawSHA256": "28B9AB5DD8FAAED00E96F2EF4295032DF9630DDB397F77D8F19167DD28C5B4D9" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-replay-20260912T125636041.json", + "mode": "100644", + "gitBlob": "d7d478c73b8d691ea657e768cd764c519bc4d9c0", + "rawBytes": 41411, + "rawSHA256": "38040FEB491E40E1360433730DE8AD727DFCDBC712E319E5800A22A9B94C91EF" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-replay-20260912T125916442.json", + "mode": "100644", + "gitBlob": "8e713bc6a67aa891ff6f4d8c46548fc550b9747b", + "rawBytes": 111203, + "rawSHA256": "B1D9822DED4D34540E665CBA932506EC251842924AA467BA58C5B1196E2348AA" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-replay-20260912T131637038.json", + "mode": "100644", + "gitBlob": "5dcaca368ac5e1a7f85140b3ade22c57244835e3", + "rawBytes": 41497, + "rawSHA256": "02D81FDE724FE4E567BF2E6BC3E5E3592F053174B626EBCE68F8BD52A87482FB" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-replay-20260912T131712734.json", + "mode": "100644", + "gitBlob": "4eb3cbb2a0acb3ffe4e62a593d2ebe6da862a5a5", + "rawBytes": 3016026, + "rawSHA256": "C159656B68A1C1757EB439277D21C36C485D39A228A516BD47995E69C8CD60EA" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-static-manifest.json", + "mode": "100644", + "gitBlob": "d09d54defb4553e8597d7dfc74ade1c2e106146f", + "rawBytes": 11606, + "rawSHA256": "3FEAE48A9FF7EA86DC7BA570D3FAA023E2AD590B9DF69A4CD768EBBEA6D04C12" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-v3-calibration-pq1-n9-full-20260912T125906228.json", + "mode": "100644", + "gitBlob": "330b72a88a12accc0a5cad4e49500fde030f512b", + "rawBytes": 1206, + "rawSHA256": "93DFD7505E6E855E831F87251EE803C5980CDA2F54BCE3D012728CF5F77C11BD" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-v3-calibration-query-smoke-20260912T125624257.json", + "mode": "100644", + "gitBlob": "b1c334503dd7e850b696168b48e7da72e200f143", + "rawBytes": 1205, + "rawSHA256": "60DCBD76700765AF369DF952A5E789C9782DFD66A436EE4C9132D55A3CFAD5D1" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-v3-final-128-20260912T130558739.json", + "mode": "100644", + "gitBlob": "60f0f27cbba293033cdd97d30d9a183be61dd4b6", + "rawBytes": 16722, + "rawSHA256": "ACB96574D5D43E5FAA61B1571591CBCA9AE41D29C0B27DEC3377F30C6E5CD9C6" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/contract-inventory-20260912T132610808.json", + "mode": "100644", + "gitBlob": "d00aa02b41bbf2aeab6a40e357023c0daf356dfd", + "rawBytes": 149868, + "rawSHA256": "F96D0EC22C7331BF5EEA3F66182529B6E54CDDF9AAA177BBA5BD4B13FE13FCBB" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/contract-replay-20260912T131025801.json", + "mode": "100644", + "gitBlob": "c4a0829b17bfe80eefd7d69b70abf9acdaab793b", + "rawBytes": 4465, + "rawSHA256": "C3CDC436AC6ED19165C874E991960017D15F88BD5B47CFDAB3B4FE62DD289C4C" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/contract-replay-20260912T132003337.json", + "mode": "100644", + "gitBlob": "220317ca7408bc5dd3f5bdf0204152a9a42f5822", + "rawBytes": 133438, + "rawSHA256": "00DFFEB5097288A4F76D7236C933A0E11B0628C979A62A4BE3126CCA16460F6E" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/contract-replay-20260912T132210348.json", + "mode": "100644", + "gitBlob": "a5ec0ac57d279049b8f7a241eeffb62579001163", + "rawBytes": 135008, + "rawSHA256": "363AF8BC6FE34E695C65F019B518B52A125383F26FA069DA655B9CCC97F9217C" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/contract-replay-20260912T132516703.json", + "mode": "100644", + "gitBlob": "54e3631b1603d368f7bef1b78d98e9bd3c316b03", + "rawBytes": 40265, + "rawSHA256": "65909FEE725067FEFE4D46EA196F81878A95942B399AF613209EA99A825F2C50" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/contract-replay-20260912T132541948.json", + "mode": "100644", + "gitBlob": "caf0b6c62fe229593d1a885fcc143b3396548c61", + "rawBytes": 133437, + "rawSHA256": "82EC95A14CF0B13143AAAD7C0ACE1EC641894791FB313B6CF39DF389D0C6A6A4" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/contract-replay-20260912T132610808.json", + "mode": "100644", + "gitBlob": "9dca171773b7df7e7d7fa182a623cd6616e467a8", + "rawBytes": 539593, + "rawSHA256": "F98F12D881F0FAF1B13A6159ED1F116009C2CD5878771093B892152ED9F894FE" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/cpp-effective-discovery.json", + "mode": "100644", + "gitBlob": "888a90a860c7b2e6a182adeaa3785580e035df7a", + "rawBytes": 14934, + "rawSHA256": "DE098CE9A3F2CCF498D3677C3F00AB68C9D87730AAE35BB05E2E0A0851C3DE57" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/draft-producer-summary.json", + "mode": "100644", + "gitBlob": "2087c3f7cd3e9cbbad3c6287713a17bed6a90071", + "rawBytes": 533, + "rawSHA256": "3F684196ED68D147CFCF0CD3CA173E22D5904529A4A37137CF0BABFA547ED506" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/empty-argument-byte-capture-control.json", + "mode": "100644", + "gitBlob": "746b5b00cfcd20906ff2b89556be053fe1fdb66b", + "rawBytes": 2313, + "rawSHA256": "8CB6D96EF0C1D56914662C5620E7F1E1CC7C374EAFCEB10314C6F317C0FDA21C" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/empty-argument-capture-control.json", + "mode": "100644", + "gitBlob": "1c8c1a1e383540f8d13c4b9e0af30b4dfa3533b6", + "rawBytes": 2209, + "rawSHA256": "86230516F2600704250D2D66FAD5F5C01DDA3D45DD358FA5163484190165D8EF" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/final-field-span-preparation.json", + "mode": "100644", + "gitBlob": "208111f9899f7e87a9c8ab76903b23d7111500db", + "rawBytes": 38263, + "rawSHA256": "58D84DE4102BABC4F0398133F2C45F97BE66B6CF233159872DFF6C183785A71F" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/hash-buffer-benchmark-owned.json", + "mode": "100644", + "gitBlob": "a509277ab2c477afd9198813d8758b9da5446388", + "rawBytes": 2499, + "rawSHA256": "64F568F7CBFB21FD2EA05D426245DCF03B89A86F7ED7FBDE34E5BCEECB791B6F" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/hash-buffer-benchmark.json", + "mode": "100644", + "gitBlob": "768f505b0afed2ecd471397812679a50427e9ee0", + "rawBytes": 3257, + "rawSHA256": "BAE105FE253ABFDD8EC2D9B1C710859C6609AA8EBAB6C40E542138A1F40ED49F" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/hash-small-file-benchmark.json", + "mode": "100644", + "gitBlob": "e40953ea57a6aa7c44baa2404d2c3c87832b2974", + "rawBytes": 61222, + "rawSHA256": "19A5AC6BC0EAF3881767215413DFAC6615329889C3F4E38D2101562C959E9B8C" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/hash-small-file-owned.json", + "mode": "100644", + "gitBlob": "b84a392556361a50bf8da110d09ff543c36d5886", + "rawBytes": 2583, + "rawSHA256": "5763A9A03B6F344D7F8620E2BB45AC6DDE0B7BBCDDDCBC93DA33BA302BF324AA" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/identity-v3-controls-20260912T120225336.json", + "mode": "100644", + "gitBlob": "d1b78d71be00f6fb70ed2c310f5cf62441e88991", + "rawBytes": 1992, + "rawSHA256": "7367E3FD75B3BD7C8765DEC88DA9AE4B36FA14560B1707E3771B547A6426E9F1" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/identity-v3-controls-20260912T120438830.json", + "mode": "100644", + "gitBlob": "682adc55652aa5aad612e5de94d61017d5a36e97", + "rawBytes": 24996, + "rawSHA256": "ABF91F122E4266ECDEE2252755769874C3DD9CB92EDF71AACA01867B11242C4A" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/identity-v3-controls-20260912T120609886.json", + "mode": "100644", + "gitBlob": "1b72cbb15f8cd98d728e718f988ee7ef9b200487", + "rawBytes": 1563, + "rawSHA256": "4D5A6D18B0E74B8684440547E0ACCB10FAFEA8B4144E4C17129C10E248A0F2CE" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/identity-v3-controls-20260912T120637882.json", + "mode": "100644", + "gitBlob": "680a11638d1eaa9a437009e8c48b760e1b8142e6", + "rawBytes": 15253, + "rawSHA256": "BE853EC667DE2DEF2694DDB1CE5F0F25D0B9BAD6A6191CDD82031B32BA5C94DF" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/identity-v3-controls-20260912T120706093.json", + "mode": "100644", + "gitBlob": "8ff3585417100f70076b723fb9cc0572b5acd42c", + "rawBytes": 2496, + "rawSHA256": "19C94FD2EF575B3B2AC0FC04F276185A5C12A6246FDA7BF8F99068F7538D6028" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/identity-v3-controls-20260912T120722287.json", + "mode": "100644", + "gitBlob": "14edf2705a43fd15538b50719f74c9a4dcd5e003", + "rawBytes": 1661, + "rawSHA256": "660F4C60340033EA224EFC5E6D6779B2F6AD40AFB8B29F410AE235BBFAD1D4D1" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/identity-v3-final-wrapper.json", + "mode": "100644", + "gitBlob": "a7cf9e13ec3838790beba3b99061994b03301cd2", + "rawBytes": 1129, + "rawSHA256": "F1034B215937BA41AFBC4A7495BB060087E284750CAB4EA3F60FF0B8A77ABF95" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/property-span-all-draft-check.json", + "mode": "100644", + "gitBlob": "5396bc0997f963ff3bc68789b61ae8d9f920f564", + "rawBytes": 33001, + "rawSHA256": "D9C0B544446B8B439CC445C0A0CA15A1F10A3355D12854C15C73C68A21D602F8" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/property-span-draft-check.json", + "mode": "100644", + "gitBlob": "a6ddfd38e67460cbb9d870b69cecb376a2cafd3b", + "rawBytes": 10505, + "rawSHA256": "C8D59B7851454D93ABDEEFD8CAF7C030D58C7967A4C56E2E3646618221D0E49F" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/raw-byte-capture-control.json", + "mode": "100644", + "gitBlob": "276b7a70b048bb9c6f36e4c14ec0d0e9a88b1b48", + "rawBytes": 2177, + "rawSHA256": "22F86D139B9A5BC99BB64075B0AC5951CD2417704E2381E47E2E018543865901" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/startup-packed-rmq-native-cpp.exe.json", + "mode": "100644", + "gitBlob": "72711ad9b04fbaba83c061a1c14e648fafe38df4", + "rawBytes": 3331, + "rawSHA256": "AEDC6C3534AD0DC03EBBCE629748330A4FA80A0A2588793F2781E58A6C53F21E" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/startup-packed-rmq-native.exe.json", + "mode": "100644", + "gitBlob": "a5d0e59b6fb52ca0edcd7a7bf0e0372588647cf3", + "rawBytes": 3313, + "rawSHA256": "89482AE63CC190F1379C76FADE26820DA142BB8FAEBB15FBA72DC48B0A9B5757" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/toolchain-mismatch-actual-v2.json", + "mode": "100644", + "gitBlob": "ecb79f5bd4f052f42c32b7c9cad9597fd822c469", + "rawBytes": 2641051, + "rawSHA256": "AF8459AC7377D3353E5EA96D362A16EF4309D8A2F2A93B9EB1820ED9594BDA11" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/toolchain-mismatch-diagnosis-v2.json", + "mode": "100644", + "gitBlob": "cbc8c6bd8ba3f92621cad0587313176a905d3e28", + "rawBytes": 30725, + "rawSHA256": "A2235AF69884771CAA39B9C9F0B74DE1CBEBDD4743FFDCBE73ECCAB27C3A6DF9" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/toolchain-order-delta.json", + "mode": "100644", + "gitBlob": "39c96869b3569aae39f67e7718849bfc4416b561", + "rawBytes": 7124, + "rawSHA256": "3B0A9A92D9BC501E8E4FDA443B2246757ED11FE128864098F7D372D489E5D229" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/witness-independent-inspection.json", + "mode": "100644", + "gitBlob": "c6a57c4c338d72baebedbb7da4ab3830ff225580", + "rawBytes": 9790, + "rawSHA256": "29F34CA018DBE14D142AD56DADDE96039487D9B34E6A14BBFAB45C31862E5190" + }, + { + "path": "docs/internal/extensions/native1/commands/audit-contract-extraction.json", + "mode": "100644", + "gitBlob": "caa7945b0a9fb76c403e27844e7e456a27dac013", + "rawBytes": 1398, + "rawSHA256": "D252CD1CD73C44C3EC3EB610B1042455488BD8A384E1B82E03DB28A862B0D306" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-bounds-01.json", + "mode": "100644", + "gitBlob": "efa05dcb931d2d9aa65c6462797d432d9188acd9", + "rawBytes": 6054, + "rawSHA256": "5F0F7D0561FB11237D3EA83F0308C43369F086D9DCC95A2733A8045B78E64828" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-bounds-02.json", + "mode": "100644", + "gitBlob": "39310162b4c11cb93e4d37d4d34d0f673a7ac31b", + "rawBytes": 3199, + "rawSHA256": "BA374D694A6394A152ECC67B509B00C772D7CC8BBA65A07BE2067A13FF6DCB93" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-build-20260912T111100924.json", + "mode": "100644", + "gitBlob": "3ced7ad136958437920d00f6090baf8e5b429ee2", + "rawBytes": 5692692, + "rawSHA256": "8486C0C039365DE086E651FBC1686531D1DCA4F000C75C62BE6A65E70E6C53EB" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-build-20260912T122050486.json", + "mode": "100644", + "gitBlob": "665b38c6255eb2da1c8d6cebea79f4b29d04c49b", + "rawBytes": 2827735, + "rawSHA256": "C62F6EC8198AF6636D0DDAE410CB6D122F520F784C8CEAA0FF69F2F539252BB7" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-checks-01.json", + "mode": "100644", + "gitBlob": "d0279a328047eaace7f465f9e51d1e20f2e7f632", + "rawBytes": 69557, + "rawSHA256": "9FFD5314D0505914E68580ABABB3867C93732929A4703BAF0CBB75914692C080" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-checks-02.json", + "mode": "100644", + "gitBlob": "8c96a9a12ad916ed14def10610bdcb7babbea1c6", + "rawBytes": 64553, + "rawSHA256": "A059B23E8873E407583578D1EF839615F35529225829106D6FF82614AB6DC39B" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-checks-03.json", + "mode": "100644", + "gitBlob": "13623c1fdc028ca3803b5699645d27f63236d248", + "rawBytes": 24568, + "rawSHA256": "A87CE7B52B29152565E0DE733FF43433D3980A6074D478F96690E00F5698051A" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-checks-04.json", + "mode": "100644", + "gitBlob": "00e474c8316e56e636d969b1926e98b6042b11cf", + "rawBytes": 17971, + "rawSHA256": "C982C3A3B379807A63D530B2B93C8E4BDB7E2957C2FDDEA2D42163B632BE1161" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-checks-05.json", + "mode": "100644", + "gitBlob": "6063d8d1bf9c067e931d05041a9f4ff9ee69b0e3", + "rawBytes": 7644, + "rawSHA256": "776FA98083C7470CAF1A437649F5110A985300D48BDEB1999C1479A4C0DEFF3A" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-checks-06.json", + "mode": "100644", + "gitBlob": "fc8dc5f20e810732c66a63b3ada1a6babccf3ea6", + "rawBytes": 6741, + "rawSHA256": "5A76F1353958B4594DAED08A700604C44EBBFDCDC803384DA1BD20E6CD36E5C2" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-codec-02.log", + "mode": "100644", + "gitBlob": "027068d19f7ebc8513ae861b56bdd6bea2a6cf90", + "rawBytes": 10849, + "rawSHA256": "C43248BB7E6199FE5C23B46BB092005004B2E548D144DA6F9D9EE42470A37039" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-codec-03.log", + "mode": "100644", + "gitBlob": "694a7ea331980e652579416f5be98a360642027f", + "rawBytes": 703, + "rawSHA256": "D4F080C782E70768B9B4ED4EE6F444FEB2532E2AE6611B18E64AE7FFAE2B042A" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-codec-final.json", + "mode": "100644", + "gitBlob": "a2b5c0cefc65e24eecda8a96e5685b9c4d43dbb2", + "rawBytes": 1717, + "rawSHA256": "58C84CFB005A4100DD2AD0B0F499721F260E2B736C722B6CD01E589286E5D066" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-image-01.json", + "mode": "100644", + "gitBlob": "597979ef9a23525a53b96149dee23416a211d832", + "rawBytes": 35990, + "rawSHA256": "230B0EBD39B5AA079C248EE3435E5DBB8133E69851E217C2146C04F1144AFB15" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-image-02.json", + "mode": "100644", + "gitBlob": "4633303c35e579e6ae4fb00b13de24a7c24db8a6", + "rawBytes": 4908, + "rawSHA256": "0E1EDD93B4CFA9E78C3A70CC5F11457C1DC8947AFDDB750B6D030BA8423FDEAB" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-image-final.json", + "mode": "100644", + "gitBlob": "5442e49bb00fefa831a07dc8f2ef855bd83745b5", + "rawBytes": 4913, + "rawSHA256": "E7C5D827F4F78602F28C7C7D589E00399D4319B55ED027B622E870C1B35A7AEE" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-v3-integrity.json", + "mode": "100644", + "gitBlob": "943e33c5325b6c21258274217e7d670e5b592421", + "rawBytes": 5730, + "rawSHA256": "34C2FFACB61D00B49C2C3B9AD2976BC23C43B97B86E3A19AA5F0BC1851EBE2F0" + }, + { + "path": "docs/internal/extensions/native1/commands/build-20260912T072514256.json", + "mode": "100644", + "gitBlob": "027a9462093ae5bd2907b68be5a0a8ff4b17b885", + "rawBytes": 11309, + "rawSHA256": "CDFA19D6BFE316D21D38C2018EA1F2391A87A1D3E55018978ABCA5FA8573C24D" + }, + { + "path": "docs/internal/extensions/native1/commands/build-20260912T072850050.json", + "mode": "100644", + "gitBlob": "f8ef49c956b626beef871162c75eb96924302149", + "rawBytes": 13518, + "rawSHA256": "716D8F31995FCB1FC1FA95BE385ACCBE0E6AE3D6640FBEB70436C1F3CFDE7B5C" + }, + { + "path": "docs/internal/extensions/native1/commands/build-20260912T073559261.json", + "mode": "100644", + "gitBlob": "bf7fb224703dcb2e37937883368a8cac59f4e50d", + "rawBytes": 18304, + "rawSHA256": "2FADA50AF95C282E6D240262497DE7D8A23DD1E70E01CD94DCBB22FB9EF0B5A2" + }, + { + "path": "docs/internal/extensions/native1/commands/build-20260912T074002536.json", + "mode": "100644", + "gitBlob": "35280ea77c463763c86c71baaea3b233eff8aa01", + "rawBytes": 16037, + "rawSHA256": "91738BE73B9D27EB8A6B6C0C15133FFA8FA419FB429DC9641108C8E1C60F616F" + }, + { + "path": "docs/internal/extensions/native1/commands/build-20260912T074238729.json", + "mode": "100644", + "gitBlob": "e237565f9856312c7f10583f031633b0d6114c99", + "rawBytes": 17512, + "rawSHA256": "B08FD8BDEA1BCF2DB8C2979A50F462E6FE3E8255AD9C7254D08D4D88A04840C6" + }, + { + "path": "docs/internal/extensions/native1/commands/build-20260912T080927170.json", + "mode": "100644", + "gitBlob": "adb28ecad7cdf3f9afa9117a2462f7763bb8c1c7", + "rawBytes": 17510, + "rawSHA256": "09A40460D3A0455E77DAE576A772D4167A67E559ACE4FE075FFA74B4914331F6" + }, + { + "path": "docs/internal/extensions/native1/commands/build-20260912T091755276.json", + "mode": "100644", + "gitBlob": "155476a9309744fdfdd008add73910ef375125ac", + "rawBytes": 970501, + "rawSHA256": "518CBBF1F1DDA3446628B653EBE4CDB8FC0A47F89D2F920F36D40CE1245EE82A" + }, + { + "path": "docs/internal/extensions/native1/commands/canonical-01.json", + "mode": "100644", + "gitBlob": "b203543bffe16dc0c56f0743d22d2acad6733fa9", + "rawBytes": 2145, + "rawSHA256": "A2A87A167918E68AA7EDF30DB9AD262E8743819E614CCF265DCF029ECAEB28C2" + }, + { + "path": "docs/internal/extensions/native1/commands/canonical-02.json", + "mode": "100644", + "gitBlob": "531132e7df2386d918f77a0d205401398f495e3d", + "rawBytes": 1866, + "rawSHA256": "A77090B43EF13CCB2773EDA954B134A5EFA7C7744028C4F468A5D5E4ED0CE9E9" + }, + { + "path": "docs/internal/extensions/native1/commands/canonical-03.json", + "mode": "100644", + "gitBlob": "2ccf00150cf52a90488f59369bc71daf67056732", + "rawBytes": 1384, + "rawSHA256": "41532868D2D6E9189E94C2C0F006B6D784220DF7B42C5A154D250255CA8EDEF2" + }, + { + "path": "docs/internal/extensions/native1/commands/canonical-04.json", + "mode": "100644", + "gitBlob": "8b9ff18a4afadeed22fe7ae8e4fd2ac0744ca0c4", + "rawBytes": 893, + "rawSHA256": "29C28D07C986E2045812E3DC24FF023ABB05F3068F386D68A86F4FBBF7218FC5" + }, + { + "path": "docs/internal/extensions/native1/commands/canonical-image-01.json", + "mode": "100644", + "gitBlob": "7eeb0c2ac7804c3ee625e78315ec800541c74859", + "rawBytes": 914, + "rawSHA256": "A16C289A697D602A40FD8D43CC83805CEC4AEC2B717C125299CC1BE9BE9D561A" + }, + { + "path": "docs/internal/extensions/native1/commands/capstone-01.json", + "mode": "100644", + "gitBlob": "43fc416c31e9cc4e1fe3c19952eb824ba6c010b1", + "rawBytes": 2182, + "rawSHA256": "C8A9C7F515E9D83A4A838B9CA32960231B6492C18DA6B8E9FE6928C903007A26" + }, + { + "path": "docs/internal/extensions/native1/commands/capstone-02.json", + "mode": "100644", + "gitBlob": "fdbcfad71717c0364e47ed07dc81e98683f4d26f", + "rawBytes": 890, + "rawSHA256": "C1FB7B2B933E77A6B20CCF403E5D703A847ECD9644A0D76613C6575490F36186" + }, + { + "path": "docs/internal/extensions/native1/commands/capstone-03.json", + "mode": "100644", + "gitBlob": "6ffacbb56b9b9c53b2c63eecf95a7a0d2e7e12c9", + "rawBytes": 889, + "rawSHA256": "79C760E7B620EAE8B914E4676268601A04C04400C639D2E58162A08E6F63D648" + }, + { + "path": "docs/internal/extensions/native1/commands/claim-current-report-draft.json", + "mode": "100644", + "gitBlob": "5786a7a79202aecad5199f80e23d94bc90255f52", + "rawBytes": 1110, + "rawSHA256": "5D6717A693063C92451AA5BA0070F253893DB8B329EE238114CEB1DF3A1679DB" + }, + { + "path": "docs/internal/extensions/native1/commands/claim-drift-native-readme-fixed.json", + "mode": "100644", + "gitBlob": "43227ea215e360a251effd9c37281b35250d6257", + "rawBytes": 1013, + "rawSHA256": "DAFE8EF920D080A8D949F947B5272D60C398973EFB581AF3B93F474DA6213E52" + }, + { + "path": "docs/internal/extensions/native1/commands/claim-drift-native-readme.json.gz", + "mode": "100644", + "gitBlob": "83332cc415c43d07ae5da8ca434d7bae713b08e5", + "rawBytes": 621, + "rawSHA256": "13C39FCF08BDD46E3FDB735A57244E9D087220BA59433746BB20A0DD849FFBCD" + }, + { + "path": "docs/internal/extensions/native1/commands/claim-drift-packet.json.gz", + "mode": "100644", + "gitBlob": "745ad9f58c2db54286824e555afccd14224e8d43", + "rawBytes": 1558, + "rawSHA256": "1C7D2F500130E861CA6288C32739533B449956C19A130EE85B8CA78D346A8085" + }, + { + "path": "docs/internal/extensions/native1/commands/claim-drift-report.json", + "mode": "100644", + "gitBlob": "8444768244cf7062281d13c2aa2484a9173a0cbc", + "rawBytes": 1047, + "rawSHA256": "96084C9E3458CFF2AA8EAA579A9FF19E7EF07EFFBD3AE510693AC6A4036013D2" + }, + { + "path": "docs/internal/extensions/native1/commands/claim-drift.json.gz", + "mode": "100644", + "gitBlob": "015a6bd866d06ad9885968c4605cf00af80739bc", + "rawBytes": 1165514, + "rawSHA256": "6FD28FEE71221A7361929A73A31F4C87369031CE06168A5EA017DD921FD62FF4" + }, + { + "path": "docs/internal/extensions/native1/commands/claim-drift.summary.json", + "mode": "100644", + "gitBlob": "29ac03a67b49a786904c15a2b09154e7edd46115", + "rawBytes": 939, + "rawSHA256": "22DEFE87BC6B2F5844037BEBEA7AE766372849629413209671F9464E2E63B80E" + }, + { + "path": "docs/internal/extensions/native1/commands/claim-native-readme-fixed.json", + "mode": "100644", + "gitBlob": "1a02deb8a709d2614794cb8a1ce15674cf11e279", + "rawBytes": 998, + "rawSHA256": "8BA05507455F7E0DACCD6E3ED4F5B59421A7928B9DD92FE9F22E53A5F8EF3CA4" + }, + { + "path": "docs/internal/extensions/native1/commands/claim-native-source-checkpoint.json.gz", + "mode": "100644", + "gitBlob": "d7a77d4310b420f0316fe60395b0d7f4fdcb42d0", + "rawBytes": 5812, + "rawSHA256": "3677A12060580E070DE15972EDC4C7E562DFD82D2BA56FBAAFA1CA86AB518386" + }, + { + "path": "docs/internal/extensions/native1/commands/committed-diff-phase.json", + "mode": "100644", + "gitBlob": "2ce215bf8bf63d030182734810aae05b3cbf1402", + "rawBytes": 698, + "rawSHA256": "9A77C15895AC6ED8F7C43E73448782D7816DCCAB6A6FB6BEA2556FB0B5CB2CCC" + }, + { + "path": "docs/internal/extensions/native1/commands/contract-01.json", + "mode": "100644", + "gitBlob": "9ebd0b3336e6d121476a265366bda717ceac8d7e", + "rawBytes": 817, + "rawSHA256": "F2129745A97A78C844CC7671E1E88AB681D69378CDD9A8FCFFB9613E7D4572CD" + }, + { + "path": "docs/internal/extensions/native1/commands/contract-02.json", + "mode": "100644", + "gitBlob": "8256ac56ef17f10a47a0f7f8f8174e206348df6b", + "rawBytes": 817, + "rawSHA256": "F58F85AC723523AAEC9131AFB175762665CD539379069C20F61F35DA560D6B58" + }, + { + "path": "docs/internal/extensions/native1/commands/contract-baseline-01.json", + "mode": "100644", + "gitBlob": "11386d5fea9aff9d0aaf3bb559b3e8c298a6a7c1", + "rawBytes": 1656, + "rawSHA256": "B75AB7AB72EFA0128B2E88C68BB29509D1A1A891AC9E4307AD7D5387B0BF5FC5" + }, + { + "path": "docs/internal/extensions/native1/commands/contract-baseline-02.json", + "mode": "100644", + "gitBlob": "081a0480bccf08737d6d6166dcd328adb9acbd48", + "rawBytes": 975, + "rawSHA256": "5B5B691636626F3A91B1CBD2F8815E45569D2C7C65DB1C5D747D2357E0F56F3B" + }, + { + "path": "docs/internal/extensions/native1/commands/contract-controls-all-01.json", + "mode": "100644", + "gitBlob": "8e2b00704346a975db7dca1f78836e08e4b9456c", + "rawBytes": 1872, + "rawSHA256": "68AB2A0A1092EC8CB70FAABBE8692B84C2358099AA80D339E5DF3B26F5531005" + }, + { + "path": "docs/internal/extensions/native1/commands/contract-field-n01-01.json", + "mode": "100644", + "gitBlob": "e066bbde6f2150edaada2e3cc1c37e35a4e7309c", + "rawBytes": 979, + "rawSHA256": "1D02AD7662043E8336DAB9FA5B863ED26AB1B03A51060FA17BDB3DA66416B246" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T075336106.json", + "mode": "100644", + "gitBlob": "f6e5593755bc5247a7c306066b98248cbb8e4676", + "rawBytes": 1489, + "rawSHA256": "F142F9FB559C07E7B0DCBE79458E7B4AAD0D6F3911F2E2DFDE6903EA93E7B6DF" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T081542413.json", + "mode": "100644", + "gitBlob": "a82cd72f8848b2880cc6249a162f8b2c6baa6533", + "rawBytes": 1489, + "rawSHA256": "E13681A3D3CAF0E317E65F8667AA47C06B3734DD63FBF785293A5341EB27FACD" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T091008993.json", + "mode": "100644", + "gitBlob": "fc878aeffc1e0dfbd26d5e27104cd78df47a6d1f", + "rawBytes": 3705, + "rawSHA256": "C7A84F1AAB452D7C00D86C45FC2359CF2B364609C1A507F9081D8F91358CB9C6" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T091026831.json", + "mode": "100644", + "gitBlob": "109c661ad194fd7583d5e5ab944c59976d0bea19", + "rawBytes": 4039, + "rawSHA256": "64CE34453F0F45CA745B5F3C659ADA5D39FD560ADC1973CD63CF540159E7B04B" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T091036366.json", + "mode": "100644", + "gitBlob": "5021cb241399a19ef75e3c823cc0cc2cd4d351ec", + "rawBytes": 4039, + "rawSHA256": "BA31DF84823C979D8E4618CAA41B5E7348D410AA71F2776277AC95F8C2FB20B7" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T091459085.json", + "mode": "100644", + "gitBlob": "c3bff1d4a3961f6a3b4056b9e4bb88d541ef63c8", + "rawBytes": 4467, + "rawSHA256": "3F6C3E2D39D6A5CCADF2E0F40F6A7FC7DF52AFAC2D9E5BA45778582157329770" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T091719835.json", + "mode": "100644", + "gitBlob": "af121f92448ff16ab7194e59ae48acafda0813dc", + "rawBytes": 4549, + "rawSHA256": "A31C7AEF2CEB3D1660EC02DF775EC37BFD707AE96E78F22D218B7E8403BFC869" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T091847484.json", + "mode": "100644", + "gitBlob": "44adec12f968c014ecf440d248696fad7574d7bc", + "rawBytes": 4494, + "rawSHA256": "C2650BE432ABD4F5D7AC3A05ECD540B250BEDF2E052EC5FEF1F3E5D837EEB84E" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T091900870.json", + "mode": "100644", + "gitBlob": "bee88d4f509b8a6f42eb4d4a6c0daea3f5cf0aa9", + "rawBytes": 4549, + "rawSHA256": "16AB16B81CAF93DEE6FA46A21C7CEEE4DF06A896D2B9B4CE605A780F4A9515CF" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T094238749.json", + "mode": "100644", + "gitBlob": "52e9bd7384a646a1ba2f9d9aeac0a97565a904d5", + "rawBytes": 116103, + "rawSHA256": "30C8F47E755E1F596816E7CDCC88C373EB7BE6AC9AE5DEA0391A5BAC7CAE8C66" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T094700539.json", + "mode": "100644", + "gitBlob": "d0df86b610102eff98154b8f48c76028ff2f9099", + "rawBytes": 4692, + "rawSHA256": "065C71B31F95F0ED44F56E07475F11F5F7D2AB7BCFEE956D09DC2991B5D93689" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T094711304.json", + "mode": "100644", + "gitBlob": "3bb10cf434d424a2604e459bd0febd84e866265c", + "rawBytes": 4692, + "rawSHA256": "9C5DBDF25A484ECBD183A9EDF42F234A2766D0B60F0B4092C2226986A57975E2" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T100023269.json", + "mode": "100644", + "gitBlob": "7db16ed953a4903110842c6842554df03222b57b", + "rawBytes": 126710, + "rawSHA256": "2F81170ED3D368B2B0ECD87343C9BBF6CCCC4A284B3ECBAF0C94E2EEFE6E8679" + }, + { + "path": "docs/internal/extensions/native1/commands/cpp-build.json", + "mode": "100644", + "gitBlob": "35545f754dfa7bb135772ad0e876f73ecbbb4446", + "rawBytes": 825, + "rawSHA256": "AF65DDD8C7218E4A314B7DEDBBA4EB201949D021AEF05C408AABAB406C7FBC65" + }, + { + "path": "docs/internal/extensions/native1/commands/cpp-import-library.json", + "mode": "100644", + "gitBlob": "030f734b2918d4dff32efb00e39841c8ce30a23d", + "rawBytes": 1053, + "rawSHA256": "537450226645A9EA017795E8147B6E31EA2FE715FB187AD7D01F0621C48C747A" + }, + { + "path": "docs/internal/extensions/native1/commands/cpp-n9-full-final.json", + "mode": "100644", + "gitBlob": "362786874bab9290c3751a1291037bd5a797bea7", + "rawBytes": 14727, + "rawSHA256": "F5B341434848A0D7EBF6C77B9717557BC204B8E36A760802C5AB41673A94163E" + }, + { + "path": "docs/internal/extensions/native1/commands/cpp-n9-full.json", + "mode": "100644", + "gitBlob": "cf35d32da34f2562def188367e919aee90bf4acc", + "rawBytes": 14719, + "rawSHA256": "7AFE9992E7EA59C424BE191E5C69E481C45BA642684CB358F9E47C760076FFB5" + }, + { + "path": "docs/internal/extensions/native1/commands/cursor-01.json", + "mode": "100644", + "gitBlob": "1fb5cccf299a8e6083fc32d83563dc92e206126e", + "rawBytes": 31789, + "rawSHA256": "975C8B63985E2CF68D31175A3D394EDD8DE757FD7B355EE3FFCBCDA2F9190686" + }, + { + "path": "docs/internal/extensions/native1/commands/cursor-02.json", + "mode": "100644", + "gitBlob": "09ae7dacd1a8be658d49cfb4943134d5e908c758", + "rawBytes": 7669, + "rawSHA256": "453F59A5FD780D29A3374A23037ED56DAB1DB2C1FA8F36CE85DDDD4226B7CAFE" + }, + { + "path": "docs/internal/extensions/native1/commands/cursor-checks-01.json", + "mode": "100644", + "gitBlob": "05b955c77f62b75069e19a53ec468b26b088d9bc", + "rawBytes": 27427, + "rawSHA256": "33DFD5B67DFBFBC32BCB8723AF453C320835C8E8CE4C1DF262C6EB853882DABC" + }, + { + "path": "docs/internal/extensions/native1/commands/cursor-checks-02.json", + "mode": "100644", + "gitBlob": "f18a129af7b5c5b41828e0b033b1d5ce0b33e949", + "rawBytes": 3764, + "rawSHA256": "3CDF88BBA30D632AF09CABCD10CF1D7C20F1CC615AEAB0B69CE70B364A863067" + }, + { + "path": "docs/internal/extensions/native1/commands/cursor-core-01.json", + "mode": "100644", + "gitBlob": "d7b7afcd9c17161627b09b19b8d3878ea8b04f75", + "rawBytes": 34569, + "rawSHA256": "6478DEE3397B27D2AAD897EF816559C93753198ED68ECB49CE0A0DAF6BA2A801" + }, + { + "path": "docs/internal/extensions/native1/commands/cursor-core-02.json", + "mode": "100644", + "gitBlob": "3e149f566c06d99153fa136a3c88afb54dd09cb1", + "rawBytes": 18102, + "rawSHA256": "D091919F9F2EB30872E90F8E57A0AA3E616243E8C4D089F4EC28686A9B016E20" + }, + { + "path": "docs/internal/extensions/native1/commands/cursor-core-03.json", + "mode": "100644", + "gitBlob": "7f59a15d2d1034c8185b39027bdb71e6d8238b13", + "rawBytes": 9149, + "rawSHA256": "7C6289F1ECF7A20F8B832D5C458AEE5DE46597BDBFD28A50BF3DB15EE8F68F66" + }, + { + "path": "docs/internal/extensions/native1/commands/cursor-core-04.json", + "mode": "100644", + "gitBlob": "dec441e107455b5a61e796731b9d7bbfb9ae3229", + "rawBytes": 5467, + "rawSHA256": "4D62B4866F3646C63974AAC450F73E4B74571DC7F1BFC512A9857B30DF0C0F26" + }, + { + "path": "docs/internal/extensions/native1/commands/default-cache-validation.json", + "mode": "100644", + "gitBlob": "ebc948ef80cb3676e8a0e11d014ce02b9d7b6d30", + "rawBytes": 245760, + "rawSHA256": "8CA79F5DA6C1CBBFBAD7F5AE895D86F5BD5060F589BE72D4CBF8B3AD8D7C9C5D" + }, + { + "path": "docs/internal/extensions/native1/commands/design-final-candidate-commit.json", + "mode": "100644", + "gitBlob": "7c43253af1506bbf280b1506ef1851ceb04e09ac", + "rawBytes": 1189, + "rawSHA256": "403C66C0684AD1F896C9AC6306E962988AA79E2F085CB1810AFAD31FB2EF36EF" + }, + { + "path": "docs/internal/extensions/native1/commands/design-final-path-precheck.json", + "mode": "100644", + "gitBlob": "cd36a59cadb0f0ded72d68d9ca5226db0229965f", + "rawBytes": 1054, + "rawSHA256": "01842A48B4D6DFA6436F91CE5FF730470C367E2304D5BABB56FCFC702278A2A3" + }, + { + "path": "docs/internal/extensions/native1/commands/design-native-source-checkpoint.json", + "mode": "100644", + "gitBlob": "d741eb4bc0dbb7c7bd6305ca0b4410065f8faf0a", + "rawBytes": 1091, + "rawSHA256": "36527457E222DD9B43BC098621BF8B104BFECEF8DF8F68F35507BEA6BE7AD293" + }, + { + "path": "docs/internal/extensions/native1/commands/design-phase.json", + "mode": "100644", + "gitBlob": "8c248ea7c85b16b5a487828451f7fd7940dbf422", + "rawBytes": 4866, + "rawSHA256": "DAB5EFEB67DE1EA2931B8532281D9722EC7BBAAE12D61516EE8E685BEC6F96ED" + }, + { + "path": "docs/internal/extensions/native1/commands/entry-01.json", + "mode": "100644", + "gitBlob": "4badf57ff474ce4629593bfbb4e31f8f4af454b1", + "rawBytes": 878, + "rawSHA256": "70FE462AB91F374E65DE034A7FC7E68BD8BC06FCA38DA145D8B2E47F0529BE65" + }, + { + "path": "docs/internal/extensions/native1/commands/exact-types-01.json", + "mode": "100644", + "gitBlob": "477a51194813d6e3c3bfa633b42c3d63088ee63b", + "rawBytes": 3382, + "rawSHA256": "4ABB38C5871334B8E568757FD434A7B6885EDC6AB610D96BBBE0BAA930AF0F6A" + }, + { + "path": "docs/internal/extensions/native1/commands/execution-01.json", + "mode": "100644", + "gitBlob": "ea40e446472ad8e1cd365cfe640ee28b3b3c8544", + "rawBytes": 2624, + "rawSHA256": "0C85343488D3110FDB123CB47B1DAF9267AF38F8E30A4D3F0BE7E481BBEADEC0" + }, + { + "path": "docs/internal/extensions/native1/commands/execution-02.json", + "mode": "100644", + "gitBlob": "ad2ca7cc98c8ae5cdbfa33ab4251450b912b1be5", + "rawBytes": 894, + "rawSHA256": "067229AD45C1764D903242847F80AB60A09291E1177BF234F61424B79E89BD12" + }, + { + "path": "docs/internal/extensions/native1/commands/execution-03.json", + "mode": "100644", + "gitBlob": "d73d1fc6fd3232bc9d7b87ba65111f84263ea34f", + "rawBytes": 894, + "rawSHA256": "A1B1CBD3157DB3441D0F3DAECA627583753A6881918A9BFF0B063D545CBCBBB7" + }, + { + "path": "docs/internal/extensions/native1/commands/final-claim-surface-inventory.json", + "mode": "100644", + "gitBlob": "cb589daac0c8037b581880d78353de4b900d94a0", + "rawBytes": 43648, + "rawSHA256": "C228D2A29EE3F860DB2A4B803F3FBA0C362FCC0FFD4F271827E7DCB7D030757D" + }, + { + "path": "docs/internal/extensions/native1/commands/final-claims-process-command.json.gz", + "mode": "100644", + "gitBlob": "b88169b2f7ba939b9ee43431c0d710c1e879c6aa", + "rawBytes": 1353, + "rawSHA256": "471EC10A7974D0BBB805D20FD4D62374611F73210C192E6EE16B2EB1BCB3DDE1" + }, + { + "path": "docs/internal/extensions/native1/commands/final-claims-process.json.gz", + "mode": "100644", + "gitBlob": "0cd0a4d09ea85f8c35feebc42b34c43d68c5307b", + "rawBytes": 22256, + "rawSHA256": "0C50B6A46D0277023FE9635A7D8A8F6C32F3251B54091A66F896911AE16DFA6F" + }, + { + "path": "docs/internal/extensions/native1/commands/final-claims-public-command.json.gz", + "mode": "100644", + "gitBlob": "59c551b04bd6a217e1d06e801dd13dd98736ce85", + "rawBytes": 789, + "rawSHA256": "771F4654B086D65F2A401FDEF3BA7D0E19933ED9F0D5A979EF92787738B49779" + }, + { + "path": "docs/internal/extensions/native1/commands/final-claims-public.json.gz", + "mode": "100644", + "gitBlob": "8fabc5911802f23a31488eda0c09ec75b9a9fcc1", + "rawBytes": 24569, + "rawSHA256": "5D4DB70088AA5FB163C2B7C918CB754F482B03678DCD13ABEDA068D7F96410C2" + }, + { + "path": "docs/internal/extensions/native1/commands/final-default-build.json", + "mode": "100644", + "gitBlob": "4cf9b592b205fad732b779c3453e50d97fcfd840", + "rawBytes": 245718, + "rawSHA256": "0285F7F1F721E8AD4B06F3124D1186120C2AA8DF7E68A4D06D9A6D4D1A731AC9" + }, + { + "path": "docs/internal/extensions/native1/commands/final-design-base.json", + "mode": "100644", + "gitBlob": "7183f522e441d7ca5f58ea0d2db7fb645a17e2a3", + "rawBytes": 1109, + "rawSHA256": "F76498183650F9F487BD445683DE406280D3853C7F449317FA0C295B82DAEA88" + }, + { + "path": "docs/internal/extensions/native1/commands/final-diff-checks.json", + "mode": "100644", + "gitBlob": "2eaa063c93e6699259962f85ecfb36af89c38efa", + "rawBytes": 1197, + "rawSHA256": "4B6D90F35ABB62F76455540005F2A609F32EA3DC88D02643866ACDA9963B243E" + }, + { + "path": "docs/internal/extensions/native1/commands/final-freeze.json", + "mode": "100644", + "gitBlob": "e4ae8611a986e7609f49b06ce000d369d67bb176", + "rawBytes": 2907, + "rawSHA256": "9B16C39CB13CC91AA2437655254AB31F27C6BBFF6C415113DC87B2A0A56A2865" + }, + { + "path": "docs/internal/extensions/native1/commands/final-integrity.json", + "mode": "100644", + "gitBlob": "e8f17e6fe9fd674dd2478d885096988cb1966f13", + "rawBytes": 20221, + "rawSHA256": "71E5D1D9E8A79527D0CE39DCD4C5C5BC3DD45EE527CD0E6825B8261399514181" + }, + { + "path": "docs/internal/extensions/native1/commands/final-metadata-check-command-02.json", + "mode": "100644", + "gitBlob": "b5076a2f6e8f2ac7091c440c4826199174694955", + "rawBytes": 1033, + "rawSHA256": "34263D52C1F34A87F4010333B1725DEE54C52911C235A95F170BA7674B545DF5" + }, + { + "path": "docs/internal/extensions/native1/commands/final-metadata-check-command.json", + "mode": "100644", + "gitBlob": "592ce9384938c430b481ab62fdd87bfd985046d4", + "rawBytes": 1028, + "rawSHA256": "EE987818C166A0AE0CB2B05D96ACC3A377EE0AF7B3852AFC88400A52B6C2808F" + }, + { + "path": "docs/internal/extensions/native1/commands/final-metadata-checks.json.gz", + "mode": "100644", + "gitBlob": "a021ad3a3834ce9b037c538df3933135106307ed", + "rawBytes": 5384, + "rawSHA256": "AF13F3AD9EBD8FDFACE7D7F02DEE89CAD1700D84FA101E15AB120D06850F3C43" + }, + { + "path": "docs/internal/extensions/native1/commands/final-native-imports.json", + "mode": "100644", + "gitBlob": "9a8542eafb7a97f9358ef3c1f0cf402a75e88463", + "rawBytes": 2924, + "rawSHA256": "B2FD1913C4D42BF9FCAC481BCAC45F108DBF687B57EAE54DE9138B0C2FE15DED" + }, + { + "path": "docs/internal/extensions/native1/commands/final-static-command.json.gz", + "mode": "100644", + "gitBlob": "fb1f1ea9f3a5b161b86a7adfe91e08fc63724b8d", + "rawBytes": 1114860, + "rawSHA256": "FB288DCBED23770DC9C45E35BF7A00D8434A064F21ACE1BC8946F93263CE79C1" + }, + { + "path": "docs/internal/extensions/native1/commands/final-text-claims-command.json.gz", + "mode": "100644", + "gitBlob": "484a29b7032308e5076c5772cc97c6ca49f21558", + "rawBytes": 1358, + "rawSHA256": "F9B8E8610C08D3A300CB09BA8112402E060309581C0BA916D08BE8EE6463AA97" + }, + { + "path": "docs/internal/extensions/native1/commands/final-text-claims-process.json.gz", + "mode": "100644", + "gitBlob": "e7eb406d00663913127a8165b206861d11e036a6", + "rawBytes": 22238, + "rawSHA256": "9441834D18427E7653D0157EBC6973710E159AC76128F7F1642FE98543507D30" + }, + { + "path": "docs/internal/extensions/native1/commands/final-validator-import.json", + "mode": "100644", + "gitBlob": "3468ca899fa6614bfe8e56a253d10ebe1ea64c0a", + "rawBytes": 1273, + "rawSHA256": "EEB93871B11D3FCB04346F2CD5931AF460A561449BD0FD0DE040ABA2DA0EF033" + }, + { + "path": "docs/internal/extensions/native1/commands/freeze-before-public-blob.json", + "mode": "100644", + "gitBlob": "e900e1094a35259526360cbbf5b304acbfd6649b", + "rawBytes": 2907, + "rawSHA256": "BD084EEF9F66048CFFD91246C837E009ADC3DF48E072752152794A0FAF87B921" + }, + { + "path": "docs/internal/extensions/native1/commands/host-01.json", + "mode": "100644", + "gitBlob": "d124d4b10973990954f3674d37d9f3a444f49470", + "rawBytes": 805, + "rawSHA256": "40BBC538EFE3BC9763B61AAFCB86E7DDD3F4AEF4BFDCB4F728FF3343FB4707A4" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-20260912T101354869.json", + "mode": "100644", + "gitBlob": "e4145f6d495740cabe42bccbab6d13f84b9a9b87", + "rawBytes": 41547, + "rawSHA256": "F363D6F308F45562DD164EAFF190EFFA1D2CFAD81E331EEC7FEE8CA5CB6D5285" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-20260912T101530710.json", + "mode": "100644", + "gitBlob": "00a7de273312d62a5dd5908b2b30bad9f844da60", + "rawBytes": 351693, + "rawSHA256": "987973262FEA98973124D58C65E547DE1084511621DFF07B42F98154AB7CDD72" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-default-20260912T124121657.json", + "mode": "100644", + "gitBlob": "7fac2326fa031299f3adb60143b8f11f56d78378", + "rawBytes": 39879, + "rawSHA256": "0E617CCA970D58564D56748BD471E70D09E4945F0DBBEEFFD54BF9CF654E4AEF" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-default-20260912T124531692.json", + "mode": "100644", + "gitBlob": "44455d8310637fb331202fad5b4522a30441ca28", + "rawBytes": 272517, + "rawSHA256": "81740862E330845822FC1340E04B24B10545C50927EAC7995E6FA587E79C0935" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-default-20260912T125020579.json", + "mode": "100644", + "gitBlob": "f6a289b0e5d5b4cae9a34f7d581ef10827c11854", + "rawBytes": 663953, + "rawSHA256": "7C9CE0DB64D31F075FCBE16CF150049048E86BACD43B38AFD73C6432164D9A78" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-default-command-01.json", + "mode": "100644", + "gitBlob": "59bd857f4703d13ed79dc57b820f97bb427ee929", + "rawBytes": 1405, + "rawSHA256": "BC4B5338AC4430F9720699067BDE3F81F9E1815D346F1F82D9AA62858C362235" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-default-command-02.json", + "mode": "100644", + "gitBlob": "38f2d52ee49eafbd2ccbdc590b2fe0256c84f509", + "rawBytes": 1630, + "rawSHA256": "5A6D45A3A7E2F7D2AB503DDA9C97DBF77528E4CC14FF423676D7E675DF9AB8E0" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-default-command-03.json", + "mode": "100644", + "gitBlob": "271bcd28d2d962273084ff58a64a4a723d20b7b8", + "rawBytes": 1918, + "rawSHA256": "E82A25C7F15FB900A3CEA534B1BCA7E2239505B0B62C54CD70FFE7768D787AF0" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-default-parser-02.json", + "mode": "100644", + "gitBlob": "690433fa81a63decad9d9f1d7fe4e53db066b9a5", + "rawBytes": 1509, + "rawSHA256": "AE0D2D0FA597B5EBCB627B4195B2BE610C44777D316F476715DBCADEDA39F04F" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-default-preflight.json", + "mode": "100644", + "gitBlob": "b7bf9ece5da39cc33895dabcc255721fef42541c", + "rawBytes": 963, + "rawSHA256": "319D11EBDAA71EE8EB324A7D74C588968BFC6C472AE658F1B13330D5034F6E80" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrated-lake-check-01.json", + "mode": "100644", + "gitBlob": "449cb44d580b909ee7b65d9fc7b87710ba915aad", + "rawBytes": 204092, + "rawSHA256": "5A3E710D6CEB6F59B4F9BF5A99E7EEA5585597FF226EB631E47AE0E8F41FA73D" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrated-lake-diagnosis-01.json", + "mode": "100644", + "gitBlob": "8db73bc2b01b12ed26ec82dbf95d94b8073c7d82", + "rawBytes": 519294, + "rawSHA256": "58C1D0DC8EC0CE78F720AD27A21536760599432B66EF22026179226CA76DCFCA" + }, + { + "path": "docs/internal/extensions/native1/commands/hygiene.json", + "mode": "100644", + "gitBlob": "21be97def5fe407f40a05357110d1b2f71889480", + "rawBytes": 158, + "rawSHA256": "7A07CBCDAEB5BBBE1B3DE4553A43E067463C01CD59DFB5A20B443B477552001A" + }, + { + "path": "docs/internal/extensions/native1/commands/identity-controls-20260912T091130182.json", + "mode": "100644", + "gitBlob": "9a770017877cf45d548a2af264724dae6dc12484", + "rawBytes": 3083, + "rawSHA256": "A20567EDABFEF552937D49B9DFF216825C7E6CBA5204F1262048CCC99070BE38" + }, + { + "path": "docs/internal/extensions/native1/commands/limbs-01.json", + "mode": "100644", + "gitBlob": "f1404af42fa187f09ae3934bd9388b0e81f14a63", + "rawBytes": 1500, + "rawSHA256": "FA6B4FC3071986966E7A40A2AE0D0AC03281F594AA089E0BEB18EDCD3A262EDD" + }, + { + "path": "docs/internal/extensions/native1/commands/limbs-02.json", + "mode": "100644", + "gitBlob": "e56abf4c8c9d4d8b03e727fe95dbead2fa323fce", + "rawBytes": 889, + "rawSHA256": "9E9A382AD2410C5CA1A98E327C8FFFE60829E550CF360D9FC01C5685A7E47113" + }, + { + "path": "docs/internal/extensions/native1/commands/limbs-03.json", + "mode": "100644", + "gitBlob": "51cc8bdd79e88fd37a24bc562fcb3b38135f254d", + "rawBytes": 2361, + "rawSHA256": "CE160E1652942F38DB1CEF9677F8F2ADB3B197E5904A3D95C2F226E31CD1E0A4" + }, + { + "path": "docs/internal/extensions/native1/commands/limbs-04.json", + "mode": "100644", + "gitBlob": "bd9e9019158ca5d6b58f61fd8cf1e217de7e3116", + "rawBytes": 878, + "rawSHA256": "88EE4B7D9E50AE9B37E3EF5BCA15FB053462C5125788202B9CDA572825BE2939" + }, + { + "path": "docs/internal/extensions/native1/commands/limbs-checks-01.json", + "mode": "100644", + "gitBlob": "154e2f96038ceb93ef29340355182c564163e837", + "rawBytes": 19329, + "rawSHA256": "EA06111BB1299639F6FDE0380B3B06D819FCA5C323083678882D65B9579F22CC" + }, + { + "path": "docs/internal/extensions/native1/commands/limbs-checks-02.json", + "mode": "100644", + "gitBlob": "2a7c8745f93a5aa2b0840b16b0596315b5acbaca", + "rawBytes": 4321, + "rawSHA256": "68A44E93E81334A746AD7F0A878435A234C429BE046191A257D42E727E0ED5F3" + }, + { + "path": "docs/internal/extensions/native1/commands/loader-emptyargs-host.json", + "mode": "100644", + "gitBlob": "6dcafda5c219e06c9d3728beadf1fc847824d8c2", + "rawBytes": 412, + "rawSHA256": "F636D0113804CF6DF0149F3D923781EA9B73C9DDB6DB061C0A5644A87695079B" + }, + { + "path": "docs/internal/extensions/native1/commands/loader-emptyargs.json", + "mode": "100644", + "gitBlob": "276e6c13b2d048868aba34611e3942c762b7b8f8", + "rawBytes": 310, + "rawSHA256": "AA498BB8431127B128F8489A838F38D0F676095C0974F8D0BA8588973A36B4D2" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-01.json", + "mode": "100644", + "gitBlob": "60ad59f47443bcaea67c8edbe4458753d4e77c23", + "rawBytes": 37354, + "rawSHA256": "CB0D103A24748AD8F393D03AC9CDA8A21F197C10D550D3B6E9C73206C0690D01" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-02.json", + "mode": "100644", + "gitBlob": "bd31a2f0b2f4767325af2da683d52a6c95157ed6", + "rawBytes": 4614, + "rawSHA256": "96842353CE8A33B968092AFF6AEAE27C413EA0C0EE15C93F678A72D2F3D89F66" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-03.json", + "mode": "100644", + "gitBlob": "5017f46ed9c458dc9313181e2a5d4bec33ea1de4", + "rawBytes": 732, + "rawSHA256": "92A31E3966E5C942429D715565AB1101A1B4F86AAB008EC8B5F9470274944D89" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-04.json", + "mode": "100644", + "gitBlob": "9959f026279cbe310489ca9b3276d92c764fccef", + "rawBytes": 10348, + "rawSHA256": "7284595EF24B34D589E2557B744FAEF8310D65BA61F2053A8050ECF1BFDC5BF6" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-05.json", + "mode": "100644", + "gitBlob": "a7b36780860980d18775f70a02f2df8ab9e8f5c8", + "rawBytes": 886, + "rawSHA256": "68A3B8AE4780B28D4AD2850AD8886526B57E6C49C755DA2550C6F638F761C13A" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-06.json", + "mode": "100644", + "gitBlob": "6104079fe8ce0529f4b2762b2bccc264e23e8638", + "rawBytes": 886, + "rawSHA256": "EC21C7078772AEA09F4712A742F0D814B218F4290D5CB62420332BA298CFED42" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-checks-01.json", + "mode": "100644", + "gitBlob": "5418786417e245933e612ac82fdc9a3a0443a7ba", + "rawBytes": 5345, + "rawSHA256": "C6A59D79CF9171CDBA43262E4E843A900679205005F106A2CFC1C91008D9BBBF" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-codefacts-01.json", + "mode": "100644", + "gitBlob": "1739f25579cda4082e26d0eb24cf8100e42d9c99", + "rawBytes": 2214, + "rawSHA256": "F0EF60EBBB8F62814E7EDCB266826C9DE59BB9D9B4E081210467F271CAB80C73" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-codefacts-02.json", + "mode": "100644", + "gitBlob": "d16d029ec9e9de69a42bb257d3e4e8ac9c5bc943", + "rawBytes": 9244, + "rawSHA256": "5121D1B2F99F7048B8940F2713A69DC42ADAD44AED48E5EC920574B40AC7FB1B" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-codefacts-03.json", + "mode": "100644", + "gitBlob": "080028cea7ce79ec72185a1dea2fe9f356c234d4", + "rawBytes": 1874, + "rawSHA256": "B230F552EC24D0E9203C231B1F0432937B1F6D4422EB421B339E23D18B1A7B46" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-codefacts-04.json", + "mode": "100644", + "gitBlob": "c6a035bd855833959307d9b3d88b0c1900935cdd", + "rawBytes": 1693, + "rawSHA256": "DB8A1B4D7615400CCFE4FCC761A56875F60BA31E5893DBABFCDACF702449D649" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-codefacts-checks-01.json", + "mode": "100644", + "gitBlob": "caaf6813892a0abb5ecf4b611647b8a42e1b94fa", + "rawBytes": 1509, + "rawSHA256": "32DEAE513DDD17A82F8ECE515BFDE7850239D9603998CE06A3A860BF7BB6B281" + }, + { + "path": "docs/internal/extensions/native1/commands/metadata-checks-before-public-blob.json.gz", + "mode": "100644", + "gitBlob": "129720d72ce3cfea87104fa8bb0dc94dc4e56273", + "rawBytes": 5430, + "rawSHA256": "414976873974C97840A1FF89454F858FB8D75F06A61704CD91FEAC56D6A07886" + }, + { + "path": "docs/internal/extensions/native1/commands/native-axiom-probe-01.json", + "mode": "100644", + "gitBlob": "8fde9ddf99757e77c6d3270b7ff13cbc0471f645", + "rawBytes": 2220, + "rawSHA256": "BFFE11FC0A82AAA85C2F9F0FFF9718DEC1067C239AC72EC470C7647789F1F22D" + }, + { + "path": "docs/internal/extensions/native1/commands/native-axiom-probe-02.json", + "mode": "100644", + "gitBlob": "f3091d4d755bac910f4a929b9120d0f531cbee92", + "rawBytes": 1230, + "rawSHA256": "AA7DC555DEB6C8A142D5D53BE91F923D5F780E9522A222159E3C21C3779AE058" + }, + { + "path": "docs/internal/extensions/native1/commands/native-axioms-01.json", + "mode": "100644", + "gitBlob": "3029d2095b6931465635451f073c61940f12cc98", + "rawBytes": 861, + "rawSHA256": "E077DFB9565E1E41CC6025EDAB73864BE2968F78A470D7F342747766F8C02D52" + }, + { + "path": "docs/internal/extensions/native1/commands/native-axioms-02.json", + "mode": "100644", + "gitBlob": "78d1f83cece6197b57d545b053816354635eb12d", + "rawBytes": 22834, + "rawSHA256": "CD3E9C38C4FB0388C53FCBD6DFC9C836B6A5EC9FCF485F8E174130C45468BB2F" + }, + { + "path": "docs/internal/extensions/native1/commands/observations-01.json", + "mode": "100644", + "gitBlob": "08119f753459c409eebadd31d45899ac812b1aaf", + "rawBytes": 19966, + "rawSHA256": "19B7DE745AF11653A67E30F94858754DA46ABDA49EB3908FE4ED4935E1C3491B" + }, + { + "path": "docs/internal/extensions/native1/commands/observations-02.json", + "mode": "100644", + "gitBlob": "8270bf00016d8200cdbbf399355758546d088b39", + "rawBytes": 5873, + "rawSHA256": "E8B81CF994D2826128BA72F97D7E0A1638C04B81CF68F04B3798F1DADCF87DF5" + }, + { + "path": "docs/internal/extensions/native1/commands/observations-03.json", + "mode": "100644", + "gitBlob": "010ffee0ade80632c73f09069aed79ee2b529c13", + "rawBytes": 2999, + "rawSHA256": "17710CA133DFEB57997C72C99B8CFA9D35190CB273D51B04554EE556F432408D" + }, + { + "path": "docs/internal/extensions/native1/commands/phase-integrity.json", + "mode": "100644", + "gitBlob": "6e13a94e69460da38c8cc8f6bc6a2559fde4fdec", + "rawBytes": 5519, + "rawSHA256": "7F59E0FD7EE158FD7957A3FA570DDB321149494C0CF6D3093DA0A6CE090EEF13" + }, + { + "path": "docs/internal/extensions/native1/commands/policy-certification.json", + "mode": "100644", + "gitBlob": "30ef3e7c6deaedda5ba8ba4453ff0c6b78483c34", + "rawBytes": 5163, + "rawSHA256": "859404C6508357D550F351E49CCCBCEA934B44A91612DFF51C0470931440CF31" + }, + { + "path": "docs/internal/extensions/native1/commands/policy-final-certification.json", + "mode": "100644", + "gitBlob": "30ef3e7c6deaedda5ba8ba4453ff0c6b78483c34", + "rawBytes": 5163, + "rawSHA256": "859404C6508357D550F351E49CCCBCEA934B44A91612DFF51C0470931440CF31" + }, + { + "path": "docs/internal/extensions/native1/commands/policy-final-focused.json", + "mode": "100644", + "gitBlob": "e68d46866d1231ead8ec9403d2f55d58bf0849b9", + "rawBytes": 10102, + "rawSHA256": "A99ACAD7DF46F5A5021AB4283E827E89E23307441CAE7738D577FECBCB6D9153" + }, + { + "path": "docs/internal/extensions/native1/commands/policy-final-full.json", + "mode": "100644", + "gitBlob": "1a78ac4262e74fabffd40657f80bd4f5a9676d4a", + "rawBytes": 28062, + "rawSHA256": "8D17E7C151F589D881DBDD687DC9D2479530C083E1DC12FC85B8FF28501A0A22" + }, + { + "path": "docs/internal/extensions/native1/commands/policy-final-preservation.json", + "mode": "100644", + "gitBlob": "8b44f6cfb3068a4b4fb0b73909678b4bbaab39b5", + "rawBytes": 174, + "rawSHA256": "A76F7A66714C793C7E7660D70036B53CAAB852D8DDB6311989FA32440EADF075" + }, + { + "path": "docs/internal/extensions/native1/commands/policy-focused.json", + "mode": "100644", + "gitBlob": "e68d46866d1231ead8ec9403d2f55d58bf0849b9", + "rawBytes": 10102, + "rawSHA256": "A99ACAD7DF46F5A5021AB4283E827E89E23307441CAE7738D577FECBCB6D9153" + }, + { + "path": "docs/internal/extensions/native1/commands/policy-full.json", + "mode": "100644", + "gitBlob": "1a78ac4262e74fabffd40657f80bd4f5a9676d4a", + "rawBytes": 28062, + "rawSHA256": "8D17E7C151F589D881DBDD687DC9D2479530C083E1DC12FC85B8FF28501A0A22" + }, + { + "path": "docs/internal/extensions/native1/commands/policy-preservation.json", + "mode": "100644", + "gitBlob": "8b44f6cfb3068a4b4fb0b73909678b4bbaab39b5", + "rawBytes": 174, + "rawSHA256": "A76F7A66714C793C7E7660D70036B53CAAB852D8DDB6311989FA32440EADF075" + }, + { + "path": "docs/internal/extensions/native1/commands/registry-kind-downgrade-coordinator.json", + "mode": "100644", + "gitBlob": "9a6a5fc8f4516f2f2aa85ff01d8b4afcfbbe92c1", + "rawBytes": 747, + "rawSHA256": "0781EA8258D7A66EFF322CE0F4E1740007A546EEA27532C420FC7B5F30A7FA89" + }, + { + "path": "docs/internal/extensions/native1/commands/registry-repair-baseline-pins.json", + "mode": "100644", + "gitBlob": "62180ebe9dcbe7fb314be7dcdc3b0299e71bb018", + "rawBytes": 691, + "rawSHA256": "93083056FDA50FBA0142B6727DF37D22EE170FB0854EA0515A3132612EE160C8" + }, + { + "path": "docs/internal/extensions/native1/commands/registry-repair-final-summary.json", + "mode": "100644", + "gitBlob": "d54f22823be46c02be6c1a92530abced7393ebf9", + "rawBytes": 1585, + "rawSHA256": "0BF9C9ADA5311923AA6E6CE977D1AA2C5D26D734DACF6FAA8B8A81C0E6C6E433" + }, + { + "path": "docs/internal/extensions/native1/commands/registry-source-pin-positive-coordinator.json", + "mode": "100644", + "gitBlob": "e0f371cd192610628d1c0598ff7547da54801c9d", + "rawBytes": 753, + "rawSHA256": "01CC7A0BEA50E8C08608D59B0F9D5916BF31CFB4AE3369D3C615F62D679E8F19" + }, + { + "path": "docs/internal/extensions/native1/commands/repair-controls-final.json", + "mode": "100644", + "gitBlob": "70ae6fbc7edf09bd80b741eb324a70bec7cd5120", + "rawBytes": 7610, + "rawSHA256": "3CF01553B7D38456FFAD18D0C92DF60A7C5432BB86BC764116B927B4816A00FD" + }, + { + "path": "docs/internal/extensions/native1/commands/repair-controls-v3-final.json", + "mode": "100644", + "gitBlob": "b52fb1e3cf7ed96818ccf75103cb6f4a50de945a", + "rawBytes": 7515, + "rawSHA256": "1548C2D5FDC8D259EC6E4C1D531C0338109813C218C5A625CB9C191CFAFF5A0E" + }, + { + "path": "docs/internal/extensions/native1/commands/repair-known-smoke.json", + "mode": "100644", + "gitBlob": "1100618bd3965cb9ed10c452525bedd936f2116b", + "rawBytes": 1315, + "rawSHA256": "F576201C872C50B149BED107F0CE63048E934733D0039E7D3A215B34149D0A9D" + }, + { + "path": "docs/internal/extensions/native1/commands/repair-native-startup-binding-failure.json", + "mode": "100644", + "gitBlob": "aca3b363ac5032523ee95127135aef25571e2bf6", + "rawBytes": 515, + "rawSHA256": "E7DE9EB8FBB91B7F0D4C75B14C66BD04ACEA488DA8ED86448C71BF8B262D6C15" + }, + { + "path": "docs/internal/extensions/native1/commands/repair-native-startup-owned.json", + "mode": "100644", + "gitBlob": "ebbdcc7691d0aad354230feebc22f4ac58e421a9", + "rawBytes": 705, + "rawSHA256": "1FC18B0C5E1E388AA1CF4697E8540E56A6B6A076284AD70830307050821152ED" + }, + { + "path": "docs/internal/extensions/native1/commands/repair-native-startup-runtime-path.json", + "mode": "100644", + "gitBlob": "264938fdadf21cd6dd3b5dc45524e83a2fac2e70", + "rawBytes": 933, + "rawSHA256": "E99AEF78D440D29B325C195864855AA54FBD3667AF4128A34F7CD1579FD684E1" + }, + { + "path": "docs/internal/extensions/native1/commands/repair-v3-control-unknown-uppercase.json", + "mode": "100644", + "gitBlob": "04a9955884a4eccddec3550f8ceaead4df3dc889", + "rawBytes": 1674, + "rawSHA256": "FC2A5A9D524D3CE083F5409C459C0651D91FD738F885629023818DAFBE6B87D7" + }, + { + "path": "docs/internal/extensions/native1/commands/repair-v3-cpp-error.json", + "mode": "100644", + "gitBlob": "9a1e8877f778efbd6116424f070526f5a6053b76", + "rawBytes": 1376, + "rawSHA256": "493E45D2C36A76FCA99D65A016F1848E08CF665D4F3621A10E06DED289980963" + }, + { + "path": "docs/internal/extensions/native1/commands/repaired-route-build.json", + "mode": "100644", + "gitBlob": "726dedd0bf62c9fde9249f1ee1763e8aace8606a", + "rawBytes": 3361, + "rawSHA256": "20C6D7F7156F0EB7AF6A3762BF50C8E1EB834C398EA417BA7C760F59F254A0BC" + }, + { + "path": "docs/internal/extensions/native1/commands/route-01.json", + "mode": "100644", + "gitBlob": "8a77e47032ed6aafff4feb5afc9427d295a47ad9", + "rawBytes": 780, + "rawSHA256": "1B212649AC414F2E985B3C4F72C97623994D5BC9FC5E0681530B9078FF579CA8" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T074345564.json", + "mode": "100644", + "gitBlob": "a990afcda12550da3c8a10d980040b1bb50acb20", + "rawBytes": 941, + "rawSHA256": "CBBE37C0F61122199A34D45146F0B45E30EEE36F45DD87925E864330708DE211" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T074851905.json", + "mode": "100644", + "gitBlob": "4e1e05e5f0888ac5811ab46dee5376e7c9c6ac05", + "rawBytes": 1118, + "rawSHA256": "BCABE60CFE0E56470266094F21F1EDF3E66D0954B572AD47F80FCB23873CB963" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T074921501.json", + "mode": "100644", + "gitBlob": "dca2426fe6650447d03093342a836116b50f162b", + "rawBytes": 18107, + "rawSHA256": "056292AD4999142D1E8A39D2DAF455E5E4259A667D04E19BF0587E00427F4621" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T075047091.json", + "mode": "100644", + "gitBlob": "096b0acb57ceac9d939bd4c7b6b1016c3871de4f", + "rawBytes": 83637, + "rawSHA256": "4341EDA40739ACB0239ABCFEBF0DE088B262184F9AE72CE716DCCAC94C113725" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T075325959.json", + "mode": "100644", + "gitBlob": "3f6ffb49d2e9547b5c88da8b610f2a6e7842fb71", + "rawBytes": 1118, + "rawSHA256": "D39DF64DE00B994C287DC7A003426450C6801218BDE899DE473051B4EDAD0DF3" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T081311355.json", + "mode": "100644", + "gitBlob": "666b330a9652cca38fc80c8352cd1dc73ffb1f6e", + "rawBytes": 83647, + "rawSHA256": "82BE145305F5BE3A6C897F9D2D43F73E1EB8AE6E8FC5916FBB295DFFFA5D502D" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T081538732.json", + "mode": "100644", + "gitBlob": "0280b83ec35a76575bf5bd78e779cac9dac3a16e", + "rawBytes": 1118, + "rawSHA256": "E0A424883AB7528B9645F2A4D8B1B692F70C8F097582B5B92941B98A9CEBD7D9" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T092619569.json", + "mode": "100644", + "gitBlob": "af944abb9d631227d1b58c9e290b88691bdd4191", + "rawBytes": 2024, + "rawSHA256": "2D5851B9EC55DF957E49AD290EBEB0D9B844960DAD04EAD754218D36BE8C95A0" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T094044361.json", + "mode": "100644", + "gitBlob": "dbb032fab9ffe54e5c614a24c0854e5e26606c72", + "rawBytes": 2165, + "rawSHA256": "83D1602C1B234644D8E938E5A46B9228F77A26C99338F150F38EEA78A2DE86F0" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T094135118.json", + "mode": "100644", + "gitBlob": "be1e3aa3204a959fd0cd932131df50f4c6fcbbca", + "rawBytes": 112175, + "rawSHA256": "621E211AE77E3DB4F97EEBB2C2577E7E84E8721481569C9D045EE22F0968037B" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T094834598.json", + "mode": "100644", + "gitBlob": "ff515bb32f59fcc677a178a62de8122fa95feed8", + "rawBytes": 2468, + "rawSHA256": "789C8174E0496B4CFCC68247F3A73E9D66B1A762820B7A2C73EDF11771F061AC" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T095846357.json", + "mode": "100644", + "gitBlob": "da49f21a7ade75aff1b58d8e6c5bbbd0753a960a", + "rawBytes": 2344, + "rawSHA256": "23A2C407B17E336388C1323CC28B3A48D0A02D757D6A89E07794A920AF08E6B8" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T095926516.json", + "mode": "100644", + "gitBlob": "6276cdd9fe5378140068b1a54cb7d503993153ad", + "rawBytes": 121289, + "rawSHA256": "5A31BDDA30A5026EDD27ED3374E4354B4AD5928C2A75591DB0BFCF780B1EB647" + }, + { + "path": "docs/internal/extensions/native1/commands/runtime-01.json", + "mode": "100644", + "gitBlob": "678cc884231638a0fe4c41adde4b31c87e97b2b7", + "rawBytes": 3410, + "rawSHA256": "36188FD19AD55CE119B5B822FB1579BDDF170D178675B83D314D1EFC028A097E" + }, + { + "path": "docs/internal/extensions/native1/commands/runtime-02.json", + "mode": "100644", + "gitBlob": "f2c5e5910e8148b7841098789bb7fc5d2dbb444e", + "rawBytes": 884, + "rawSHA256": "2E23D7CD6098EBA99971AD49BF416DB6082936A4009D4E39E324718CFF8A57C6" + }, + { + "path": "docs/internal/extensions/native1/commands/scheduling-inference.json", + "mode": "100644", + "gitBlob": "827a3fb46ad9f0bacec145cfd09a705886a529c3", + "rawBytes": 828, + "rawSHA256": "5BD275F9ED0C5C35920CAB8FFDD3E76B1050BA3ACC61D9C468F310FBB97C42CF" + }, + { + "path": "docs/internal/extensions/native1/commands/thin-01.json", + "mode": "100644", + "gitBlob": "234718ce07423d20fe5d989c93cbdcbd954212ca", + "rawBytes": 2548, + "rawSHA256": "C495339D8A01D960460C2293CA81211D1A9CEB1E9DA2E7E1FA1144BE7B8FE4A3" + }, + { + "path": "docs/internal/extensions/native1/commands/thin-02.json", + "mode": "100644", + "gitBlob": "2d62e04d31b48c2ae4c0b4e9195bcd5b5d07b6ee", + "rawBytes": 778, + "rawSHA256": "42311F28E41DD4310841B0833EC930F34B66BC3382AF8D1AD0097F15F47995A7" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-01.json", + "mode": "100644", + "gitBlob": "b8165ae385dbdad8e47a8646730439f786d05f66", + "rawBytes": 1537, + "rawSHA256": "8E5B1F77AD44301F8C03760BC77F3AAA6F18028792DB466D325D78383AC58D41" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-02.json", + "mode": "100644", + "gitBlob": "a62973a5892ff57069f177f189b5f8cfdd702c82", + "rawBytes": 1566, + "rawSHA256": "B92803F61981FFA7B64DE060568B7543ED54BCAE50FFD6018D96374C9B778E85" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-codefacts-import-01.json", + "mode": "100644", + "gitBlob": "1a7b7376f849a361527b47297ce038875573e50b", + "rawBytes": 1610, + "rawSHA256": "9167C0E94E36CBF1B81953F792AC33216EA9EFD4EF8DB09B64E2B784DF0EC40B" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-compare-positive-01.json", + "mode": "100644", + "gitBlob": "491699db5062d95a44505cf939ed38e223368c74", + "rawBytes": 1075, + "rawSHA256": "A053EB2383542434D5BCB067EBBE0BFC985630875F63218A7165249AEC917979" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-compare-wrong-01.json", + "mode": "100644", + "gitBlob": "f470945588e36d5fb1e19f1c11675bb8c26aad3c", + "rawBytes": 1072, + "rawSHA256": "2D4FD0F4F1C4C0B590481620FE8AED396107C580D8A2D79154C1547B60806099" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-controls-20260912T120702123.json", + "mode": "100644", + "gitBlob": "ea0e3e9298aa4183e514d92ce6a39b321398deff", + "rawBytes": 16514, + "rawSHA256": "BB8E08BD2DF3C0FE9A305678C4B3C355CDAED10C67DE69E8C2CFEDD91796B470" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-controls-20260912T121157154.json", + "mode": "100644", + "gitBlob": "fd6d5b1a3287b86cf96cb01c1a0b41cfeb691325", + "rawBytes": 16477, + "rawSHA256": "945970E3ED008F8796E5CC517433865ED13D4E20023BF778B5ACA620626365C9" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-controls-20260912T121837285.json", + "mode": "100644", + "gitBlob": "3a1ccee3ffae46fe493ec0f6249c916ae44e1308", + "rawBytes": 43834, + "rawSHA256": "71690B65E283EDBAC82D6A9171A1CF4C4A33E0145890271AD8BE47AABA05C756" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-controls-20260912T125248495.json", + "mode": "100644", + "gitBlob": "a366681004ddb47259a9049531ff352925725192", + "rawBytes": 25130, + "rawSHA256": "221705A5887506CD1709EAC76A0B82EC92F7513C05ADA001A30B15817D9C2992" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-controls-20260912T125634462.json", + "mode": "100644", + "gitBlob": "730d6281e9d64efec2ac3d11635d562d6c08f569", + "rawBytes": 16497, + "rawSHA256": "FBAD7181AFD653A53442AE21833BF42F74B1F5759D75FBB45659C36EC823E1DF" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-controls-20260912T130117776.json", + "mode": "100644", + "gitBlob": "453cc8bb63c459ef888407f573666090a53855e6", + "rawBytes": 53360, + "rawSHA256": "ED0A09875DDB653270F58EA7FE7DF6D16C938E70E6CA0DC963F7124A2AF1D6CA" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-cursor-import-01.json", + "mode": "100644", + "gitBlob": "f6501551bd7214658d105c4bdededcd6633899a4", + "rawBytes": 3870, + "rawSHA256": "859F0FC56FD63848B8D4B80942B073B9E498286B63E1D3AFFA543F57A13782B3" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-default-01.json", + "mode": "100644", + "gitBlob": "f814c2d93bdfc6db4f37d576b944e1b5154a4b72", + "rawBytes": 3318, + "rawSHA256": "E575A1A4DF67BC4F60E05F23C1E246D89BBF95A792611BFAF68A3A4C689E0A13" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-durable-all-01.json", + "mode": "100644", + "gitBlob": "4692b2877c5ba8e6ba1cb5f383a96af50f7ea027", + "rawBytes": 4258, + "rawSHA256": "6F6471042A86F7F39252E1B8467E03284A2E9E451F952D054972D36B81621F9C" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-durable-all-02.json", + "mode": "100644", + "gitBlob": "adaebc2d070b895f8e9e20aea768669a92527879", + "rawBytes": 4374, + "rawSHA256": "3B3688DD7842BB0EAA8E2567BC1083EACC2BC3A433A674C8F25496748DDDA46F" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-durable-positive-01.json", + "mode": "100644", + "gitBlob": "44c77b31ae446fd3e6bbd8573b2a6e424014ec37", + "rawBytes": 2096, + "rawSHA256": "D22E83D84D7F162FDD863890F82CE0B3C52A9E130FB6D62BE77BF3121DBE28C3" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-durable-positive-02.json", + "mode": "100644", + "gitBlob": "b4d7d2205dc7a5dbb2608b836c8d990f6d6f3bd2", + "rawBytes": 1522, + "rawSHA256": "D2ECC69928C5DC84A55CFF87C8B873D3BFD37363A483AB36568630D4A716624A" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-empty-channel-01.json", + "mode": "100644", + "gitBlob": "870830d9c7d9caa9c07844136d9730f621b11226", + "rawBytes": 879, + "rawSHA256": "D7B1BD126FEA79213681E3FD465FDDF46FFDA54EBFE9522239586DB88B52CF12" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-fuel-format-ps5-01.json", + "mode": "100644", + "gitBlob": "b3c1321e24c4c1b1a49699a26727b286b503e880", + "rawBytes": 1487, + "rawSHA256": "224BAE7D1DE24398DBBA908F6C5CACC02F678B92F3DE092BD641E52EF330B21D" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-fuel-format-ps7-01.json", + "mode": "100644", + "gitBlob": "22494f60abe206ecb55565cffae695d96aeff173", + "rawBytes": 1527, + "rawSHA256": "E840EB738FDC50FE9066ABC8E6DD1010C238057E17114D571C79DC5D42FB63D5" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-limbs-import-01.json", + "mode": "100644", + "gitBlob": "1e0b797f09b348502a0e8e3732879c20ffbebf41", + "rawBytes": 4784, + "rawSHA256": "33685CEEBDA2996B3F8426E8BEA29036EF1AAA5D84E49BD5BAE8EC50F69ABA44" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-limbs-import-02.json", + "mode": "100644", + "gitBlob": "e95741ea8a9a65cf2315955ccd7a29351b017b4b", + "rawBytes": 4416, + "rawSHA256": "441DB3E4F086CF53D5213DC33DF8FF5F1552709FCF7A7AF3E004A86BA58A2DA4" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-machine-import-01.json", + "mode": "100644", + "gitBlob": "a72627da3f1d56c8b1df62a158f2ab103dfca94a", + "rawBytes": 5445, + "rawSHA256": "A75CE0ECCB285F4A81F83895F511F7AC337F45F5CE37697832CFC2028A6E506A" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-malformed-01.json", + "mode": "100644", + "gitBlob": "65181b5fbd6f905504a534e1366757476c600c07", + "rawBytes": 893, + "rawSHA256": "84CDB0F418B2676A0C6D32FE46A66E8DC9A168491AEA3326BA80743464C1BA3A" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-selected-01.json", + "mode": "100644", + "gitBlob": "381d4ad585270a3db6d8a4085907d588f0b25586", + "rawBytes": 1112, + "rawSHA256": "4F446E84A08E9AA61F81B5A5BBF1EF29DC621A862B312A0855B85F6C890848F5" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-unknown-01.json", + "mode": "100644", + "gitBlob": "a141ba4b0fae4a2d8b76d5bce737cd3e870447bd", + "rawBytes": 924, + "rawSHA256": "7AB2B57754B40CE04A9B089A3849F0A7E2BEC7EA1C6B217EEF3B1892D4E4EB99" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-whitespace-01.json", + "mode": "100644", + "gitBlob": "20f02b73dcf9281219069367cd7c0c18772cc3fb", + "rawBytes": 907, + "rawSHA256": "08C2535425D4DBA8BF72DF102C56B43C917FCF93154A8746362BC58CF5EF54C7" + }, + { + "path": "docs/internal/extensions/native1/commands/warm-20260912T095318994.json", + "mode": "100644", + "gitBlob": "67b1f6f957d88d22fd688b4dff9c58e0069784fd", + "rawBytes": 54492, + "rawSHA256": "622481FD9D2ED43EBCFF87576E7053B09AE78B0106E568EE5073AC3778467EEF" + }, + { + "path": "docs/internal/extensions/native1/commands/warm-20260912T100814051.json", + "mode": "100644", + "gitBlob": "cfa336fe4d5c71859b648f0fb053512d1a0b315b", + "rawBytes": 65114, + "rawSHA256": "87EC19B2BF8A1FAE3530B1938D09749549F2CCF7992CB1F865710635B046C142" + }, + { + "path": "docs/internal/extensions/native1/commands/warm-20260912T102817544.json", + "mode": "100644", + "gitBlob": "df2b5e4cb34630b475cdc95e758df7e1903cd877", + "rawBytes": 312751, + "rawSHA256": "2DC7707ACEAF228446F82A8B526205D26499BDB269E66BBD87AC89D12F678568" + }, + { + "path": "docs/internal/extensions/native1/commands/warm-20260912T104121341.json", + "mode": "100644", + "gitBlob": "c29954ec612ce8bfaea4b80563298681e9b79e4d", + "rawBytes": 13540979, + "rawSHA256": "5F00B0F44E9B539D4AF2D1C4D36B4BFC3852844575741D03FFBF87482D1EE339" + }, + { + "path": "docs/internal/extensions/native1/commands/witness-arrayrun-01.json", + "mode": "100644", + "gitBlob": "947ab5599ae5616370fbd03122d03ff13e03d6de", + "rawBytes": 2150, + "rawSHA256": "94F9D8F398A3BDB3DACB0CFC14031DA487142532DF2479AD4279A477FC4718E1" + }, + { + "path": "docs/internal/extensions/native1/commands/witness-export-01.json", + "mode": "100644", + "gitBlob": "282f5420a5d639da8854fbcd89e2f3b51300ec7b", + "rawBytes": 5554, + "rawSHA256": "007A3B6070D8FBA5BE4A043C3715CBAA58F7070AA1F6C8B2CFE53AA7B1745506" + }, + { + "path": "docs/internal/extensions/native1/commands/witness-export-artifacts.json", + "mode": "100644", + "gitBlob": "aa20762de62562624f00c298ad4274a923c177c4", + "rawBytes": 12512, + "rawSHA256": "129A39464B161895861F54203FB6A7D6D6CE39D4FB1B259B658437322062C049" + }, + { + "path": "docs/internal/extensions/native1/commands/witness-export-check-01.json", + "mode": "100644", + "gitBlob": "f6377d07fb812d0f84d7b301f16b3d9835d4cb54", + "rawBytes": 2973, + "rawSHA256": "1AABC6F50CB4A809A8B525DD4E7B7214BC898DA293A327A925252C88798883BE" + }, + { + "path": "docs/internal/extensions/native1/commands/witness-export-check-02.json", + "mode": "100644", + "gitBlob": "bbe2e4d628b8278e0f3858a5f966c7b8c895215f", + "rawBytes": 2837, + "rawSHA256": "EB43E98C8C88170BDA3206CBED8BBE56615FB42C7822CE2DCF1A554B9212150C" + }, + { + "path": "docs/internal/extensions/native1/commands/witness-export-check-03.json", + "mode": "100644", + "gitBlob": "4680e2c1757edbcb73512a71b309665262e62752", + "rawBytes": 2163, + "rawSHA256": "08AF20A323B2B5DC2A212F42F016F2A27D14540325EDD5164B470AA17DA12192" + }, + { + "path": "docs/internal/extensions/native1/commands/witness-proofs-01.json", + "mode": "100644", + "gitBlob": "4e7cfcf00fe1b4b98e40d139c1924d36ac914604", + "rawBytes": 2721, + "rawSHA256": "2FF9BF1DD18315DD953B3C4886286C1F0BEE2625B5A802C4C41E26D47DC5D4DE" + }, + { + "path": "docs/internal/extensions/native1/commands/witness-proofs-02.json", + "mode": "100644", + "gitBlob": "6610c039af75585c633cf3d4fd8208a38cd8b0dc", + "rawBytes": 7336, + "rawSHA256": "DFF7CC33C162C3698A148366E9A57227D002A40CCAA28C37A53EA861E91CFA6A" + }, + { + "path": "docs/internal/extensions/native1/repair-r1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "4fb7f8a30aacea56c760ce337e9b7fa5be4e46c1", + "rawBytes": 33351, + "rawSHA256": "59509FE6779A33DCFE541A6B182456C5A28CF390EBB765F68CEF3E7FB4753B08" + }, + { + "path": "docs/internal/extensions/native1/repair-r1/CONTROLS_RECEIPT_d0b4cef.json", + "mode": "100644", + "gitBlob": "2fda8946dbcdfa6ee9b36476002de6b5124f409d", + "rawBytes": 140190, + "rawSHA256": "15E0E8CCE044757D22634C8FD3DD21CED04A28A1F641DBF3CC434E4E94E820A4" + }, + { + "path": "docs/internal/extensions/native1/repair-r1/RECEIPT_ARCHIVES.json", + "mode": "100644", + "gitBlob": "8f98c063aec5df552809bab100b4cd6fb3f588b6", + "rawBytes": 11895, + "rawSHA256": "9D43E4372C04C5ECC5EFB88A8BCD8E7FD9F862DBD8054D5AE8F5D55237ED4329" + }, + { + "path": "docs/internal/extensions/native1/repair-r1/REPORT.md", + "mode": "100644", + "gitBlob": "9be8139b4455e9c0b006fff15e45ad0cda466e8b", + "rawBytes": 30747, + "rawSHA256": "BD83C87ED4B5B82FE34B98635A041E51B6C326FE4B0CBAD01C84D9C7E2D24880" + }, + { + "path": "docs/internal/extensions/native1/repair-r1/receipt_archive_control_helper.py", + "mode": "100644", + "gitBlob": "5cb77df82f8d7eb0fb72d775096a969f0083de3b", + "rawBytes": 9081, + "rawSHA256": "ACA55BC949B7F1034908AF84204E214493F7F7B3A2D3F958FA17C833EF0434BA" + }, + { + "path": "docs/internal/extensions/native1/repair-r1/run_receipt_archive_controls.ps1", + "mode": "100644", + "gitBlob": "fe8eed9044c30de12ef6a9e9a2722078035f5528", + "rawBytes": 23630, + "rawSHA256": "71A0E7E382E15C66015B40579A5B903711F0B4B2DF1155D065920C485CB8464F" + }, + { + "path": "docs/internal/extensions/native1/repair-r1/verify_receipt_archives.py", + "mode": "100644", + "gitBlob": "de451edbe3e44a9a60672b24eaf0b430d4e05b2a", + "rawBytes": 19448, + "rawSHA256": "5805CC886B3FFAA7C149EAF2EB903B88E71247EF103B0C0EF99863A16334458B" + }, + { + "path": "docs/internal/extensions/opt1/.gitattributes", + "mode": "100644", + "gitBlob": "85d70dcaa28b954b72e266f4bc41a4c9ac85b1f5", + "rawBytes": 1115, + "rawSHA256": "3764865B0BA810E09327B9059E2A4E0A044E4CBD61553003074F8020DEF95780" + }, + { + "path": "docs/internal/extensions/opt1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "bd5d0eb38fd4a301eb89b027fcc434fc18dbee75", + "rawBytes": 35888, + "rawSHA256": "E21A7B6658E170DEEABF01A4F9A4C8593C5642F6048D2662A93306F002ABDD5F" + }, + { + "path": "docs/internal/extensions/opt1/AUDIT_DISPOSITION.md", + "mode": "100644", + "gitBlob": "49b2840079bc11aa66d3d67a863b6a4c12f851ab", + "rawBytes": 4625, + "rawSHA256": "C7A68E9ACE42B2CA1962A249EB7917A458810753494E12F6258000A91CF032D4" + }, + { + "path": "docs/internal/extensions/opt1/AXIOM_ROOTS.json", + "mode": "100644", + "gitBlob": "4c9314d23730f318c1a4f99ca13e2156912f277b", + "rawBytes": 9189, + "rawSHA256": "CA2908657FE00CF4E0527BF81AA6D095285C18BC5FC66F098C532A1CF812B6EF" + }, + { + "path": "docs/internal/extensions/opt1/BLIND_SOURCE_AUDIT_PROMPT.md", + "mode": "100644", + "gitBlob": "217dc766f8e52f7569d2e6a8ecc19e8e7a4d3117", + "rawBytes": 26357, + "rawSHA256": "5665D4A273C0F0CBE44388DE1C7CD76245C415EBB7457DFD5D630B52462E6AC6" + }, + { + "path": "docs/internal/extensions/opt1/BLIND_SOURCE_AUDIT_REPORT.md", + "mode": "100644", + "gitBlob": "dc7287787b5bb1761ab13e241d1e342a9222ffef", + "rawBytes": 44217, + "rawSHA256": "D40BE15F651E4F640DEFD4455E594BCCAC7C92AFCD0A915F0CACB37614C342CA" + }, + { + "path": "docs/internal/extensions/opt1/CAMPAIGN_RECEIPT_REVIEW.md", + "mode": "100644", + "gitBlob": "9d6c6bde769d71133936d1abd79c1d2d3c4dcab7", + "rawBytes": 3647, + "rawSHA256": "934F5C864359BC9FD3099B72E6FECF1DA98E00BC6FB0A4A1A6C52EED7CA6BCF6" + }, + { + "path": "docs/internal/extensions/opt1/CHECKER_REVIEW_15E.md", + "mode": "100644", + "gitBlob": "a9b53fd910842a4d03c32986a166ac58dba1bef3", + "rawBytes": 7087, + "rawSHA256": "EDC45AAC39301CBCEF8DBF36EC0EC9117CBC7A914E0DE2B123E8104CDC8233BF" + }, + { + "path": "docs/internal/extensions/opt1/CHECKER_REVIEW_BBBE.md", + "mode": "100644", + "gitBlob": "10e4fae7249456bceede7049d6703d539f944342", + "rawBytes": 3686, + "rawSHA256": "3B6C124E626C19F8B01EF00D573819C41301DF9F404DD9237F3C24A565D1C66C" + }, + { + "path": "docs/internal/extensions/opt1/CLAUDE_JOB_FINAL.json", + "mode": "100644", + "gitBlob": "0207d51f68ce44bc7ced77c10b317adf8e77ca08", + "rawBytes": 2169, + "rawSHA256": "98A2970B0A6590E1779D11FC7CB8BADBD782298EA2016A33ACFB65090A90B303" + }, + { + "path": "docs/internal/extensions/opt1/CLAUDE_JOB_START.json", + "mode": "100644", + "gitBlob": "aa6bf247e3a05638860c99381989204a5355f5de", + "rawBytes": 5012, + "rawSHA256": "DFEB56610EBF38E32AD72625C0B90FFD6AB6B10D1E590E94D92F0F48A578C6EC" + }, + { + "path": "docs/internal/extensions/opt1/CLAUDE_SOURCE_IDENTITY.json", + "mode": "100644", + "gitBlob": "40f6910d098b23f2f8c1e00c0e10424bec1b928d", + "rawBytes": 63023, + "rawSHA256": "4191CE36ECE567D8E60F135A2704C194A536DE38D990C654056245C15A43A768" + }, + { + "path": "docs/internal/extensions/opt1/CONTRACT_AUDIT.md", + "mode": "100644", + "gitBlob": "938ff30aaf3e77cf6ab3491b9546f22281e2e9ae", + "rawBytes": 9657, + "rawSHA256": "1CA92DB80E82224BE124381AF07A57B69331D5B13C515BCD940F7BD0624BEB13" + }, + { + "path": "docs/internal/extensions/opt1/CONTRACT_ROUTE.md", + "mode": "100644", + "gitBlob": "c18e698ca2d220a8b04900f48ac750124cf02410", + "rawBytes": 7355, + "rawSHA256": "F9837CA963710FE1074E6CEC40877BF06C53338F6CDD1B5A5AF0F80539EE4E22" + }, + { + "path": "docs/internal/extensions/opt1/REPORT.md", + "mode": "100644", + "gitBlob": "90a3972aa286c5756ebee789b08725cc31e39f6b", + "rawBytes": 28729, + "rawSHA256": "8FB2E742FABC26BEC9C6912078721D5CA8910769A7500C494C46BA15D0EA68D4" + }, + { + "path": "docs/internal/extensions/opt1/RESOURCE_WAIT_20260912_REPORT.md", + "mode": "100644", + "gitBlob": "ccef83c82e964b41a96e992642cbab6b0d9516b7", + "rawBytes": 15469, + "rawSHA256": "BD63F061CBB4CE2B2335F844F2975CBF9620ADF403692AA1C25FA93FDFBA8997" + }, + { + "path": "docs/internal/extensions/opt1/ROOT_COMPOSITION_PLAN.md", + "mode": "100644", + "gitBlob": "cb72d557c7078a3a099f1114a4601cbd480fc928", + "rawBytes": 5242, + "rawSHA256": "64BD687F1F7EC0F9BC3105FFF2B03FDD7D2DA4DD101B9E42FE67C9CABF102151" + }, + { + "path": "docs/internal/extensions/opt1/ROW_EVIDENCE.md", + "mode": "100644", + "gitBlob": "92c79d9f5cedb0b54efda2a59020b16448396c72", + "rawBytes": 16496, + "rawSHA256": "EB2C96CEE98722B28C77CC33004379BCC12855B7943D381141F988B24450B667" + }, + { + "path": "docs/internal/extensions/opt1/SCHEDULED_FINAL_REQUEST.md", + "mode": "100644", + "gitBlob": "ac71ee945d0448942f34cb7a377cdf872c96b347", + "rawBytes": 3669, + "rawSHA256": "AF193708B14B767C6B429ADCF5FF726C5C219F2D23C62DA5315498C84A565624" + }, + { + "path": "docs/internal/extensions/opt1/SOURCE_FREEZE.json", + "mode": "100644", + "gitBlob": "620e639a1c54b2dd23453c8b0e0ff2bb90ef209f", + "rawBytes": 1206, + "rawSHA256": "D966E19EE39C8480522D7BB83041FF71C49BDB608E90EAB23FB43D52B329A29F" + }, + { + "path": "docs/internal/extensions/opt1/STORAGE_REVIEW.md", + "mode": "100644", + "gitBlob": "5d2ef3c1a9b09f5a904b56a758403085450f3965", + "rawBytes": 2429, + "rawSHA256": "8E42B3D1A20D051CBB37F30BD4FD3AEFCFC2DFB4CD6E4B85CA65AB6E89954B76" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/20260912-071055-038-Primitive.json", + "mode": "100644", + "gitBlob": "b824d62d53226888491100e26799f98c79ae1e81", + "rawBytes": 875, + "rawSHA256": "F8020A2342DFEED3DFFC2E7B284BD51E12C75A9D017D09A81934571995327B40" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/20260912-071115-933-Calculus.json", + "mode": "100644", + "gitBlob": "d146706c96891dca436b1b42b919bcbefb526ed5", + "rawBytes": 871, + "rawSHA256": "38E04345BA342D0D011496EDA044B4EAA976A6BE552F036C6FB380DCBD87CBBC" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/20260912-071129-992-Structured.json", + "mode": "100644", + "gitBlob": "0299c42c75e3117be2b5f4f5ab8ab015915c307d", + "rawBytes": 878, + "rawSHA256": "CFA30A9035AE69DAE7AE1250979462CD2AD687A3ED4CA362A0E5E66FA06F41B1" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/20260912-071153-549-Compiler.json", + "mode": "100644", + "gitBlob": "fba970005ea09b207ca5a35e43e0777ca84e845d", + "rawBytes": 872, + "rawSHA256": "D85CDB5E6196CC721B7B3A5E2319A5BB02631E0FD195748DEFFF70C5370E2A81" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/20260912-071244-077-BranchBound.json", + "mode": "100644", + "gitBlob": "a6dd3c4c551ea476c63d87cfbd542b1e2c409e47", + "rawBytes": 893, + "rawSHA256": "9BDB7B18AD7BAD11264C1F1BD7D26E2AD0F6524359D8FBDBCEBFCC80B3EE71A5" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/20260912-071445-906-BranchBound.json", + "mode": "100644", + "gitBlob": "cfaa99022c5489ec534b2df310c3c1e2e2d2dc4d", + "rawBytes": 892, + "rawSHA256": "332E373E584BBBC6EF18853A7ABF03139C20ED94536827F98C07C88934D67C1F" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/20260912-071538-136-Axioms.json", + "mode": "100644", + "gitBlob": "1c24879b4d19c439cc9b1175af82e453c99c5bcf", + "rawBytes": 4075, + "rawSHA256": "CAE51FD3C00C37850B356DF3B3AD80708E393E9B22C17143CE929F2506CA9160" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/Axioms.lean", + "mode": "100644", + "gitBlob": "e646384c06e39b3e8521fa12e39fe1844c98eef6", + "rawBytes": 1119, + "rawSHA256": "049CF6714D76FD11C55EAC8D0C91D077DE99B3B7C3F298E268D3B095B0A81D4A" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/PLAN.md", + "mode": "100644", + "gitBlob": "9777bbfa5e0a40ad20f625e55e28a6c1f5523a92", + "rawBytes": 2653, + "rawSHA256": "E95727B250B6E1C26FC502B93697BAA9166FCA2FC637546AA783DC1A21C18A2F" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/REPORT.md", + "mode": "100644", + "gitBlob": "8587a9c9cd119ec25cea2a0e3f2bd24ef19a9303", + "rawBytes": 10932, + "rawSHA256": "01FFF26B2CFD45553AC9B8F023041A788F6E6F8ABF046E55CF0AD11796AE3CD2" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/check.ps1", + "mode": "100644", + "gitBlob": "8bad7fa61764e3deef46d1529a4fec7e4f6fb48d", + "rawBytes": 1837, + "rawSHA256": "44A8DA036E2E21970DA6B7DDD1E2EAE43A944523372459BAE1E97B466BCC9126" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/hygiene.json", + "mode": "100644", + "gitBlob": "fddf13ed138175b53e5c863f3105ac95abc5baa1", + "rawBytes": 643, + "rawSHA256": "75D11784E82E6A9915082AC86332AB0D2E724B86852426D151B91C2D1626BAAA" + }, + { + "path": "docs/internal/extensions/opt1/capstone-resume-plan.json", + "mode": "100644", + "gitBlob": "45d560887eb3374f879292a65cf88dec562709bd", + "rawBytes": 50, + "rawSHA256": "F4966F34774C32685C9E035EB2CA0AFF71201E5F8BD20D52A6BFBC4B417BD123" + }, + { + "path": "docs/internal/extensions/opt1/certificate-consolidation-check.json", + "mode": "100644", + "gitBlob": "dcb1a220faa731f8a2c0a0054b7ea40c38190197", + "rawBytes": 312, + "rawSHA256": "437E61892C2E21B52D6CB493D393836A692988C4D24BA4616862409A28F17A39" + }, + { + "path": "docs/internal/extensions/opt1/certificate-freeze-claims.json", + "mode": "100644", + "gitBlob": "ca948837a05f7b450554171971155b70bee8cd7c", + "rawBytes": 541, + "rawSHA256": "55FEAFC46968B2F0C5D67F2CDF7401B748EFE840ECF41FDEE6D75286B64A00AF" + }, + { + "path": "docs/internal/extensions/opt1/certificate-freeze-design-base.json", + "mode": "100644", + "gitBlob": "19a1121f3d8b22d11d86057b82dbde0765a5899a", + "rawBytes": 623, + "rawSHA256": "BFB0808DDF0C28DD1BA231BE3A76EC34236DCFE98CA44B760E91220ECE34F956" + }, + { + "path": "docs/internal/extensions/opt1/certificate-freeze-design-phase.json", + "mode": "100644", + "gitBlob": "17b198fb3dfab718ae1d899b1b2bc783c0c409b5", + "rawBytes": 839, + "rawSHA256": "3FE5B1BE8EA1FFA748CA4125484F57A8A471D478160AFB4D0669A28B7AAC44ED" + }, + { + "path": "docs/internal/extensions/opt1/certificate-freeze-whitespace.json", + "mode": "100644", + "gitBlob": "1c814a9fc9cdc727a578635d50b81b62fd501eca", + "rawBytes": 371, + "rawSHA256": "FFC8EA84C6E52733BC8EA4E4C1570F1EDC9979D9B8C0D0FECB2E85707C956B50" + }, + { + "path": "docs/internal/extensions/opt1/certificate-independent-check.json", + "mode": "100644", + "gitBlob": "5b12e2995f8ff1a6d1ee8b2e6e21dce5bba41081", + "rawBytes": 30666, + "rawSHA256": "D4464B694C3DDAF56DA4B62BE53CF91D6B26DA25678DD0E76D47437870F86D8A" + }, + { + "path": "docs/internal/extensions/opt1/certificate-independent-check.py", + "mode": "100644", + "gitBlob": "2c8b91e81ddd2635259112c1aee9390ae652849c", + "rawBytes": 5436, + "rawSHA256": "AB31A997FD0EA861F105FDA617858D8824956CCCE0B310836687FB2C733F9200" + }, + { + "path": "docs/internal/extensions/opt1/certificate-refreeze-claims.json", + "mode": "100644", + "gitBlob": "3ceb53061c4b527dd743cd719ab587dd831aceef", + "rawBytes": 541, + "rawSHA256": "536BB14E8ED5C1F10F4287FFBA541D7FEFD869570C59BEC2B31822F1FA0DC3F6" + }, + { + "path": "docs/internal/extensions/opt1/certificate-refreeze-design-base.json", + "mode": "100644", + "gitBlob": "a294ddae75e64bc636bbf8f0b50a3b5cdb0a5dd9", + "rawBytes": 623, + "rawSHA256": "F1BD0367BA82A5BB713FEE5DE51F290DC6782E5C68EE131B52D917EB63F9152F" + }, + { + "path": "docs/internal/extensions/opt1/certificate-refreeze-design-phase.json", + "mode": "100644", + "gitBlob": "fc7d93a473d118557146b1cfa27b07106e14e7f6", + "rawBytes": 621, + "rawSHA256": "D9076DDC0F60F601B4968B2C2D7BEBEA8BFE06DF49DE7024BE2363FD706F2361" + }, + { + "path": "docs/internal/extensions/opt1/certificate-refreeze-whitespace.json", + "mode": "100644", + "gitBlob": "1a3055e8eeec2352aadaf5279a1ca53fd649857f", + "rawBytes": 371, + "rawSHA256": "4DFDA2FE7512F4D522D070C3EB01D616CF494AB4B8D18412344340F5D4C66925" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/FIELDS.json", + "mode": "100644", + "gitBlob": "3760470717560aafc5ae4652522eff1953d001e7", + "rawBytes": 11640, + "rawSHA256": "0D1529C98D35B6FF2AC53D58D107F0A47EC8F5D263F51819C085827C055A63BB" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/REGISTRY.md", + "mode": "100644", + "gitBlob": "8785623d792ff3dbcb9b65c15dee10567f940efc", + "rawBytes": 5953, + "rawSHA256": "997C8A493E5DD368044349BAD691D40D498A78ADAFA66F2EA5AFC51D7908721A" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/RUNNER_REPORT.md", + "mode": "100644", + "gitBlob": "65cc59d0c73fd836ee4af9d825d16f21ea54f23b", + "rawBytes": 20159, + "rawSHA256": "EB59209616D32284AC4370B8A8D26E629A4BFE38E904BAAC508C76260BE534C1" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/evidence/a01-import-root-failure.json", + "mode": "100644", + "gitBlob": "de971a9e1a77729b4d48805f66bef0f8e0b95edd", + "rawBytes": 153256, + "rawSHA256": "5F987FAF04FA40BCF2319ED2F9C3063D389C0F7411BA21C4FA6B82F1F4FB6A5A" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/evidence/checker-boundary.json", + "mode": "100644", + "gitBlob": "642e34da0a57e5c7e8f44e515abada6ce4f45c7f", + "rawBytes": 3502, + "rawSHA256": "6870368241743AADC3E51882F46FF4368D9B72E6E939A831C71C6F9D8D7ADDB0" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/evidence/focused3.json", + "mode": "100644", + "gitBlob": "1cfa5aaa9d43e2924be229c8b07ee92254447209", + "rawBytes": 934903, + "rawSHA256": "85EB9C4F2F4F5D964FE4722E4D55E5DE9FA1196C62CCC0392988B558F261D6FD" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/evidence/full80.json", + "mode": "100644", + "gitBlob": "6c97d253ebdb58eaab48a4c8372ecf908426bd6e", + "rawBytes": 1382859, + "rawSHA256": "451E108122B077310137E8A2CA206062BB83274EC01A3CE7387FEDC271EA66EB" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/evidence/library-controls.json", + "mode": "100644", + "gitBlob": "55cd321fe6eaf8263440652724a3562897a5104b", + "rawBytes": 286241, + "rawSHA256": "A2DA227FB1CA66A0403E2F17160F746E84124FC5EB75B2E48098AB8395379FF6" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/evidence/prepare80.json", + "mode": "100644", + "gitBlob": "ed0855b11765dd4c099e49f137273c6b28a17532", + "rawBytes": 127479, + "rawSHA256": "B2E4FECABF82CFBB9E04FE4732B3FC9F0E59178FAEF22306D6E09E8E0382BD10" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/evidence/selector9-final.json", + "mode": "100644", + "gitBlob": "cbe2ceb9432f1586499d06f67dc5dc2030da9eac", + "rawBytes": 20351, + "rawSHA256": "A9CA2C1BB3CEDA7CE2834ADB5109DC0536815AA3E655B5C95E8602D72461E0B4" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/evidence/selector9.json", + "mode": "100644", + "gitBlob": "2895c7b7dba8da08cd406207e55bb2a8b2dfc6de", + "rawBytes": 24907, + "rawSHA256": "C4C5301A38D52BFB88A525FE1111A78B2F5598B1DF4A9358ECD5E6232E91D13A" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/evidence/uncaught-boundary.json", + "mode": "100644", + "gitBlob": "b845007c7087a632e4b51258b50d1d41030190d1", + "rawBytes": 2821, + "rawSHA256": "9E089837103FB2A1D968789C46725F61D7B312744265E13AD376AEDCABAAE507" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-build-snapshot.json", + "mode": "100644", + "gitBlob": "169622f89d468902a1328a8faf22f9529095445e", + "rawBytes": 424, + "rawSHA256": "04AE861A4C82AF33DD59849287DEC4F48E34E1BA61F31C8388BE03E1D04CE09D" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-claims.json.gz", + "mode": "100644", + "gitBlob": "0fae86e162e6f220a31d747520d45e1620788fdb", + "rawBytes": 11761, + "rawSHA256": "08167E54224598F390183A4EE2038ED8A69BB2E72CD52C5B3BB8506474C9C141" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-committed-design.json", + "mode": "100644", + "gitBlob": "4013ef9ec5deea669fa145690d6c9e71878ea3b7", + "rawBytes": 589, + "rawSHA256": "BAFA5C9497EABCE97A1D056382B7CF958F707AAC094F772E7733FF0E14CDC90C" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-committed-whitespace.json", + "mode": "100644", + "gitBlob": "54c0eead4715bb094c6b886222dd94e1ab60872e", + "rawBytes": 372, + "rawSHA256": "FC37E45574095D4E0121759A46511BD14A6AF3CA1660AED5A1133617CCF7DCCE" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-design.json", + "mode": "100644", + "gitBlob": "71ebe17e3f16d184b8c85b50023f1e23e31fcaa0", + "rawBytes": 568, + "rawSHA256": "A5A3C2AAD2A1E2273FF15D384B0F138FF02F881D72A0AFA2EC4AC56B66EF0B57" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-frozen-row-check.json", + "mode": "100644", + "gitBlob": "416725a794e0ccc27eb7d95ed2834c4361f6ef0a", + "rawBytes": 311, + "rawSHA256": "4F52FCD1D9D8EA212A8B3735E9C477CC7F2E249CA84920989FDB93078B6D0318" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-native-trust.json", + "mode": "100644", + "gitBlob": "71487dd5d5376ed1f839a2337d50b3b96c783d85", + "rawBytes": 310, + "rawSHA256": "C80B8BAB7ACDC4394FC1B66923798686A38FDBE4D509EA7B720074C05B8B13B9" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-phase-design.json", + "mode": "100644", + "gitBlob": "5c9d14840b1616d2ce37337f143511cab1940139", + "rawBytes": 585, + "rawSHA256": "7A82E852E03320FED52C5FC8B971C4FB046B290B2C16B5A8F3250ED2F397F195" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-report-claims.json.gz", + "mode": "100644", + "gitBlob": "4dbace32334765620f1ee094405b12c11e2c5ad4", + "rawBytes": 3724, + "rawSHA256": "718E2FA06AB7547546D5647B0A02536C11ABC81FD0A916DB2F6DC890754BFC41" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-report-design.json", + "mode": "100644", + "gitBlob": "ad93f155cbca988e0190fdab5e8dd3530024716c", + "rawBytes": 544, + "rawSHA256": "B252537DE31CCA61C0F59E7517302DA86F4E8FD1C3287E8874071025099D9B35" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-source-manifest.json", + "mode": "100644", + "gitBlob": "363a1255d084e9a04b37c5f3b91c864a10e8a0d1", + "rawBytes": 3447, + "rawSHA256": "C5BEFB4A98E2A66FBB1E7597E8A22550B2E3A4712A6BEDE1B113EFBDF4A554AA" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-trust.json", + "mode": "100644", + "gitBlob": "92fbc475a3bf7e00b29b00bcac7f86d88845559d", + "rawBytes": 390, + "rawSHA256": "15D186460818D17DC5CFB1EDE5AFCECD2998A23DD60AB071CF289BC22794E881" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-verification.json", + "mode": "100644", + "gitBlob": "833358983e832f377c395900737a43355ba08471", + "rawBytes": 3149, + "rawSHA256": "CB1963CEF206F5CAECD05466DA4D2CA2F7ED684A7BA8C6100DD86E44D973BCF3" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-whitespace.json", + "mode": "100644", + "gitBlob": "0a57d1e62ed751042f56d2b0a095d8006d4cfd71", + "rawBytes": 424, + "rawSHA256": "3F6E286DA95D014E9F3C6BE7DBC67C472B9BB573D8AFA481455838376B969FC3" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/20260912-084823-803-Compact.json", + "mode": "100644", + "gitBlob": "f3b4b17b8dc30c54b917b56f9236b2fba9b7b7c3", + "rawBytes": 895, + "rawSHA256": "7AFAE6BA26D203B4A912FC66C856E1F398B8AA65B0C72EDB5FAFE9247AC29C45" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/20260912-084901-469-CompactProof.json", + "mode": "100644", + "gitBlob": "dc2d2203d0fa5e9a89309affa3713a0535c91735", + "rawBytes": 4506, + "rawSHA256": "4279C74414260141F185461D4D3F2E1478F403B1E7A81C9D8690EEA637D640E6" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/20260912-085040-423-CompactProof.json", + "mode": "100644", + "gitBlob": "dc45b16f48f7320e1be6d2a289c8440b0321e8cf", + "rawBytes": 2571, + "rawSHA256": "FDCF0A010EF71BF76958441531A36393A204822F152F3C9EDCFE893A17E956F5" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/20260912-085200-649-CompactProof.json", + "mode": "100644", + "gitBlob": "2363ef8d9c0500880a2956ade10ff5a896c354c1", + "rawBytes": 908, + "rawSHA256": "562AF6A0A915F68F436523E93D070C622AA12F466855B423E1EE09FC94ABCB62" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/20260912-085248-004-CompactSafety.json", + "mode": "100644", + "gitBlob": "272b1fa495cae1929802f68540137e9cd72c49a0", + "rawBytes": 1447, + "rawSHA256": "59A09BF8D0BD6693D776D199ED40B03EC5FCAFD725F1082CC36EB53EE66A6240" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/20260912-090310-823-CompactSafety.json", + "mode": "100644", + "gitBlob": "3397478fdcc4d11e01b7743a603bfef1a9c0d265", + "rawBytes": 912, + "rawSHA256": "7F79CB02A40F01AFAD43965972DF4683C8F1B648325733562EDD53520AE47A49" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/20260912-090340-416-Axioms.json", + "mode": "100644", + "gitBlob": "dc13facb14702bd6a7596281cdda2a5d15f41f17", + "rawBytes": 5649, + "rawSHA256": "F93AA3A26B117AB1E73E0E38AA1EC7B0DC73B000CCCC49267CD66B2BF628E889" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/Axioms.lean", + "mode": "100644", + "gitBlob": "8eced0c19d2b6935b2f3dc64b9966774f14ab724", + "rawBytes": 1466, + "rawSHA256": "727E2C58C62040B3C5800219FEDDE8B566FF3EA2D5C49B12546612F66EF2935F" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/CERTIFICATE_SOURCE_REVIEW.md", + "mode": "100644", + "gitBlob": "31874cbbfa23d50f1d73a99f911870965f947a9c", + "rawBytes": 2580, + "rawSHA256": "92654FC7D2B5720C8A40EE2E26B2461377A53680B830033FECA0F64E6E32B5EE" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/PLAN.md", + "mode": "100644", + "gitBlob": "f3bed146a135b3dcc8d2582737a15b63f8c84a75", + "rawBytes": 2584, + "rawSHA256": "4AE090C92041861EC7A63D2B7F69440474C4FBFEA36EAD561D95498BD7DF633A" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/REPORT.md", + "mode": "100644", + "gitBlob": "01b860f56d432053ff667f71a740126b3bf3e249", + "rawBytes": 18304, + "rawSHA256": "3239E7EADF1E0E2AA03ABD96AA9DC5BD2F305C4C7BE6C7F7A1AD3C8E1CF9CE6B" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/RESUME.json", + "mode": "100644", + "gitBlob": "77088bab230c467df2f2d116fb2822a707d8394c", + "rawBytes": 884, + "rawSHA256": "8F51968010D6CE363B72C4FC8510A0CE4C46E796872B9C8FCB76163816FD5695" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/RESUMED_DEVELOPMENT.md", + "mode": "100644", + "gitBlob": "8fd8ae853ad34108d8444b13838cb35589497eb6", + "rawBytes": 3356, + "rawSHA256": "EAE19A4AD99FB2B3E7E86B6030A5916B896ED34BE1074EE90F1B5DB1FC381858" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/certificate-source-review.json", + "mode": "100644", + "gitBlob": "e7409051cd704df0cc63e28dc43bf917266eddc4", + "rawBytes": 425, + "rawSHA256": "AE6BE09AEF5867926EED53871DA2EAB02EDB6AC78334AC4F2B4DC0532CC6C63A" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/check.ps1", + "mode": "100644", + "gitBlob": "5c11dbdaacaa7a16bb8c382a93391d0a0e90a864", + "rawBytes": 2380, + "rawSHA256": "08422A0A46060F662DFC22675282CCCBF6C5FE98A415C7366988CB069330513E" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/final-leaf-checks.json", + "mode": "100644", + "gitBlob": "986b39ec3abda768e5601dfe7cc87322eaf2618c", + "rawBytes": 3377, + "rawSHA256": "F3E20ED546ECE012062A99EB856613DF5E09559BCA67ABD79930FBD2CA838CBE" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/phase-static-checks.json", + "mode": "100644", + "gitBlob": "e2285e7ee5967ff12dad9e3a97d13540ae789f67", + "rawBytes": 425, + "rawSHA256": "6743C04B38F81EC56EC0D57CEDF936D9FA557ECF5CB46F44EAB3028E1C15B72D" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/20260912-085342-909-CompactStatic.json", + "mode": "100644", + "gitBlob": "9d9e2aea9e1ceb88f90457a19724d693f2b11095", + "rawBytes": 5604, + "rawSHA256": "421330AFADF3460947326D3CFD2293C00F86C496300ED44483C47B49D225943D" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/20260912-085459-926-CompactStatic.json", + "mode": "100644", + "gitBlob": "e5b34d2c418870aac2c7b0385d54ad5eb0819b49", + "rawBytes": 908, + "rawSHA256": "FE696B23BB8AD9E1F82F34C04DD2CFED288123D0F263EADBD279F19B7FE892C3" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/20260912-085506-634-Types.json", + "mode": "100644", + "gitBlob": "919eb3a8dada239c3536458e306a50afebe6dd73", + "rawBytes": 14437, + "rawSHA256": "19356B94B9AD3A6C8316467255F2758D02F14004AEB228A4C1AF23456FD9D58C" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/20260912-085620-197-Query.json", + "mode": "100644", + "gitBlob": "70155a96a334c27eb380dd8f436286c40f9f6451", + "rawBytes": 2935, + "rawSHA256": "0A71CA87BE84A7B3F09300708006066C37B63536D9DC994A4BF1B12E455B3045" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/20260912-085823-722-Query.json", + "mode": "100644", + "gitBlob": "e39ed459c830f1ae11507052f4cb3abfa525ffaa", + "rawBytes": 884, + "rawSHA256": "4B7A66D6E0022E9DEFEC7AB6564B504847A406A79CC1BC24AC61EE0C8004B4D8" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/20260912-085851-734-Measure.json", + "mode": "100644", + "gitBlob": "22c9c568c941ebb743646ad5c6c89d2d03d857dc", + "rawBytes": 1526, + "rawSHA256": "9712E297C60EB5C8ACB75EBA3EC3014B3CF288753D5AEEFC0BC25419ACD4FD66" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/20260912-090142-761-Query.json", + "mode": "100644", + "gitBlob": "62fee6ade232109db2e917f330e6647854f1bea8", + "rawBytes": 884, + "rawSHA256": "FE9E2FEBC97B6E5C59D3433EE3EDE1BDCD0CA03AEC8E733FDC4FF28FA4CD106F" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/20260912-090148-784-QueryTypes.json", + "mode": "100644", + "gitBlob": "c8fd47fbb0e4e521b83cedba30700f6d22cc2b8d", + "rawBytes": 10976, + "rawSHA256": "FE18BF368397FCB26B11267210B9ED708A7F3CF790395DCE0D7DD80B2C46B3D8" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/20260912-090227-589-Measure.json", + "mode": "100644", + "gitBlob": "849950f2ffd88755587edc009db1bcdb61b85923", + "rawBytes": 1528, + "rawSHA256": "780A78C18CBCA37BF789E0FD1CA5845FDD65D4C278749641DF4697582CA2F8FB" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/CONTRACT.md", + "mode": "100644", + "gitBlob": "6e0056a8585797b14633fe41e1c6a2392898bf6b", + "rawBytes": 6628, + "rawSHA256": "5FF9AC6B1A64F64320B3AE2F45CA8585CDC6999F13D9EBCAFF482C6D91C22B59" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/Measure.lean", + "mode": "100644", + "gitBlob": "3972ba630c8c04334bc041a025e12d5194e60ec4", + "rawBytes": 969, + "rawSHA256": "8DF1007BB02C218EBC4F04C56B46F90C03D486BD59727C1BE485AC1C9AA434AA" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/QueryTypes.lean", + "mode": "100644", + "gitBlob": "1f56d6ad857e174cb816e82e64f9870a5304dd50", + "rawBytes": 1361, + "rawSHA256": "19ECA8B5FE4478DC99DADD8CE03BA3777CFFDB97486CC6AE6EB4430ABCAB3159" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/REPORT.md", + "mode": "100644", + "gitBlob": "4f5fa21952ed36377bf47f5f328bf33985d723ed", + "rawBytes": 13704, + "rawSHA256": "DEE26E3F2C8B90F87C9FF9D4B9D3F9E8663E8DFFDC066C9FAED0FA903D797B0C" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/Types.lean", + "mode": "100644", + "gitBlob": "c4a311a494a6b1d18f32e5e5ac2488d3b8eb2427", + "rawBytes": 988, + "rawSHA256": "06495A99FB8D5C825B5B3718CF82887FC29595E029380835158FFF42C1AACA24" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/check.ps1", + "mode": "100644", + "gitBlob": "a0ba77d50fa2cd521e5c703e312734989dc04c1c", + "rawBytes": 2068, + "rawSHA256": "03F3017AD766A9B2D194C58692FD304481B40C5A0BA10AE094272DF3A55BD666" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/hygiene.json", + "mode": "100644", + "gitBlob": "fcb6c1765b6739b9843504bf466bfbadabc36264", + "rawBytes": 1488, + "rawSHA256": "781E058040A8FE4061C2CF2F28C52B21C0CF24F736112D68419346EE9F996B6F" + }, + { + "path": "docs/internal/extensions/opt1/composition-checked-manifest.json", + "mode": "100644", + "gitBlob": "8eee99fcda53122ed6cce566a4051e2e43b3915a", + "rawBytes": 1584, + "rawSHA256": "F03F3263E6957895EAD692C09336C98295B983375EC3B74C14215AC7CEF18E45" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/20260912T0909250020255Z-axioms.json", + "mode": "100644", + "gitBlob": "c57f5ed18279ace9964c8a96cd80aebf7e2a2368", + "rawBytes": 23017, + "rawSHA256": "F1C2DC0F11CBDA559D47ACE223A5C0806629A76399A768B9C751E13643F7C4C2" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/20260912T0922141726079Z-axioms.json", + "mode": "100644", + "gitBlob": "8a897c23ab987efee67cf7732e39a917b5826d12", + "rawBytes": 52220, + "rawSHA256": "8E8E84AF416AAACE4328706C360210B4A48E24D306DEBA20DCF057481D4ECFD8" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.Capstone.20260912T0904477547021Z.json", + "mode": "100644", + "gitBlob": "415ca4349b8892f64d5844c438b53287f8cb0f52", + "rawBytes": 1425, + "rawSHA256": "23BC4401036411F7B453B34F8EEF86C42C514E947D088968327E64542D637C89" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.Capstone.json", + "mode": "100644", + "gitBlob": "415ca4349b8892f64d5844c438b53287f8cb0f52", + "rawBytes": 1425, + "rawSHA256": "23BC4401036411F7B453B34F8EEF86C42C514E947D088968327E64542D637C89" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.Certificate.20260912T0904184780573Z.json", + "mode": "100644", + "gitBlob": "b0bd8dd73100fe945e59f3b59b53474dcfec80eb", + "rawBytes": 1436, + "rawSHA256": "83EAE680D8E3CF57BB0A7F02561883BC82577D651D0E7628C5B221FE5A76A26A" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.Certificate.json", + "mode": "100644", + "gitBlob": "b0bd8dd73100fe945e59f3b59b53474dcfec80eb", + "rawBytes": 1436, + "rawSHA256": "83EAE680D8E3CF57BB0A7F02561883BC82577D651D0E7628C5B221FE5A76A26A" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.Consumers.20260912T0904550751995Z.json", + "mode": "100644", + "gitBlob": "166a894dfd994882fc928efc74c5d77cb2054988", + "rawBytes": 1428, + "rawSHA256": "A99865249022A28CFF6831744BCBD1521D304A7B6A49413922BF69C5D14C2B8B" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.Consumers.json", + "mode": "100644", + "gitBlob": "166a894dfd994882fc928efc74c5d77cb2054988", + "rawBytes": 1428, + "rawSHA256": "A99865249022A28CFF6831744BCBD1521D304A7B6A49413922BF69C5D14C2B8B" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.QueryProof.20260912T0904107871054Z.json", + "mode": "100644", + "gitBlob": "902a79d976572ff8df611e8ec4470add495bb622", + "rawBytes": 1432, + "rawSHA256": "BA05922219808E78C74EB9232DEA3E2476D08048D2B21FEA34F49D38A74D4EEC" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.QueryProof.json", + "mode": "100644", + "gitBlob": "902a79d976572ff8df611e8ec4470add495bb622", + "rawBytes": 1432, + "rawSHA256": "BA05922219808E78C74EB9232DEA3E2476D08048D2B21FEA34F49D38A74D4EEC" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.QuerySafety.20260912T0904137135959Z.json", + "mode": "100644", + "gitBlob": "c75cecbd31885ba7a09aad2781077352553c7d23", + "rawBytes": 1436, + "rawSHA256": "6408E084C7EBA6F163DDE0E5D5D097810EEDDBF4835C8A7A57C2B1C85592A9B0" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.QuerySafety.json", + "mode": "100644", + "gitBlob": "c75cecbd31885ba7a09aad2781077352553c7d23", + "rawBytes": 1436, + "rawSHA256": "6408E084C7EBA6F163DDE0E5D5D097810EEDDBF4835C8A7A57C2B1C85592A9B0" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Packed.ArrayRun.20260912T0907263701277Z.json", + "mode": "100644", + "gitBlob": "de2ed5960461ecb5ec1bf81a009c26688f5fb12c", + "rawBytes": 1400, + "rawSHA256": "2FC6881D3579267B1540F8F6A51406B5056D4394BAD1DCCB28834F2F5AC1F63B" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Packed.ArrayRun.json", + "mode": "100644", + "gitBlob": "de2ed5960461ecb5ec1bf81a009c26688f5fb12c", + "rawBytes": 1400, + "rawSHA256": "2FC6881D3579267B1540F8F6A51406B5056D4394BAD1DCCB28834F2F5AC1F63B" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/scheduling-overlap.json", + "mode": "100644", + "gitBlob": "cccd889a1f2d69b749bdd009899da9fb116f2fe0", + "rawBytes": 1137, + "rawSHA256": "E9A2253E539EF1D1278F116BB5D0C45081DF26EEFD1516245EF014915130257D" + }, + { + "path": "docs/internal/extensions/opt1/continuation-entry.json", + "mode": "100644", + "gitBlob": "49e9bfb3dcd2832f08792ad96405d381248aea0d", + "rawBytes": 824, + "rawSHA256": "014F6DFF932F672D844C8356AF342A012A6E48C70C9CACB2A23F665787BAD352" + }, + { + "path": "docs/internal/extensions/opt1/final-evidence-identities.json", + "mode": "100644", + "gitBlob": "8f116678395084dba455e2a03274cfb52677da52", + "rawBytes": 1306, + "rawSHA256": "82D15A8BA8B269E591CAE01EEDA2D787123DB5568D94A2F32C1777A5A17728BB" + }, + { + "path": "docs/internal/extensions/opt1/final-report-before-storage-claims.json", + "mode": "100644", + "gitBlob": "90e6089a88717a56f9fb68d2542881faf216f472", + "rawBytes": 762, + "rawSHA256": "BAC4A2BFA2BDF2C428C6323DE0CBB61A6A4BC4B51BC248D7F9B0E1A625346F0D" + }, + { + "path": "docs/internal/extensions/opt1/final-report-before-storage-design-base.json", + "mode": "100644", + "gitBlob": "410865ef2d90360c1203173cd43f4ccecec8dbf7", + "rawBytes": 647, + "rawSHA256": "75B0103370BF4D78F900E7B0EA336847E26DB7BA8DE90666D44146A687EF30E3" + }, + { + "path": "docs/internal/extensions/opt1/final-report-before-storage-design-phase.json", + "mode": "100644", + "gitBlob": "099fc61d39ade54a165913c4c2de9ef0c3df9cf3", + "rawBytes": 645, + "rawSHA256": "EEE3B65442C7F5620BCEB7D28D88795A5338FA1BA83115358A30B070C641D136" + }, + { + "path": "docs/internal/extensions/opt1/final-report-before-storage-whitespace.json", + "mode": "100644", + "gitBlob": "484a74b92e4d25732c1fbe07333623809c3eb7a7", + "rawBytes": 387, + "rawSHA256": "D2F94D08A72EB97CF489FC9DCF844B91B272B3C25AC8622EFD3A5E5668A37AB5" + }, + { + "path": "docs/internal/extensions/opt1/final-report-claim-check.ps1", + "mode": "100644", + "gitBlob": "60209b954bdca870141958cf0c6f1fccafb9b731", + "rawBytes": 2499, + "rawSHA256": "30F083CA9C59B4397E2879B69D89241432E29C0AC8C33590A5803F130668429F" + }, + { + "path": "docs/internal/extensions/opt1/final-report-claims.json", + "mode": "100644", + "gitBlob": "543b3e23e81be5bbbcff7847203b1baabc3fa44d", + "rawBytes": 1242, + "rawSHA256": "E1ABB075A6761C3704F2692750F1748A63EB47ECE9533324524D96F475BBB152" + }, + { + "path": "docs/internal/extensions/opt1/final-report-design-base.json", + "mode": "100644", + "gitBlob": "66f063f4b046851d95178bcfaec4ba429b0963a8", + "rawBytes": 684, + "rawSHA256": "5493B1B594C865453689C0453D574E9662467A58A928B0B8248D80B4D2D15547" + }, + { + "path": "docs/internal/extensions/opt1/final-report-design-phase.json", + "mode": "100644", + "gitBlob": "10df1327fd3e01f736ec4f99fe97bf654e8ecb33", + "rawBytes": 682, + "rawSHA256": "3ACCFF510040F90091AC6EFFC872C2DF156ECF3B9E8724A037C51C39FB2D2703" + }, + { + "path": "docs/internal/extensions/opt1/final-report-hygiene.json", + "mode": "100644", + "gitBlob": "aab64100860cd228030f9bd902cbee4d44819313", + "rawBytes": 363, + "rawSHA256": "FAB0D5E37B57B301F9E424B5F4C6CE5B930D3E6BBE5D5CE7FFB674B828E5BE05" + }, + { + "path": "docs/internal/extensions/opt1/final-report-index-bytes.json", + "mode": "100644", + "gitBlob": "eadd023731b30598b073375b9d8f3c50556fa676", + "rawBytes": 2275, + "rawSHA256": "06D4E94B6E69BA7736BA6521922A4F71F3B476E03DA8EB504CC640786A9C1A9B" + }, + { + "path": "docs/internal/extensions/opt1/final-report-index-whitespace.json", + "mode": "100644", + "gitBlob": "24a4ddfea3de9bd653d52f3e84bc4445ffab6eb2", + "rawBytes": 505, + "rawSHA256": "E3BF5FECA3B8B7D9FD798066C41767791331BEA7997B999DC88C982B2D7F0B48" + }, + { + "path": "docs/internal/extensions/opt1/final-report-storage-whitespace-first.json", + "mode": "100644", + "gitBlob": "8ca9d3fe1134a254924f78d112ad3ac3c3919c9a", + "rawBytes": 489, + "rawSHA256": "F6D62405DF797CB6CF0D19518E6708C5D3DE063D2D8211B949DC5CD4F3343319" + }, + { + "path": "docs/internal/extensions/opt1/final-report-storage-whitespace.json", + "mode": "100644", + "gitBlob": "6df6613d743bfc6e7ef88a9490eb994b83b7e3d4", + "rawBytes": 361, + "rawSHA256": "F00DB22CE9D17D37D8115000BEF33219ACFB9986C475588744BAF49BF8BF3CC5" + }, + { + "path": "docs/internal/extensions/opt1/final-report-whitespace.json", + "mode": "100644", + "gitBlob": "04fa0595a8793c0b859e869d55efa3cb855f2fc2", + "rawBytes": 399, + "rawSHA256": "745C78AB1141C8333CDBFDDBC144B86A381CEB89D14574CCBB8E63F81B0EEEEA" + }, + { + "path": "docs/internal/extensions/opt1/final-source-manifest.json", + "mode": "100644", + "gitBlob": "5c718ee22a5b7a2f4cb0800e229a864e962226f7", + "rawBytes": 9411, + "rawSHA256": "41F867CB8BDBA0AC528974842A131853574E5B5BB66361A5EB9CEEAA75A5608B" + }, + { + "path": "docs/internal/extensions/opt1/freeze-claims-attempt2.json", + "mode": "100644", + "gitBlob": "7652e2e38705107c1a3ca25f2285461c7ec8e16a", + "rawBytes": 711, + "rawSHA256": "C455BF7D69A6719CE8FADE81D29B94105C101F753A2968C3638ECE6AE6DA80A5" + }, + { + "path": "docs/internal/extensions/opt1/freeze-claims-pass.json", + "mode": "100644", + "gitBlob": "8c49dc5348bf6a743a9d36fb9aaf5f26efd82891", + "rawBytes": 484, + "rawSHA256": "6B7E373FD244252C1189AE0EB3CDD265F45C48F14E2CD862CFD4522A7D44564D" + }, + { + "path": "docs/internal/extensions/opt1/freeze-claims.json", + "mode": "100644", + "gitBlob": "eabc08c5f28248eb43b3fd6bf0a7c5cccc20b569", + "rawBytes": 835, + "rawSHA256": "F9AEABF228081DF4CB95CA6CC6901D8276F956347ADF335A4573567C4DC0BAEE" + }, + { + "path": "docs/internal/extensions/opt1/freeze-design.json", + "mode": "100644", + "gitBlob": "0f68730eac79f68227c2c847c36917c05b3836b0", + "rawBytes": 518, + "rawSHA256": "73E4CC9DA66CF41B9E69FEDDB1C656E3E20779E47259A6C287E99AF803507823" + }, + { + "path": "docs/internal/extensions/opt1/freeze-native-trust.json", + "mode": "100644", + "gitBlob": "ea0e827fe53d266a9e766ee7abb605b5f45bf8f2", + "rawBytes": 120, + "rawSHA256": "4046AEC39A9489A8B4D83BA9994B9E39250E8EEACB03E005B94E69CB35292616" + }, + { + "path": "docs/internal/extensions/opt1/freeze-source-manifest.json", + "mode": "100644", + "gitBlob": "4df002e53576e7e63b24035e35144344c6aa6640", + "rawBytes": 3778, + "rawSHA256": "96700BE0F86DBF7ADD1202380CAFE33360D2297F54F8F2335CBB465D08E7103A" + }, + { + "path": "docs/internal/extensions/opt1/freeze-trust.json", + "mode": "100644", + "gitBlob": "c8c5fb79528344f8ed05e0c84815ed18ded9b55b", + "rawBytes": 120, + "rawSHA256": "0B6E7FB93852D5CEB7022F5DCCFF39F42B661164B4B760EE6D6F34FA49253E7B" + }, + { + "path": "docs/internal/extensions/opt1/frozen-row-check.json", + "mode": "100644", + "gitBlob": "d9d937d0b9068009b2c96bc074eccafa0f534063", + "rawBytes": 1185, + "rawSHA256": "0F9AA7E67576C7CD62C7B616BC7A99C27D9AE4D4A9BAFBD73E25C321D434E5C6" + }, + { + "path": "docs/internal/extensions/opt1/import-repair-hygiene.json", + "mode": "100644", + "gitBlob": "7ca895bd081903a25390458c6832b475e216b2ca", + "rawBytes": 338, + "rawSHA256": "AF74D3F0921C4B02B341BB80B06FDF0EE335057815EB668BBCACEF9B51C56686" + }, + { + "path": "docs/internal/extensions/opt1/import-repair-refreeze-claims.json", + "mode": "100644", + "gitBlob": "6e1e6f2e3d0221f0878a18685d29e81192e680ef", + "rawBytes": 563, + "rawSHA256": "84C44752B086CAD72ABDD715A11BB6F17DEBA856C05378C79E59C28D06784A56" + }, + { + "path": "docs/internal/extensions/opt1/import-repair-refreeze-design-base.json", + "mode": "100644", + "gitBlob": "f394b8d16b5eb829698f5cd641ae97a96be8b53f", + "rawBytes": 647, + "rawSHA256": "5D9893A7C3E5AA4AE54628117E7B5629A73C99DAE286A1AFB72AE4A96B9AFAFD" + }, + { + "path": "docs/internal/extensions/opt1/import-repair-refreeze-design-phase.json", + "mode": "100644", + "gitBlob": "cd7afb2444cec0d8b4e36605b69cf5beac6bffa2", + "rawBytes": 645, + "rawSHA256": "3D1BDB4B32748A5474D0658054E2A3EF2291A9FD887C7333A1D9427B6D825785" + }, + { + "path": "docs/internal/extensions/opt1/import-repair-refreeze-whitespace.json", + "mode": "100644", + "gitBlob": "6856b5661f5966d364f3c4f0a81e2b16225631c0", + "rawBytes": 386, + "rawSHA256": "841596819014C1CD21441DBF8C776CBC177F3D841AB4F9AD20B3061CF8AB309C" + }, + { + "path": "docs/internal/extensions/opt1/import-repair-source-manifest.json", + "mode": "100644", + "gitBlob": "9aa4177063eb13717c9482772390fc551c4b636d", + "rawBytes": 4763, + "rawSHA256": "8143B412B8CBEB6C90C8EE00FB17762FA708A47831207913FED9C0A3F5FABC5E" + }, + { + "path": "docs/internal/extensions/opt1/local-final-scope-check.json", + "mode": "100644", + "gitBlob": "8317750eab45995f58973e78a69a81e762072714", + "rawBytes": 415, + "rawSHA256": "3E0617F0025B6F1646283A3692180FA5319B7767FDA9AEC8AB22AD96C5988475" + }, + { + "path": "docs/internal/extensions/opt1/query-build-plan.json", + "mode": "100644", + "gitBlob": "e405d726e143e3596a6ea2fc20b496bb7319a988", + "rawBytes": 12999, + "rawSHA256": "799C039592DDD8D42293BED5F94AEB4846EDC113FFDBB8EBF60E17D48CAFA4F8" + }, + { + "path": "docs/internal/extensions/opt1/query-development/BranchCapstoneChecked.lean", + "mode": "100644", + "gitBlob": "33394feababc91b760f64cd1d44c680f751496c2", + "rawBytes": 4034, + "rawSHA256": "F56C0D5D62B0BA4E480108BAE36CC11CAE5F3CEBF4772EFDA813D2BB4DBB2D65" + }, + { + "path": "docs/internal/extensions/opt1/query-development/LAUNCHED_BUILD.ps1", + "mode": "100644", + "gitBlob": "5fe81d41eb776c3c0c39b836ac9997bc86708b96", + "rawBytes": 3292, + "rawSHA256": "C6A5A2FD340FBEC6EEF66D1E014B28719F81DFFD5498CBBB5F50EE13C22F5E33" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Backend.json", + "mode": "100644", + "gitBlob": "fc8b37f478652827d44f6e9bc1883c2c78a639bf", + "rawBytes": 1332, + "rawSHA256": "F552EBA7694CC8BEB494C2CCBC27871E87BB2BFB7C974EC0CA91275DE6DAFD59" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Cartesian.json", + "mode": "100644", + "gitBlob": "b39da338e9d4ed550ed7d73cbed4604c9a2d5626", + "rawBytes": 1341, + "rawSHA256": "576FFB263966B0FBE7FD2EF75AC59C17D951E0E994D9DB7A8B26FB1347863392" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Cost.json", + "mode": "100644", + "gitBlob": "7143d9bb0d7338073a64b2250416d0e121fd8862", + "rawBytes": 1319, + "rawSHA256": "3307EA82D5CD1AB3AB50100ADD3850165C13F156435E6380C04238B5EEDA0E23" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.EncodingLowerBound.json", + "mode": "100644", + "gitBlob": "d2b93cc6a8ade999714c27398a0a76ef0580b23f", + "rawBytes": 1376, + "rawSHA256": "09FA3092E5DE54B04E373AE277D7EA368C5B318DEEFF9AF10C4A728F7B196ED7" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.Arithmetic.json", + "mode": "100644", + "gitBlob": "c3c591a49b17b748698d7d578929b785e837b7a6", + "rawBytes": 1402, + "rawSHA256": "305DDC7722CBBC3BC514F3162ABEDC71EF48F2F0F16901EF03D52C6034FB48B7" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.DenseEntryTable.json", + "mode": "100644", + "gitBlob": "ff4c670218916970ba0f0df6aca6744fbdbbdd5c", + "rawBytes": 1421, + "rawSHA256": "20C0325F4957A136BCFC045B52D137A1E4C56E1F3F61654128C79B388616E594" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.DenseWord.json", + "mode": "100644", + "gitBlob": "d005994b40833eabbf4dfeaf4b8aadcfa48f8db6", + "rawBytes": 1398, + "rawSHA256": "AB9F876246C881A74F216AC68C7DA905BE0DB60EE6C90078B768F8EA5B586072" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.Directory.json", + "mode": "100644", + "gitBlob": "7a39177e03b686e0715d9df0f48d33a29604f01a", + "rawBytes": 1398, + "rawSHA256": "60F22B9378D56E1FD6DE78B3D52C7392C91F559AEB56405D2754996D601527B5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.Entries.json", + "mode": "100644", + "gitBlob": "eee679f21b55c07bd474ec93db36bfcd7979691c", + "rawBytes": 1390, + "rawSHA256": "6C2DC392B4CE382977CC42434BB98525848BAD1EFF340FE118BA8B60FA8E4A06" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.Family.json", + "mode": "100644", + "gitBlob": "6d66a6d1c2eb9750c8421fe926ae406ef23d83e5", + "rawBytes": 1386, + "rawSHA256": "91F5F033935C02CD9D2F1CD4DB868091DBAE57DD79AD8C9C6256E7D1C4DB9B5D" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.FlagRank.json", + "mode": "100644", + "gitBlob": "abb06712fa224f3dce352570b9b5c070773d2c67", + "rawBytes": 1395, + "rawSHA256": "6782CA57FA4E8FBD4FAA236AFE3D9FA9C108E3DBDC8205B7D0A2B8842AA92641" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.LowLevel.json", + "mode": "100644", + "gitBlob": "df6ae7f22e6b51e69d5fab6e3567d5435ddf3c31", + "rawBytes": 1394, + "rawSHA256": "7CE68787B168F7AEA023564D781D805745B06CD5FDCF65404CF8760A2422C308" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.Params.json", + "mode": "100644", + "gitBlob": "3f99157c3fd58086bbbeaa27644a11292fc098d9", + "rawBytes": 1386, + "rawSHA256": "A03AB8A2AA91035FA3558ADC197223A295D2C0EFF9B9745A3B41D1F32516A394" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.Primitives.json", + "mode": "100644", + "gitBlob": "10a7836a0f5d23a9b5158e2d75320e2cf18b8110", + "rawBytes": 1403, + "rawSHA256": "20AA4AED043CAD0E989C317D4D657CD0BE95C799AA61484FB9D9957497897169" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.RAM.json", + "mode": "100644", + "gitBlob": "39d1df7eec47042f3d9110afbf6fbf5b263b675a", + "rawBytes": 1375, + "rawSHA256": "5FF389CF709189694F43F3F38F3FF24E4AE9714293B12AEA1A9CA5BD9E0FC4F5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.RAMStoreParam.json", + "mode": "100644", + "gitBlob": "209a678afae4b7cb78a066639a4494fe6a3362b6", + "rawBytes": 1414, + "rawSHA256": "159BD2A552CE41E98C2C2074603CC9CAC4AC8F06CDAAC24EA3BAE6B62B9ACB9B" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.RelativeSplit.json", + "mode": "100644", + "gitBlob": "b87d962f1530867c92243c86343504b7d1e4b64a", + "rawBytes": 1414, + "rawSHA256": "BCA933CC2F8A05B0DA672C5C713786E3329987F81E381B5B908F05737963BF4C" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.RelativeTables.json", + "mode": "100644", + "gitBlob": "bfd45589057a82e0f8e11312c8b426a3d02103ad", + "rawBytes": 1419, + "rawSHA256": "1FF092E5F06FF7564107341E6B74DB309D9700B2BBF733418DE2D944C1C120AB" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.SelectFacts.json", + "mode": "100644", + "gitBlob": "f46aaebffbb564f5e162dd351af1a1308235ddaa", + "rawBytes": 1406, + "rawSHA256": "481EB52FF7D42BA8276219D6EC34731EBD21E267F54AD22423E1B4E83AF33832" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.SelectSource.json", + "mode": "100644", + "gitBlob": "19618c2f0e437f845d03dd1c50bdb0ba5b78128c", + "rawBytes": 1410, + "rawSHA256": "26D124D13AC84D0F8B1812B01134488998050433A85D066F3BF89AF9348346A2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.Slots.json", + "mode": "100644", + "gitBlob": "27be1523f43b10c3e726b39a82e2d71187aacef3", + "rawBytes": 1382, + "rawSHA256": "86F0569A02C5033DD113A64943D34CEFD726517D6BEE586D0B5F6284F86474EC" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.Source.json", + "mode": "100644", + "gitBlob": "7b4392eb0e386cee47a492e14d86f01aa969d4fc", + "rawBytes": 1387, + "rawSHA256": "50323DB24CD8F4DF8FD1F7B067CF1210B57D1C24F85A0033AFF356E47CFBDA79" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.LCA.json", + "mode": "100644", + "gitBlob": "6eb3dd08cc636eda63bafc794f04e3f7d2599068", + "rawBytes": 1317, + "rawSHA256": "05855E1541726693D26B2616E12DAE17C10ED209672D6BF6B9A9DCF0EEC93B54" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.ListLemmas.json", + "mode": "100644", + "gitBlob": "28b9af5f992ab2e69cd9477d9537d2b6aa07179c", + "rawBytes": 1344, + "rawSHA256": "780D6C1FEEF1E4D6E1341ED5D73B9995F72433B1C4933CE576F76DAC30CA6300" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.LowerBound.json", + "mode": "100644", + "gitBlob": "a55bf6560265ce0443832aa8913b6dd95d3b424a", + "rawBytes": 1344, + "rawSHA256": "6AC5E1F5DF205034DB724ABA3AB9D1BD94BC6C8C78FB79E568B71E81A93A7F0A" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Microtable.json", + "mode": "100644", + "gitBlob": "d6e5bcf129a10cf92b70c717b480800e99c5e327", + "rawBytes": 1345, + "rawSHA256": "55A6AFC8E17D0EB7E66D90B223A4BA2E87AC4C14EC20139FCB95904F35D32AE7" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.PayloadLowerBound.json", + "mode": "100644", + "gitBlob": "687cc612d76ca9a4526e1d2a293ca03a4ad28e5a", + "rawBytes": 1372, + "rawSHA256": "18B0436ED703E16B13BD181F83724FC52BBF39ACD56BE7494CA884BDC674F317" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.PlusMinusOne.json", + "mode": "100644", + "gitBlob": "69ebad9b61f1fead3991f863f5d0f42b563b97e4", + "rawBytes": 1352, + "rawSHA256": "AF81C051C6C50B139C8D3BEFE6101BB56D14E663ED3B7E56B62C6DD6EF2DD185" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.RAM.json", + "mode": "100644", + "gitBlob": "ca1130e89bf9fc2892e26cdc269bfed8d65423e6", + "rawBytes": 1316, + "rawSHA256": "7FABAD833C2DB00EE229F71F090CAF691A7FF7FA1254961143A78411E197D387" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.RankSelectSpec.json", + "mode": "100644", + "gitBlob": "8695d6edb78586e330055ac7731f0fc69c508ade", + "rawBytes": 1359, + "rawSHA256": "28F8CA078412A61BCC24D8639EE44C86EBE153050C9D6A7EBEB851EB0CE16C84" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Reduction.json", + "mode": "100644", + "gitBlob": "91deef3b22db05bde6587d480e7a04f3c61efd0a", + "rawBytes": 1340, + "rawSHA256": "689FE67DF50F007769A5861519BDA38FECCB1CB37E84927939847B14BE0F6087" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Refine.json", + "mode": "100644", + "gitBlob": "c110565ad4d72a55c51b0e17d7634aaec1c206a0", + "rawBytes": 1328, + "rawSHA256": "476C2C2DB42A878D3C4B4C22500ECC035C7FC9A3955A6D2ECD9B3DB81C3796E9" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Shape.json", + "mode": "100644", + "gitBlob": "9c94d72b5fdbc22212b78741d6e6abc0f650a985", + "rawBytes": 1325, + "rawSHA256": "841A514AFD4A3729D2CDCDADE8BD65B16EF5C2502B099159CD787817F25859DC" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Spec.json", + "mode": "100644", + "gitBlob": "1d60209816a15dbfd028f0e58cab31dfc844f5b9", + "rawBytes": 1320, + "rawSHA256": "DA6CB769E81DEFABC8B84EF2FCAC0ADF57EE787E2F83F9F8303252A360637C92" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Succinct.json", + "mode": "100644", + "gitBlob": "18b9101f26fe0984f83baf6525846bd56e156f4d", + "rawBytes": 1337, + "rawSHA256": "125EC94BC3DBD57AB20D6A38EE5FE77E4959DEAF1F4AE0DBCAF69AF95B1318B9" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.BlockLocal.json", + "mode": "100644", + "gitBlob": "8d068786a714586be8daddbb04fcd162f02300ff", + "rawBytes": 1403, + "rawSHA256": "45F9D77D4C717EB41AFC61CD4DBCCF8551FD9F86BBC02C449AB10A23AB5E8B4C" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.EndpointMacro.MicroCodebook.json", + "mode": "100644", + "gitBlob": "2c4b4f588d51b3b36a16e89636505a66dc80812b", + "rawBytes": 1534, + "rawSHA256": "A830185571883BA013C91C819C51A9BDE0DF16657F8E3707BD36E589A5BACF62" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.EndpointMacro.RangeMacro.Concrete.json", + "mode": "100644", + "gitBlob": "8ffce50c833a0fd73db26bf31497045bc6442d66", + "rawBytes": 1560, + "rawSHA256": "4CACBE0C07E692FD73684D1C27BD545AF4D158F69D7200F48B0FAEC5939D8973" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.EndpointMacro.RangeMacro.PayloadMacro.json", + "mode": "100644", + "gitBlob": "3f8de5f24cf3e461b2bdfa215fdf216b1a4e560e", + "rawBytes": 1577, + "rawSHA256": "2D2EBF7779B03511EC6E74E90565CB4811FADEDF781354576CE30765A9B2078D" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.EndpointMacro.RangeMacro.RangeTables.json", + "mode": "100644", + "gitBlob": "fb5fa68fde18c37fe4cbf819aca956bf13beb6c3", + "rawBytes": 1572, + "rawSHA256": "BC77306132B43F7CC1C1419919494B1A9A067C55F64768E1A975DE6FC62F8B72" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.EndpointMacro.RangeMacro.RelativeMerge.json", + "mode": "100644", + "gitBlob": "8d461230213a014aea682f84918bd8381f844413", + "rawBytes": 1579, + "rawSHA256": "CDC399E4381FE07026BE723F4803893CA58D1385A02A11811AA1EAEB0218F51A" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.EndpointMacro.RangeMacro.json", + "mode": "100644", + "gitBlob": "527042f2b31c6e98e15f24d4324344ce1cd5955d", + "rawBytes": 1521, + "rawSHA256": "BBA26B07F5510DD539B82315FAFE8B983668664FAB1E2E902FB0C7702B79B6AC" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.EndpointMacro.json", + "mode": "100644", + "gitBlob": "7947fb44b6a8717968a494f3e32cb92801ff34e9", + "rawBytes": 1476, + "rawSHA256": "597598F62E3FE1FD04DE27F471F309DB5E00B85904BF735CC2CA8408D2F1361D" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.Candidate.json", + "mode": "100644", + "gitBlob": "fa267201976c3a72ac44b7031168e9197ed30422", + "rawBytes": 1534, + "rawSHA256": "1DEDAD8E67B173727753BD3005039DFA952718F1FB1643F0098E335FCDEB4D39" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.InteriorDirectory.Base.json", + "mode": "100644", + "gitBlob": "491db58b6115ba927da4ed5b2d832878c4a1226b", + "rawBytes": 1589, + "rawSHA256": "D428EFB3DF8AB401FBAD3A5E4BB6198315A59DA3699DEFA8EFF643729746742A" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.InteriorDirectory.SparseLevelWidth.json", + "mode": "100644", + "gitBlob": "042e3d574b7ab687911cf53a6cdd10add5878142", + "rawBytes": 1637, + "rawSHA256": "60FA3E067E3089D054A5C834FE69AA292B506DA461C6B6C0C82CBDC90E70A85F" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.InteriorDirectory.ValueDependency.json", + "mode": "100644", + "gitBlob": "ef6bf8ae229952e5f5735fc725383b3bd9325b74", + "rawBytes": 1633, + "rawSHA256": "090540424063E0D596C3F4B5C6149178732CCADD58D039E9FDF9B7E2FD2964A4" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.InteriorDirectory.json", + "mode": "100644", + "gitBlob": "4d844cda97ca32d5ff50ff3b5ae8e83274097b13", + "rawBytes": 1566, + "rawSHA256": "2A1AAF8ECA5773713ACBFDFF8CFBA1954861E8C84264D093915453CD3AF3DD07" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.InteriorRAM.json", + "mode": "100644", + "gitBlob": "951fb498cfd6b30bfb68570ba27440210644d764", + "rawBytes": 1543, + "rawSHA256": "63CC3979C2B79A3850B9CEC05851734696A186176B6DA98B6CE4F07F1B6DF73B" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.LocalGlobalSparse.json", + "mode": "100644", + "gitBlob": "cd93adfde80bbb7c0ec5219625b783ad961f2073", + "rawBytes": 1567, + "rawSHA256": "7F890B48A45BE67DB8631808BF9E9F34E3F4375EE4E7F7C2DACAE30925CEBB0E" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.RelativeScan.json", + "mode": "100644", + "gitBlob": "c65fbbffe9c487232175610d4b839fd998626668", + "rawBytes": 1546, + "rawSHA256": "73DF4276FB6B7E3E02CDA9823859672FA1B883B2C1B3A5D5C0F46DA5C885F3BF" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.TwoLevelCandidate.json", + "mode": "100644", + "gitBlob": "0ecafd1d25faec6fe034667c45f05a50c11ab0d3", + "rawBytes": 1567, + "rawSHA256": "B4A0471ED7024FBFE4B3E1970042CFA6AED143AA1A1ACF1CE34829F7AC94A545" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.WordReads.json", + "mode": "100644", + "gitBlob": "8bad9e4df745595228a6991c63f9c98dc0361717", + "rawBytes": 1534, + "rawSHA256": "E47AB1CD46089C57000D0EDF4E56A30A35EC5C9C2769F982816848EAB7614DAB" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.json", + "mode": "100644", + "gitBlob": "0c4a5813cec704f527b603323912ddbdeb40afa8", + "rawBytes": 1492, + "rawSHA256": "D20E8610FD33E030DE4CEC47B815F53969A7D55139C6CD169E64FF283E537B89" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.PrefixRange.AnswerSemantics.json", + "mode": "100644", + "gitBlob": "845ee3cf13160596acd6d931c8ac964999fad070", + "rawBytes": 1535, + "rawSHA256": "2CFB592E5499D61AF578BA93B8BACC25A2F4B5A63A49508DC0CB561C4D80BE5D" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.PrefixRange.LocalSparseOffset.json", + "mode": "100644", + "gitBlob": "2667638cb78545ebd8a7acba3e484a97374ecfd5", + "rawBytes": 1542, + "rawSHA256": "3F3D02D1C51A424E114D9F16A52C87DF0EADE3A5E8158CB98F1995ACE5D556D2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.PrefixRange.PrefixArgMin.json", + "mode": "100644", + "gitBlob": "8425454d725660f97466ba6a3d0bbef8fffc3ddd", + "rawBytes": 1522, + "rawSHA256": "EF13B0581791BC6EFBA57F382AE0FC6884C566A28A4BFAFA7AFFD35C72126DB5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.PrefixRange.PrefixWitnessTable.json", + "mode": "100644", + "gitBlob": "303c32bcd0104a7c73b9c3fab02a9efb757b399c", + "rawBytes": 1546, + "rawSHA256": "761610B731F19915C36DE7347AD182368306D2A394511C1D2FC6A1C90AD556D7" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.PrefixRange.RelativeSummaryCandidate.json", + "mode": "100644", + "gitBlob": "a392323cf4e1d08e325fcdc643b4c89b0ea0bf93", + "rawBytes": 1571, + "rawSHA256": "B180D7E7746C11D3FA8AE35B54668EEE8ED431E5B77BE781F9C0E2636C2057D0" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.PrefixRange.SparseArgMin.json", + "mode": "100644", + "gitBlob": "7b3408f57cc64e32cc13ae627c909a1570d6f781", + "rawBytes": 1522, + "rawSHA256": "C8630B6292756A2EF04DA2253AC146C6F5C841E298C188D4993E8DF9F0F0997D" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.PrefixRange.SparseLevelTable.json", + "mode": "100644", + "gitBlob": "36203883d6d7ceb985b6c46607386d28165a37eb", + "rawBytes": 1538, + "rawSHA256": "990BAC4DFDDE10607D95CC12F6635E40E0B92265BBC1B147395E5E3A45672E8F" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.PrefixRange.json", + "mode": "100644", + "gitBlob": "5db6d097f144dade6005ad1f5c4bf78d7e55c775", + "rawBytes": 1468, + "rawSHA256": "2E4E7429623CEE6EBCDDB24238E3B04222C4DED254D33E1B97C2B566047E9162" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.json", + "mode": "100644", + "gitBlob": "0240ae20690433f6addad8d2a05aaeb2a7545b39", + "rawBytes": 1418, + "rawSHA256": "88E72EAE767B52F4D9609FAA74C583DA071EAED7B5F44DD8B23CB56D496B1FC6" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RangeSummary.json", + "mode": "100644", + "gitBlob": "aa533aa807901782da880eb190db6f4a1e2e3ffe", + "rawBytes": 1410, + "rawSHA256": "AD8948EBCB5D6784B1E0EAA142C7F70E71A102F6FB16D68330A2A8D16D23B587" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RangeWitness.json", + "mode": "100644", + "gitBlob": "6335b4dc1b4293d3cf5e22abbef7569c39ef878c", + "rawBytes": 1410, + "rawSHA256": "333E352E3B537077B244750C29F828B4D679E72712C88A9E2EB4B54CED7BA74B" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.AbstractMacro.json", + "mode": "100644", + "gitBlob": "e3177728985efb3756cbab7b5bf0d0c9b2abbfc3", + "rawBytes": 1483, + "rawSHA256": "8089D9106DC081565B41D0FFA82B0CAE95D71171642951C355D62F8064EC7864" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedFringeChunks.json", + "mode": "100644", + "gitBlob": "5b573096459d1eb95db704e379188479341b54ee", + "rawBytes": 1509, + "rawSHA256": "D17BB4EF5891B68AE4D22E310E80EA70A6FE4A3EAC0974BA57E477D63364DED6" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedFringeSubstitution.json", + "mode": "100644", + "gitBlob": "1bad1190b855dce3bee58963e682c823d6a754bf", + "rawBytes": 1533, + "rawSHA256": "B00D8428BB9489B3A7CAE6CD951ECC8EEC8EE5617B5CA209C6054DABBB4AA7EA" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedFringeTableFacts.json", + "mode": "100644", + "gitBlob": "f7080e63df9a792cf8c06810cee911cbb7e1d392", + "rawBytes": 1525, + "rawSHA256": "ED6905D5489C2AAE0CF94F6893D7F045D33134BF9E5883365FD48D47020D51C2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedFringeTrace.json", + "mode": "100644", + "gitBlob": "220d54084ed75f23771137ab18bd8eb7fc9406c3", + "rawBytes": 1505, + "rawSHA256": "4CB282B436C4A8F66D4C881BE5EEB277DEDFA2BA7EDA9DB1EF496ECED88C7A88" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedFringeWiring.json", + "mode": "100644", + "gitBlob": "ae868ea5f09acd37f3590ee7881fc0f387794a75", + "rawBytes": 1508, + "rawSHA256": "A3ABBE6BA3B2F002B3D0ABF7E57D5D3327EA76421ED6748F1E1D0F350B140D43" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedRankSelectLeafTrace.json", + "mode": "100644", + "gitBlob": "64499d3edbca0a4e147c9fceacd0aed237b49e93", + "rawBytes": 1537, + "rawSHA256": "8C85D5333BF216766F984D2239201F101AEA1AAD0025709DACF8F5E2637D5A3A" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedRankSelectLeaves.json", + "mode": "100644", + "gitBlob": "9e4f4f11fb42e505138918221cf144abb398e492", + "rawBytes": 1525, + "rawSHA256": "5605F6B6964DBD9D8CD7AA83286B3E697791CAA0831B7B52CE6A99564C9E0491" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedRankSelectTrace.json", + "mode": "100644", + "gitBlob": "448e3dbfb772d6f8a8e1fe2402fd5847b240310e", + "rawBytes": 1520, + "rawSHA256": "05A742D6D6E184C7AC179D85A446ECB03C7A6CAA968301E7632758C6BF862CBB" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedRankSelectWiring.json", + "mode": "100644", + "gitBlob": "39c8404d545a74bd587ee3c4234fc47c65560ad0", + "rawBytes": 1525, + "rawSHA256": "3FBF1133F36A6C3669044E540DAD75D185A1A917D89CC60007882EABCDD98C04" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedSameBlockChunks.json", + "mode": "100644", + "gitBlob": "b42611ac845acc5566039cb476d905198f4fa952", + "rawBytes": 1520, + "rawSHA256": "FFD4DD7ECB8395C10AB8C79CE48441E678F8D099B54088F887A5B891933F258D" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedSameBlockSubstitution.json", + "mode": "100644", + "gitBlob": "4fdab1898341817ea4bd34e21eb2d46cfef979c8", + "rawBytes": 1544, + "rawSHA256": "89914CB16D58EACFA7CA1CE7C33D236A616ADD2756E4861C544C8052CBF436D9" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedSameBlockTrace.json", + "mode": "100644", + "gitBlob": "58669ecc1f358b8604291dff420f9966d0b9b981", + "rawBytes": 1517, + "rawSHA256": "8D5B6579BED8870B99C17E6A4C236733F706394EDD424A8BB268D9486D279E27" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedWordChunks.json", + "mode": "100644", + "gitBlob": "9aa99ccfbd8b98e4d6db9faa26f6d9e8237f418a", + "rawBytes": 1500, + "rawSHA256": "C2389CEB6EE5C04FBF540315E1B3E2F3F605B49BEDC4814140984492E679333E" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.CompactEndpoint.json", + "mode": "100644", + "gitBlob": "30558460daf8c588ade0b1c1131d9b029e0ff02f", + "rawBytes": 1493, + "rawSHA256": "A7A4903D1F465F48BC63194F9CE3B0C8F22A8545370299C834AE01F6CEE90810" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ConcreteDirectory.json", + "mode": "100644", + "gitBlob": "ce678d684ae74b735b41ee1d3a141e6f590717cb", + "rawBytes": 1501, + "rawSHA256": "5E170AF6F6C4C8817B8F873B3D7E45A8907431FEC212E66767A4109AE80A4EE9" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ConcreteDirectoryRAM.json", + "mode": "100644", + "gitBlob": "db3b0649ca382865f4e0760ef98bf86d6e092c79", + "rawBytes": 1513, + "rawSHA256": "932FBB935D9AAFDAC7625F919B6E7F23CB70CDD8E7CE2DF55B20448887E76F79" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ConcreteDirectoryRAMStoreParam.json", + "mode": "100644", + "gitBlob": "f23904209a65d82d05e2a655c67450f6789c8c60", + "rawBytes": 1553, + "rawSHA256": "EE79999223211A0E6A8DD8E1DAD7CAD44C13E78146719A4C8AB0DCABDABD7FDE" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.EndpointCodebook.json", + "mode": "100644", + "gitBlob": "d211397ec6672c6fa3f2f788fbe7007449145e65", + "rawBytes": 1497, + "rawSHA256": "F5E9C74ED3704BA3D02A09FE382543AA05EAA43EEF0E44F8DB70EA07E5D8097A" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.LocalBPDecoder.json", + "mode": "100644", + "gitBlob": "eeb7e83686c28e906d1aaf2aac76864318b236d8", + "rawBytes": 1489, + "rawSHA256": "93C9769AD371942901498F1BCEC257DC257689BACCF2FFDD134F6124A0EE3FE2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.MacroMicroFamily.json", + "mode": "100644", + "gitBlob": "946918c6148d1b0c23fc3164e87d5e7130434b77", + "rawBytes": 1497, + "rawSHA256": "136952B867DD66A5FA93F17B81B5DFC83FF702884807431D1D5EAF7B2469072B" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.json", + "mode": "100644", + "gitBlob": "1cc833be7e1207f4a3774b3f9f5c65ba04e17362", + "rawBytes": 1426, + "rawSHA256": "94B5308448BE19F2BE37317827CD804AD23717A55383BA5720A9E53A43D892CD" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeSummary.json", + "mode": "100644", + "gitBlob": "3174abf336e3bef317fc5c8417b06231942210fc", + "rawBytes": 1423, + "rawSHA256": "39F8594194AA15BAAEC5F0D0B3ED3E1007B08612E2A8F1EAB044F6FCD83F5C53" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.json", + "mode": "100644", + "gitBlob": "1bf1a72d6aa6e10724d1950a8c9e8d0f73cdcc10", + "rawBytes": 1356, + "rawSHA256": "916A33F82B5A44610C6D2DC31594E1E119C95C765EC70C47FEF4DCD6617DB36C" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.FlatPayload.json", + "mode": "100644", + "gitBlob": "797b09530e624ab7229e7aaf9afdb514d1f524ff", + "rawBytes": 1426, + "rawSHA256": "642B1FA7140FB9433FEB4606DFC54CD4C6D79EB385F45BC22CAEE70560CA42F4" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.GeometryClosure.json", + "mode": "100644", + "gitBlob": "445c115256756fcebfd19da390426c541a543e8b", + "rawBytes": 1441, + "rawSHA256": "1D30CED4E031CCB3982E84ECA899473297630DE8E2802212494204AEF49DABAE" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.Address.json", + "mode": "100644", + "gitBlob": "3d3192a8844722c20c5f0dbe44305f0213959043", + "rawBytes": 1473, + "rawSHA256": "BB4A64A66BB0E19DECB8170B7CB344A334A147D7CCA02CEC67B0BAFDFB984C49" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.Boundaries.json", + "mode": "100644", + "gitBlob": "0ece9834f23c8f7000bd340b892f06cffe3a9eed", + "rawBytes": 1486, + "rawSHA256": "470236C88FBC04B9652D084FFA26677774EA6E5AC1964EF31E897D399AE3A179" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ExecutedUniverse.json", + "mode": "100644", + "gitBlob": "0786f57d76b27824b2c79831377bff74778f2706", + "rawBytes": 1510, + "rawSHA256": "BBF0F69BEE22BE8287F46A9AD10EEC5278BC57A8FFB3956E22B5CD17D4B21DF5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.Header.json", + "mode": "100644", + "gitBlob": "688d24122fd296acf8e17c24467886804d43b248", + "rawBytes": 1470, + "rawSHA256": "B6E49DD7B546192A1DB968790F545215E173855B8E9ABFC778469415AAD3C036" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.Memory.json", + "mode": "100644", + "gitBlob": "95ad78d4a14a006f04520db8311f5c50decc2490", + "rawBytes": 1471, + "rawSHA256": "FA4F404603E7416D5DB9074B45D5B5A8E8DC4034DE1135A91D69F6C3DB599794" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.Payload.json", + "mode": "100644", + "gitBlob": "60593c8c0caa58de453aa556edfcce8d94a29cfc", + "rawBytes": 1474, + "rawSHA256": "E148142B9167887ABDAC2B24D3CFAA8B5E399695DBB1E8F8E524644659354942" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.PhysicalRead.json", + "mode": "100644", + "gitBlob": "b1169950ef0f48f7cbbdfe72e0e1f9a004ab2bb7", + "rawBytes": 1495, + "rawSHA256": "95CF7F8E718F7016B253D63A16AFE24CDEDEB21729BE45609C7FB60283D9255A" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.Probe.json", + "mode": "100644", + "gitBlob": "dee31bde665f5d6ad67014f228dfa2a0d94f0daf", + "rawBytes": 1467, + "rawSHA256": "0F67582C28D14B2122AB155AD91C078BDC623BACAD293D01A5DBED1B24AD135F" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReadProgram.json", + "mode": "100644", + "gitBlob": "31041fa7a447464ffd7960dc2806c4aa55cd9cb8", + "rawBytes": 1490, + "rawSHA256": "C7D10D342A7F296D2E0A2AF5589902F8FFA874F37CA1A7B13DF03968D2D91BDB" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerCloseGeometry.json", + "mode": "100644", + "gitBlob": "4c328c832570b376ade5a8c48f45bd78221a6f13", + "rawBytes": 1530, + "rawSHA256": "A50158C20449F603074C7C85C671E6B77826D7A7497FCD3CF244836FB9B3D655" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerCloseRead.json", + "mode": "100644", + "gitBlob": "8df02575878c6c0ad69c5f6d34f8ca4a15cec1d6", + "rawBytes": 1513, + "rawSHA256": "3023A618C930190B1F4A0AA7C7169AFE4750F90D5F95035A601B0795FDBB8035" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerCloseWidth.json", + "mode": "100644", + "gitBlob": "1b6d9d6bb2e25130fcee39976e40f1f929b9c179", + "rawBytes": 1518, + "rawSHA256": "B05F7DCF5CC5C068428A599EC210F52817C980A162CCE68586A59BE6FF8F6317" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerClosedGeometry.json", + "mode": "100644", + "gitBlob": "0d8ec69d47556926c2a16a7c673c0825a22aa668", + "rawBytes": 1535, + "rawSHA256": "BF6A540D4BFDDE1F090A86835FFD5D71590FCF106CCA7C62E0E8A6C4F5CD34EC" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerComponentAccess.json", + "mode": "100644", + "gitBlob": "b8989c36d30ddb06deeba5ba9c871d32c0fbec9d", + "rawBytes": 1539, + "rawSHA256": "495EE76E6821C046C975D210BB366A3CEA9D3471FB395A456EBD86F8DAB1D0AE" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerConcatIndex.json", + "mode": "100644", + "gitBlob": "203843f53e8333f76b53b8d4cd6454e72844a1a8", + "rawBytes": 1522, + "rawSHA256": "1431A3D0ABB26B8AA0FF54523F12BAA1643B8FE1DDABC11C01BCDF828E73D93A" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerController.json", + "mode": "100644", + "gitBlob": "45590db5b68e02bafaf57026b2d5677544e96b7a", + "rawBytes": 1518, + "rawSHA256": "F09FAB76829A4A973FD3F9A4E5D81E74A0BEFEC8A4E1AC134EA76871799FB08E" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerControllerProof.json", + "mode": "100644", + "gitBlob": "fd763e000c7c98466a07857fdd14dadc101e0989", + "rawBytes": 68549, + "rawSHA256": "D7DD2AA276709B68E642665E2B28E0964B1DC19A1F118AB321DEDD82A90277E5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerCrossing.json", + "mode": "100644", + "gitBlob": "14f31ce19b36a28d7e5c3c4c5b3e236fab169adc", + "rawBytes": 1510, + "rawSHA256": "572D4ADF695FB3955B83FDEF8B39256928F5AA2ADB87FB123C655E834017270D" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerEntryAddress.json", + "mode": "100644", + "gitBlob": "16861314d401347c3651b504c0a6fc820add364f", + "rawBytes": 1526, + "rawSHA256": "91B503B3B8F26D5A72BCF8D4E4C3165E2E853FA6034AFA700F749A008EA421A2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerEntryChunks.json", + "mode": "100644", + "gitBlob": "ee80ac72052f6c3966bd625e2bb5f44dabdf2329", + "rawBytes": 1522, + "rawSHA256": "EFCC312367AF907C7723876273FB2852EBD188F62C6B9D269F2D57C4103D1BDF" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerInteriorCount.json", + "mode": "100644", + "gitBlob": "571e46589acbdf5f370d9e4ccb9ec1e428ed710b", + "rawBytes": 1530, + "rawSHA256": "FF7D4FE2D7231A58A24F5A1A7F753B7DFD92E99F55B4E524CFCED44EC851A6CE" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerInteriorProtocol.json", + "mode": "100644", + "gitBlob": "554897ede3091d42ba91ebfe619f12a62e1e98f2", + "rawBytes": 1542, + "rawSHA256": "C7D3C3BA339B74280678A73CEBE7CD5E6CEF4548610A13DDCFD6FB2A8103071E" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerInteriorRead.json", + "mode": "100644", + "gitBlob": "c2a9e39b718ca564cdca0af455e6db807736a16b", + "rawBytes": 16129, + "rawSHA256": "5CEDA7560BAF01A1EFE2C68538D3F99C8EB2D674CBE7132897BD5640868B4377" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerInteriorWidths.json", + "mode": "100644", + "gitBlob": "0de56b383212ad099ea476e607f715a557625cdd", + "rawBytes": 1534, + "rawSHA256": "8E6E0BD6F1D63A63B9ECDF6429CD715E86DD2423A8DA80EFB094C415B727460C" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerLcaProtocol.json", + "mode": "100644", + "gitBlob": "7000c1eb92e0a9bd4781c2249beac7c63e1d19a5", + "rawBytes": 1521, + "rawSHA256": "2047F53C68E7F95B24D4F58941DE2F851856E5864DFEE3A1523BAC9F677725E6" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerLength.json", + "mode": "100644", + "gitBlob": "370deb694c782db12bc6bbac35142287604142b3", + "rawBytes": 1500, + "rawSHA256": "F8CEB2400D67F57E6F9EEB7F591D330785691210A777ED073EEBA26038C5868A" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerLogicalLowering.json", + "mode": "100644", + "gitBlob": "27e60d3dc11f44ae86692e2986c46b751baa992b", + "rawBytes": 1538, + "rawSHA256": "B29A7A63389BEB5A3091AF6E349DFB44EA0AC06B770948C7B92133AA7A3BFD1B" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerLogicalProtocol.json", + "mode": "100644", + "gitBlob": "deee4ace73a4c7b683443f90393016ccaba5ad7d", + "rawBytes": 1538, + "rawSHA256": "5B1F1F9C6B79133974CD64FE7CB52372318742D4D1F3086DF9BCCC2119EEF359" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerLogicalSimulation.json", + "mode": "100644", + "gitBlob": "591d330c4f65968ed91ea7afd168d8bb521a1155", + "rawBytes": 179274, + "rawSHA256": "C31DE51BE143FA756E4F65A173FFB5FB6D5E518EF6D0D6F1DE62D04107B17694" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerMachineWords.json", + "mode": "100644", + "gitBlob": "8bf1e03e1da89d0aed780ee4fad15d810bca9958", + "rawBytes": 1526, + "rawSHA256": "DBBDC8F635236E1B34BEF4C38EB674D8F52788F76AA81B1A27782E87F16873E0" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerMemory.json", + "mode": "100644", + "gitBlob": "82a6d2ea26b2ce8407aec0fdfce33c629a535c73", + "rawBytes": 1501, + "rawSHA256": "EBA3A83095EC4D14A80E33AE65B53311214EDAE3F367895777F5DACC9FEBA52C" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerPayload.json", + "mode": "100644", + "gitBlob": "9ae5d4bffd1c92f73a5f5be27c0658a3b3ea62e0", + "rawBytes": 1506, + "rawSHA256": "7880C63EA1CF8E9342058B0D1E2CEB801CAF8F7F2FC04928EB20C7CF83FC11DC" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerPhysicalRead.json", + "mode": "100644", + "gitBlob": "cf20405edeff008e3390aef01711b4bfc3efc20f", + "rawBytes": 1526, + "rawSHA256": "7F93DB89A5E5CA6F7F26C077C8B27307D5C82BC8FC76583DC548B318C1D81417" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerProbe.json", + "mode": "100644", + "gitBlob": "988b049b14307cad472adf08fe7b0fabea3cfb1e", + "rawBytes": 1498, + "rawSHA256": "1698483B4BFE100920CCD8081B115F5760B929D6B2B5DC47E13C7D6ACAF74FBB" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerSelectProtocol.json", + "mode": "100644", + "gitBlob": "38c64d44551fd266d40c88275019ba14e9a10301", + "rawBytes": 2194, + "rawSHA256": "8ACB45993066E659E2075CB4B6A8FCE7FCCBDDDBC7EB3FE1451E1216DEB9DC47" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerSourceAddress.json", + "mode": "100644", + "gitBlob": "4acf0a106db154ae89a7b95d81373a4606927bbe", + "rawBytes": 1530, + "rawSHA256": "81A380847C57330C63D9B2A29B51A856BE92691F862E673F891AF2B3E83CB7AC" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerSpace.json", + "mode": "100644", + "gitBlob": "4b8b446f9eb7a44e86ac8a26cddf777186cae47a", + "rawBytes": 1498, + "rawSHA256": "B99DCA338704134B6CF5F59C8C7DA8F21907B91AD70B28E322C6DA96D69F2281" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerSparsePrelude.json", + "mode": "100644", + "gitBlob": "ad2a8d0b5b62c37bd4b0c3677974ef5cc2ba2713", + "rawBytes": 4648, + "rawSHA256": "C02B88E49D8077B32F94A07FD496175B97636C264D8547071699745386B621DF" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerWholeProtocol.json", + "mode": "100644", + "gitBlob": "4f06c9d2ad048c24bddd02f9a47992e51ab12f59", + "rawBytes": 1530, + "rawSHA256": "E583292A7BA104CECA87076D7C51E87548063B39FAB7AC071F832D6A7831086B" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerWidth.json", + "mode": "100644", + "gitBlob": "7afb2ecb76687d013c090d3e26c4de424e05d2f4", + "rawBytes": 1498, + "rawSHA256": "FD87D4D11F4F8E90429CB42E3C20D0F96270B6D6F47871E356F91D01B110E387" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.SourceFactorization.json", + "mode": "100644", + "gitBlob": "7b409f2a4a7368904fb621113733761460c50989", + "rawBytes": 1522, + "rawSHA256": "93D9AFE9F76694901A82AAA33B76E417D7901DFBE6FCAB5163F8E392A46B2011" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.SourceGeometry.json", + "mode": "100644", + "gitBlob": "cb576e88b3790479428ac67dcd2d8e70d6033173", + "rawBytes": 17783, + "rawSHA256": "2F5B540FB561112204EE042DF16338D8436BA6A22730144D85C28CBC50223E27" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.SourceWords.json", + "mode": "100644", + "gitBlob": "58ef1a0c1a598a9fefb73cce79bdb169ea984744", + "rawBytes": 1491, + "rawSHA256": "C0BF6493D2BAEC45960815BFA8275DDFC1CABA115A6EC134F8C7CDE96A25113B" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.Space.json", + "mode": "100644", + "gitBlob": "d5c8db5162fecf6a0bdfc65077fda76d73c76548", + "rawBytes": 1466, + "rawSHA256": "7EC30494B447969EE113B90C05480742060390F8925796543F9CEBBF991F05CA" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.WordWidth.json", + "mode": "100644", + "gitBlob": "a61b79e1df0444f6050cb05cd1fd9512dad081c6", + "rawBytes": 1483, + "rawSHA256": "31587DDC00F9263375D4A28B2728DC77B0B906A1A0A364D193294FE926544094" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.ReviewerPhysical.json", + "mode": "100644", + "gitBlob": "466d7f9ef64199276eb620e0268db8661b109675", + "rawBytes": 1446, + "rawSHA256": "F4EF49DF91C8872E52234A87BF3CD864AEF9CD128DFFFED5479AE3DF50EE498A" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.ReviewerReachabilitySmall.json", + "mode": "100644", + "gitBlob": "7eaf2164cac3509ef0266e1c2b0268e926578f5a", + "rawBytes": 6795, + "rawSHA256": "A4AA061121D1A1DF7036D4EEEBCD6417F3B49BFC2816FDC0B362C4D6E840715B" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.Segments.json", + "mode": "100644", + "gitBlob": "d501dff94636ba0b8edcc94cba72e4cde858feda", + "rawBytes": 1413, + "rawSHA256": "F0CF5E5285F71EA6E2E4AC19FACD4E528D5CD2C84D8DEBAD4F3CA942AEAA01B5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.json", + "mode": "100644", + "gitBlob": "8c887b0c92ba6235abde9dac91ab6a7d6d2b93a6", + "rawBytes": 1357, + "rawSHA256": "73179AC088A67FE38574982F0C6CBF91D78960F5B29BC472B7479B8F2210D3FB" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinalModelAdequacy.json", + "mode": "100644", + "gitBlob": "24f21569f99aff1c0795c595d3fa2df78e4b6c71", + "rawBytes": 1408, + "rawSHA256": "D75DA48F48C3F14982B1121A6740FBF4BD762C49F14008A9C00DB4E2951F3268" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinalRAM.json", + "mode": "100644", + "gitBlob": "96109bab0992f25de18dbca1c3ab86fd678e4524", + "rawBytes": 11616, + "rawSHA256": "EE1B4B355735844D8881BBF7819D4664CBDA6FCB31C5D781147C2A0685C5CBA6" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinalStoreParam.json", + "mode": "100644", + "gitBlob": "4d47e32a8dd842b6b987ea1530cb7ea9b57a9d49", + "rawBytes": 1397, + "rawSHA256": "B3933C7627209FAE908E3109163B0AC7A4D6C10A5B2A85621802578B5F899079" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctRMQClassic.json", + "mode": "100644", + "gitBlob": "1f0a029b3edc091d23e40e4f2b414c1d8e88403d", + "rawBytes": 1377, + "rawSHA256": "0B1CFF823990EB558853B943B60143E7D6B43C210DB491151446B6E39AFFC601" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctRank.json", + "mode": "100644", + "gitBlob": "969580e45ef6ad72169b86a0cbe35a1055f2a484", + "rawBytes": 1353, + "rawSHA256": "83171FD7B15F1E3C115AAC65E0CDC87B5BC69E256F9A8B3075108234DE1E23BD" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.AsymptoticFacts.json", + "mode": "100644", + "gitBlob": "fa5989710e51be9d8e9e877bfe7bf5ff1febeb3d", + "rawBytes": 1426, + "rawSHA256": "07A833E17514C37FD9E1DEF6ED20B542BF96EAD765D7EC027C25B783F9B9E0E1" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.Basic.json", + "mode": "100644", + "gitBlob": "610b16e078fd371d6f953592b8a37f2bc7b3464a", + "rawBytes": 1436, + "rawSHA256": "E251D8C86752931B560B58A8B7114E64C88836535FC18F47B9884B4C0A620CD5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.BuiltRouting.FlagRankTables.json", + "mode": "100644", + "gitBlob": "6b0283275366f0e5255eb889e0fc333a587cb0e9", + "rawBytes": 1527, + "rawSHA256": "EAF45DF9BB3B1EA9997C5DB252BE6AEA0D1F96AEC0A2947E34445A291E092FF4" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.BuiltRouting.LookupDense.json", + "mode": "100644", + "gitBlob": "08f46517d741411e16e9d3f979202beb97236019", + "rawBytes": 1515, + "rawSHA256": "C2E2C8E85F9EA12AF081A8D3703C65266337D257C2524D1A5139B48556AB1C8E" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.BuiltRouting.RelativeEntries.json", + "mode": "100644", + "gitBlob": "4060af0fb50c50347ce13adb3fc029d61ddcb554", + "rawBytes": 1531, + "rawSHA256": "5517BB0DD5A2E0985CC475197D1173F80926AFB167B27146D247B1F36C78EB74" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.BuiltRouting.SlotBasics.json", + "mode": "100644", + "gitBlob": "bbbb17ac34fe3b42d43f7482b95fe4faad876a91", + "rawBytes": 1511, + "rawSHA256": "507FEDB7DE01DA41DD0D7266BC8C54BF5077B2B7887020F51A39E4FE4967CE70" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.BuiltRouting.SpanBudgets.json", + "mode": "100644", + "gitBlob": "24c862455adcb69a15e395921b1208321d940b88", + "rawBytes": 1515, + "rawSHA256": "77A12A2D44A8FA2887D97E655E9BDA0C1564ECF9E1DD736162A585DE7008DDEB" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.BuiltRouting.WidthBounds.json", + "mode": "100644", + "gitBlob": "81136611dff718f262954dbf279678eaadab2f22", + "rawBytes": 1515, + "rawSHA256": "38C94ECD8AB9EFD59A118E474AE845B7EA80D6E3CE49DE08F03E83AD81ADB70F" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.BuiltRouting.json", + "mode": "100644", + "gitBlob": "ccd1c235d572ad558db67a0b517c1a24b2204eba", + "rawBytes": 1464, + "rawSHA256": "88D2C8F5E9C88A20B67F250A776B3DF5C5524109D25F96515C20BE89490EE637" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.RelativeSplit.json", + "mode": "100644", + "gitBlob": "f627143e7f24f7e3bc06d318a80ffc0604fe5e24", + "rawBytes": 1469, + "rawSHA256": "FCA4A688626002535C3EBA96AD61173CD023FA84ACCC90B62B07648B5C70D38D" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.SparseExceptionCloseData.BuildProfile.json", + "mode": "100644", + "gitBlob": "f943c93efb491fb9cde8950579b3b2f16cedfa6c", + "rawBytes": 1566, + "rawSHA256": "658D63E5BB7CB6FE3EBEEBA69057E143E122F3AC665A80A15113827885F2ABF6" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.SparseExceptionCloseData.BuiltExact.json", + "mode": "100644", + "gitBlob": "a13b4cc2c0af25b7852fd759d71a0cabe84ef4bf", + "rawBytes": 1559, + "rawSHA256": "C73662BF33FE5A50457E47AE098204657539DFFEFAAD63577C6CFE84F34BA7F2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.SparseExceptionCloseData.DataSurface.json", + "mode": "100644", + "gitBlob": "f2413173561ec8d4f7c4304ae52ffc4b6401f8d0", + "rawBytes": 1562, + "rawSHA256": "79B16A1CAFE051A34DAF8D3C5F61C53E3A77724D71E65D63402C734B3A88E474" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.SparseExceptionDirectory.json", + "mode": "100644", + "gitBlob": "44c2244e0e83c13175981dfd9629aec44b75c54b", + "rawBytes": 1512, + "rawSHA256": "694F1E35E694CB0DF38E77DFF461496036A669D617C75566DE24AF56D32EFF66" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.DenseLocalTables.json", + "mode": "100644", + "gitBlob": "83583cdbcbd2aa47a45ec88b8415901d5f75d670", + "rawBytes": 1430, + "rawSHA256": "0CD5B2A754495155A1E04F6E6237D9F39BE852CA120343F9FBFFA71CD2C42A3C" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.TwoLevel.BPCloseNavigation.json", + "mode": "100644", + "gitBlob": "dd0fd994f1eb47385cd48538f77c15f51ba662be", + "rawBytes": 1472, + "rawSHA256": "DBB710B986C84C40351FD05C3F5289189758E76E4F8646BBE62C9135B803A345" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.TwoLevel.ClarkSource.json", + "mode": "100644", + "gitBlob": "f54518383df1d2c3a5cad9a810e9234a992a9fa4", + "rawBytes": 1448, + "rawSHA256": "1D1EC4F6C6568DAAC2EDC54AD02152F8B3EA438FEEAFDAADBE60601CEB0CEA7C" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.TwoLevel.RankSelectAdapters.json", + "mode": "100644", + "gitBlob": "72491b91e927ff2194861c8c08ee30f0f88f7a6e", + "rawBytes": 1476, + "rawSHA256": "C23D5BC5A6EA56E68CB8CCFA6ECD6215C148185CDD0A3279F15E9E87C9BEEE35" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.TwoLevel.SelectData.json", + "mode": "100644", + "gitBlob": "987f22d89a15408186ab543b831d2368ec3af6d1", + "rawBytes": 1444, + "rawSHA256": "3A2E67A0195D1AB8F924C137C8B74FB0151CC9A9240A46840FD525E061ADE891" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.TwoLevel.SelectSamples.json", + "mode": "100644", + "gitBlob": "7429102cb26d89c33064fdaf8b5b317b59374d7a", + "rawBytes": 1456, + "rawSHA256": "1E533DDDAD7EC4018AF1629D504D1704711D62678E8A14EE14B73D7F05B493EA" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.TwoLevel.WordExact.json", + "mode": "100644", + "gitBlob": "60b5af4a40b7f00b787ba489b6ba229a3a4ac4f0", + "rawBytes": 1440, + "rawSHA256": "AD330EB7487BC8BCCD32BB010CFD1DD4C67B8B41180100E3B3F3B5E7B63DF9B6" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.TwoLevel.json", + "mode": "100644", + "gitBlob": "a75a0a1b97f9dd0575679c6a8d7eb127f95d0921", + "rawBytes": 1398, + "rawSHA256": "EB17436F02B6C542732E4A73DDB7C106EC74C699348D50E97B92CD400A3D7325" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.Asymptotics.json", + "mode": "100644", + "gitBlob": "49d17e90b1a27c618d9d91afb2de1006e581b388", + "rawBytes": 1407, + "rawSHA256": "67792DA386B44107B60B58C7EF4EAF0BFD8A36E9FB7579DF2E127B31D1B9F6D5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.BPAccess.json", + "mode": "100644", + "gitBlob": "b4077c4920b1024cffd4751f78eb749125f475a9", + "rawBytes": 1395, + "rawSHA256": "51B62F6B5F57D323F23AD8019679032DE0D1813C2DDECEF76A1B32410DF4EE7E" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.BPCloseLCA.json", + "mode": "100644", + "gitBlob": "5e1d617c3286faee83e1866158e3dd747a5e49d8", + "rawBytes": 1401, + "rawSHA256": "65EA446CBD627E98A1A647A367B3CCBEF6F0B822C12E9D622612F238959799FD" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.BPCloseLCARAM.json", + "mode": "100644", + "gitBlob": "f0855d08671f2d8db0c071e09616555c04dce573", + "rawBytes": 1413, + "rawSHA256": "807E6DB4A785B4F8DD1473CE54881D51E32D26C3E42DDB1B8298A3FFD99D1023" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.BPCloseRMQNavigation.json", + "mode": "100644", + "gitBlob": "22395603697572b50648314e1ea80b752a840f1b", + "rawBytes": 1443, + "rawSHA256": "321779A2BD88B590F78C4BCD72AB0D03242F767649AE8091FDB3918806821EB2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.BPCloseRMQNavigationRAM.json", + "mode": "100644", + "gitBlob": "cd15657634655590937890dab806c68e0ca9cdaa", + "rawBytes": 1454, + "rawSHA256": "34CD5F2BF41BD39196538C6505AC2F8DC33F74CC07805305B6ECE82965B5449E" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.BPShape.json", + "mode": "100644", + "gitBlob": "7b2a0d9bf8dd66ee3ad6b8f3a98055f39ee459b0", + "rawBytes": 1391, + "rawSHA256": "BA62C2F0A4755D443050C34C5C08D7C16B8997851ACAA925A3DCC0856EF4891C" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.BroadwordRMQ.json", + "mode": "100644", + "gitBlob": "1fd99ae7b77886d3734d3cd48c8203de46403a59", + "rawBytes": 1410, + "rawSHA256": "902947DEE39B45846E3F0D2AA9158ECBE7D2DFF7006819B15D2D91190522E219" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.MachineChunkedTable.json", + "mode": "100644", + "gitBlob": "d372d8fd9a7c42d225cd771a7b9aac831ad99b56", + "rawBytes": 1438, + "rawSHA256": "32B1E62774330C9931F39F714A51515934CF06EE38FCB909F64A77617EFA465B" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.MachineChunkedTableProgram.json", + "mode": "100644", + "gitBlob": "f0101d0d00d48edea302361df5f8bee450917716", + "rawBytes": 1466, + "rawSHA256": "A29ED495753953EE08AE6C8F240AA293ACF3B44CCA924E3B2C8124C4FD6BF0D9" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.RankSelect.json", + "mode": "100644", + "gitBlob": "62ef334d97b3ad1c29c6cbf3511ab038c8f09071", + "rawBytes": 1403, + "rawSHA256": "CE3878BCBF38663D74A02EC5C8EB7BF4E47280DC3FE48CFB535C89ED3254797B" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.RankSelectRAM.json", + "mode": "100644", + "gitBlob": "43ff79be2651d6774b56bf87575a697f50467667", + "rawBytes": 1415, + "rawSHA256": "75E347A0A14988955C7369385694EBC31210DF83FAF2734BC2F6643E1CA016E4" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.SelectSamples.json", + "mode": "100644", + "gitBlob": "e0d7313e9e9e9b0742fc71d24f2ac4cd000f899a", + "rawBytes": 1414, + "rawSHA256": "CEB94F839CD97086D1DA9C969A4E3C87167C346615A0D11E2BDF340E575CF2E6" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.SelectSamplesRAM.json", + "mode": "100644", + "gitBlob": "82db0ec85247b07821e311929039e30a44814582", + "rawBytes": 1426, + "rawSHA256": "E71C10583F681996FE0170D349A6CDFBC9A0935D237ACB2E07C1B6A605EB4375" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.Tables.json", + "mode": "100644", + "gitBlob": "023ab2a580e6f92dc6c8530f2016a9311349db7c", + "rawBytes": 1386, + "rawSHA256": "F458963611CB56C40F836A3E6A1783E9CA7D8A3BCB9D29346CEBF68A487DE0A9" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.TablesRAM.json", + "mode": "100644", + "gitBlob": "ae4fd0482bb418132a76c28dee86b43cd22761b0", + "rawBytes": 1398, + "rawSHA256": "44263766E57751AE17772B8C08DA5A2A61129D21A7D5F849014D251B25FFBE40" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.WordStore.json", + "mode": "100644", + "gitBlob": "b53a1a59554646ab6e8ce7d52b87e4ce92132637", + "rawBytes": 1399, + "rawSHA256": "832CF7FD9D9528B520D5A9929A4DFC38E8F0E303C6B8E49492217E0AB87E27B4" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.WordStoreRAM.json", + "mode": "100644", + "gitBlob": "862a533dc45d916a00a74fc5432d8e2468f10921", + "rawBytes": 1411, + "rawSHA256": "92814826F32CF4E2273D08B91BC66066A65F3E3B644DD2C8158297BF12FAA523" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.json", + "mode": "100644", + "gitBlob": "01e3cda7add36373bcc56b262c617143ddc6ec83", + "rawBytes": 1356, + "rawSHA256": "EA7DE8AD3DBCAFD8C37114672B0AE21E688AB7EEC3F98ED618934D21905003E4" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.TableModel.json", + "mode": "100644", + "gitBlob": "b52018b5b2c140c7e0d39addf0de52f60125ce83", + "rawBytes": 1344, + "rawSHA256": "F32E20CEA4B6A82B7296BF4ED1DA6CEE2095E0664B8B04696FB98E2210ED9E09" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Window.json", + "mode": "100644", + "gitBlob": "9a4856eecfa16ee5a2550807193963153af9b80a", + "rawBytes": 1328, + "rawSHA256": "007875DB33D34813A3AD8EAB40D14D07EC2AC9A12E99DC9A0A08B7CED436029B" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.E1FringeBridge.json", + "mode": "100644", + "gitBlob": "8459d8462c59fb86ee8a6ae8737ea07b1a1b65f3", + "rawBytes": 1395, + "rawSHA256": "AF76838A21B4FEC5DF4516DEAD76798B873E01793137547E7BC7F40CAE55BD8C" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.E1Machine.json", + "mode": "100644", + "gitBlob": "63be4a91194e3967684b403d7c2d16656be5d66b", + "rawBytes": 1375, + "rawSHA256": "1429F043964D8655F8B9C629B67138D54392DC78CC6DF4DDA1C1EB01DC6C13D0" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.E1MachineCalculus.json", + "mode": "100644", + "gitBlob": "11a40ded0093bc4a7311c25847157320d7841231", + "rawBytes": 1407, + "rawSHA256": "22DB5A189E91B4D5610919FB8F138E9F0D3C9F28CA9BC589CE6AB8D4E9D4E7A7" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.E1RankBridge.json", + "mode": "100644", + "gitBlob": "ccfc90b5ab96e1bdafe205cdd5dd36a97a3cbe77", + "rawBytes": 1387, + "rawSHA256": "3A6E81D154544D319032F3F6711152BC7A8E9A348133D10FD5F21FAAD3597054" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Optimization.BranchBound.reuse.json", + "mode": "100644", + "gitBlob": "33dd5080fa0d571ad14328a9e345237da7404fee", + "rawBytes": 293, + "rawSHA256": "30A28DBEFBEC72B7E074714003A961E301F3C0DE0CD8065A5258B1251CEEBF1B" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Optimization.Capstone.json", + "mode": "100644", + "gitBlob": "f0d38d670be6e2c7ce6eb15739e35bef4460bb28", + "rawBytes": 1425, + "rawSHA256": "A5D3AAB6C1ADCC2F2E67138F9857A6E3A904B64E735E2DC87FFF9375F5F83D10" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Accounting.json", + "mode": "100644", + "gitBlob": "ceb285c2ad70b4544899695afa1d3d25451111db", + "rawBytes": 1408, + "rawSHA256": "3820AAA6C079836EAA54D861D1C88FC4FCF04ACB2AB87F9E949F93BB1B212B27" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Allocation.json", + "mode": "100644", + "gitBlob": "8750443193994a1b5c45f32828e059ccd9661938", + "rawBytes": 1408, + "rawSHA256": "23FE620862A385903145297DBAC9F7DD6E1B1838C685C988DFE85A6B3519712F" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Calculus.reuse.json", + "mode": "100644", + "gitBlob": "4808c931173fe3b5fa15fcd93a7de36b212ae3fe", + "rawBytes": 284, + "rawSHA256": "AAFCBBE218D4D48DB72C9369C1401E73DADABB61E2943C670E2310E26E5A1485" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.CandidateProof.json", + "mode": "100644", + "gitBlob": "ef824bfca876931f2a2d5c4e282a9676294174e9", + "rawBytes": 1424, + "rawSHA256": "22FD10A93767BBC85E1B8A1E90953BBCFBADE646C3EB70F49C99064FC95BAFE1" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Capstone.json", + "mode": "100644", + "gitBlob": "a874728c0624b8e13a65cd48787ae51d9cc6c3a6", + "rawBytes": 1400, + "rawSHA256": "974C32F67814A77C3D501352B6DE73E62F070343AE4E9DE2D9E093A9815CCC21" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.ChunkArithmetic.json", + "mode": "100644", + "gitBlob": "800a827f34d15f44c62a590d9dab01eea4bcf22b", + "rawBytes": 1429, + "rawSHA256": "2EE2B8FE4783EB3419AB851F523C83261E5F0692C1E59B7016F45202597B9CDF" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Compiler.reuse.json", + "mode": "100644", + "gitBlob": "53b32e3b1b2c7fefe2a7f42552ff19559381b5be", + "rawBytes": 284, + "rawSHA256": "5FCCF89BF4053F9FA578A49A44A1A5078629F446B7A88D615F516A4909DC83B5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.DensePacking.json", + "mode": "100644", + "gitBlob": "b701c74b733e5f02e29bac15cb2c6f5144d0e2cf", + "rawBytes": 1416, + "rawSHA256": "F106CD6E3A739838CC51652329E73F4E07D935BD14CCE167D21546FD819AF6E8" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Frame.reuse.json", + "mode": "100644", + "gitBlob": "feb47b9ceb002bb6ff5a5555c753f785d7d38524", + "rawBytes": 281, + "rawSHA256": "434E6D03518C0FE925011293CB969450367B861B12D1DF9227BC16BE368BA879" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.FringeProof.json", + "mode": "100644", + "gitBlob": "2dd074446b0eb8c03affb82aa2cf87f9046fad5b", + "rawBytes": 1413, + "rawSHA256": "D5D106F807D8A17BC918826AACECC38921A261E31BCA1E1FFD462E697D5363B2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.FringeSafety.json", + "mode": "100644", + "gitBlob": "f5195c0ffe2eb0880c417e58a6e906dc4ac734b0", + "rawBytes": 1417, + "rawSHA256": "0BBADE0F7F66D0C8304E35E4FEEC0DE177FFC3B992BA7B75758D0F12DD4FAA26" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.FringeSource.json", + "mode": "100644", + "gitBlob": "add2ff40b1a6015d3240b7750bda3632645b80b9", + "rawBytes": 1416, + "rawSHA256": "537B89158D75ABE4914D6A58AE9D6F5B62BFFBE372B3DF270827BC3C82B376B0" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Guard.json", + "mode": "100644", + "gitBlob": "192902e6c01b00db791e0822608c3f959c5d0a9d", + "rawBytes": 1388, + "rawSHA256": "BCB254C65C4BAD5C498A44BCF3FE5432DDE4C5D27EEFDEDDF90EEA8818D71C1F" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.InteriorCandidateProof.json", + "mode": "100644", + "gitBlob": "bc55829349174919a7d36bde659a450dff329a38", + "rawBytes": 1457, + "rawSHA256": "FBE72F95B65418D724D1ED327CCE0280529328C7650B81648A090EF0A6E2A658" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.InteriorLocate.json", + "mode": "100644", + "gitBlob": "94103f1c4f8aa0e72025d04dd4158b37a2b88465", + "rawBytes": 1425, + "rawSHA256": "A99AAF33860C1F65702901355471CA488E92776ACC3B0439475053C8E543F4A0" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.InteriorReadProof.json", + "mode": "100644", + "gitBlob": "6f28fffdfe398a69cfce721a2fc6ef2b03c716c9", + "rawBytes": 1437, + "rawSHA256": "9640C0B4D2CACEBADA6B146C599D66485EE639A138A0F19170A0E4307C31716C" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.InteriorSafety.json", + "mode": "100644", + "gitBlob": "5a9df64a5c676f839ae6cec8411695a624fcb744", + "rawBytes": 1425, + "rawSHA256": "8119DC9B8E3F9082CE34E572500F22C6B6E32067BD44344D3CF5541C89009E98" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.InteriorSource.json", + "mode": "100644", + "gitBlob": "148bffdf15e8021add9d7213d6b4f79cf6db9358", + "rawBytes": 1424, + "rawSHA256": "481E8F45AB62E35A8F7F864A6F6C19B6FA0F111368178909308DBD437E3122A6" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.LCAProof.json", + "mode": "100644", + "gitBlob": "92cf2503c3dc7170bdffeade855a293081669e80", + "rawBytes": 1401, + "rawSHA256": "D6F67F8497858819560A8BF4F1304E2313BA2557975DEEF748C41E6379DB9952" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.LCASafety.json", + "mode": "100644", + "gitBlob": "d1b540852e3da17d9e3bba96bd0ce23de37b219c", + "rawBytes": 1405, + "rawSHA256": "00089953D612B68E7014ADA243A336531313727052EC48688DE1CB00BE9446D1" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.LoadSafety.json", + "mode": "100644", + "gitBlob": "e816a52b3fe7b67b091a3a9c69fcd012b16dab4a", + "rawBytes": 1409, + "rawSHA256": "B04F7E5872F09727AFF7D67A51A532F38C83B6BA3DD890BFDEC94FD219A52ED6" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Locate.json", + "mode": "100644", + "gitBlob": "36c736086a5cf85bf1b88f12adadb5a9ecc362e6", + "rawBytes": 1393, + "rawSHA256": "7F923D313677C16413A63E7B213D3A6D91B53AC95F716A8E33A3D3B270F1FF1E" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.LogicalSpan.json", + "mode": "100644", + "gitBlob": "d1931f6cfa406ac949ae3de52307b0ffd37498e2", + "rawBytes": 1413, + "rawSHA256": "537ACD62714B8298AE958B765A4E66C2EA59C9FE7A3FBF482B9C6C97531DD869" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.PhysicalRead.json", + "mode": "100644", + "gitBlob": "a1d10b209c6388f7861a445e50d241919c2fb1f8", + "rawBytes": 1417, + "rawSHA256": "2F7CE20361C58624B20B061CE2FE8D600ECB3B24BC52959A3605D0EC96838DC5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Primitive.reuse.json", + "mode": "100644", + "gitBlob": "6a36eb61ff2d858a3b67d1f63ef7691ce2c4bbab", + "rawBytes": 285, + "rawSHA256": "27160E8474DE25B1C484393A2AC04B273289DE6E6823F857D02B4C58A13C4187" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.QueryCertificate.json", + "mode": "100644", + "gitBlob": "eeb5c521cdf5bad950b56b63ab864ac272c6369c", + "rawBytes": 1433, + "rawSHA256": "91EA66A9EB4FFF083C64B1D6931164A24C78E2BB0637FEACECAF32193932D1C2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.QueryCorrect.json", + "mode": "100644", + "gitBlob": "9c2d697117fa9055c2aa10f2d4ca1a04a46f0ff2", + "rawBytes": 1416, + "rawSHA256": "ACB83CBD09B5511903340BFF79055ACBC7582E03F01809F22C543A715DBB54F4" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.QueryObservations.json", + "mode": "100644", + "gitBlob": "51a7c35b2d52f4cdbf42c27f42dde2473b87b7ed", + "rawBytes": 1436, + "rawSHA256": "B6C9DFF685B5BF01FEB6F054392DBB58DBEFC4AFAA2E5B47C03DC52D62F04AB0" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.QueryProof.json", + "mode": "100644", + "gitBlob": "aebfbcb8faf53385801aa2026dcf103893178873", + "rawBytes": 1409, + "rawSHA256": "19515482C720D60AEC70DE5DAE561649EA9EC01DEB95646C9E2D6A5984ED87FE" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.QueryReference.json", + "mode": "100644", + "gitBlob": "e97bb982c443da3c592a6aef13518da196758df6", + "rawBytes": 1424, + "rawSHA256": "2C287489EE2FD0ACEA9CBD8D864C433BB52D6B2BED133ED31FA21259C71D020A" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.QuerySafety.json", + "mode": "100644", + "gitBlob": "704f9c06e53c8b1c6e78e3e48385e3254ecc1717", + "rawBytes": 1413, + "rawSHA256": "C5D282CB3269C23B65B19F4DDCAEC274D1433CBF6105677A68FCF4D31CDA3286" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.QuerySource.json", + "mode": "100644", + "gitBlob": "74a44ffb88b3849b42b487a6515dbc960a89ea09", + "rawBytes": 1411, + "rawSHA256": "62D6B043D741244A4039321B1A466EA261D835DBB6187F04583F6A991517D7DD" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.QueryStatic.json", + "mode": "100644", + "gitBlob": "755e32ad57c188a67270b5e817940484adba36c1", + "rawBytes": 1413, + "rawSHA256": "BE08344EC8386D02D0943C08F423338851C41261088DE07C701FE368A2D2779D" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.RaggedWindow.json", + "mode": "100644", + "gitBlob": "6a84f9b01cce890877c14d20aef4aea87012d65b", + "rawBytes": 1416, + "rawSHA256": "A09B3647A5588363BBD947DDC39F266F34ECBA82EA110CFEAEB580CCB17CEF58" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.RankProof.json", + "mode": "100644", + "gitBlob": "ca1cd4c47706178f3d279946e195942c17bb3283", + "rawBytes": 1405, + "rawSHA256": "E14FD56728049CEF192B9D2DEFA6FF2C915251D25F0E0DCEB5DD2F6090542729" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.RankSafety.json", + "mode": "100644", + "gitBlob": "496849b0a60d2473f5cc61175de4745fc8914250", + "rawBytes": 1409, + "rawSHA256": "EC8BAA545B3B7EC0E3FE5D72DA0969E76821B8525D308074868EE5E5BFCB926B" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.RankSource.json", + "mode": "100644", + "gitBlob": "7101cf560258731760e826dec86ecc0740a1ad04", + "rawBytes": 1408, + "rawSHA256": "160A1EDBA0701037FDED801F631CCC019C73777CBD03CB7391B3137FF88474FA" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.ReadInterface.json", + "mode": "100644", + "gitBlob": "7d84123b8911ee28b1c63635e70b0de7508b2b14", + "rawBytes": 1420, + "rawSHA256": "19F7BF4948DC871B79AC4599148765AF4F15EB6E739A44FC33286D853F341014" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.ReaderSafety.json", + "mode": "100644", + "gitBlob": "4858994ad2bc8533223dd68591dd35a2619f3a95", + "rawBytes": 1416, + "rawSHA256": "C117551D92269F0E043C1439804999B94CC50809D02035CE6548BBBE9873BBAC" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.RegularLocate.json", + "mode": "100644", + "gitBlob": "8a38a193560292da2c07a5d864357562f9f7705c", + "rawBytes": 1421, + "rawSHA256": "292EB3017D185D3D353470EF4DDB2536E889BF4613A232D0EB13B7D4DEB106E2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Safety.reuse.json", + "mode": "100644", + "gitBlob": "f7415c96e1ba46167c9f9878017a77386d16f584", + "rawBytes": 282, + "rawSHA256": "D87E0834D269CD7760FEB8E3E7350840EBDCB333C13330FCA70DC4EE5C195471" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Scalar.json", + "mode": "100644", + "gitBlob": "37240e9ec726d154160f2ecf5ed1ff584ea3f4da", + "rawBytes": 1392, + "rawSHA256": "4D7D93A5FE17DB61E0F9134252E21FC892517947AA632B08B47769F7E57D12C4" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.ScalarSafety.json", + "mode": "100644", + "gitBlob": "ed96862d0996b42e4de803cf972a477074d93dcf", + "rawBytes": 1416, + "rawSHA256": "5A06C8D1614BC35D717DD8A75A4028B492E1310D785F1AF933C2F0B9358137EE" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Scratch.json", + "mode": "100644", + "gitBlob": "12d7509b548e7d514888c76bcad5dbf9615f11e0", + "rawBytes": 1396, + "rawSHA256": "F327FA2FCE2F98D5ECB48564BD234F687502179EE5ED270827492F97B6EF6966" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.SelectProof.json", + "mode": "100644", + "gitBlob": "abf86d75ffebd2b0958351eced0fc47b9e91729a", + "rawBytes": 1413, + "rawSHA256": "AA52EB32126C0C8EAD33C7328DCFB39C4B8A9D8D6FB4EE142D4608DA38549DFD" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.SelectSafety.json", + "mode": "100644", + "gitBlob": "386ddd97c861fa76b7d53a131a2bc1d6354bc0fc", + "rawBytes": 1417, + "rawSHA256": "DBD5DFA43C75F513D1075874A6DC8C4BB32BD9B5B8F19DFFAEDEB1C3F8F101EB" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.SelectSource.json", + "mode": "100644", + "gitBlob": "1801518f2419f437f96efdb10e32ae4b49b26e0f", + "rawBytes": 1415, + "rawSHA256": "B9ABB6ECBEDAAFEE00C6F5A0091DE26ECBFBBE2A479E4F5D6C61F25077C2EFF4" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Setup.json", + "mode": "100644", + "gitBlob": "b25149d329a92b5f0fd2c322acd223f62755e767", + "rawBytes": 1389, + "rawSHA256": "4D28643EC4E3CDD48144C574A1015947C9273172B09D59E00FAAAFF79AAEEC6E" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Span.json", + "mode": "100644", + "gitBlob": "dcd9801035c7c7914e7b0d5fe496e063966a9c99", + "rawBytes": 1385, + "rawSHA256": "1F83993AD157550B62AE22C2580ED35E3EE4E1974368107ED8BB1FD6A186401E" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.SpanAssembly.json", + "mode": "100644", + "gitBlob": "353ddc004d79d5842bb2765b5df4f6ffadc51214", + "rawBytes": 1416, + "rawSHA256": "7352B35462D35448599498600656EDEF8A36745460F567F50664D85D073CC49E" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Structured.reuse.json", + "mode": "100644", + "gitBlob": "66b870dfc051f2e4dc6076789f278624fa60e437", + "rawBytes": 286, + "rawSHA256": "A9D4F5ED3AB28D84854D3A3C7AB4AA70FEBC0F86359A34042E951499F5D90C0F" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Width.json", + "mode": "100644", + "gitBlob": "3e27685779f25fe2a94b869e9a1da0121cd5465c", + "rawBytes": 1389, + "rawSHA256": "3E861BEAD0479F755B02C5B7F959DBEECF5FCE80156A06B1A330AE2BED67C353" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.WindowProof.json", + "mode": "100644", + "gitBlob": "75bdf66ed853ad526579c6bf84db05c42eb69720", + "rawBytes": 1413, + "rawSHA256": "36CC07A9D42C9DCE5208FCB8699A18AEC4804715044A47047DBF60BB32BB8908" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.WindowSafety.json", + "mode": "100644", + "gitBlob": "4732f2bd78e062c3b2b5dcde3a20f4836a912b99", + "rawBytes": 1417, + "rawSHA256": "E23CC414E1B16B4C64CD294A02BBC528864664E402C46FCD1D878F0C3B36D237" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.ReadStoreEval.json", + "mode": "100644", + "gitBlob": "515f9130bcf916a4f50a7595180e0daa2944cdc7", + "rawBytes": 1390, + "rawSHA256": "C39B048966E6E3574B9973CFD4762F438A06A91EDA73AA1FB25E5398260C0881" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Register.json", + "mode": "100644", + "gitBlob": "bd56ce1b896b0af6ba85ae15348f34ee78812864", + "rawBytes": 1371, + "rawSHA256": "EDC909AB8CE627C64754C40F3F8CA0E2583629FEAD640E671D31BAF0137994F7" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.json", + "mode": "100644", + "gitBlob": "25e42af93b4d716669dcbba4f6be0b4f1db289d0", + "rawBytes": 1333, + "rawSHA256": "81F7B54FFD1C1A6BB27AEC4F19342332DA94BDA0C8F925314EE738810C4F4181" + }, + { + "path": "docs/internal/extensions/opt1/query-development/capstone-branch-pass.json", + "mode": "100644", + "gitBlob": "f0d38d670be6e2c7ce6eb15739e35bef4460bb28", + "rawBytes": 1425, + "rawSHA256": "A5D3AAB6C1ADCC2F2E67138F9857A6E3A904B64E735E2DC87FFF9375F5F83D10" + }, + { + "path": "docs/internal/extensions/opt1/query-development/capstone-first-failure.json", + "mode": "100644", + "gitBlob": "4de1b64e6c7f3a4fde87af320d015a86c1d9bed8", + "rawBytes": 4356, + "rawSHA256": "DFD5855BED02484DE412A08C8F0D14C23382B3C748284358A47852A4D150D27D" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/20260912-072230-413-Frame.json", + "mode": "100644", + "gitBlob": "443a7fc9cf442eafbeed9c7ecb96b6acbbef4136", + "rawBytes": 867, + "rawSHA256": "C74B47994C1EC8FE7190DD2E8CE913E1F2A2A819478D823DBB0F74FAF40DE992" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/20260912-072257-771-Safety.json", + "mode": "100644", + "gitBlob": "811235951ba585b6da784fefb5424fa11eb9f0df", + "rawBytes": 870, + "rawSHA256": "674B48DCF1A64CF4EA090FC85F732745D5878EF9F8D805C6BEC90E1934117AFE" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/20260912-072317-427-SourceRelations.json", + "mode": "100644", + "gitBlob": "e7999cc18729469fe1c1f231feae4d7b7994476d", + "rawBytes": 16589, + "rawSHA256": "B95F15697EBD770F7AEE0785E0DCBCC81245F163736F4ABF59F584063CC69299" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/20260912-072444-505-SourceRelations.json", + "mode": "100644", + "gitBlob": "6d49f30a0a42216918cfb3c45f0a0eed398ee9dc", + "rawBytes": 6579, + "rawSHA256": "69D751008A709BCB74008C56B281C08B872803ED5D073706EFE94D5F0E1259A6" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/20260912-072545-457-SourceRelations.json", + "mode": "100644", + "gitBlob": "861252f274d70fd8a4ec4f6ff2c8c5b8d620f225", + "rawBytes": 909, + "rawSHA256": "375352F4DE6EA39228D30727866687FDB57710A2119124EC75539561AC277380" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/20260912-072553-584-Types.json", + "mode": "100644", + "gitBlob": "a55faf41f5a160a3da98db23ff0f3ad73f9fbbdb", + "rawBytes": 11888, + "rawSHA256": "7F2EFC270064FD650077C650900397F7BEDF6C57C0D8E42E2889C27236140DD9" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/CONTRACT.md", + "mode": "100644", + "gitBlob": "33364ec377f79ed9f7ce2560fc0e837ad3e0c5b9", + "rawBytes": 4223, + "rawSHA256": "A94F7323C282CDB0B8D1512699771AC71C5C457EF51AF374A000AF08179F8978" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/REPORT.md", + "mode": "100644", + "gitBlob": "83bf754518156cf720ea7ac693e2aa56c463b0a1", + "rawBytes": 13348, + "rawSHA256": "95799A33B9DCB129F8C4541408A40D2319D7203DF1FA0F2B8FFEC8B130AA1636" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/Types.lean", + "mode": "100644", + "gitBlob": "0c17956936cd2bd84fa5fbbea2ab3feac87101ad", + "rawBytes": 835, + "rawSHA256": "BFAF00282DE4A909D7780D1AFE71C960ED693D3F109931A8FE503B3AAE1A86B2" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/check.ps1", + "mode": "100644", + "gitBlob": "4ee7b37c363bebb8371f9c5877ac5de4bad1f9b2", + "rawBytes": 1997, + "rawSHA256": "BD95F3B065521B0A0CE2A5C36EC3EE3FD10E8CECAC32F5B3BAD0C698FC31ABF3" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/hygiene.json", + "mode": "100644", + "gitBlob": "145f47243dc09ab3f897494bd848a9c0755c529d", + "rawBytes": 652, + "rawSHA256": "2807F552D290C853F7494453F397D1BE25938717EF16606BB58D39A8222BD0FF" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/.gitattributes", + "mode": "100644", + "gitBlob": "79251caef4b743f3bdf7b268f8b66a859601fb77", + "rawBytes": 801, + "rawSHA256": "8E4F9BB9284238F2BCF3B17D0AE28FD631AC2957B3A1C48252D9CC9CFAD676F1" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "9fd9cace09ceba1058f83765405762c0fa5e1d2f", + "rawBytes": 64577, + "rawSHA256": "690D9FF348D86C2AFDB93016D2626E837721BA1B633A7916DDA55284672B4561" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/PROOF_IDENTITY.md", + "mode": "100644", + "gitBlob": "81708677bf85742da2e43a4811507aabded1bf9d", + "rawBytes": 37806, + "rawSHA256": "719C068F469729787700FBA2B6C9BC90F9798C0D8E8FBA944B7DACC1A68B91DA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/README.md", + "mode": "100644", + "gitBlob": "b4481a512b232a951abfacd500a57c7f1a710d0f", + "rawBytes": 12669, + "rawSHA256": "291E115D5AC35CEC517AA3F6199BD7CE7224A181E1FF949E918A418131ABC007" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/REGISTRY.json", + "mode": "100644", + "gitBlob": "bcda60d2bb7c3f924b2257897b2fb99e66e5b453", + "rawBytes": 9334, + "rawSHA256": "59DB124F0A3B42057977E2613BC0FB841EC62C8CEBD2E0E5BFD5003CFE4F9C0E" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/REPORT.md", + "mode": "100644", + "gitBlob": "cfa93ce3d770e4953c4bef86d68be7b64e0a91ae", + "rawBytes": 28707, + "rawSHA256": "C137409DB5E11A51DF193174739BC38D003FBC03F63EC1BA42CA75BE898EBD3B" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/axiom-union/20260913T0055245605662Z-axioms.json", + "mode": "100644", + "gitBlob": "94c3d85757336e599409388284e1d6a8b9d0bce7", + "rawBytes": 42084, + "rawSHA256": "BCDAC03A4B240DD7A7692847E419722F35470DFC38E2715F41DE9819B75C4D06" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/axiom-union/INVOCATION.json", + "mode": "100644", + "gitBlob": "8a3905684a62865001028bfd0e02c23bc9da55c7", + "rawBytes": 751, + "rawSHA256": "FFE20603A4D0A4693E52734D70993E05B1B0EE1D173DC7AA56B56911D54B3E61" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/certificate-80/IDENTITY.json", + "mode": "100644", + "gitBlob": "fb6ecc9164e1cbb17d17f3aa0df5aa4dc3fd1876", + "rawBytes": 397, + "rawSHA256": "C5A11DD73189B0A9F556B1B5DB3D2A91C86EFF586F0585C343E9334F22BA0BEF" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/certificate-80/RESULT.json", + "mode": "100644", + "gitBlob": "1e5dcd778a1bb7f313b972bd9523f9b0442ee92e", + "rawBytes": 53830, + "rawSHA256": "BF5A0C0A008C7BB0F57264E759B0985B16479208F721327E8A2D249F5FA17D6B" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/certificate-80/SPECIFICATION.json", + "mode": "100644", + "gitBlob": "28420455353fd77f14530c9ae8429bbfb6f3ad29", + "rawBytes": 2236, + "rawSHA256": "28A3C24F5396D6350D47F45E264096107CC8ABD5D40C7483005A6DCA039741BE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/certificate-80/stderr.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/certificate-80/stdout.log", + "mode": "100644", + "gitBlob": "a2e0e2b5ee3ae49a4e6d8b99863a416cc7455105", + "rawBytes": 19674, + "rawSHA256": "34A7303E3AB6EC7E220C701B5E4EE4611B4F6C7089B938E4583F61DD6E9E8AD4" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/claim-scan-a/RESULT.json", + "mode": "100644", + "gitBlob": "36353a42de92be2be299ead0798059524cff46b6", + "rawBytes": 898, + "rawSHA256": "260284C3B1416D6A13BFF273D8ABCF3DFC4A65EF95A8ECF81D6A3CCFBFA5CFBF" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/claim-scan-a/stderr.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/claim-scan-b/RESULT.json", + "mode": "100644", + "gitBlob": "a87bc97350effb2dc59113098c2cf543ad0f6b52", + "rawBytes": 902, + "rawSHA256": "5BE7F4732147008B02C5988592A61F38FA43F15C29530EF19A2FDBD636DC8F1D" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/claim-scan-b/stderr.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/claim-scan-c/RESULT.json", + "mode": "100644", + "gitBlob": "b991c08ab2d1899700683a77db57b7f199d44146", + "rawBytes": 1322, + "rawSHA256": "97C2C038310C2E9FC26C6764F9453008D00B2746DA771B1AF67EEDC8BCD5C74C" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/claim-scan-c/stderr.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/claim-scan-d/RESULT.json", + "mode": "100644", + "gitBlob": "5ef991a7826c77bd5378d962a3bc802c919a11cc", + "rawBytes": 1322, + "rawSHA256": "3F946D4C9DCAB28A99BAE40DD0C94902DCFB6FB5C02A94B15EDE5A5D82B479B5" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/claim-scan-d/stderr.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/lake-build-attempt1-wrong-flag/RESULT.json", + "mode": "100644", + "gitBlob": "13162dca4d09b0d96e8d1334e087a7569d78e376", + "rawBytes": 2475, + "rawSHA256": "298FD5F5C236AFCF40FD8F428228DF319D2AF2E528D830E2FC9D3598A5C51109" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/lake-build-attempt1-wrong-flag/stderr.log", + "mode": "100644", + "gitBlob": "63d0f6e646c4911b219ebdde29a48adddd34950f", + "rawBytes": 34, + "rawSHA256": "0CCBC6FE2A3EA0A8F40382DCEF8AC918F83AD1A42A2EE363D36650A75C6EB05E" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/lake-build-attempt1-wrong-flag/stdout.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/lake-build/RESULT.json", + "mode": "100644", + "gitBlob": "455ebd0473f8efc7a1d2e90cbb7da9287a401822", + "rawBytes": 247426, + "rawSHA256": "CCFA0C741F0962C634A741DF1E059BAFCCE26ED2AA3FEE5EE15713FBE5FE1499" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/lake-build/stderr.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/lake-build/stdout.log", + "mode": "100644", + "gitBlob": "4a65b2fd1c88ccd712e74d3b1aa39e4cd370e5f1", + "rawBytes": 109246, + "rawSHA256": "A387E1527714D4AEA2D9CB737D26AAFB211E1EAC41A99632E40B27BF91383F37" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/plans/certificate-80.json", + "mode": "100644", + "gitBlob": "28420455353fd77f14530c9ae8429bbfb6f3ad29", + "rawBytes": 2236, + "rawSHA256": "28A3C24F5396D6350D47F45E264096107CC8ABD5D40C7483005A6DCA039741BE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/plans/regression-49.json", + "mode": "100644", + "gitBlob": "b0539e0eeae181a576a1d73a8f847dec0a81908a", + "rawBytes": 2123, + "rawSHA256": "F407ACCE0CF2F8664B22B71B977C4A274DAC95CCCCC5B68A8C6DA18D2FF1CA5E" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/plans/runtime-27.json", + "mode": "100644", + "gitBlob": "ceb23f7621537bfa90f5904503da6c1365f746be", + "rawBytes": 1701, + "rawSHA256": "F1D68FA8AA2B83ED96D90B1BFC9C5A897211E01E98E36E38459F6A70C5DAF02B" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/prepare-r1/RESULT.json", + "mode": "100644", + "gitBlob": "b9bc07504ccd107854d482e5314566ec1f599cf9", + "rawBytes": 465592, + "rawSHA256": "33712034A1C59B72D7B35D9907284113B3D3768165E3EC9E6DC159E1FCF25FF2" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/prepare-r1/lf-install.json", + "mode": "100644", + "gitBlob": "0ef395f5aff1230dca1a7612872124903cb59c1c", + "rawBytes": 214771, + "rawSHA256": "2DE395E8BA6E8909F62D49DD6AEAFCBBBA647A0694A64039551A4B7F73AC7551" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/prepare-r1/windows-install.json", + "mode": "100644", + "gitBlob": "4350d933d81b251a17853c5e4a5881dab0d40108", + "rawBytes": 214796, + "rawSHA256": "A3FE7EC7651FAB0B85AEDA340F8A9A477519B0BB543435B9B5900B34C618F0AB" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-001.json", + "mode": "100644", + "gitBlob": "0bbcf3809c53e91d9fdd45d4d836b86585c57b0f", + "rawBytes": 1190, + "rawSHA256": "AE111322A7686833E3D26FE029E3E36A2C4780E11D160073BDDC71863B11E1ED" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-001.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-001.stdout.bin", + "mode": "100644", + "gitBlob": "97b9d54bfb7a66330592e4d63951318547a2e5b7", + "rawBytes": 41, + "rawSHA256": "813E228511628C4ADE08271DF3ED679170F9801E4C383428A8B492D3F3EB33EC" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-002.json", + "mode": "100644", + "gitBlob": "aa16e87650f6724da55fa1b71dfd5a7cd8437512", + "rawBytes": 1234, + "rawSHA256": "53A2EE9B09B22DBEE88591B82964AD67EC9D771B87C55AB1A2F1AC1BA33E016C" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-002.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-002.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-003.json", + "mode": "100644", + "gitBlob": "bc477d6af301e8a40e1f6ac3c611abeeac7828f8", + "rawBytes": 1235, + "rawSHA256": "F8349B143A3B648A7E031293C3B13293C83761EF8A15F893C27EEBDA9D8D82F2" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-003.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-003.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-004.json", + "mode": "100644", + "gitBlob": "f2ac69902a1dd7f3effd52cffc31b3c0af3b01c2", + "rawBytes": 1497, + "rawSHA256": "AF1847C9EE46DF0A45E4FB8652CD73728A1BE32C7AE3DDB83D346C512D399AB0" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-004.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-004.stdout.bin", + "mode": "100644", + "gitBlob": "539328d7c4bf06ca53176deec58e39608dc48900", + "rawBytes": 68359, + "rawSHA256": "954F4354774E6571FC392A678B8CFF302A7C2F361166558BC2D5607CB400AB20" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-005.json", + "mode": "100644", + "gitBlob": "6892b3a825d33befdd1e7daeb02073ba79d0d769", + "rawBytes": 1454, + "rawSHA256": "17136E974059CA690F1E8F9CA5E60CF8281631BD314A919C46944B33C1FCC74E" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-005.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-005.stdout.bin", + "mode": "100644", + "gitBlob": "c8f6ee5e6632fd4c7317d1f703251e0d7de74491", + "rawBytes": 88876, + "rawSHA256": "19B0B3EAAF3E9F799247595A21C7988AB4B917F8952730C65E7B5EF98A200F38" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-006.json", + "mode": "100644", + "gitBlob": "f6ada55b0ec526cf8911f532f53ba427b6836f42", + "rawBytes": 1230, + "rawSHA256": "CFAC88AEB900A63D0B9141CE8A9B8B1CD02C38034C18E5181277D5A846712658" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-006.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-006.stdout.bin", + "mode": "100644", + "gitBlob": "96d856ad8ad44f4bd84f862ee5275fb3b57015a9", + "rawBytes": 24783, + "rawSHA256": "BDD50082D978815E9005EDE9C34A9757F83693806307EE766E4CCD3C8472AAEA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-007.json", + "mode": "100644", + "gitBlob": "bc609170914a9ed242967fb88a91e8c232e77333", + "rawBytes": 1230, + "rawSHA256": "DE72B2864CF8E6A72EEEA8FA16D1FE4685F86147909E079BE9C58DD3E7BBBF28" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-007.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-007.stdout.bin", + "mode": "100644", + "gitBlob": "bd5d0eb38fd4a301eb89b027fcc434fc18dbee75", + "rawBytes": 35633, + "rawSHA256": "486420760DD5C43312DD0A0E9432771B55ADDE1953088B70597269E057A06051" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-008.json", + "mode": "100644", + "gitBlob": "dac06935abf70780dab2d6167553744428ede2d4", + "rawBytes": 1240, + "rawSHA256": "5603248F79E5BFCE523E71E379EB70CB7DBC07480F567CEB1BA18805AC9CD307" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-008.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-008.stdout.bin", + "mode": "100644", + "gitBlob": "3760470717560aafc5ae4652522eff1953d001e7", + "rawBytes": 11640, + "rawSHA256": "0D1529C98D35B6FF2AC53D58D107F0A47EC8F5D263F51819C085827C055A63BB" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-009.json", + "mode": "100644", + "gitBlob": "403a49c67d287cf967f30845def55739d4a514d4", + "rawBytes": 1223, + "rawSHA256": "1BA3DE52603EDDB20C81669EFF3C0BA5F98186FF31CA4B8DB7E6C1718B70C456" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-009.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-009.stdout.bin", + "mode": "100644", + "gitBlob": "7a78c403e548df7ba7e7782ab081f08c4f4ad32b", + "rawBytes": 24706, + "rawSHA256": "6A435EFF7E3CD2A2DFEA248B3A8ABEBABAF10FF643927C5C3FCAE52E666E7CB5" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-010.json", + "mode": "100644", + "gitBlob": "b65099f9cafaaf0973ef0868e58c230201f5ebb4", + "rawBytes": 1224, + "rawSHA256": "9C4936BC7D04181C049D09C8E64617BFA6BA4A71D4A9F83C19B2FE15663AA597" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-010.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-010.stdout.bin", + "mode": "100644", + "gitBlob": "4c9314d23730f318c1a4f99ca13e2156912f277b", + "rawBytes": 9090, + "rawSHA256": "0D4F03AC19F890B67894B74042FF7559ADD574A8D160539AD3565A48289BA0AE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-011.json", + "mode": "100644", + "gitBlob": "02ff154131de2fa6bd4687664d655baa160a1cb2", + "rawBytes": 1496, + "rawSHA256": "75FAF48D86B9477BD0F4E6B1315D2DDA3AB5A70CCE47403C4B9AC92E4B94CE80" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-011.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-011.stdout.bin", + "mode": "100644", + "gitBlob": "9e115d5f5c9e0eeea83a9e31f475494c216ad144", + "rawBytes": 90913, + "rawSHA256": "250C459FCB35FAD451C65861B7FDB6B7D5A771550357DF7322159AF8CF48BDDE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-012.json", + "mode": "100644", + "gitBlob": "966d0c6b228862cb3f82b8c4d957bbf398d50fa7", + "rawBytes": 1230, + "rawSHA256": "5A394E7D202947CA8F15A4C10D54E36C904CFEB33ADECD8295961EF0FDACA5A3" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-012.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-012.stdout.bin", + "mode": "100644", + "gitBlob": "bd5d0eb38fd4a301eb89b027fcc434fc18dbee75", + "rawBytes": 35633, + "rawSHA256": "486420760DD5C43312DD0A0E9432771B55ADDE1953088B70597269E057A06051" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-013.json", + "mode": "100644", + "gitBlob": "4c7368036a1b189a50710dc5e07126e136bebbda", + "rawBytes": 1240, + "rawSHA256": "46150E8FB8BEF365F4B027B3839B1581B03BE6BB9160A1E5D6CB07ECEDF13F26" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-013.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-013.stdout.bin", + "mode": "100644", + "gitBlob": "fdd3690e0af9cc8322aad33d5bafe135ca970a34", + "rawBytes": 32051, + "rawSHA256": "58387DF5DC955C5634A0E2BCCCCDFDB7CC72552D4B1FB89F2F68577F9BFF0706" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-014.json", + "mode": "100644", + "gitBlob": "e7b3d7e4209d752a8a2742a29f7118a1f92fb55a", + "rawBytes": 1236, + "rawSHA256": "23C6F70D4415DD966F5BE6A549E7855E22E50BF04CAB11D57F75851B9673E0B4" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-014.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-014.stdout.bin", + "mode": "100644", + "gitBlob": "81708677bf85742da2e43a4811507aabded1bf9d", + "rawBytes": 37806, + "rawSHA256": "719C068F469729787700FBA2B6C9BC90F9798C0D8E8FBA944B7DACC1A68B91DA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-015.json", + "mode": "100644", + "gitBlob": "2ef24344290a8adc1a271a8d8ca24d203f999025", + "rawBytes": 1521, + "rawSHA256": "A00A7501778F2EB1F58CCA6CCB036FC5C86330F4E42BA135776C94C0C456411D" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-015.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-015.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-016.json", + "mode": "100644", + "gitBlob": "f63b5715134fc138bdb300561d5f219bf5ccbdb1", + "rawBytes": 1481, + "rawSHA256": "ECC7B302E2C934C3A228AD77DD29CFC0B9946B252C26FADB2A9922E542A3A0C2" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-016.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-016.stdout.bin", + "mode": "100644", + "gitBlob": "b101dc308c09d6126c80b402ee0c8a112277b237", + "rawBytes": 4611, + "rawSHA256": "5160689EF625A76112CD3ACFFCF8CCE0488133A14E88FAC5800CE967EFE44256" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-017.json", + "mode": "100644", + "gitBlob": "68e69625dd6c0d6ced1a3f225f7fbbe1921c3a5f", + "rawBytes": 1454, + "rawSHA256": "87E787AB208FE5397610C13D31BAC03F470F8855DFBBB4005B069281F3BB2656" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-017.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-017.stdout.bin", + "mode": "100644", + "gitBlob": "c8f6ee5e6632fd4c7317d1f703251e0d7de74491", + "rawBytes": 88876, + "rawSHA256": "19B0B3EAAF3E9F799247595A21C7988AB4B917F8952730C65E7B5EF98A200F38" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-018.json", + "mode": "100644", + "gitBlob": "a96bc2c725c6c652d8688084591b8e80f2b23637", + "rawBytes": 1454, + "rawSHA256": "F72924344C69571A28569D35E718E0839D3C9D9D8933DB26360E9A7B4FA249AA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-018.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-018.stdout.bin", + "mode": "100644", + "gitBlob": "c8f6ee5e6632fd4c7317d1f703251e0d7de74491", + "rawBytes": 88876, + "rawSHA256": "19B0B3EAAF3E9F799247595A21C7988AB4B917F8952730C65E7B5EF98A200F38" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/process.json", + "mode": "100644", + "gitBlob": "dcc45f954f4257ce328cb34ae8c1f549cbd4bb25", + "rawBytes": 1046, + "rawSHA256": "A765A87BCEC496108746469643592D2B0A415101F7EEDA3E4B8C69DC36D3D89E" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/result.json", + "mode": "100644", + "gitBlob": "d926f955b3ebd1fb86b64697eef547fa3129809b", + "rawBytes": 543685, + "rawSHA256": "0F80FEC5E49D0FAE83C498C87B6D30A1973ABAAC955070E22B3ADDB11290CD58" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-001.json", + "mode": "100644", + "gitBlob": "8fbc18403cbef3eb7578872d5dbad860e58b94bb", + "rawBytes": 1190, + "rawSHA256": "379CC5AB46DA03C965043564427E7F93F251D89305F7F5CA3A9FB9C0BAD14205" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-001.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-001.stdout.bin", + "mode": "100644", + "gitBlob": "f12142ba38d47f2798b766f01c3cef9e7e9735d0", + "rawBytes": 41, + "rawSHA256": "F33BE2901E99D992A7CFB2F8BD5C41A270F222A087090A9AA5A2054627CBB64F" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-002.json", + "mode": "100644", + "gitBlob": "489fe089aec6b6ca11b9c956f0f3d2fb37fed2ef", + "rawBytes": 1234, + "rawSHA256": "BDDCD471D0ACC5C9D216D5C683571C49FBCF34B85500328E60E93B86BDA7417E" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-002.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-002.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-003.json", + "mode": "100644", + "gitBlob": "0529f1fb349413702391a66d23421d70afcf34a2", + "rawBytes": 1235, + "rawSHA256": "C2F5F4BF651AED8ECD5A4881D5EF63570FD125FD7DC40D7E046932DDE4F777D6" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-003.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-003.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-004.json", + "mode": "100644", + "gitBlob": "89d6fa9d10c6d8ecc296f8aba0bfb8c3af6cb0e6", + "rawBytes": 1496, + "rawSHA256": "DA6D02E05C78A31D58CAB66F1FB67F47F26F4B8A9E3B1D3511F324573F8C96CE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-004.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-004.stdout.bin", + "mode": "100644", + "gitBlob": "539328d7c4bf06ca53176deec58e39608dc48900", + "rawBytes": 68359, + "rawSHA256": "954F4354774E6571FC392A678B8CFF302A7C2F361166558BC2D5607CB400AB20" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-005.json", + "mode": "100644", + "gitBlob": "4abf1a0ed0ad2c9d93eed64473e7eef97e441704", + "rawBytes": 1455, + "rawSHA256": "0B7C20C98642DDBA9E83E704582B9213BBD68B9ED58ABB1D5B30A1151E076A11" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-005.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-005.stdout.bin", + "mode": "100644", + "gitBlob": "c85dca28255babeb1670c4526e2576c1ae561b7c", + "rawBytes": 107590, + "rawSHA256": "3956F3032D7DC6429DFABFCA34ED853C478FD9C3D6EB9BB6D4D1C985A9D5A78A" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-006.json", + "mode": "100644", + "gitBlob": "f913fbd0f7d06dff739c06193b1651356720c086", + "rawBytes": 1230, + "rawSHA256": "F52117FEA2E30BDF0F097D69D9D4BA3E9F9575EF0A03C41BFB338223D1F59BD1" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-006.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-006.stdout.bin", + "mode": "100644", + "gitBlob": "96d856ad8ad44f4bd84f862ee5275fb3b57015a9", + "rawBytes": 24783, + "rawSHA256": "BDD50082D978815E9005EDE9C34A9757F83693806307EE766E4CCD3C8472AAEA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-007.json", + "mode": "100644", + "gitBlob": "486481e790317d33eff8bc5d11ddc4c62e831b60", + "rawBytes": 1230, + "rawSHA256": "98944A95A35250BADA9329E90764EFEE9A20DE52E690ED684121B1585AAF5D0F" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-007.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-007.stdout.bin", + "mode": "100644", + "gitBlob": "bd5d0eb38fd4a301eb89b027fcc434fc18dbee75", + "rawBytes": 35633, + "rawSHA256": "486420760DD5C43312DD0A0E9432771B55ADDE1953088B70597269E057A06051" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-008.json", + "mode": "100644", + "gitBlob": "b9fa3dd0375dc20397027b0608bd698e89c55ce7", + "rawBytes": 1455, + "rawSHA256": "FD35CC640994A065803FFC325B07CA0D7930C977C263653DCFD531C1237C5BD3" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-008.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-008.stdout.bin", + "mode": "100644", + "gitBlob": "c85dca28255babeb1670c4526e2576c1ae561b7c", + "rawBytes": 107590, + "rawSHA256": "3956F3032D7DC6429DFABFCA34ED853C478FD9C3D6EB9BB6D4D1C985A9D5A78A" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/process.json", + "mode": "100644", + "gitBlob": "b038c7e18cb8315c99944cd85a8c70b53680b5bb", + "rawBytes": 1336, + "rawSHA256": "049620067C9B191E5420F18929BDF35E4E17D780BBB47FF33655FD4704CB6F11" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/result.json", + "mode": "100644", + "gitBlob": "5a9458361594def433e3462faa51daaeb25dae77", + "rawBytes": 236051, + "rawSHA256": "2A4F3A10EA0048A22ABDBA9B8B81FC249325A0D9DEF42EBBC56B3F238D294CBE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-001.json", + "mode": "100644", + "gitBlob": "5678264e8f6da757e825514a7a6e9abfb9b32a5f", + "rawBytes": 1190, + "rawSHA256": "EF9BA0562D6904D076E4209D4390AFBD1A8FA4544B3701A249AEDABEE9F2EBF6" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-001.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-001.stdout.bin", + "mode": "100644", + "gitBlob": "c5dba678ffcd745862e13c731b2698463ca3bf9f", + "rawBytes": 41, + "rawSHA256": "8A9C659661F0FDCEF1DB9A753156CAE7577A8A8162B64C2268511D7CB62152F9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-002.json", + "mode": "100644", + "gitBlob": "bf7594f59d6639605e6a5b37cd2890d7640ab304", + "rawBytes": 1235, + "rawSHA256": "A2A3C0B55BD05507049E3DF8F4AD58BF4164EAD158455AAF06D5554C76E70AFC" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-002.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-002.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-003.json", + "mode": "100644", + "gitBlob": "cfd8cedf529da933957e51fbb17796d636108e95", + "rawBytes": 1234, + "rawSHA256": "896FBAF7AAF52B8FBA486EA3FA6B02E04E2586046D5D08BADF4C525FC418538E" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-003.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-003.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-004.json", + "mode": "100644", + "gitBlob": "f04559f95da3376c6d45e46d8ea416620c60d779", + "rawBytes": 1497, + "rawSHA256": "4B0DC08262F5BA641CAECBCB94061E387EDB2D7A12F5CECAD3F453CB5DFE7D63" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-004.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-004.stdout.bin", + "mode": "100644", + "gitBlob": "539328d7c4bf06ca53176deec58e39608dc48900", + "rawBytes": 68359, + "rawSHA256": "954F4354774E6571FC392A678B8CFF302A7C2F361166558BC2D5607CB400AB20" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-005.json", + "mode": "100644", + "gitBlob": "72fc018d6c72349d5233d1e4d108d953dc6d330d", + "rawBytes": 1455, + "rawSHA256": "A4D2D3716117482BDE7DC14A20F5BF0C3296E91EC87199D14F5A17A7E6246D64" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-005.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-005.stdout.bin", + "mode": "100644", + "gitBlob": "91a242f75d835a0c123040f5cb2b67c2ccea051a", + "rawBytes": 111272, + "rawSHA256": "324A4B9D41064758DEDFD3E46936FC54B8107FD1B903F24A20BC2CCBFC663826" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-006.json", + "mode": "100644", + "gitBlob": "8ea4ed198a130c58cf78b40de82f0a31424789cd", + "rawBytes": 1230, + "rawSHA256": "410525760542D3EFD72A4B6D10209BAEA6BAC32479150AB5E899A2808C3B51F9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-006.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-006.stdout.bin", + "mode": "100644", + "gitBlob": "96d856ad8ad44f4bd84f862ee5275fb3b57015a9", + "rawBytes": 24783, + "rawSHA256": "BDD50082D978815E9005EDE9C34A9757F83693806307EE766E4CCD3C8472AAEA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-007.json", + "mode": "100644", + "gitBlob": "cd379992ea3af1e8cd28a7611638b593a888ee7f", + "rawBytes": 1230, + "rawSHA256": "D1C1CC3677BFCE2529775BCD921C2A84CD34DAAA2C61B06A178FCAE447267074" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-007.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-007.stdout.bin", + "mode": "100644", + "gitBlob": "bd5d0eb38fd4a301eb89b027fcc434fc18dbee75", + "rawBytes": 35633, + "rawSHA256": "486420760DD5C43312DD0A0E9432771B55ADDE1953088B70597269E057A06051" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-008.json", + "mode": "100644", + "gitBlob": "e25f5da50f46b930b3777d5a91dbad4f1edc5b73", + "rawBytes": 1239, + "rawSHA256": "878708D2AE422020A36780047859EE199001DFEA8B717E9A0CCBE013DC9A2382" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-008.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-008.stdout.bin", + "mode": "100644", + "gitBlob": "3760470717560aafc5ae4652522eff1953d001e7", + "rawBytes": 11640, + "rawSHA256": "0D1529C98D35B6FF2AC53D58D107F0A47EC8F5D263F51819C085827C055A63BB" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-009.json", + "mode": "100644", + "gitBlob": "0e16f68664fd66251bd931f2f923fab64db1f30e", + "rawBytes": 1224, + "rawSHA256": "223551B9C7BDD44FB306016FED93BF7AFAC19E280C30869FAB62D1065E41A1A7" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-009.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-009.stdout.bin", + "mode": "100644", + "gitBlob": "7a78c403e548df7ba7e7782ab081f08c4f4ad32b", + "rawBytes": 24706, + "rawSHA256": "6A435EFF7E3CD2A2DFEA248B3A8ABEBABAF10FF643927C5C3FCAE52E666E7CB5" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-010.json", + "mode": "100644", + "gitBlob": "8a1ad87378cf6f88bf51b120f1bd0448e6d461e4", + "rawBytes": 1224, + "rawSHA256": "A4C33CA61D0BA0573296A47BCD281483F868B197A4EC85530C8379E4DF0463A1" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-010.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-010.stdout.bin", + "mode": "100644", + "gitBlob": "4c9314d23730f318c1a4f99ca13e2156912f277b", + "rawBytes": 9090, + "rawSHA256": "0D4F03AC19F890B67894B74042FF7559ADD574A8D160539AD3565A48289BA0AE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-011.json", + "mode": "100644", + "gitBlob": "8fb5111e11eed8c7c2108eaa4368c23305e78261", + "rawBytes": 1497, + "rawSHA256": "791384894174F65ADB6425DD87FFEE3883A9CA510C3F8DD65CBA4C2530C18DDA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-011.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-011.stdout.bin", + "mode": "100644", + "gitBlob": "303c58c52a6738e98ec4ed2d676d1c3cc498c786", + "rawBytes": 113807, + "rawSHA256": "11C14EEFC05A6FFE6F644B10DD031A04B8AE0376844F675A9ADCC1609A267411" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-012.json", + "mode": "100644", + "gitBlob": "4996431bc212b97974d8adba7907baad4c7df9da", + "rawBytes": 1230, + "rawSHA256": "2D96D9F52F0798D1BD8D7F07C6DBF1E10E08B8A3D1D72A55F31E255392E7F422" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-012.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-012.stdout.bin", + "mode": "100644", + "gitBlob": "bd5d0eb38fd4a301eb89b027fcc434fc18dbee75", + "rawBytes": 35633, + "rawSHA256": "486420760DD5C43312DD0A0E9432771B55ADDE1953088B70597269E057A06051" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-013.json", + "mode": "100644", + "gitBlob": "c09972f808a928ac81fe5612586a6543618fc39f", + "rawBytes": 1240, + "rawSHA256": "1C2B7096FB3E206EA194441560A9D9292D19D2B54973145264C2E7824DB63F64" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-013.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-013.stdout.bin", + "mode": "100644", + "gitBlob": "9fd9cace09ceba1058f83765405762c0fa5e1d2f", + "rawBytes": 64577, + "rawSHA256": "690D9FF348D86C2AFDB93016D2626E837721BA1B633A7916DDA55284672B4561" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-014.json", + "mode": "100644", + "gitBlob": "70c9a9e00d1e4047217793d60faddb53e1d7dffb", + "rawBytes": 1237, + "rawSHA256": "B3618116483A66DDF3A5206A867A05D03565C3808FBA7D719BDDAF08ACC9C7D5" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-014.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-014.stdout.bin", + "mode": "100644", + "gitBlob": "81708677bf85742da2e43a4811507aabded1bf9d", + "rawBytes": 37806, + "rawSHA256": "719C068F469729787700FBA2B6C9BC90F9798C0D8E8FBA944B7DACC1A68B91DA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-015.json", + "mode": "100644", + "gitBlob": "91c2d239537f53c6aa601e65c64a638add29e0ec", + "rawBytes": 1521, + "rawSHA256": "A7F0CF8FE9D5B012729DE35157367481A0DA7BA41975DEC8C661E399314194FF" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-015.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-015.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-016.json", + "mode": "100644", + "gitBlob": "e9a44bdb4669aed9435b9de4d9349528a3a95cd0", + "rawBytes": 1481, + "rawSHA256": "175A13A24FEBFEE41A54205EFA5EED7C6B8DCE8DBE17210DD37CDD5F09FA5563" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-016.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-016.stdout.bin", + "mode": "100644", + "gitBlob": "8fc2e260632e387b58a5d07cb77701b22c68ff55", + "rawBytes": 4611, + "rawSHA256": "3111DB4DFD9DD148AB70F4D78E762F78C9994F0B5C9D805A36B5D4AD3D623204" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-017.json", + "mode": "100644", + "gitBlob": "dd0a10300e9a09622a046f25760323cc9b986750", + "rawBytes": 1455, + "rawSHA256": "F807D40C6310A4F7A0BC96074106F1B7FA3923440264AC8CD9376DCC4B3A4AD4" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-017.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-017.stdout.bin", + "mode": "100644", + "gitBlob": "91a242f75d835a0c123040f5cb2b67c2ccea051a", + "rawBytes": 111272, + "rawSHA256": "324A4B9D41064758DEDFD3E46936FC54B8107FD1B903F24A20BC2CCBFC663826" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-018.json", + "mode": "100644", + "gitBlob": "f72753927cbf9066240513ea70f5a7b35e48fd20", + "rawBytes": 1455, + "rawSHA256": "22CD1B7D1F60566ADA3911E334AC0E7E7DEFBDD04AEAB53A3C7611792097D9FA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-018.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-018.stdout.bin", + "mode": "100644", + "gitBlob": "91a242f75d835a0c123040f5cb2b67c2ccea051a", + "rawBytes": 111272, + "rawSHA256": "324A4B9D41064758DEDFD3E46936FC54B8107FD1B903F24A20BC2CCBFC663826" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/process.json", + "mode": "100644", + "gitBlob": "3359b1da30ba271964a0b8a27a2e839c821e63b6", + "rawBytes": 1046, + "rawSHA256": "04DCFEE265CFEDB81DF514644803CE7B57F73CB6070107C624A3B912A10313DD" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/result.json", + "mode": "100644", + "gitBlob": "8c730b33eca2fd5f709d6cdaef29398a78728dbb", + "rawBytes": 543691, + "rawSHA256": "D180C5EC6281F297DCE3091687F6DA136D83784650B3B0846C4B789E06510313" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/IDENTITY.json", + "mode": "100644", + "gitBlob": "44d0539a706634d98e7137447f9b2a7d828843e3", + "rawBytes": 396, + "rawSHA256": "69FAE4175530C7A65D7B1737D445741B5A8634B074F46CDAE90CFD019C4A9C2F" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/RESULT.json", + "mode": "100644", + "gitBlob": "bce6c611783d246464de4c46237a94e72ac96616", + "rawBytes": 11880, + "rawSHA256": "0AB69A10BB6CAF5453AD0BA7DCFE4B49BA5D6824F2A887C6BE16C091AE23EC9C" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/SPECIFICATION.json", + "mode": "100644", + "gitBlob": "b0539e0eeae181a576a1d73a8f847dec0a81908a", + "rawBytes": 2123, + "rawSHA256": "F407ACCE0CF2F8664B22B71B977C4A274DAC95CCCCC5B68A8C6DA18D2FF1CA5E" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/C09-MIDDLE-OMITTED-restoration.json", + "mode": "100644", + "gitBlob": "dc95d574cf148d394078905e98414030461978ca", + "rawBytes": 525, + "rawSHA256": "905B1886BC406D72411C6182C691219ABF225D8C99E18D974BA348B7FD6A8FD9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/C10-MIDDLE-DUPLICATE-restoration.json", + "mode": "100644", + "gitBlob": "dc95d574cf148d394078905e98414030461978ca", + "rawBytes": 525, + "rawSHA256": "905B1886BC406D72411C6182C691219ABF225D8C99E18D974BA348B7FD6A8FD9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P05-SOURCE-TOKEN-restoration.json", + "mode": "100644", + "gitBlob": "80144e73576e92bc5d66cd474a97919170b04b57", + "rawBytes": 486, + "rawSHA256": "4147F09C50BEF089668D2C89D99BBBC94510F0C0CDCB9E95D7CE7575EEB3FBFA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P06-ARTIFACT-TOKEN-restoration.json", + "mode": "100644", + "gitBlob": "326943a101becbb2ee7f0076a0d8c7f271518705", + "rawBytes": 508, + "rawSHA256": "E7131480510326D9939B7F6EA32CC20C6108B641F1C12FA765E872F457793E65" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P07-ARTIFACT-MISSING-nested-failure.json", + "mode": "100644", + "gitBlob": "3c1c3477a3d04788e09e803d6e0098ff1e28ff02", + "rawBytes": 1146, + "rawSHA256": "F306DCD75B2D986189008FA3C5F517FE475846055D9545D8198B14D6BB545CA6" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P07-ARTIFACT-MISSING-restoration.json", + "mode": "100644", + "gitBlob": "326943a101becbb2ee7f0076a0d8c7f271518705", + "rawBytes": 508, + "rawSHA256": "E7131480510326D9939B7F6EA32CC20C6108B641F1C12FA765E872F457793E65" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P08-ARTIFACT-STALE-nested-failure.json", + "mode": "100644", + "gitBlob": "963df18de15ef61334e8038af8782fb28dc49fac", + "rawBytes": 1013, + "rawSHA256": "E73E5863F62D1E014F03F3365576A9A8A560B588D21E6DB83507E43E4A308A63" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P08-ARTIFACT-STALE-restoration.json", + "mode": "100644", + "gitBlob": "326943a101becbb2ee7f0076a0d8c7f271518705", + "rawBytes": 508, + "rawSHA256": "E7131480510326D9939B7F6EA32CC20C6108B641F1C12FA765E872F457793E65" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P09-SOURCE-PROFILE-restoration.json", + "mode": "100644", + "gitBlob": "43a29200eac0dcfd625651c2ef1487b06cb7665f", + "rawBytes": 532, + "rawSHA256": "9D8814F36E7B1549D39839F9ABA6C84DEAA0F54134AFD7EB97C19C01900B209C" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P10-BUILD-RECEIPT-restoration.json", + "mode": "100644", + "gitBlob": "82520ad5e28736c34f7a3da73af78e26ce0ed386", + "rawBytes": 531, + "rawSHA256": "4F4193F5F46CCEB04D87E3630D58D7D0D266FE981A88BEC8842D9DB76FF79CB9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P11-TOOLCHAIN-TEXT-restoration.json", + "mode": "100644", + "gitBlob": "ddb5676811a933360e51a08e250faf1eca8f8361", + "rawBytes": 479, + "rawSHA256": "544DFB38111AB496F9A9D668548715B1080B6029AB86F80C7CBDD73907C4DF12" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P12-IMPORT-OMITTED-restoration.json", + "mode": "100644", + "gitBlob": "148c552dddde65ba0bfcfda684c9967cc2c130b9", + "rawBytes": 501, + "rawSHA256": "B67F77A048FDD21908B1420AF6E36D01D5A8A5962A7E3B3FA3365237A0C88D74" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P13-IMPORT-DUPLICATE-restoration.json", + "mode": "100644", + "gitBlob": "148c552dddde65ba0bfcfda684c9967cc2c130b9", + "rawBytes": 501, + "rawSHA256": "B67F77A048FDD21908B1420AF6E36D01D5A8A5962A7E3B3FA3365237A0C88D74" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P14-SOURCE-SPACE-restoration.json", + "mode": "100644", + "gitBlob": "80144e73576e92bc5d66cd474a97919170b04b57", + "rawBytes": 486, + "rawSHA256": "4147F09C50BEF089668D2C89D99BBBC94510F0C0CDCB9E95D7CE7575EEB3FBFA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P15-SOURCE-UTF8-nested-failure.json", + "mode": "100644", + "gitBlob": "16d19c4c2aa007e8b51cfe386d83c5c09d1b0c9f", + "rawBytes": 1092, + "rawSHA256": "E6EE064E7CF6ED416A887A65D8ACBDF44071BC7DED58B830F42FB23F18AB8126" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P15-SOURCE-UTF8-restoration.json", + "mode": "100644", + "gitBlob": "80144e73576e92bc5d66cd474a97919170b04b57", + "rawBytes": 486, + "rawSHA256": "4147F09C50BEF089668D2C89D99BBBC94510F0C0CDCB9E95D7CE7575EEB3FBFA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P16-SOURCE-BOM-restoration.json", + "mode": "100644", + "gitBlob": "80144e73576e92bc5d66cd474a97919170b04b57", + "rawBytes": 486, + "rawSHA256": "4147F09C50BEF089668D2C89D99BBBC94510F0C0CDCB9E95D7CE7575EEB3FBFA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P17-SOURCE-BARE-CR-restoration.json", + "mode": "100644", + "gitBlob": "80144e73576e92bc5d66cd474a97919170b04b57", + "rawBytes": 486, + "rawSHA256": "4147F09C50BEF089668D2C89D99BBBC94510F0C0CDCB9E95D7CE7575EEB3FBFA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P19-EXTRA-ARTIFACT-restoration.json", + "mode": "100644", + "gitBlob": "23b71374f17e7f22ee7673b89f45703c8b35f19a", + "rawBytes": 70768, + "rawSHA256": "AEC31169A8011E973C4DF074973B9BDF8125696FDD1E31216D7B79E3AD26F6B0" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P20-SHADOW-DIRECTORY-restoration.json", + "mode": "100644", + "gitBlob": "b178bf3844f94a373b6f2e5c2a6371d6a23c436c", + "rawBytes": 70762, + "rawSHA256": "6419EEF8696BA7A59D016F1B6C05BE1DB0D7615D29A779B5C318E23D7EE9D043" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P21-ARTIFACT-SIDECAR-restoration.json", + "mode": "100644", + "gitBlob": "23740fb7bc4da4c31e7e9ae0894f9d2144160d88", + "rawBytes": 70787, + "rawSHA256": "9B816C60DCAB454D197C0A53B9AC24C6A392CB2652D94A6D19C29005A52970AA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/R08-MIDDLE-OMITTED-restoration.json", + "mode": "100644", + "gitBlob": "d999e3af2b0a0024ed0325214bf9d12555df28b8", + "rawBytes": 518, + "rawSHA256": "28F6F6AE31540DD82A7397317598CCD369A0D00F4B5A97137BFB628DF61C08D1" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/R09-MIDDLE-DUPLICATE-restoration.json", + "mode": "100644", + "gitBlob": "d999e3af2b0a0024ed0325214bf9d12555df28b8", + "rawBytes": 518, + "rawSHA256": "28F6F6AE31540DD82A7397317598CCD369A0D00F4B5A97137BFB628DF61C08D1" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/RESULT.json", + "mode": "100644", + "gitBlob": "8469a93815a4292767126418b4f1d203ca528344", + "rawBytes": 113872, + "rawSHA256": "246F53054F8DD081EDFEC90874534FEA2E133489872DABD9CA01664F01156192" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/V01-SOLE-SETUP-verdict.json", + "mode": "100644", + "gitBlob": "21729a397a3e422a76960d46526bedd1713452b0", + "rawBytes": 175, + "rawSHA256": "E9D7DBB1B3AE1D490C30D805D8E66C9013F121D342006F1CEE8B0848D9FBAAE6" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/V02-MIXED-STDOUT-verdict.json", + "mode": "100644", + "gitBlob": "3dfeb4266c5e56de81f66708721d7a095137a4f4", + "rawBytes": 228, + "rawSHA256": "8BF7693E8B6C45BDE24C64DF5441A59F779B3FDB60CFAA3CE0736DCD3DC4A028" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/V03-SUCCESS-STDOUT-verdict.json", + "mode": "100644", + "gitBlob": "0629cd35dfd04333ac9bf09c870b8be8204d76b1", + "rawBytes": 230, + "rawSHA256": "B94A644278506B55D89133F3AEDB2BC784501A39B84CB79EE1AB044FDCF19882" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/V04-WRONG-STDERR-verdict.json", + "mode": "100644", + "gitBlob": "3fb8583ecc248afe4b3b72bc33d74ec5f712cbe5", + "rawBytes": 231, + "rawSHA256": "31417EBE11CD21E031EEF8B8773E0459DE1CC902F1CE4D4639D323BFAA9035E5" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/V05-ALLOWED-PROGRESS-verdict.json", + "mode": "100644", + "gitBlob": "71b2c4051dbe3920f48dcb2e66775195056da9cc", + "rawBytes": 181, + "rawSHA256": "F421487D1A9A0EFBEADCAA6DD6624FA9815DD16BA4B8B0DFB37590CBC4719B56" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/V06-DUPLICATE-PROGRESS-verdict.json", + "mode": "100644", + "gitBlob": "f037ffa28c1d294f5eadc5dd295957ef55c1e764", + "rawBytes": 237, + "rawSHA256": "BECF65636AC794285E33A32C8201374657942F451406F15035AD7DDC0A5D58D6" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/V07-REORDERED-PROGRESS-verdict.json", + "mode": "100644", + "gitBlob": "9dae2e436d6c7f73327535b575f01a6e127d900c", + "rawBytes": 237, + "rawSHA256": "D11C552242C5A1C6216CCC5801ED31834BA8FA08102E6FDEA0AFBEE8AE382006" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/V08-EXTRA-STDERR-verdict.json", + "mode": "100644", + "gitBlob": "a41ff19b841d05a49676f3ca8b8571ebb409a266", + "rawBytes": 231, + "rawSHA256": "F8F905A829C23C214A187762A9CD214AAF15A662B296E2B7196BC2E706F63B8C" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/V09-PREFIX-HOLDOUT-verdict.json", + "mode": "100644", + "gitBlob": "5548db51189b55071111ebe24cee7c7333a85879", + "rawBytes": 230, + "rawSHA256": "FF15C97A7590EC0CF0EB1DAED2AE935A178580D917B1DE15B5D21A91264F73BE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/identity.json", + "mode": "100644", + "gitBlob": "4686ecce5457d1b35a9877ecde209e69bf14310d", + "rawBytes": 441, + "rawSHA256": "DDE0EE7CBB6098F9A762F6F1615E8A67562762A4A12DBEC126C589EF0FE7F7EE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/stderr.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/stdout.log", + "mode": "100644", + "gitBlob": "ed2cfdbebfad9904c63305126019212837db2189", + "rawBytes": 1912, + "rawSHA256": "9E1D31CC96F4AE09D6A8AD08EF069BA180E9CB550D30F0736BEDDC5E8DCB0EFB" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/runtime-27/IDENTITY.json", + "mode": "100644", + "gitBlob": "fca3f78b81f7800de01bdf8318bc2bbdfab230f8", + "rawBytes": 393, + "rawSHA256": "6032D42915B2CB8CBA8DC24245758F2ED0F3CFCB0AC3EEB2C6D414FD2F329F00" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/runtime-27/RESULT.json", + "mode": "100644", + "gitBlob": "19c59af2365d6fdb1aca636e3450dfdc2d7ce056", + "rawBytes": 11348, + "rawSHA256": "AA3D8D9CE004E0736E0AA0A9BA004E736236C03E388F96F522C886E42666D97A" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/runtime-27/SPECIFICATION.json", + "mode": "100644", + "gitBlob": "ceb23f7621537bfa90f5904503da6c1365f746be", + "rawBytes": 1701, + "rawSHA256": "F1D68FA8AA2B83ED96D90B1BFC9C5A897211E01E98E36E38459F6A70C5DAF02B" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/runtime-27/stderr.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/runtime-27/stdout.log", + "mode": "100644", + "gitBlob": "6a718e97da0812a68704c6260471dd998c1bc46a", + "rawBytes": 2106, + "rawSHA256": "E5CD7B9CBF20996B6A7877FF3A1093AC99E4556BA1E6918B9439F6603C80691D" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/runtime-53/RESULT.json", + "mode": "100644", + "gitBlob": "510e58b1a6623e799cc12686db90e804998ebfa8", + "rawBytes": 87799, + "rawSHA256": "AA71E8D2E2C411BFFE031E2FB7B0AB86F0B87AB5429A414C795D0522F937EB00" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/lf-A01-UNCHANGED/executed.json", + "mode": "100644", + "gitBlob": "38e81e50f77df3c1504a1647e455fecb926f5579", + "rawBytes": 844, + "rawSHA256": "D754F489C164E09FA9D291AB5E25E69C8C7FCC2306406A49AB126E0671C1B30B" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/lf-A01-UNCHANGED/summary.json", + "mode": "100644", + "gitBlob": "f57a8b0d5f039aff5400bf3fca1d3ce3e614dc4d", + "rawBytes": 7926, + "rawSHA256": "B8227E7E58140FFE6619B43948524CB704E94658E0B251ACA67604941F647F74" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/lf-W28-stepBound/W28-stepBound-Consumers.stdout.log", + "mode": "100644", + "gitBlob": "49aea9adf781c314f08baf8c07845f5a90b179ae", + "rawBytes": 343, + "rawSHA256": "46EC0F12821201B4D9A0ECC3CB3BC2AF7B48F81E2CC6D1F32787DB14FD15763E" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/lf-W28-stepBound/executed.json", + "mode": "100644", + "gitBlob": "1c94fe568ce30979d9cf432fd880bb78c7e481f3", + "rawBytes": 844, + "rawSHA256": "D1BFEBE109E78526821C069E1CA79771C29C639209272B3B0645C5D5B8C33434" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/lf-W28-stepBound/summary.json", + "mode": "100644", + "gitBlob": "fee4f4d0fe84d300c02ca573af3002800a57cf90", + "rawBytes": 8838, + "rawSHA256": "35D8AE0A5891D0B3891D36DB05F393E477264328B69D3149EAA9B9BE711C7ED8" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/lf-library-selftest/library-control.json", + "mode": "100644", + "gitBlob": "e1c3f7292ae9ebb1fd0bcc28236dfbf965b31bd0", + "rawBytes": 843, + "rawSHA256": "D02EE2854553246B89EC25A67EE4CC7C472E0843A35DDB345ABA6B643E1A7D16" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/lf-library-selftest/summary.json", + "mode": "100644", + "gitBlob": "e7345e41850ae8b66250fe19f8667a4b74bd058b", + "rawBytes": 4429, + "rawSHA256": "0748D02D5EB35D25D9FC48191353E0B38F414E51119AB833D0A31AE3A39F72A4" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/lf-runtime-startup-only/summary.json", + "mode": "100644", + "gitBlob": "a4ff8a08772e26e66e40c5477bee22cb4d8a27c7", + "rawBytes": 98299, + "rawSHA256": "742DED8E73F07AB695F900ACE06CBDC537FFCDCBC05CC203580F5E21D55BFD78" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/windows-library-selftest-powershell51/library-control.json", + "mode": "100644", + "gitBlob": "2920fb44daf3b14e3db794531cd649e957ecf077", + "rawBytes": 1060, + "rawSHA256": "F2CAA3AA69905B872F55AF47ABB3D4F32A40768C67EEFF150D2BFCD339B8EDB4" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/windows-library-selftest-powershell51/summary.json", + "mode": "100644", + "gitBlob": "e68fc70a9b64ca6de04f6922bdf249990079c16f", + "rawBytes": 8122, + "rawSHA256": "38D9BC35B047C93C08DBAFB992FF1FD1781E8A51246EE8BFA9F68A0B5AF2D03C" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/windows-library-selftest/library-control.json", + "mode": "100644", + "gitBlob": "52ad6b59ce0eea9f470b62db860e742fb0afb64d", + "rawBytes": 843, + "rawSHA256": "537D3D7BAD4CE6E358480E94373A8F542A5983CDBBAD2E5B2010085730150623" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/windows-library-selftest/summary.json", + "mode": "100644", + "gitBlob": "365bcef53b5272fa774026bdd967afb2e68e3531", + "rawBytes": 4458, + "rawSHA256": "25CBE297A780F14FBEE045613A7D80B6F44B47B8DF0D7C2B009ECD58D3A10AA7" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/freeze-integrity.json", + "mode": "100644", + "gitBlob": "d94d141d3a1d603af05a499e4cc1647ad233d126", + "rawBytes": 3588, + "rawSHA256": "D7563A985B954F139FE3DF81AA45FCE1336F749E031EBA95B6DEC4A758C857E1" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/prepare-checkouts.ps1", + "mode": "100644", + "gitBlob": "d4ab9dcc14d358cf851094dfa6079f02ff306bf3", + "rawBytes": 4570, + "rawSHA256": "04DF708AF450D374C2029C3D2356C649DD7AFC897207D27A25951AD6DAE46408" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/.gitattributes", + "mode": "100644", + "gitBlob": "dec65d7ad94b973c87a547099e442f3e124538a4", + "rawBytes": 11884, + "rawSHA256": "7BEA47E94099D26BBE5D16009717D9066D00C59EBA6FAB9814BBC42714B78CB2" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/DEVELOPMENT.md", + "mode": "100644", + "gitBlob": "1e8f4f310a5418b7e1dc77c4c17213abdd844ca6", + "rawBytes": 2976, + "rawSHA256": "42C8CA60B99C3A27040B1780DD2FFB66B50E558E284B1C9BE98A6CE3FBD79155" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/README.md", + "mode": "100644", + "gitBlob": "fa7e57a8aee4437efe5d0fef4653cf108ec6c894", + "rawBytes": 2930, + "rawSHA256": "B0973CBCF11011F52126F0E122EDF86245E8CA9AACCDE57FE38719DCDC6507D4" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/check.ps1", + "mode": "100644", + "gitBlob": "e606c4c606978351480e52fec04c96d9eb41f9d7", + "rawBytes": 2398, + "rawSHA256": "288B8DEF19720BD53F448EC80598CD658CDCD3C287178D0677C8515F5D5FB496" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/check.py", + "mode": "100644", + "gitBlob": "b9371490047ccd2b4d16329be4d6a499cb449410", + "rawBytes": 26009, + "rawSHA256": "AB47AF51D7074C00B1A3A8C73CA5321EC5447B284C0EDEBA04CE2A5D8954A38A" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/registry.json", + "mode": "100644", + "gitBlob": "18c902e9a1ba9b6bfcc8b2639e96eccf489e3179", + "rawBytes": 1401, + "rawSHA256": "ADD660412125551A7F73CDC1693E953EFF5CC6CCC9582DBF09F8B21EF2E032A1" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-001.json", + "mode": "100644", + "gitBlob": "fabe38e01835dd2746f7217a5e18d6c508957de2", + "rawBytes": 1196, + "rawSHA256": "437736C6CEB992E04BCA72116535469B0E48690E6314837A390C3FDC50548E15" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-001.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-001.stdout.bin", + "mode": "100644", + "gitBlob": "10ad37bc51367b2668d4db62d9742137bf808bf6", + "rawBytes": 41, + "rawSHA256": "45AC888455EA4AEF7C2599CE38E52991800E604D3735FD45881D8D5076E41D2F" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-002.json", + "mode": "100644", + "gitBlob": "c807cc1224d160d56ce8b1e515d2d74208488eee", + "rawBytes": 1241, + "rawSHA256": "5394F7E4F5A1D46C27C17EE614DF88A1D11BF26D0F146659ADF9A1648809F8AF" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-002.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-002.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-003.json", + "mode": "100644", + "gitBlob": "f2d796683347e486320eaab9ea53a7c2f9638fac", + "rawBytes": 1240, + "rawSHA256": "3FEB84472415A73120917549B997E703DAE9358C837EE20EAE65B11B9E699BCC" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-003.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-003.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-004.json", + "mode": "100644", + "gitBlob": "b1ea73ae64931a4001ef243bb1f6dd0ff33f88df", + "rawBytes": 1502, + "rawSHA256": "327F07167F5ED5375E55C625AE25D58A33543312C0FC380304744205D44B7C32" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-004.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-004.stdout.bin", + "mode": "100644", + "gitBlob": "539328d7c4bf06ca53176deec58e39608dc48900", + "rawBytes": 68359, + "rawSHA256": "954F4354774E6571FC392A678B8CFF302A7C2F361166558BC2D5607CB400AB20" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-005.json", + "mode": "100644", + "gitBlob": "3bf9e57d67ed151b68e9dbd65fc7354acc511c98", + "rawBytes": 1236, + "rawSHA256": "234FADD2A6E97D307CF31323140CA103248AC65E393E4F0554338781DCEF1CE7" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-005.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-005.stdout.bin", + "mode": "100644", + "gitBlob": "96d856ad8ad44f4bd84f862ee5275fb3b57015a9", + "rawBytes": 24783, + "rawSHA256": "BDD50082D978815E9005EDE9C34A9757F83693806307EE766E4CCD3C8472AAEA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-006.json", + "mode": "100644", + "gitBlob": "f70587215e9239dd3e26517d07fb826e148cca9c", + "rawBytes": 1235, + "rawSHA256": "498B9A03892A1F36CC75E6DBEBEF460ED4C82C3C0FE7AFF8BFF459232CEDC431" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-006.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-006.stdout.bin", + "mode": "100644", + "gitBlob": "bd5d0eb38fd4a301eb89b027fcc434fc18dbee75", + "rawBytes": 35633, + "rawSHA256": "486420760DD5C43312DD0A0E9432771B55ADDE1953088B70597269E057A06051" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-007.json", + "mode": "100644", + "gitBlob": "fadb74d3ec95e7f56ba709a17d5f7189fbf1e441", + "rawBytes": 1245, + "rawSHA256": "7154CA8079C8403448A7B6EFE8406776CB59ACBD490D5042BEE57D033CBBE32D" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-007.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-007.stdout.bin", + "mode": "100644", + "gitBlob": "3760470717560aafc5ae4652522eff1953d001e7", + "rawBytes": 11640, + "rawSHA256": "0D1529C98D35B6FF2AC53D58D107F0A47EC8F5D263F51819C085827C055A63BB" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-008.json", + "mode": "100644", + "gitBlob": "fb526d0f2bcd6e3b39bc2dd080db88a750f09662", + "rawBytes": 1230, + "rawSHA256": "BEDFCCF8BA300D172F4D8B7DD1C2AB896E9242EA3549F5103ED567CE917EE651" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-008.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-008.stdout.bin", + "mode": "100644", + "gitBlob": "7a78c403e548df7ba7e7782ab081f08c4f4ad32b", + "rawBytes": 24706, + "rawSHA256": "6A435EFF7E3CD2A2DFEA248B3A8ABEBABAF10FF643927C5C3FCAE52E666E7CB5" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-009.json", + "mode": "100644", + "gitBlob": "6e47bd62944b951aad7a64e5eb075c70de72a0fd", + "rawBytes": 1230, + "rawSHA256": "2CD0B483698E4F475CD4B4295F6F7FE9CA694C32C69B1175888E6E5276944FA7" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-009.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-009.stdout.bin", + "mode": "100644", + "gitBlob": "4c9314d23730f318c1a4f99ca13e2156912f277b", + "rawBytes": 9090, + "rawSHA256": "0D4F03AC19F890B67894B74042FF7559ADD574A8D160539AD3565A48289BA0AE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/process.json", + "mode": "100644", + "gitBlob": "4bc6ee76be1257761e8cd6e3e340a50f28495e09", + "rawBytes": 1474, + "rawSHA256": "5CCA6C004D2FED7261FF7C53F888F07EF5E6479A77DD923C1DFE0A9FD001B36A" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/result.json", + "mode": "100644", + "gitBlob": "a644cbb5a2187a9f85aacc9690a974a412028f14", + "rawBytes": 258011, + "rawSHA256": "73163B98D940CC59DD5458A781BFEB2A47B04C1C8CCE1F2BE52CB39498A63B63" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-001.json", + "mode": "100644", + "gitBlob": "fe6da93a5c5718a1e4ef835a25b7d1afab9942b4", + "rawBytes": 1196, + "rawSHA256": "F263D627648AC4DE38976DAFBEFDE1B2B7C70E558E2DBFE915EBBE2614221EBD" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-001.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-001.stdout.bin", + "mode": "100644", + "gitBlob": "10ad37bc51367b2668d4db62d9742137bf808bf6", + "rawBytes": 41, + "rawSHA256": "45AC888455EA4AEF7C2599CE38E52991800E604D3735FD45881D8D5076E41D2F" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-002.json", + "mode": "100644", + "gitBlob": "038eca6c7025dcfb0d22c285ba074d52650cd98b", + "rawBytes": 1241, + "rawSHA256": "0FE3639B92409F748170BE0C15D143788F5F73D64FEF55DF3A3D2BAB93415D17" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-002.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-002.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-003.json", + "mode": "100644", + "gitBlob": "7c7d2953e478fc99809a25f97e3a1271ae71e044", + "rawBytes": 1241, + "rawSHA256": "0A8647ECB60F767BC30B7218E1E8656DBCBE8AB142C354DEF5ED9D3F7A805344" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-003.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-003.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-004.json", + "mode": "100644", + "gitBlob": "d4f9554aff2cee1ec249a2c99f007cdbf80dfff1", + "rawBytes": 1503, + "rawSHA256": "26220B11D8E7BE113FB02D8663BD1AC99D1D019482F12BA93DBAD7A8D776B29A" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-004.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-004.stdout.bin", + "mode": "100644", + "gitBlob": "539328d7c4bf06ca53176deec58e39608dc48900", + "rawBytes": 68359, + "rawSHA256": "954F4354774E6571FC392A678B8CFF302A7C2F361166558BC2D5607CB400AB20" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/process.json", + "mode": "100644", + "gitBlob": "97b4e44cdbba7508e7427cb61963742559e62ec3", + "rawBytes": 1759, + "rawSHA256": "900ACFC74743C61FA34EC94FCFB43D5296B06F268E3F19BAEFFA573EE4730161" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/result.json", + "mode": "100644", + "gitBlob": "d486100c8324e453c59e7cf599712528fdd7c776", + "rawBytes": 216984, + "rawSHA256": "EF852B6C574A9A6E114FEA1538D65D8E8012B1BFFEEAA8380AB1485ACD19A4AB" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-001.json", + "mode": "100644", + "gitBlob": "03180e938a23801ed2138d15b6ebde74dcd40256", + "rawBytes": 1196, + "rawSHA256": "05058DD47572C0CCE48B88E92F202C42F0069C9B2693A899C5F5EA588D819871" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-001.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-001.stdout.bin", + "mode": "100644", + "gitBlob": "10ad37bc51367b2668d4db62d9742137bf808bf6", + "rawBytes": 41, + "rawSHA256": "45AC888455EA4AEF7C2599CE38E52991800E604D3735FD45881D8D5076E41D2F" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-002.json", + "mode": "100644", + "gitBlob": "de538c568117a8ef73170f5c799013b8c545fb53", + "rawBytes": 1241, + "rawSHA256": "96AAC2C0187F3B72D3944D3303ED80128DDF67DDB0673363C020358458670D68" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-002.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-002.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-003.json", + "mode": "100644", + "gitBlob": "3092fde7ae5f7a62d9bd9b133f275c4fd356daf7", + "rawBytes": 1241, + "rawSHA256": "970BDB76CEB298D35F4D9012915AADD51C907F61DD9E0DC65C172586FE63FEA2" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-003.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-003.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-004.json", + "mode": "100644", + "gitBlob": "ce90f25e2d703979538ffb46fe1a095b21c168cd", + "rawBytes": 1502, + "rawSHA256": "5ABDA3E84133B9E13079679830B65A679DB6B2F58369CBA0B15B13605891CFF9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-004.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-004.stdout.bin", + "mode": "100644", + "gitBlob": "539328d7c4bf06ca53176deec58e39608dc48900", + "rawBytes": 68359, + "rawSHA256": "954F4354774E6571FC392A678B8CFF302A7C2F361166558BC2D5607CB400AB20" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-005.json", + "mode": "100644", + "gitBlob": "a5d30a5cb73eab77bed5d6e94e0daabc1edeb5b5", + "rawBytes": 1459, + "rawSHA256": "7EE6BEFEB85403AFF151A9F5AF706BBC9044956F1F04AD4CC63647296E6C74BD" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-005.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-005.stdout.bin", + "mode": "100644", + "gitBlob": "b135a0846eb41af84fb599df0524fc61eec6c962", + "rawBytes": 66829, + "rawSHA256": "B0D9DF27CF51042A17F4BE283545C7C19B330E25FD0FA7E2971977B483FA2F5A" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-006.json", + "mode": "100644", + "gitBlob": "03c9a522e44b3141a7bd78a66937c0e66a4ab567", + "rawBytes": 1236, + "rawSHA256": "1EE487F543901AA6E4AE0CFBFEB43908122A72B319ED61FA4BB108B233FFAA5B" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-006.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-006.stdout.bin", + "mode": "100644", + "gitBlob": "96d856ad8ad44f4bd84f862ee5275fb3b57015a9", + "rawBytes": 24783, + "rawSHA256": "BDD50082D978815E9005EDE9C34A9757F83693806307EE766E4CCD3C8472AAEA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-007.json", + "mode": "100644", + "gitBlob": "7a9ff74fd8e360585aa4119854a8ea4e9909db38", + "rawBytes": 1236, + "rawSHA256": "9FB44D74744E314E6496DA84C486D0417BA24CBD80A44CA1A2E9AD7A1933E292" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-007.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-007.stdout.bin", + "mode": "100644", + "gitBlob": "bd5d0eb38fd4a301eb89b027fcc434fc18dbee75", + "rawBytes": 35633, + "rawSHA256": "486420760DD5C43312DD0A0E9432771B55ADDE1953088B70597269E057A06051" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-008.json", + "mode": "100644", + "gitBlob": "ee3251eb690b7c907e1483d2b1c7d593d48b581a", + "rawBytes": 1246, + "rawSHA256": "F23E6A2FB34D07712EC35EA0D658ABE0F8EAD7A923A288ECB750C8A11E368980" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-008.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-008.stdout.bin", + "mode": "100644", + "gitBlob": "3760470717560aafc5ae4652522eff1953d001e7", + "rawBytes": 11640, + "rawSHA256": "0D1529C98D35B6FF2AC53D58D107F0A47EC8F5D263F51819C085827C055A63BB" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-009.json", + "mode": "100644", + "gitBlob": "94278895900c80dcb0fcc1d44aaf553e5b1cb5c2", + "rawBytes": 1230, + "rawSHA256": "4D1B21EE33DF720F5D039457F6E07A09375827017083E619C056A671C582CCBE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-009.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-009.stdout.bin", + "mode": "100644", + "gitBlob": "7a78c403e548df7ba7e7782ab081f08c4f4ad32b", + "rawBytes": 24706, + "rawSHA256": "6A435EFF7E3CD2A2DFEA248B3A8ABEBABAF10FF643927C5C3FCAE52E666E7CB5" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-010.json", + "mode": "100644", + "gitBlob": "a3110083a3bad98be3c5fc0faea6c6ec5519399f", + "rawBytes": 1228, + "rawSHA256": "70D528593521988187564ED7E1197E3C4929C48D5FF326DFB0D968707DC4BD6D" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-010.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-010.stdout.bin", + "mode": "100644", + "gitBlob": "4c9314d23730f318c1a4f99ca13e2156912f277b", + "rawBytes": 9090, + "rawSHA256": "0D4F03AC19F890B67894B74042FF7559ADD574A8D160539AD3565A48289BA0AE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-011.json", + "mode": "100644", + "gitBlob": "baa3a06251817a16f0137c0a62b82a9179058226", + "rawBytes": 1460, + "rawSHA256": "4A244FA7231A10DBD75CC11A36B75797FD96F24CF93F68800A3CDDB1BD1D2F53" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-011.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-011.stdout.bin", + "mode": "100644", + "gitBlob": "b135a0846eb41af84fb599df0524fc61eec6c962", + "rawBytes": 66829, + "rawSHA256": "B0D9DF27CF51042A17F4BE283545C7C19B330E25FD0FA7E2971977B483FA2F5A" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/process.json", + "mode": "100644", + "gitBlob": "b15e6eb932d96f9c315d8466c1c5ba24388a2f2e", + "rawBytes": 1473, + "rawSHA256": "DE01D42569F10ADA97405D0BE370CB81B14CD899CEC1D58436E4767DAF57A213" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/result.json", + "mode": "100644", + "gitBlob": "259f4b7541eed219aa31fa65385db3c7b6c2d8ca", + "rawBytes": 261488, + "rawSHA256": "CFD79D9E0CC7E4166BB9419B2CF3CD54CA3DD9767C6174BF97E084E2FD06B03E" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-001.json", + "mode": "100644", + "gitBlob": "2dbae161b1adc43134a9f69365e92425a7ec69a8", + "rawBytes": 1194, + "rawSHA256": "CA9C09ED96A4FA701B680A83E13B35681D0BFE89E400B5D38DFE508BF4CB327F" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-001.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-001.stdout.bin", + "mode": "100644", + "gitBlob": "10ad37bc51367b2668d4db62d9742137bf808bf6", + "rawBytes": 41, + "rawSHA256": "45AC888455EA4AEF7C2599CE38E52991800E604D3735FD45881D8D5076E41D2F" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-002.json", + "mode": "100644", + "gitBlob": "4bff5ebff4751d6d02e5f423332d6b94d322b338", + "rawBytes": 1241, + "rawSHA256": "B934433543CDDA36C676C3724D5053ABBA2A91324F6AFF8B8F81E301C1C7143B" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-002.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-002.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-003.json", + "mode": "100644", + "gitBlob": "726d7c940b7562dd016ee421fe58d6880649d64b", + "rawBytes": 1241, + "rawSHA256": "5DA6AB1CBA939653D41B45392A502E0A58798DCF169C98638428BFD17C264224" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-003.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-003.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-004.json", + "mode": "100644", + "gitBlob": "f63cc03e78ca6352cd9c9e11ce0b79f7836fe9b7", + "rawBytes": 1503, + "rawSHA256": "BF85F4BC78EC77F406BB6F8481E9187CAE76F6D03405B43D6E4606257DEE85C7" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-004.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-004.stdout.bin", + "mode": "100644", + "gitBlob": "539328d7c4bf06ca53176deec58e39608dc48900", + "rawBytes": 68359, + "rawSHA256": "954F4354774E6571FC392A678B8CFF302A7C2F361166558BC2D5607CB400AB20" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-005.json", + "mode": "100644", + "gitBlob": "71096ff3aafab13e8e59359ae89e8e299a35e531", + "rawBytes": 1460, + "rawSHA256": "8017AEF38B8447CB3BDA4A3C7D8CDB2D9B409FDD1338F7F0E6095B8442AC25AA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-005.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-005.stdout.bin", + "mode": "100644", + "gitBlob": "b135a0846eb41af84fb599df0524fc61eec6c962", + "rawBytes": 66829, + "rawSHA256": "B0D9DF27CF51042A17F4BE283545C7C19B330E25FD0FA7E2971977B483FA2F5A" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-006.json", + "mode": "100644", + "gitBlob": "9bd3e44ce9f5b6f829da80880603937f6feae84b", + "rawBytes": 1235, + "rawSHA256": "B8311242D14F1B40701E9DFB7907DD913ADE2D6FBFA1CC912AEB536B7738FD55" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-006.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-006.stdout.bin", + "mode": "100644", + "gitBlob": "96d856ad8ad44f4bd84f862ee5275fb3b57015a9", + "rawBytes": 24783, + "rawSHA256": "BDD50082D978815E9005EDE9C34A9757F83693806307EE766E4CCD3C8472AAEA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-007.json", + "mode": "100644", + "gitBlob": "a77c7d0260111ca3e5c3be855440cf43759f396b", + "rawBytes": 1236, + "rawSHA256": "D4414939ECFE2562919FB2546D46BEE2B0A17DBC6CD24D87EE7D48394E652D7B" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-007.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-007.stdout.bin", + "mode": "100644", + "gitBlob": "bd5d0eb38fd4a301eb89b027fcc434fc18dbee75", + "rawBytes": 35633, + "rawSHA256": "486420760DD5C43312DD0A0E9432771B55ADDE1953088B70597269E057A06051" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-008.json", + "mode": "100644", + "gitBlob": "2cc5fbd86b243ac84e2770f9798ff8103423d07f", + "rawBytes": 1246, + "rawSHA256": "945A0A9E4AA65C9C33C2234BC7CD2BA00F041BE5617E97CA60F1007087C21F7E" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-008.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-008.stdout.bin", + "mode": "100644", + "gitBlob": "3760470717560aafc5ae4652522eff1953d001e7", + "rawBytes": 11640, + "rawSHA256": "0D1529C98D35B6FF2AC53D58D107F0A47EC8F5D263F51819C085827C055A63BB" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-009.json", + "mode": "100644", + "gitBlob": "2337c5f4c2fdd0aaf1f07ac9a7d1d0edbc71f7a8", + "rawBytes": 1230, + "rawSHA256": "75512231B3F6432B8E3C1CE58196C068623E16AC7A9B764BF7244DC516CDE1E2" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-009.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-009.stdout.bin", + "mode": "100644", + "gitBlob": "7a78c403e548df7ba7e7782ab081f08c4f4ad32b", + "rawBytes": 24706, + "rawSHA256": "6A435EFF7E3CD2A2DFEA248B3A8ABEBABAF10FF643927C5C3FCAE52E666E7CB5" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-010.json", + "mode": "100644", + "gitBlob": "b89bdd93866d587bd882f11ef801d2640c64c925", + "rawBytes": 1231, + "rawSHA256": "4B894F7C03530853795F9FD6BE5156497B4390D2C36930D6857B7320D6F2EFC8" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-010.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-010.stdout.bin", + "mode": "100644", + "gitBlob": "4c9314d23730f318c1a4f99ca13e2156912f277b", + "rawBytes": 9090, + "rawSHA256": "0D4F03AC19F890B67894B74042FF7559ADD574A8D160539AD3565A48289BA0AE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-011.json", + "mode": "100644", + "gitBlob": "ab56e5d5aadb535acd1c26a1a079311c6543da3b", + "rawBytes": 1460, + "rawSHA256": "4C49720764FADFFEBB8D167F05A536429F2F6ECA2248CEEB3E7920EE6533DEDD" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-011.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-011.stdout.bin", + "mode": "100644", + "gitBlob": "b135a0846eb41af84fb599df0524fc61eec6c962", + "rawBytes": 66829, + "rawSHA256": "B0D9DF27CF51042A17F4BE283545C7C19B330E25FD0FA7E2971977B483FA2F5A" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/process.json", + "mode": "100644", + "gitBlob": "96230bc9722a4766c750e6e527272e76228effb0", + "rawBytes": 1473, + "rawSHA256": "8E4995C80EB575CA904A128BFD965AE9DE85114A4EA7F6F845A4BB04D5CD0E31" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/result.json", + "mode": "100644", + "gitBlob": "9fbf8d15b4edef2c7e0d8b750a7ca962b9e71876", + "rawBytes": 261490, + "rawSHA256": "8872D99690A49F2C3BD059DC71023A42977028E2343D564A3F5AF51CC9939485" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/profile/.gitattributes", + "mode": "100644", + "gitBlob": "9c1a2ed32bb8ec1191c5dc332ea9700fa0af5943", + "rawBytes": 561, + "rawSHA256": "6042504A00DCAA30BFEC535D61686CFE22B98065CDE695B80ECA0FC572A3CD75" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/profile/BUILD_DRIVER.ps1", + "mode": "100644", + "gitBlob": "29f3b5d558cbf037791c4a0d47bc86ac8645e215", + "rawBytes": 17548, + "rawSHA256": "A14F1205C57AC4D475C38E3D73179FC1645EAF1D5BC4962DAD9F3C42655588A9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/profile/BUILD_RECEIPT.json", + "mode": "100644", + "gitBlob": "4e79ef322c0bbd75814d28600f84f3e73a4153dd", + "rawBytes": 734327, + "rawSHA256": "EED1ECEE4A031A9C3CFCADEA445307D8E15E70E732E6FFDD5B166D135292B64E" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/profile/README.md", + "mode": "100644", + "gitBlob": "516ccfbe9dd7384e28faa97019392fc5a8ce8db4", + "rawBytes": 9888, + "rawSHA256": "30A5DEB7F03013A51B495A5D30DAC2596FC5D1FD2E94AF928506134837B3D926" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/profile/SOURCE_IDENTITY_CHECK.json", + "mode": "100644", + "gitBlob": "fd9303a2eb8162392c362688dc433f120c8164b4", + "rawBytes": 314, + "rawSHA256": "E9D16D471E46497586658D52BA6B346A5BC92AEDD306CB032DAB8B5020C7EF18" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/profile/SOURCE_PROFILE.json", + "mode": "100644", + "gitBlob": "534850c886539b9334c5d9f18fc27c257c333660", + "rawBytes": 1039454, + "rawSHA256": "B83ADA3BAA438D812DA076B48422C0A92F88CE686CD48EF982F39DE7701699C9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/profile/TOOLCHAIN_VERSION.json", + "mode": "100644", + "gitBlob": "50bb8de202db60474638d4b75ff9c78ede1eaa59", + "rawBytes": 886, + "rawSHA256": "5ECAF07FB8A1B0F081A4321DD4CBA3133E63728FDB86AA217A664118C91577A7" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/profile/TOOLCHAIN_VERSION_CHECK.json", + "mode": "100644", + "gitBlob": "ef0fd251048ef2d504afc98272f22416ab708feb", + "rawBytes": 707, + "rawSHA256": "BC0D11B70E3FA7593FFFF29195C5A17037CDFE63DF153C64733B979C79FF805C" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/provenance-reproduction/checkout.json", + "mode": "100644", + "gitBlob": "2cc14c6b87f66620819b087deb05ed357b4e9a99", + "rawBytes": 491, + "rawSHA256": "AC677628EECE057C583F55D417F317AB391FC8B6500CD19DACAF788C5B7C4FE9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/provenance-reproduction/fetch.json", + "mode": "100644", + "gitBlob": "81c39e82ccaefd9632ad91de3357a8fd73e193bc", + "rawBytes": 572, + "rawSHA256": "F2AA7C343D3AD3E3E45D7B00E06D886427CAAF07BD809F21601F637CCCE22334" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/provenance-reproduction/init.json", + "mode": "100644", + "gitBlob": "0fce03eb91321b2c00dd181da264f832dd8bee9d", + "rawBytes": 491, + "rawSHA256": "DEE455B1F90954840C3BE3EC2131B37B18005E90D22E2E6330473D92C4947FDE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/provenance-reproduction/lf-profile.json", + "mode": "100644", + "gitBlob": "9c2391ce6bc7cccb4ebebc0b97872f2aa29f28a6", + "rawBytes": 285, + "rawSHA256": "E410DC3BD06794B8180FE9E5632181BD983DB090D8EEBB4F2B40014EC42F7C7D" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/provenance-reproduction/raw-library.json", + "mode": "100644", + "gitBlob": "be321df155fa52e964f12c0712b5febace21d644", + "rawBytes": 1430, + "rawSHA256": "569FC9CF918FA6A60DE36833BC2176D8A71821FE42C1DA12716425BB76F0794F" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/provenance-reproduction/restored-status.json", + "mode": "100644", + "gitBlob": "213b3bcc02ef6fdbf876fe45bdf35ee6102245d5", + "rawBytes": 290, + "rawSHA256": "489F9B6F20997E320B1051E3F4578B3890BC2BFFED155E9880CFD448FDE6C182" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/provenance-reproduction/source-artifact-pins.json", + "mode": "100644", + "gitBlob": "f38ef492a422ae143705175071a868f1422fcc86", + "rawBytes": 118279, + "rawSHA256": "3A3110C60B0906257A170EE6BC550A6A3E0F4CD5BD38D414F64ECDB7DFF9EF30" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/provenance-reproduction/summary.json", + "mode": "100644", + "gitBlob": "9b2b8590f7b32086138f8a40a104007b571e5ee8", + "rawBytes": 482, + "rawSHA256": "3D03746CFB268606C17E1B825F1F3C2404037F9D7D749C82870EB8A0EC5E41FA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/run-command.ps1", + "mode": "100644", + "gitBlob": "f5bfabd18940cc46407f603ea039be670cb0dfd2", + "rawBytes": 6015, + "rawSHA256": "4E9CEFA6709720F672D0C0337297B83FC33E1FFCD9963A62CE72202322AEE0A4" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/.gitattributes", + "mode": "100644", + "gitBlob": "3ca7a684bfd3f7e00ec198867b1dc20668667b44", + "rawBytes": 1093, + "rawSHA256": "CB6F85C6781E7980C8F5C74AAA713F1ED5B5E69A58AA49C75AC2ACE88B7CB623" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/README.md", + "mode": "100644", + "gitBlob": "1e462cdfd300b5acff35bed3fbbda9f71e1763e9", + "rawBytes": 6183, + "rawSHA256": "630C124E87DDA7FB7A7AEA54CABF4C7C20EE50261553618EFF4F9297242CE564" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/REGISTRY.json", + "mode": "100644", + "gitBlob": "4621407c3ba15dc31ca86da6768c8d421b3f7442", + "rawBytes": 12444, + "rawSHA256": "35DEE68D8EFBB972FB35276BC03B1EC18071048D83E0BFAC0334DAA9364ADE4D" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/RESULTS.md", + "mode": "100644", + "gitBlob": "bdb7379bd2cbde3fb342aa3e796e5dfba2ccd8d0", + "rawBytes": 7535, + "rawSHA256": "A32D6A4EAC4ECE606A873B48A7D5D5072526104391089326411430FEBD03BD19" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/evidence/development-full-1.json", + "mode": "100644", + "gitBlob": "d49f4a0c97394c9f9dc17f6bbbb8140f75702bf9", + "rawBytes": 60410, + "rawSHA256": "42758D526392FD5EA923807FF9CC4561A07F82A860E25A491A4ED963DD3B2AF9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/evidence/development-overflow-failure.json", + "mode": "100644", + "gitBlob": "be46acc610c59fa2c89d08f58de833e0f62d7759", + "rawBytes": 1777, + "rawSHA256": "DCF039BC5EAEFA0FB00BD453D41FC83B415E8841A3F32D9F1BA2A03917EB1292" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/evidence/final-runtime-repair.json", + "mode": "100644", + "gitBlob": "040568c918d866c9da0fd07b2d270a766d4a4fa3", + "rawBytes": 88913, + "rawSHA256": "D53853E373DFD04500BC4F1842C3AEFEB92ADADBAF74FA4161D648A4406594AD" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/evidence/final-runtime-wrapper.json", + "mode": "100644", + "gitBlob": "27a3669982b2f201d0657d96e12d642a039e4c40", + "rawBytes": 7981, + "rawSHA256": "EBE14AE1CA6979D897B90CB1EC3C47ED51F2F89F2A4F0011696B5626BCA77F8C" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/evidence/frozen-raw-reproduction.json", + "mode": "100644", + "gitBlob": "bca6df58c4364d6558eec1433245d2e9e267a872", + "rawBytes": 3291, + "rawSHA256": "B132C2A76400AA98C723C9962D9CCD020F43C1C1A3FF9D5B1E5437B85EA1DAFF" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/frozen-reproduction/RESULT.json", + "mode": "100644", + "gitBlob": "f8d5d8528b873b5502c57051ac6a143ead8bea70", + "rawBytes": 2685, + "rawSHA256": "739CED2CBE0A8EED869B7EF941E55CD42D315A7BB416D03789FA5C201D9F9458" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/frozen-reproduction/mixed-streams.ps1", + "mode": "100644", + "gitBlob": "fed74d73245fce35619ba4780f76eb81ef8a2572", + "rawBytes": 180, + "rawSHA256": "4EC6115EB4F44000A09C073E697FBE3A106FD125C1E94CF2EBEDE24152063574" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/frozen-reproduction/sole-expected.ps1", + "mode": "100644", + "gitBlob": "90977fdd0d84c21b00ed4cd7bf8c7738bb44e5e6", + "rawBytes": 97, + "rawSHA256": "4A4FD004E3979A1F2D05E0B0C3C33BCA0AF2E9C00DCAA24020E59A805476FAFA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/frozen-reproduction/unrelated-only.ps1", + "mode": "100644", + "gitBlob": "118f8c5a1bb19e2eb3c4acf13b57d5a95b6a2ab4", + "rawBytes": 91, + "rawSHA256": "957CF83AD76BFD0CE34D86090F3D8704B353A81023A7691CC8F93D01CC1ABB39" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/replay.ps1", + "mode": "100644", + "gitBlob": "14868ae0d9ea940db1af11edaddfaa3d92f59066", + "rawBytes": 19726, + "rawSHA256": "77511FC8F0013CD839599E80AC192CCBADB2733DC925286FA788956B191A1077" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/reproduce-frozen.ps1", + "mode": "100644", + "gitBlob": "31f765d6ba6be396196274617f1b091245112f07", + "rawBytes": 4677, + "rawSHA256": "85353A39ED6353E571076A66A41DE9471F285D3725B4F0C0D9B741BF46C3A857" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/review/PARENT_SCRIPT_BEFORE.ps1", + "mode": "100644", + "gitBlob": "6aa6f7536e0e23b505673f8c175f4ba5fe39261c", + "rawBytes": 16561, + "rawSHA256": "9F52C599FEE4B7BEE683BA9A87156A028959E37339AFA7AD8E430D04517C71FD" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/review/README.md", + "mode": "100644", + "gitBlob": "bf136b7080919af995047d57a1e7447c43170337", + "rawBytes": 4499, + "rawSHA256": "AA8A040BC344F542769C34A6C38EB7E76304113AD2D0D63573A586D5C42887B9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/review/RESULT.json", + "mode": "100644", + "gitBlob": "be6f67caad2f986a0866f223832baaf6c6e2cd0e", + "rawBytes": 2738, + "rawSHA256": "6B94BC821130EADDEA08C8818A0A0B485B6610AC6E9E799397DDB346BD555231" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/review/fixed-controls.json", + "mode": "100644", + "gitBlob": "36d3e2c6794517acdfe67b0d79eb07648335c6ff", + "rawBytes": 27889, + "rawSHA256": "3EB4611C50E28C0708986C2ABA87679CFEEC20BCAB4B1E00CB4921648BB41FFF" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/review/mixed-success-stdout.ps1", + "mode": "100644", + "gitBlob": "3414697777ef5b6a5ed141231a1d5f606bf22542", + "rawBytes": 239, + "rawSHA256": "0A30A82FDD1D7FCFF0D2A7E14F5D2C1CE1EA09FF25277FDC607F394DB779CE5B" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/review/mixed-unrelated-stdout.ps1", + "mode": "100644", + "gitBlob": "e67db033990296be5b418e10035c5fed50b4a5ce", + "rawBytes": 211, + "rawSHA256": "75FA54CFBA3824C3E2063A70C777BE87B097F47C8A243F8EFD587CF7D4288608" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/review/replay.ps1", + "mode": "100644", + "gitBlob": "7ffd775d5460c15f149853b845484a195f8d2c74", + "rawBytes": 2664, + "rawSHA256": "EA33E00E5C1D83C615DFBE98553D39997EA3492B0A3F8EEB2D320647732E7F79" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/review/run-fixed-controls.ps1", + "mode": "100644", + "gitBlob": "d1634201f68a62db6b8f03a204f52bd2da131ac3", + "rawBytes": 3313, + "rawSHA256": "288951C138DF0B5D44836BE09F42976586AC2102DC55D2C7C82B47C1BD6F82D7" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/review/sole-expected.ps1", + "mode": "100644", + "gitBlob": "d0c293d1099a538e3a7487df3df3523b9f9793f9", + "rawBytes": 128, + "rawSHA256": "1D479AAE3FA4775CB3CEB928FEDCD4F3A8AD5CF9B43D8A2807BEC7DB1CBB8265" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/run-bounded.ps1", + "mode": "100644", + "gitBlob": "89f07d3640a4c3259645430bff26e6172dc80b09", + "rawBytes": 2424, + "rawSHA256": "1CC0A634394749CB56000A03C15C805D3A209EF8AE9D4284E6A0295871B111CC" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/.gitattributes", + "mode": "100644", + "gitBlob": "40ffcb2e7b5576390e868bc926fd7b2d90f8fe06", + "rawBytes": 718, + "rawSHA256": "CB9ED8254A683519B59A24842AA1F928677CB4BC790A0B21CB0961011D6324FA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "a291d46d5ad592ec1b215dc31d59d38883a05a10", + "rawBytes": 33574, + "rawSHA256": "A1C1912126AB17D2B11B6A900F445CCB5832F815529756D5BCA89B4CE1397DCF" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/RECEIPT_ARCHIVES.json", + "mode": "100644", + "gitBlob": "341989ae42a368d142ffe83c70e4b8f7112ff7f4", + "rawBytes": 9954, + "rawSHA256": "BB808AB761F6136215B361AB93E7405843040ADB8D6BCBBAE963CDC6B0F15492" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/REPORT.md", + "mode": "100644", + "gitBlob": "0e5bdc9b6fae2ac7c3d5f0e610ca616b0e9c27a7", + "rawBytes": 46596, + "rawSHA256": "6934D5AE549A055954D4D7038FC34228810742B5A54B0C39B4847888E8431032" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/preservation/check_relocated.ps1", + "mode": "100644", + "gitBlob": "85be19e39057c10b88146e0d234422064534a1a0", + "rawBytes": 7097, + "rawSHA256": "8F3E53880AF81CF6AF3B3F325043F924632923ECD969B8EDD309C53B419D891F" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/preservation/check_relocated.py", + "mode": "100644", + "gitBlob": "258d37c02a4105c29fade62d9f45f18be182d562", + "rawBytes": 29354, + "rawSHA256": "DA0DC413F1AF56727F5E009A79DF115D4933272854DC17967F15879020D2060C" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/preservation/relocation_controls.json", + "mode": "100644", + "gitBlob": "ab9776919c6579a556a08fcd4d93a4482520f4f3", + "rawBytes": 978, + "rawSHA256": "D0DE6D0B68CC7334054210432AB0B40A6E3995DDA5400A8D2423E4DA64C2DB6E" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/receipt_archive_control_helper.py", + "mode": "100644", + "gitBlob": "5b81f42c7f92ac99f2454f44991b35a7a31634d3", + "rawBytes": 6180, + "rawSHA256": "EFC3775D6B8C55E85F7AC4CE52865B6AAB5B50A79FFCF52A66CCC39D2A301CEE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/receipt_archive_controls.json", + "mode": "100644", + "gitBlob": "058f480d94432b649731b6e0c147b45d86922698", + "rawBytes": 3790, + "rawSHA256": "69FF8EB23D710A0134C408D2029A177CA6D73E64E1EA9F63895EF3566BDFA447" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/receipts/checks-3b82967.json", + "mode": "100644", + "gitBlob": "4527767b88522e949fe54bccec74076f3fd25b95", + "rawBytes": 24593, + "rawSHA256": "17376CCF3323C3BA18811E4A409C0A694EF16CC8C2F727523931152A7429C77E" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/receipts/controls-3b82967.json", + "mode": "100644", + "gitBlob": "9599082670bc8b3e82854aec89d4fbf2c31db71b", + "rawBytes": 30154, + "rawSHA256": "4B75CBA83529F84DE99C01CEE166AE9D76D9C0476D5BB9B34D94FD7872D3823A" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/receipts/preservation-3b82967.json", + "mode": "100644", + "gitBlob": "8576e46804b57889fa160252fcd70ff3050f8796", + "rawBytes": 51499, + "rawSHA256": "85986D1BAF47272D971E2658C0F7A5ED84664F5AAAF4DB16D3C04C72DC85532D" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/receipts/scan-base-4cc9501.json", + "mode": "100644", + "gitBlob": "682f8b3eb7eb5ab66f03c3b6e63511f033eb725a", + "rawBytes": 20267, + "rawSHA256": "C288B9DF8342F77D141637B48E0CF93E88AAD716D4F535BBBA9BB929AC2AADDF" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/receipts/scan-repaired-3b82967.json", + "mode": "100644", + "gitBlob": "3f82b3a5ec424418a2bc55c880dbf6fd1b5512f1", + "rawBytes": 6099, + "rawSHA256": "E09229DAF12E45186BDA4659D3AB18E838A1086CB1694F05833E53ADA190B782" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/run_receipt_archive_controls.ps1", + "mode": "100644", + "gitBlob": "d2328ae593630279aeb142a9c5dcaaa2baf81818", + "rawBytes": 17574, + "rawSHA256": "1C247F13FEC0EA2C1CEAACC3B57E76039F1EFD747000FA520CED2E0DBDF067AF" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/verify_receipt_archives.py", + "mode": "100644", + "gitBlob": "5507db6f73d57b7eafd1a8468762e3077ea329b3", + "rawBytes": 27132, + "rawSHA256": "01C91E8FCDD25B57430369420A1C359132D06D6F484522B4E3CBA70DBD63E367" + }, + { + "path": "docs/internal/extensions/opt1/replay-source-manifest.json", + "mode": "100644", + "gitBlob": "241c66d5fe7fec1b8391c0c52653b24616d8d744", + "rawBytes": 4649, + "rawSHA256": "ABF64C86D32412386978AA788CA92D9D1B0FE36418C626E4F05BACAC0542B22C" + }, + { + "path": "docs/internal/extensions/opt1/root-composition-plan.json", + "mode": "100644", + "gitBlob": "529a00fc1a24439189d1ba1d1faf4277715ed9ba", + "rawBytes": 239, + "rawSHA256": "1D5D04AEDF782FC9412FDFE7955816C11DEBD8595541469D3465EBE9A3EC9F3D" + }, + { + "path": "docs/internal/extensions/opt1/runtime-prerequisites-plan.json", + "mode": "100644", + "gitBlob": "5aab8ad094734756b0c3b4bd086c500a4ab665aa", + "rawBytes": 44, + "rawSHA256": "11230E0E01FAA36D958A9C5B85A373F24DFBE290A804BB395A73E766C1D0EC81" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/REGISTRY.md", + "mode": "100644", + "gitBlob": "7c38145bbed1a4e12c7c4758d6f1898129e9dec4", + "rawBytes": 4943, + "rawSHA256": "94FBB20F078EEAF8C199B85F74B34E9C0293AAD7DECF1AE7F5E9FCF36B940AF5" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/REPORT.md", + "mode": "100644", + "gitBlob": "a6fcc6987c8c61141236fc8a46399d4e45644c13", + "rawBytes": 19773, + "rawSHA256": "92ADB83CED48B409325BB472A0A3C61FE9506B3F6B8285DE65ACED408A2A7CD6" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/checked-source-hashes.json", + "mode": "100644", + "gitBlob": "95345551dd393c7a69ef8f05e264d81df2366e9d", + "rawBytes": 600, + "rawSHA256": "C14708FC3FA9D661CF0B597B722082225E0C8AE9FF0E72EB669B4957792A916F" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/continuation-source-hashes.json", + "mode": "100644", + "gitBlob": "91b4c0c3eaf36b3b58076ea62cd78f2ebf904924", + "rawBytes": 621, + "rawSHA256": "066A84597BF6348C7C0A9E52A4EDD98CA79B3B16B2CD0010A537E63A0035CDE0" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/deadline-covered.json", + "mode": "100644", + "gitBlob": "e54ef17c1ad3abb0e4b80c79a9f3b9c58960e0ef", + "rawBytes": 3927, + "rawSHA256": "AF19867B3CC67C3E7890501DF9C2494938231CE0FE77EA1B6BB04472025991FE" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/deadline-first-uncovered.json", + "mode": "100644", + "gitBlob": "a66c0ea8c7e6da6e762bfb4c773dfb12a155c7ae", + "rawBytes": 3788, + "rawSHA256": "9401B78D769A2639E621A1C42E1782D7512741635037B97D803B62292EEBB73D" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/deadline-host-coverage.json", + "mode": "100644", + "gitBlob": "1a459a445c0dbf300d17c6179e346249be15c0d2", + "rawBytes": 182, + "rawSHA256": "AE2927746B6835BD0E721E29F11676CA807DC52F65228987AB1A6214AC43A0F8" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/full-runtime.json", + "mode": "100644", + "gitBlob": "67dad1cc6085f41f481068284641cb7c0ef627a7", + "rawBytes": 510115, + "rawSHA256": "A7EB5831A88A7431607D5FE1D7189318D41978391E0A10BE3ED336C014563661" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/interrupted-before-full.json", + "mode": "100644", + "gitBlob": "af87864beaaa33e6d72adb19794db618ea63c55a", + "rawBytes": 1784, + "rawSHA256": "D76BD74773B5B40518C57B5B611CD13D2CB0581DA38E70BD588561A39B100C6E" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/powershell7-selector.json", + "mode": "100644", + "gitBlob": "6c74400005a50aaf606d8006f26da98712012d9b", + "rawBytes": 23413, + "rawSHA256": "B399B5193D9E0F6D828BA55FDD9ECA15322A116D1066F7557C3DFD25D272930A" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/startup-checked.json", + "mode": "100644", + "gitBlob": "2211f10a0ff7401ceab0b01b6d56de83977adb32", + "rawBytes": 173188, + "rawSHA256": "AE128EFA28AB54EFFA1B9381C3E04B9F17F11081716675169B5474959E759DDC" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/windows-powershell-selector.json", + "mode": "100644", + "gitBlob": "63910c48bf30f005f34ecbd38ea1fb54a6c706dd", + "rawBytes": 44302, + "rawSHA256": "0946A0FE7E5B8B2DFCA5CA76F31863A43EE55694B6A771C90B3B4EF4B9A3DD15" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/kernel-attempt-1/RMQ.Validation.PackedOptimized.20260912T0911577149359Z.json", + "mode": "100644", + "gitBlob": "b9951a6dbf679edc3b9fe24354189bf4bc395005", + "rawBytes": 7143, + "rawSHA256": "C618620A957F8DE205A5A90B8F9C6727A6060982C491AC2F276B2F2118AE99FF" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/kernel-attempt-1/RMQ.Validation.PackedOptimized.json", + "mode": "100644", + "gitBlob": "b9951a6dbf679edc3b9fe24354189bf4bc395005", + "rawBytes": 7143, + "rawSHA256": "C618620A957F8DE205A5A90B8F9C6727A6060982C491AC2F276B2F2118AE99FF" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/kernel-attempt-2/RMQ.Validation.PackedOptimized.20260912T0913380735403Z.json", + "mode": "100644", + "gitBlob": "d0924b767ab8560b3d1a536b05323bfd70ffcd43", + "rawBytes": 1388, + "rawSHA256": "90C4C951DC62E99661F255AFF1CA71F359290F5E14384D045ED20B42FEC4CE2E" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/kernel-attempt-2/RMQ.Validation.PackedOptimized.json", + "mode": "100644", + "gitBlob": "d0924b767ab8560b3d1a536b05323bfd70ffcd43", + "rawBytes": 1388, + "rawSHA256": "90C4C951DC62E99661F255AFF1CA71F359290F5E14384D045ED20B42FEC4CE2E" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/validator-plan.json", + "mode": "100644", + "gitBlob": "406737c81b76ae41769f20c86e4dae990d8314bb", + "rawBytes": 36, + "rawSHA256": "2BABC5547271A4A23A78A8186CD80A68FD8E4B4962FD5346E5C27C2582134AB1" + }, + { + "path": "docs/internal/extensions/pre1/.gitattributes", + "mode": "100644", + "gitBlob": "9bd69dd96a4e84d257b6d97cc197fa0215573443", + "rawBytes": 129, + "rawSHA256": "CA36DC03D28B9591E3D97BD76E0EF1F8A3A3584A04CEDA79B27CDB55AB571607" + }, + { + "path": "docs/internal/extensions/pre1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "166a048000d4f5de9d19b7a3bd9f1a3f270efae1", + "rawBytes": 126306, + "rawSHA256": "7B0488CAF93553AD801B5F801D6E9E61871BF5D224E8CBF906D413844D3BA057" + }, + { + "path": "docs/internal/extensions/pre1/AMENDMENTS.md", + "mode": "100644", + "gitBlob": "f459e88d92950b240864495184ce9e1a6ebc83ab", + "rawBytes": 34078, + "rawSHA256": "5875B3C6B8F243321BB0A8F3FD9ABBF3E75F6387F1EEBFDB6936DC04B3882D7C" + }, + { + "path": "docs/internal/extensions/pre1/ATTACK_TABLE.md", + "mode": "100644", + "gitBlob": "7b840ab8964a67ef026cd8150cd68c8e330bce22", + "rawBytes": 8212, + "rawSHA256": "1B8BCCD323C6E80B4A6F15B18305C357435B8C83BFAAE5DA1ABDB2BE915DC3E7" + }, + { + "path": "docs/internal/extensions/pre1/BUILDER_PLAN.md", + "mode": "100644", + "gitBlob": "1bbde52be65889ef6b59cd3a4b0745521152ea89", + "rawBytes": 69280, + "rawSHA256": "5DDEA33280CA08DB590BA847F5210D0317425CDC8EF191836EB28F255D8C0ECA" + }, + { + "path": "docs/internal/extensions/pre1/BUILDER_REPLAY_DESIGN.md", + "mode": "100644", + "gitBlob": "0dc145c0768dc0ea19d63f6aea06997da096066b", + "rawBytes": 33478, + "rawSHA256": "2D335C81AF45E7FD207D07B22FDF2C50E0FE0933FA471DC6ED2977E6FBBC62C3" + }, + { + "path": "docs/internal/extensions/pre1/BUILDER_STAGE_LOG.md", + "mode": "100644", + "gitBlob": "4b140e76af38d4ad665a7670347bb4856940b315", + "rawBytes": 127416, + "rawSHA256": "FCAE86DCAD1FCBAFE0153251926D8B4608C4B30575E00999AED4BD2737ABB132" + }, + { + "path": "docs/internal/extensions/pre1/CONTRACT.md", + "mode": "100644", + "gitBlob": "58c2c69883a45a5f6ea81346ed1121e46a8d13a7", + "rawBytes": 50947, + "rawSHA256": "3DBE6E8C3DA5191C12D193113A8A2303CB2285D393EDCA95613D968E3FAF1F94" + }, + { + "path": "docs/internal/extensions/pre1/REPLAY_DESIGN.md", + "mode": "100644", + "gitBlob": "8af8542a322febda78710e424dc231f666da4463", + "rawBytes": 10951, + "rawSHA256": "6021056C4D80F73A8FAC162CBAF5C3FD307D4F9486274B5AF17394A463B86EB2" + }, + { + "path": "docs/internal/extensions/pre1/REPORT.md", + "mode": "100644", + "gitBlob": "a4f0104aabdd452b9459d3baeff64542c976930c", + "rawBytes": 150971, + "rawSHA256": "663F25A0637187A49EF1F2E9AA50713ECB5B9894AD50E8C0E7A9F47153397A49" + }, + { + "path": "docs/internal/extensions/pre1/SOURCE_FACTS.md", + "mode": "100644", + "gitBlob": "c4191dc06dd86b4571809bd0cbf30f34233707dc", + "rawBytes": 6006, + "rawSHA256": "49F6589F23D197D443780152A45498310A87D2B7E04A166F2D6F3E683F988473" + }, + { + "path": "docs/internal/extensions/pre1/builder_cases.json", + "mode": "100644", + "gitBlob": "45778d8177bd746d85a7ef93d75e4b22281573c4", + "rawBytes": 87144, + "rawSHA256": "911ED51BC30F2260508000D6C6E892C840D80AFBBA0233610559289861E1C931" + }, + { + "path": "docs/internal/extensions/pre1/builder_manifest.json", + "mode": "100644", + "gitBlob": "cdb685ca943f38b9a727559677290b8794e4b2fe", + "rawBytes": 3016, + "rawSHA256": "2D860BF6B6DD4CBDD6E1147B3A66C738926B17FB01C833C8E754118AB641FBEF" + }, + { + "path": "docs/internal/extensions/pre1/contract_cases.json", + "mode": "100644", + "gitBlob": "8c95728686e569aaec1f0cfeb7d94c66b3208f6a", + "rawBytes": 19219, + "rawSHA256": "85EAFFCD86E95C0F8468A76596C1153BB0A6B986F5B3A977B40926E1776E6C97" + }, + { + "path": "docs/internal/extensions/pre1/evidence/Input-check-r2.json", + "mode": "100644", + "gitBlob": "1ce8161e1180f97ceaadfcf6bfe5050024b9d0f4", + "rawBytes": 3580, + "rawSHA256": "385D256E603DC4523CE54760B940237FFA831613104B7EA92A4CA2722A657D5C" + }, + { + "path": "docs/internal/extensions/pre1/evidence/Primitive-check-r2.json", + "mode": "100644", + "gitBlob": "145f5347cae99d2b89426200d17a455835f9d916", + "rawBytes": 505, + "rawSHA256": "947223783505D60BEC7460D42AFF9870BFF6426C568879825CD39BBAAEB24994" + }, + { + "path": "docs/internal/extensions/pre1/evidence/Primitive-check.json", + "mode": "100644", + "gitBlob": "61268f60c97cbab020db7d3efdddd95246693c13", + "rawBytes": 5381, + "rawSHA256": "0EF34FD60E6C9789F985EB6D46662571CF3425334D21845903C5E7196DDC3ECA" + }, + { + "path": "docs/internal/extensions/pre1/evidence/REPLAY_INDEX.json", + "mode": "100644", + "gitBlob": "f3311e1f8a5dec9c948c51990eac93af253699f1", + "rawBytes": 6022, + "rawSHA256": "DF45ABB5B7DA9C40A5FBF644629635BA9C47E5DCDDAB82046038B81744D454F2" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.Shape-check-r5.json", + "mode": "100644", + "gitBlob": "fd07d65ee4232dff9e8f0427feabce86e6edc647", + "rawBytes": 1032, + "rawSHA256": "F07E6B06D4EAF8FB26B22F3C804B2C48356E6B286C6D906CEF61D1F8D69561C1" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Conservative-check-r7.json", + "mode": "100644", + "gitBlob": "921fecb764dc00d75be5ad329086c971d91aed00", + "rawBytes": 23787, + "rawSHA256": "3F59B240F66B9CFF9B5BBF1C2FF8D909DA621F3D42E5F248B9FEFD34C2D04275" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Conservative-check-r8.json", + "mode": "100644", + "gitBlob": "c4c410542a5019fd38a6272de21ac3db313c2dcb", + "rawBytes": 543, + "rawSHA256": "E600FC324D19772FEE89191D172B1722782E2102A1FD87BD870FE943A57A58DC" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Contract-check-r7.json", + "mode": "100644", + "gitBlob": "409bfd8ae07316e6c2ea09fea82c48046faec24c", + "rawBytes": 535, + "rawSHA256": "7981F8035FB3C9C17E28A72CC817328BF8DBEAEBBF72559D4A2AEE185C315EAA" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Contract-check-r8.json", + "mode": "100644", + "gitBlob": "3833a903877b8765fb3d925ba1f7e252eea7d038", + "rawBytes": 535, + "rawSHA256": "BD46CA11D154BF1972AA106223826D67ACA2F6432E0F0642057E451855476B41" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Controls-check-r5.json", + "mode": "100644", + "gitBlob": "e694c4b4abbb080b3584ff6153d8d7a335fb4d19", + "rawBytes": 7322, + "rawSHA256": "E994AF2080EE1B338ED8EFC77FE2BE471C72196CEF398602370C84661FD2DF1A" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Controls-check-r6.json", + "mode": "100644", + "gitBlob": "8a24e611f4c1aa94c4158e918b4c4a814954acd0", + "rawBytes": 5869, + "rawSHA256": "83A1F1C000119AFDEC2BC18BBE82D5368B887AD1395306BAECCEA1EBB4CE706B" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Controls-check-r7.json", + "mode": "100644", + "gitBlob": "310d9b0595c2a4b17e6099c0cd7b245d0ca94658", + "rawBytes": 535, + "rawSHA256": "344F3720E08B8FC7680FC3DABCA5F9126EDAEDD109D8C55023889265DCFA6451" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Controls-check-r8.json", + "mode": "100644", + "gitBlob": "05936c9748bccaa41e286eafbd90957570c54f4c", + "rawBytes": 535, + "rawSHA256": "957F992257F990286C0FFFBC8AAC708A130C8BE6AF937E726059B66CC9948A11" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Input-check-r3.json", + "mode": "100644", + "gitBlob": "c7960fda818a7aa9d6ea8bec2ac3ef73eff87168", + "rawBytes": 522, + "rawSHA256": "F7C7CC2F0253D6AA6284FC3008E595159FC91EFEF845D1823119FEDB40D24617" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Model-check-r3.json", + "mode": "100644", + "gitBlob": "eb2952ab38f7936824b0e8d2aa5686c76d8b0310", + "rawBytes": 3999, + "rawSHA256": "212EF834BD2C34F18493531AFB1EDB20A49C7A9967E0BF987B7F413DAFA935B2" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Model-check-r4.json", + "mode": "100644", + "gitBlob": "47e7faad6a5ee35186c45bc8e9e62c42a9eafa97", + "rawBytes": 2911, + "rawSHA256": "7E3AE7F940AB52D5DCE2399FC26CFF44E52896AEF15D39F8E1708DCA25F68BC1" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Model-check-r5.json", + "mode": "100644", + "gitBlob": "11c125cce63e05a4788cb6e25a99946f99586472", + "rawBytes": 523, + "rawSHA256": "5191770DF1A5C982F7961BDC0C2AB3F7B07E2F0B3CAA0D76098E21E7441B3955" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Model-check-r8.json", + "mode": "100644", + "gitBlob": "fd84d6013dd8eda8d3be159e8d96bf35bebdebb3", + "rawBytes": 522, + "rawSHA256": "8F84CCC5915B9B4FE36836006B68C1DC4E4A9D24E0CE9FEA09608ADCD5A808E0" + }, + { + "path": "docs/internal/extensions/pre1/evidence/aggregate-gate.zip", + "mode": "100644", + "gitBlob": "9e82dbabd5ac1a28d0dd4f862f11346a25165bf6", + "rawBytes": 2488373, + "rawSHA256": "E701983375FB3D632A01FFAD26DAE2BE3E38CB9BD990EE9791F05D924269192B" + }, + { + "path": "docs/internal/extensions/pre1/evidence/aggregate-summary.json", + "mode": "100644", + "gitBlob": "57a201ba96ee1dc8fca83487ebd6f12cad0f7446", + "rawBytes": 5123, + "rawSHA256": "6BB95BC989398EC71E403DF4F06E94A0FCA6A74126A1C25864CD62D80490491A" + }, + { + "path": "docs/internal/extensions/pre1/evidence/archive-integrity.json", + "mode": "100644", + "gitBlob": "2febfd154e47ad41a7999b36669222439554bdb8", + "rawBytes": 5873, + "rawSHA256": "C92CE6C0578C96CCAA9D47166D11FBC30D8F6C36049078B595073C7974E46037" + }, + { + "path": "docs/internal/extensions/pre1/evidence/audit-archive/2026-09-12_PRE1_contract_fresh_blind.md.gz", + "mode": "100644", + "gitBlob": "066ab81ff6387a8cf342e7799a729aee4d5ec1bb", + "rawBytes": 33919, + "rawSHA256": "E8F77103CE5AB4E15734AF6E09564D3FE8A6BDA8C2463C2776471E8A02D0FDBD" + }, + { + "path": "docs/internal/extensions/pre1/evidence/author-final-checks-summary.json.gz", + "mode": "100644", + "gitBlob": "8cf2fa3e8dbc7b784ec1a974a0a3162cfc535041", + "rawBytes": 1199, + "rawSHA256": "DB44F7AC0D2DBFE58CAB93CCF20B0BF1ABD14B71625C458AC72F66822FD45E39" + }, + { + "path": "docs/internal/extensions/pre1/evidence/author-final-checks.zip", + "mode": "100644", + "gitBlob": "ef7e51eb73cfbb60e14543b690c3b2ae42415fe4", + "rawBytes": 2332193, + "rawSHA256": "34D9F499033F67EB0373537B372AE63F6A5116FBE27B0A7547D40ACEBBF1424C" + }, + { + "path": "docs/internal/extensions/pre1/evidence/deadline-margin-check.zip", + "mode": "100644", + "gitBlob": "22caa734160e214ee78da049b330bb6a3ca5ba1a", + "rawBytes": 3398, + "rawSHA256": "58564BF8B345A85E942BF0F3F6744F697EEA934B354CF22E4ADA0E8040D50084" + }, + { + "path": "docs/internal/extensions/pre1/evidence/final-evidence-summary.json", + "mode": "100644", + "gitBlob": "346ad868efdf8c01a5350e3a1a53e35c493eed24", + "rawBytes": 11588, + "rawSHA256": "629D98184381F0D538A92DC7B8C28B6168D7BC79E01519464262F19A941D1BD8" + }, + { + "path": "docs/internal/extensions/pre1/evidence/focused-C01.zip", + "mode": "100644", + "gitBlob": "d3920cd184c1a5e320b614be5ddb115a6a323731", + "rawBytes": 51920, + "rawSHA256": "4A57AA1F63F36ACD9DAFCB4C843CA8D468AA9270939D8C3CD0ACEA6A7E04BD71" + }, + { + "path": "docs/internal/extensions/pre1/evidence/gate-failure-diagnostics.zip", + "mode": "100644", + "gitBlob": "b04dcf140b4edaccbe11f4e1a8abeb593660a46e", + "rawBytes": 5240, + "rawSHA256": "A709586842FA18AE57F3CD87999E677DBB1AA90DCAD7CB5B47CD2AA0B5C09D58" + }, + { + "path": "docs/internal/extensions/pre1/evidence/initial-build.json", + "mode": "100644", + "gitBlob": "9aa00707d027f76c92bf9edaa11cea811b3bdb24", + "rawBytes": 671, + "rawSHA256": "B26C8250CB2B0B2DC8A33DB12C15BE7BAFEA6A6B9B2537D889D0A4D447505E46" + }, + { + "path": "docs/internal/extensions/pre1/evidence/postgate-final-checks.zip", + "mode": "100644", + "gitBlob": "1a9b9e4f1a096359667053fe5123b8821ee6ff61", + "rawBytes": 1172050, + "rawSHA256": "890D595F45D2FF98D4D478DC03D3CB644735BE71AD3C08843CCC7B4EB8F0F486" + }, + { + "path": "docs/internal/extensions/pre1/evidence/primitive-build.json", + "mode": "100644", + "gitBlob": "7740441cda96a67900823dd81f1ef5cec4c6fb6e", + "rawBytes": 2560, + "rawSHA256": "7367026A8773FB9F89C7354D6DFAAC0BB33179BF2EB948D84129EB2AC54BBA8F" + }, + { + "path": "docs/internal/extensions/pre1/evidence/ps5-registry-matcher.zip", + "mode": "100644", + "gitBlob": "86b094dca031b94d1c1632532963e25ce0061965", + "rawBytes": 1008, + "rawSHA256": "4D8418A4AFF2CB02FB4DDFD31C30E1C131A3545CA34B8F34C231D3F4C473877C" + }, + { + "path": "docs/internal/extensions/pre1/evidence/ps5-selectors.zip", + "mode": "100644", + "gitBlob": "aca6c790dea6968833ad7b8d5b0c7f029db6f844", + "rawBytes": 9813, + "rawSHA256": "278E2095F846D88236F6B67F75B0938C0E11E9BA8CA1E6262471A27D3E8F2CC9" + }, + { + "path": "docs/internal/extensions/pre1/evidence/ps7-deadline.zip", + "mode": "100644", + "gitBlob": "c7208b6b90e838a115c1a31ad4eb711466061d13", + "rawBytes": 3406, + "rawSHA256": "0DFE2785591C500414070524A714786A6F8DD423FC105473C3868B995B9CBE90" + }, + { + "path": "docs/internal/extensions/pre1/evidence/ps7-registry-matcher.zip", + "mode": "100644", + "gitBlob": "0710b3ed9879eefec666ef4817545b67c6cc91e3", + "rawBytes": 943, + "rawSHA256": "FC01A94307AD981BD5763967839BE836C98E826997F677DD1EB0B00A4A09BE14" + }, + { + "path": "docs/internal/extensions/pre1/evidence/ps7-selectors.zip", + "mode": "100644", + "gitBlob": "83c06faca43eca0733c888b7b0f44ac68bb0c331", + "rawBytes": 9186, + "rawSHA256": "4D518769461B29DAF0B5EA21A7F281EF62B44C3F59718CCE2006F0B4FEA93E3E" + }, + { + "path": "docs/internal/extensions/pre1/evidence/replay-full-summary.json", + "mode": "100644", + "gitBlob": "4299f4b51921aac54dbbad2dd30a227e477908d6", + "rawBytes": 14500, + "rawSHA256": "47AC250E4E306617B9BA05941BE20C7417EF760ECD4B397FD7EDCD7073C87036" + }, + { + "path": "docs/internal/extensions/pre1/evidence/replay-full.zip", + "mode": "100644", + "gitBlob": "eadd16208862614d571e15c74eda07409000f432", + "rawBytes": 394230, + "rawSHA256": "2C27A21720206014042DDB7B1EE57B4322AC665BF1B4D2C999AD6CE7705C6A12" + }, + { + "path": "docs/internal/extensions/pre1/evidence/replay-inconclusive-startup.zip", + "mode": "100644", + "gitBlob": "ceeb1df311c3c8c1785277666741349475416177", + "rawBytes": 28326, + "rawSHA256": "F611F107C1FEA26241505A3DD6EB0E7725E1D7D42290985C5B01657B3F5BC2D6" + }, + { + "path": "docs/internal/extensions/pre1/evidence/startup.zip", + "mode": "100644", + "gitBlob": "6d49aac4eb31a056ab29eafd0c650817ac2056a0", + "rawBytes": 31912, + "rawSHA256": "CF0251628B1AA2D2408768ADDCA688D37145F885F877712D73BCD7B478EA6662" + }, + { + "path": "docs/internal/extensions/pre1/evidence/typed-consumer-final.json", + "mode": "100644", + "gitBlob": "a4cccb195bf4b3f5274139ea4e241aebadd49a6c", + "rawBytes": 2403, + "rawSHA256": "65D2051211837334368ECC17E8DF7C9277DFDF50A83C4E8AA908A7A61156BFF1" + }, + { + "path": "docs/internal/extensions/pre1/evidence/typed-consumer.json", + "mode": "100644", + "gitBlob": "4109f54442bd2417661c9bde4e4f160e672cbb17", + "rawBytes": 2873, + "rawSHA256": "964283BB8A0FF2A5D7F72DDB07C4A6F570CA965217BB793015EFC2C86877B4B0" + }, + { + "path": "docs/internal/extensions/pre1/primitive_manifest.json", + "mode": "100644", + "gitBlob": "88443b4a8bc49e89e2a01b8b4d144ca2d461ff5a", + "rawBytes": 627, + "rawSHA256": "308D30D13B89117FA5D75A7CDAE561BC1132DFF33AA9740C06233CAB034EE409" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/.gitattributes", + "mode": "100644", + "gitBlob": "a4d7d77d1297e414a4e7481b04371ac472f77365", + "rawBytes": 174, + "rawSHA256": "1EEF15FB19FA9A9AB5C368C3417D3502E61782FF0BEF1BCDC77A65EA6DC7371B" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "8afedb2a3cfbb6d8ae159d0aef4b57827cf13ca4", + "rawBytes": 40623, + "rawSHA256": "305A35019DF93CDECB13E1D2F8AB252DBBFE40F2CD06A4E78DC6317A5D77630E" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/RECEIPT_ARCHIVES.json", + "mode": "100644", + "gitBlob": "699f96c6c0f53c72f02479ef6fd4214116c79551", + "rawBytes": 5095, + "rawSHA256": "8351A360960132F8F37FF15189FB6BFB84422FD83DB3DBB725F0DE98C3F0885B" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/REPORT.md", + "mode": "100644", + "gitBlob": "b98e2b68a2baa2485257cb050aa2c1067f524315", + "rawBytes": 44353, + "rawSHA256": "8E39B60ECD3FACFD86749326734916962CC3670CDA57430712BCEE3292063C5F" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/REWORDS.json", + "mode": "100644", + "gitBlob": "57d61db39e5a8d737bb7b536abff69d53ed9f037", + "rawBytes": 5108, + "rawSHA256": "8FCEA55E77C01C13FC1EA8137875F62065E6513A5833B9989C88B7DB3A772E23" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/build_repair.py", + "mode": "100644", + "gitBlob": "1dba9c1f97d6a2d28e2144182f6195f3c85cf096", + "rawBytes": 12869, + "rawSHA256": "9E8741F82762DA06683FD023C479984234B407A0E0641B8B79957673268FEA4E" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/check_preservation.py", + "mode": "100644", + "gitBlob": "a0e863a41a8b906b6147788aeebdcc9b5313620c", + "rawBytes": 16282, + "rawSHA256": "345048E430E98E9185C3A409AC6165644077FD8AB4C2D5B28ED39ABE25D14C42" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/claim_scan_detector.py", + "mode": "100644", + "gitBlob": "4efcd5df2aed1e5d3deee0bff48c761e2aa5fe11", + "rawBytes": 13995, + "rawSHA256": "CDBCBC8816E094A9BA20D49410EB78F9C724F40153267D36697615AD087C8C76" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/checker-modes-84ae12f.json", + "mode": "100644", + "gitBlob": "46e3ab3f9213ac645c0051b78ff4f76aba67689a", + "rawBytes": 30970, + "rawSHA256": "EEA3CD642AB7C5D94EBCE92F27EB44016BCACCE638F7FB19450A16AD6034EA0E" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/checker-modes-e977053.json", + "mode": "100644", + "gitBlob": "732fb0e1e696a6d76fe5d8c86c7c4a516af83972", + "rawBytes": 30971, + "rawSHA256": "7D61361A3BFDFE4B98A93ED848AE150759C87832261B688E0B599561F622E9A0" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/checks-e977053.json", + "mode": "100644", + "gitBlob": "ea5e395d7dd334d1efba62791866cb29ebbfb91f", + "rawBytes": 2692, + "rawSHA256": "7BCCE381F2A937E95AF16AB99061B960FCA0C21B64EB0C4AAC6AE7A105BD8804" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/controls-e977053-incomplete-attempts.json", + "mode": "100644", + "gitBlob": "b423f901cdaa1ecc450e7931d63d499b69e3f386", + "rawBytes": 91573, + "rawSHA256": "FBD98BD4B582791B66AE9FD197E8B195A2BE8B2423A9E0D5F40D534345D03690" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/controls-ece8ae5-ps51.json", + "mode": "100644", + "gitBlob": "659aa5b9f943d29e8819b55712ddd4e0444defde", + "rawBytes": 79009, + "rawSHA256": "6E1252B420B5D658998B2143062E57E839A9020A6B0513373E9681034DB82252" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/controls-ece8ae5-pwsh.json", + "mode": "100644", + "gitBlob": "1fa56a1fb0bb63e4b6fce6e476bab3ffa00a73c9", + "rawBytes": 78752, + "rawSHA256": "5F4568CFF8057367522F3B07D828AE070B47D82A7CBFA633E9B20B5345D98A87" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/controls-focused-runner-fix.json", + "mode": "100644", + "gitBlob": "2c90fa2f5e72c91568cc0441905932ec69b719f8", + "rawBytes": 8962, + "rawSHA256": "8A30F9DCC95005DB66E45B299F329F13820C409AFC56D7BBEEF28B3FC6D5E7FA" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/hit-accounting-84ae12f-e977053.json", + "mode": "100644", + "gitBlob": "340f013745ef348a735fd75864ad75fa2beb511e", + "rawBytes": 2172, + "rawSHA256": "C85644E02EAB7318EF22DB072038460BEE9663D07B90BAAA11DB094B30D29C0F" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/preservation-e977053.json", + "mode": "100644", + "gitBlob": "502b4ff21125879a7e271c07f4ab89b1c3776c1d", + "rawBytes": 13833, + "rawSHA256": "C11BB96D3372EB2103A8879AA191BA86A4001B6A8C1EEC0DA04E4A076840EF4C" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/reproduction-84ae12f.json", + "mode": "100644", + "gitBlob": "aa9ac87d3ce304705ded23ebb23b7bd0f8dd3a69", + "rawBytes": 24839, + "rawSHA256": "B095113C73381BD1AA5A3E351CDBB24493C7BB9A312807ECE10F509F178502CB" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/scans-e977053.json", + "mode": "100644", + "gitBlob": "150c3b247644d90bcfb763824c0b7f7ec5028556", + "rawBytes": 12144, + "rawSHA256": "BF2FD2CA2B0B94832E35B9CC46F097C0E644EC5D243E14450ABA8EE31F9AD2AC" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/verifiers-e977053.json", + "mode": "100644", + "gitBlob": "579f292748126db4427b6a462e5fe944a2943ec4", + "rawBytes": 5066, + "rawSHA256": "0B8372DB5FE35B3503075126E28509AA5786B1965B470C32C967A34B4A9884F3" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/verifiers-ece8ae5.json", + "mode": "100644", + "gitBlob": "05ed2ad2310040b772cf101de75f7b22231e41ec", + "rawBytes": 20160, + "rawSHA256": "2CC4ECC7CBC679534A2407DAA9B42A5EA76E13CF27C690D1D24AA0168AE98562" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/repair_control_helper.py", + "mode": "100644", + "gitBlob": "15ecfc0b00d74627a9817284bc61ae7dab0f93ce", + "rawBytes": 11198, + "rawSHA256": "7D4ED15EDDFF0E6358D1973E782240CFC215EA9CB393DA8B3B82EC45C246A476" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/repair_controls.json", + "mode": "100644", + "gitBlob": "1e227e13d4486fca59377ee7d4c0f2e179ea4af1", + "rawBytes": 7582, + "rawSHA256": "3B44C6BC3693B1017D4451BDC5DF1E372AF97AFEE1B7183366C7C349C5EB7ED7" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/run_checker_modes.ps1", + "mode": "100644", + "gitBlob": "ed3a9977b88b7c198adf4be26c26920afb1294d2", + "rawBytes": 11820, + "rawSHA256": "578E9779BFFBF7BCF65EB7886E8379E702B7E3AD05A78540FC2AB8C9398B3DB5" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/run_claim_scans.ps1", + "mode": "100644", + "gitBlob": "9b18c6564d452421d13776677df72fecaa08627b", + "rawBytes": 10015, + "rawSHA256": "0A3CE98812903458B103008FD519DE3A8CE72D2F87F3D5CD9646AD14C7B97AF8" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/run_repair_controls.ps1", + "mode": "100644", + "gitBlob": "3cb1d35aa64d4d60dd8bc8f7d249f377ee02e6dc", + "rawBytes": 23099, + "rawSHA256": "3C7AE3B0AEF6FBB4A83EA027C528AD4AC8EF16E5FAE8C6EDC337FF4E683B1B87" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/verify_receipt_archives.py", + "mode": "100644", + "gitBlob": "4352d77640533519caf97a01bfdabf7581dddd80", + "rawBytes": 32791, + "rawSHA256": "76AFAACBA4D788856F4F023872019CF999C63B2AF41AD9FBCC6DA5D2D278A3D3" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/verify_rewords.py", + "mode": "100644", + "gitBlob": "79fb096c0e9379cb3a8d22410343ec6fd4500d62", + "rawBytes": 21504, + "rawSHA256": "B980778487D495B2BC7434EDF26D03C758A5A81FFD975C3DE5F93A7F0F65DF85" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "ca1a2c086cdc47f5d0cb6fd29fcfd2937e1c5e0f", + "rawBytes": 51944, + "rawSHA256": "5056D888AC2C79A7B1F011206E8B32AE78D078A8A0DB3F812345635A9FDC1027" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/REPORT.md", + "mode": "100644", + "gitBlob": "5f85e2b1e9ca96b6b34e636a6cce6f995364e3d1", + "rawBytes": 28219, + "rawSHA256": "66EAFCF92D325AB3D90B7444CB101CA34773DD10B7C94BF68CB1239F97C2E42C" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/marker_controls.json", + "mode": "100644", + "gitBlob": "a941723cd42205f1b9151c271d53479607249f68", + "rawBytes": 25912, + "rawSHA256": "554072EC7FFD20DE73A74EF78528A6B7902B100A4B13B0BCE6B7C86FB4678310" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q1-build-consumers-341bc28.json", + "mode": "100644", + "gitBlob": "f0304059d93be6584b94b67fb22a8d343f8f206a", + "rawBytes": 14869, + "rawSHA256": "C873D58D3BD17C29DDEA4D4A0B2766B4A4FF4D5B712F2B54FE2CEE3EC0981074" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q2-focused-replays-c33f2a8.digest.json", + "mode": "100644", + "gitBlob": "7ddcb20a896c990f456a3d2cd13b3bbe3160e744", + "rawBytes": 37466, + "rawSHA256": "3A689E197A2236CBDB57650FA245DA202ED23D7F07A5830415F304EAFCB9ECEB" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q2-focused-replays-c33f2a8.json", + "mode": "100644", + "gitBlob": "ad2e7305c5107df919adb546d821be67afa09409", + "rawBytes": 8293, + "rawSHA256": "27E170E7AC997A972FA7F04B764C658214D40F36EE5FE3D3C11B5C431C563C3B" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q3-marker-controls-26b175e-ps51.json", + "mode": "100644", + "gitBlob": "1d7bd325421dbd432274bb6397e97a449df88d16", + "rawBytes": 112308, + "rawSHA256": "147F2E34E546DD509ECDF22EA829E453FBC4F9A6E5ADCA2ED106AA5D8C15FAA6" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q3-marker-controls-26b175e-pwsh.json", + "mode": "100644", + "gitBlob": "1db92f1d9c50b54254e6cc9d0471be9b9e0db827", + "rawBytes": 13891, + "rawSHA256": "D43C613E31B260AF8C4ECB69CF3A850ADA59FFEA4FCACE0BB5B63AE50F349375" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q3-marker-controls-26b175e.json", + "mode": "100644", + "gitBlob": "d58fe48cf1e973c50b79097b4af12d52926bc7a0", + "rawBytes": 5920, + "rawSHA256": "63A267D75D204AE47E87648EBAC9915EFCD5BA60797C197C57666DBB91AC08F4" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q3-marker-controls-e935f84-attempt1-ps51.json", + "mode": "100644", + "gitBlob": "e51a2b6e56268c89035035a8322724daccabe823", + "rawBytes": 112325, + "rawSHA256": "6210FD56F661987BE039663E6370558199E41EA0425E8477D4A8777BD396B450" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q3-marker-controls-e935f84-attempt1-pwsh.json", + "mode": "100644", + "gitBlob": "8535506f3f786dd6fa8fb00274a311985325a496", + "rawBytes": 13997, + "rawSHA256": "0E4A6552CC5D982CB636E8B1C71C5FF13613D7DFD32C2E39A8CE603FB464A70C" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q3-marker-controls-e935f84-attempt1.json", + "mode": "100644", + "gitBlob": "6743adb933405e1787fa7ed9af7898a57c804d0e", + "rawBytes": 7005, + "rawSHA256": "F191E8082C6FC9E64E252CE6D6726657E752DE13FD79B660E1B68D754E383038" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q4-builder-replay-full-f5d6128.digest.json", + "mode": "100644", + "gitBlob": "e29c716674f951b1158e254a4788e825f98821e4", + "rawBytes": 276464, + "rawSHA256": "9E26D05C041690E8CC8C73A2C86A38F9308301AEEF20D22D5B718B71343372AB" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q4-builder-replay-full-f5d6128.json", + "mode": "100644", + "gitBlob": "fdb8f6b8d70f7c44f29de7b022cc79fc6e10faf4", + "rawBytes": 4137, + "rawSHA256": "B205D5C09EC98B7AED38E92335AFDD27104B94C5936E815402FFBA6D63A6DE37" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q5-contract-replay-and-selftests-f7bdf20.digest.json", + "mode": "100644", + "gitBlob": "82852aa6f833861aa3faf0907f0fab89487a0cae", + "rawBytes": 102729, + "rawSHA256": "8997264344C6FA8680C09C41FF7B74EF0FE0ABE857CEAEEA54398D599930ED96" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q5-contract-validator-selftests-f7bdf20.json", + "mode": "100644", + "gitBlob": "1509c128b6d215b7e33632271d24c0fb7f6d5752", + "rawBytes": 20230, + "rawSHA256": "7FA0C101BEBB0899852C9E118875554E59787A96AD9F51BAE35637918C532B8B" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q6-claim-scans-9598f72.json", + "mode": "100644", + "gitBlob": "353d58e005e1fd59f34a8f869f3069e780bb340f", + "rawBytes": 6424, + "rawSHA256": "30EBA9677921448179B0B8DC692CAC3739F38B58FF43B0F97FD2FF357573AE7F" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q6-static-checks-9598f72.json", + "mode": "100644", + "gitBlob": "4eed9c3127ba7439c5cad3907a58f55256a179f0", + "rawBytes": 21467, + "rawSHA256": "7B7C8F4650DD262185A26482736AEAA7981047E3133E82482D3E547BB159FC81" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/run_marker_controls.ps1", + "mode": "100644", + "gitBlob": "33e336860111a7eb7d1d2eb875b42f5d96458cc0", + "rawBytes": 25996, + "rawSHA256": "763AF78EA72149FF92D080EA04B39BCBBB8371F35120DB7CED39F62EBA4504AB" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/apply_consumer_edits.py", + "mode": "100644", + "gitBlob": "aa0ebf9538ca395ccb8ecfe9fb7877c2eaab464a", + "rawBytes": 9826, + "rawSHA256": "8C0B7E702B288280B377D7A4D91F9C8B7F744FF6E6C93835D40DF343CE0C05C5" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/cab_probe.ps1", + "mode": "100644", + "gitBlob": "dd1f23e247ca3d7571e18d5d921a9aaf96d3901f", + "rawBytes": 4734, + "rawSHA256": "65975106ACB5F0A7365F08CE71D2D6BA53ED991A64BE56D491FE0337915059F3" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/clone_cases.json", + "mode": "100644", + "gitBlob": "2239e2292978aa240f239bf846968595964bef87", + "rawBytes": 34934, + "rawSHA256": "FC706E3811651949B11BB6B48363B3AEA97190D7A9D0235EE5D3D90B016124CA" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/clone_mutant_probe.ps1", + "mode": "100644", + "gitBlob": "b778fd024784ccc04cbe898125a8ed62828df726", + "rawBytes": 4250, + "rawSHA256": "55B33FC42C69CD4822D2FF311619D3DC4C0EB1DB807481A05A318C71AAD30BE7" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/make_marker_registry.py", + "mode": "100644", + "gitBlob": "4d3faa3df71bbdcdf1fed56ef928c024e3340212", + "rawBytes": 7335, + "rawSHA256": "B9022B920B314F6CCB677D83EAF27656A9159499F6192DA841D549AD639945D4" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/make_registry_v2.py", + "mode": "100644", + "gitBlob": "1f826cf31fcb4afcfedddd5cbe167b4b4576bb58", + "rawBytes": 5300, + "rawSHA256": "763997C57836DE44FACB2E16E07927FB4014AFB8D9A48C9D28C525147F1B0E12" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/marker_block.py", + "mode": "100644", + "gitBlob": "e303f0af86ecbe21deea23013ad09e05ff7f2fc2", + "rawBytes": 3085, + "rawSHA256": "7899AF501D6427D0A6572007DE22EC2EA770B264943E429E42848037E3F95A75" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/mechanism_toy.lean", + "mode": "100644", + "gitBlob": "ff4949ee91f6e29dc6ab52ae27ec1258120c0095", + "rawBytes": 2047, + "rawSHA256": "88399FBEB37F4766DC3925AEEA0108F78A3F714ACB0746B5789A6F22ED72FD61" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/mechanism_toy_variants.py", + "mode": "100644", + "gitBlob": "d5f7ce8db5bc258b6538deae6063156dfe463906", + "rawBytes": 1693, + "rawSHA256": "ED7C7D6667D11401295D7110311AE2B9AD2B024D65ABC99128C98D26E50BF6F4" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/p2_2_work_probe.lean", + "mode": "100644", + "gitBlob": "92247bfe7792b106670150183517ee18cca6daae", + "rawBytes": 1818, + "rawSHA256": "95F002099B86F8F77882C38BDFE9C03F7CB4D2DD76197FFBB9C64C93DFF3C205" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/queue.ps1", + "mode": "100644", + "gitBlob": "c4f8b8c33861f9cd9a308602021d49b53fe3f10b", + "rawBytes": 2554, + "rawSHA256": "3A65D5EFCA05CE8E48F110FB6C4B9883CFDE319DCF4C5B20982399EBF858B9B5" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/runsafe_mutant_trial.lean", + "mode": "100644", + "gitBlob": "0aa55521e295be888b0a5396287b32b3d46a228c", + "rawBytes": 3577, + "rawSHA256": "7A100040C52C211B059E1651E46A13C0AD70099E3846C535D51C87F9FD9AB3AF" + }, + { + "path": "docs/internal/f03_evidence/F03_COORDINATOR_FINDINGS.md", + "mode": "100644", + "gitBlob": "222efcede6e4f73af780d125041c84440ec76754", + "rawBytes": 9846, + "rawSHA256": "D0474352835FBBEB2D7639177B2974BC4C34E9472537563E35DFAD61F68D448F" + }, + { + "path": "docs/internal/f03_evidence/README.md", + "mode": "100644", + "gitBlob": "86288c8a12ad7b2a82511f6c5130171db39e892f", + "rawBytes": 2838, + "rawSHA256": "7211AFD058AC8C49A29C7E71B718E967DBD0B0EB9868A506DD7188243AFDF820" + }, + { + "path": "docs/internal/f03_evidence/T1_COORDINATOR_FINDINGS.md", + "mode": "100644", + "gitBlob": "c43d7f076c0e27b82cb76c87a21cecf54806a4fa", + "rawBytes": 3267, + "rawSHA256": "3428203FBBB459E8ED682DBA0EE824BBB5007C5E463990DEA8E26E413DDF773B" + }, + { + "path": "docs/internal/f03_evidence/adv6_L1_big.lean", + "mode": "100644", + "gitBlob": "5b00f3abfc14571ab35a55378e71c8837c8c17b7", + "rawBytes": 4829, + "rawSHA256": "2296F855F37754F6BEE4EBCD559E3EC0D3BC031B97ABA2BE7200BF57CF372661" + }, + { + "path": "docs/internal/f03_evidence/adv6_L1_cross.lean", + "mode": "100644", + "gitBlob": "18beaa24784b467ba4639e9d600164ec7dd6507a", + "rawBytes": 4349, + "rawSHA256": "4E2B66AD2B7ABFD035ACAEC63C778ED56F46872DBC2D211F2013A996B5C2D8CD" + }, + { + "path": "docs/internal/f03_evidence/adv6_L1_degen.lean", + "mode": "100644", + "gitBlob": "717516493b62f1f9eff846b427c45d3a7fb9c416", + "rawBytes": 7122, + "rawSHA256": "1F662CC299653B365EA1B3F231ED9829FC15C1D836E0711AC14F72DF990B88FF" + }, + { + "path": "docs/internal/f03_evidence/adv6_L1_forced.lean", + "mode": "100644", + "gitBlob": "4d213a6cb6c1933c348270e2eefb920b05346076", + "rawBytes": 4911, + "rawSHA256": "58302C766DF60226A0FBD574B902E440E25F74F1403C5593851E842574F53B9E" + }, + { + "path": "docs/internal/f03_evidence/adv6_L1_forced_out.txt", + "mode": "100644", + "gitBlob": "2d944985193025bdbd8ef1e66e5aa861c77fd519", + "rawBytes": 917, + "rawSHA256": "C237126F01017FBE06CCAD9D6D492FFB60556AC356C922D3005B78BE13E37AE4" + }, + { + "path": "docs/internal/f03_evidence/adv6_L1_real.lean", + "mode": "100644", + "gitBlob": "09676973ed603d386abc94afebf51a61c366a657", + "rawBytes": 4993, + "rawSHA256": "B086DB935B42728A772DADF111B28CCFE4F73784F61F85B1D264031AD2126DB1" + }, + { + "path": "docs/internal/f03_evidence/adv6_L1_refute.lean", + "mode": "100644", + "gitBlob": "54987d83a27def1b1bb9c132d83a9b898d76bf6e", + "rawBytes": 8567, + "rawSHA256": "EF835AE1CA55B62361096EF563E51413B4CD924A6E7BB0865D3E07B80530DAF3" + }, + { + "path": "docs/internal/f03_evidence/advF1_attack.lean", + "mode": "100644", + "gitBlob": "16e2e24c4ca3fda75a018fd2f7bc12d03a595daf", + "rawBytes": 7694, + "rawSHA256": "91A9269F28D97B426F522AD3C8F8E70CF61353B7524F58145259CF40A98A7E10" + }, + { + "path": "docs/internal/f03_evidence/advF1_attack2.lean", + "mode": "100644", + "gitBlob": "688496c7b8d445e5403d31b4b5a1d9e476c12826", + "rawBytes": 6559, + "rawSHA256": "48A95206C8FCC5B33B0A091DF326E6744AEE58A708F5FF6D761938268BCA0AC1" + }, + { + "path": "docs/internal/f03_evidence/advF1_attack3.lean", + "mode": "100644", + "gitBlob": "c96f4ab804b314c7876f02cd56f13ccc1ef58f2f", + "rawBytes": 4931, + "rawSHA256": "75D7DDCB305732A350A1D34BF222EAD10A97386ED036772D8EC996BB0A365EB4" + }, + { + "path": "docs/internal/f03_evidence/advF1_reach.lean", + "mode": "100644", + "gitBlob": "6df91d76d18f966f7f9309a6db0b483b8737b770", + "rawBytes": 6551, + "rawSHA256": "42B2E60349E3785CF2009B0E5DADA2AF615F5906A705C3628EEA9E734130757A" + }, + { + "path": "docs/internal/f03_evidence/advF1_refute.lean", + "mode": "100644", + "gitBlob": "c69bf86bc4ad050012f6ca7629fcdca80f9c24b6", + "rawBytes": 8233, + "rawSHA256": "10385A7C8BAFB73793D4ABD79A43693C8BCDEAF47A2C48FCB1B92BB7D9B7BDD9" + }, + { + "path": "docs/internal/f03_evidence/advF1_refute2.lean", + "mode": "100644", + "gitBlob": "94f1ad811137f30c17d6dac4f3d5b6ef6f9e025d", + "rawBytes": 6372, + "rawSHA256": "63747A41E13265337783EDAB0F7320E0E3B1FD1655A36EA2766269E46B20BE9E" + }, + { + "path": "docs/internal/f03_evidence/advF5_antivac.lean", + "mode": "100644", + "gitBlob": "ec2dcbb5412ff8d2175999380f920e4d775d1049", + "rawBytes": 4071, + "rawSHA256": "841ECCB20C1D4F07997010CB0AAE8B0EED1F39453332F67FF88A00DE2DF33642" + }, + { + "path": "docs/internal/f03_evidence/advF5_antivac_out.txt", + "mode": "100644", + "gitBlob": "29b1ddf845353b72e53558730c8ed69ca5084a10", + "rawBytes": 4423, + "rawSHA256": "AAC7213F6B329D3738B4C07CDB40BDBAB64AAD6F563AE79994A747CCFA11F403" + }, + { + "path": "docs/internal/f03_evidence/advF5_live.lean", + "mode": "100644", + "gitBlob": "e413938829553fdb343e12c7dc158d214fa2064b", + "rawBytes": 4492, + "rawSHA256": "638DE48FC052F46AF0300045E842F76D8C1197BFA7D7C8108C6C6301D7255CF8" + }, + { + "path": "docs/internal/f03_evidence/advF5_live_av.lean", + "mode": "100644", + "gitBlob": "7d3bd53c2d5d82fa16cbdebc0e47286689618360", + "rawBytes": 3727, + "rawSHA256": "DB32698BAA1379B638D30C3E37A573EFD80FA431231AE552A52F5E4F63946C56" + }, + { + "path": "docs/internal/f03_evidence/advF5_live_av_out.txt", + "mode": "100644", + "gitBlob": "cca181778bb455e320d3ab3fc3d9428ff76b7361", + "rawBytes": 1140, + "rawSHA256": "0884572FB34A95DACC16535126074395AD095C7EE20B807084D7CEE2ECC0EB98" + }, + { + "path": "docs/internal/f03_evidence/advF5_live_log.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/advF5_live_out.txt", + "mode": "100644", + "gitBlob": "30de603098d62e2214ccb9914d57401be8445546", + "rawBytes": 272, + "rawSHA256": "0F0392944F536416DAA5F8294215093C575702ED2F594DBAF0E57CCBF8DC4C64" + }, + { + "path": "docs/internal/f03_evidence/advF5_rand.lean", + "mode": "100644", + "gitBlob": "6569408b0fdb2c42cef03b88651431edfc0fbf79", + "rawBytes": 6505, + "rawSHA256": "DF977646DEDFA3C83D0E2F759D10E31BEC5ECD1DD5B1D6D932F8A72CF02D8CEA" + }, + { + "path": "docs/internal/f03_evidence/advF5_rand_out.txt", + "mode": "100644", + "gitBlob": "47735f142da34fd9c881a992841c1f8c2609e0ee", + "rawBytes": 2118, + "rawSHA256": "AEFF543853D475E19726D65C3D2DD64BB5F6F63FEE4058ABC59B1222C24B4893" + }, + { + "path": "docs/internal/f03_evidence/advF5_realstore.lean", + "mode": "100644", + "gitBlob": "0eebe26dc937a6b94b3162194ae1faea9f89d40d", + "rawBytes": 4057, + "rawSHA256": "DAFD050AE29D9A641934B1619CDAD9FFC9E8687858162E330141BA883AC6EF46" + }, + { + "path": "docs/internal/f03_evidence/advF5_realstore_out.txt", + "mode": "100644", + "gitBlob": "4da2132dff19ae82e499c214453843a80fea4697", + "rawBytes": 461, + "rawSHA256": "063234C228D26205D7BD1FBB825FBC3221C2C75EE8EBADA1EE4BB7638D9F5D31" + }, + { + "path": "docs/internal/f03_evidence/advF5_seg20.lean", + "mode": "100644", + "gitBlob": "9825c8e266d976ec70baa70729decc0d2e79169a", + "rawBytes": 2778, + "rawSHA256": "F21D8A537F3B43C285C9BF2BAE368C09C3613D200894304959C836A3713D98E4" + }, + { + "path": "docs/internal/f03_evidence/advF5_seg20_out.txt", + "mode": "100644", + "gitBlob": "20ebe9c2277bf833426813c059b21864c1a0fcfb", + "rawBytes": 205, + "rawSHA256": "9AA375FD682949671F3EC490E3B0D8AC013CDB7A456A4E2A02787B00DE7CACA3" + }, + { + "path": "docs/internal/f03_evidence/advF5_seg20b.lean", + "mode": "100644", + "gitBlob": "133d7bbf2ce487a28643fad64a8f7fb7259b956f", + "rawBytes": 1840, + "rawSHA256": "45B21637A8AC8F59C6696569F008ECC71ED6C550527B99DF3B5CF13D08DE6BB0" + }, + { + "path": "docs/internal/f03_evidence/advF5_seg20b_log.txt", + "mode": "100644", + "gitBlob": "5a6a98bdf28057616afd7b55a920f4440fc59a77", + "rawBytes": 1444, + "rawSHA256": "E8EFCC30699AFD6179BF5ACDDA67BED3679BDA810C96967C16586B57202D6428" + }, + { + "path": "docs/internal/f03_evidence/advF5_seg20b_out.txt", + "mode": "100644", + "gitBlob": "5c93fe57e9d1fccb757b64a9677a53bcb05331f4", + "rawBytes": 1442, + "rawSHA256": "0F693EFA05E9733678FA6FF1ECF4FB66C51DDCB84E99B89100DFFE41E0B2C7CC" + }, + { + "path": "docs/internal/f03_evidence/advF5_top.lean", + "mode": "100644", + "gitBlob": "72a8dcc75bbdb63ca4e50524cbee659201222b27", + "rawBytes": 4292, + "rawSHA256": "487E7B46431406FF249CBF24DB38E49382C372CFC52720338A437D97341C37AF" + }, + { + "path": "docs/internal/f03_evidence/advF5_top_out.txt", + "mode": "100644", + "gitBlob": "4d10ad510bd3c141f3f97998884c69437a6be421", + "rawBytes": 729, + "rawSHA256": "CFCC838EB98D35F361214E04B9695824092A38590C023A92B57D47C66A5A6D20" + }, + { + "path": "docs/internal/f03_evidence/advQ_f1_core.lean", + "mode": "100644", + "gitBlob": "f811ed5264b8f2ddb4e07edaec714b054ad3ffc9", + "rawBytes": 6363, + "rawSHA256": "61AB1F4A9B110A2D9A04C4A6411C02597AFF9A108AE23AE69B38698308B4574A" + }, + { + "path": "docs/internal/f03_evidence/advQ_f1_quant.lean", + "mode": "100644", + "gitBlob": "6a7e63c7156207fad102398931834e1fe964997d", + "rawBytes": 11570, + "rawSHA256": "45747A4F6184060BAC11480D4434F178621407E6CB919F94A35647E01DF10992" + }, + { + "path": "docs/internal/f03_evidence/advQ_f1_sweep.lean", + "mode": "100644", + "gitBlob": "2a3b075eb1ea1f1a36dc333451a62d504e02a026", + "rawBytes": 5534, + "rawSHA256": "960412AA54FE7152A903F46B80DAFE1B9312442AAF15DBED889629A571A69DB5" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_forced.lean", + "mode": "100644", + "gitBlob": "0b625228f0cb3eae2ba5ae5272c4ef35962283d7", + "rawBytes": 3991, + "rawSHA256": "0B8FA153FDFC8FFBFA0FBBA791D14A62AF1DDE3FCB1470C1C0B8EA37CE64E3A3" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_forced_out.txt", + "mode": "100644", + "gitBlob": "f73a87b739aeadac47f6cd93a171a01b7fcbf84d", + "rawBytes": 3272, + "rawSHA256": "E05E82F70D038384D23F7850DDE0641A9B0AC5C082833A2576D4A18354E538D2" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_global.lean", + "mode": "100644", + "gitBlob": "e38263eb6d38eb08826d91d66776f618bd0c02c8", + "rawBytes": 6190, + "rawSHA256": "0F1E01696AF991AF5C1B36135B6B8197C2690DD91E298E299D4D046FA7BF1EF8" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_global_out.txt", + "mode": "100644", + "gitBlob": "49f75996e8777e96d8097e684c47a0176764e011", + "rawBytes": 459, + "rawSHA256": "5CBADCB2904D83D414185435EAB83C37A790E8538763B10371057D8BAC87E98C" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_offsets_thm.lean", + "mode": "100644", + "gitBlob": "b361406c2c18f68538acdafa48d596aa263f3b4b", + "rawBytes": 4815, + "rawSHA256": "7DECB57A627866E946C7578B0DFA6335CD40F6834B495312584CC9F6DEAC35CC" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_regime.lean", + "mode": "100644", + "gitBlob": "c664cfc8ee37563a9c149a86d3b050d63c39cdf2", + "rawBytes": 5040, + "rawSHA256": "2458D558DAD5DFD9F62B9064B05949EAAAFCEB3672020EB1E3424551E4978D04" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_regime2.lean", + "mode": "100644", + "gitBlob": "8667296960bcf61fb04c0251b2f8ad0a7326dfc5", + "rawBytes": 4806, + "rawSHA256": "5AE86F40E93D2AB344A441DE868D9345FE9E0C04A9C9EBB3CCBE2C2A7460C98E" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_regime_out.txt", + "mode": "100644", + "gitBlob": "8056689c3cce7839d11b799aeaca398b5c68df38", + "rawBytes": 4083, + "rawSHA256": "F505717258D3EF5108BE34CA658A2FBEB85F5583E353EC0044EF5A73F70F588C" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_uncovered.lean", + "mode": "100644", + "gitBlob": "421b69f6d19d9fb93e0e47bf8517650e6166a760", + "rawBytes": 5289, + "rawSHA256": "3D87D3362A56AA0A3AE759D2646249222AA5324C539DCB45C02E7F3B8BCBD2CF" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_uncovered_out.txt", + "mode": "100644", + "gitBlob": "467ab1ad59b880c9f1f5b8abce5fdf9e14b60057", + "rawBytes": 3185, + "rawSHA256": "31D1B50BA11DB7E90E21A519B159DFACAAC5B21FFF3645E621F262E02486FE5A" + }, + { + "path": "docs/internal/f03_evidence/advQ_f6_big.lean", + "mode": "100644", + "gitBlob": "2debecdcde893031994576270329d8802faa5243", + "rawBytes": 6596, + "rawSHA256": "4DCC601D51F5339E5929CA91EA688985C758D74DF6B07D6AE3FC6D9A77124E2C" + }, + { + "path": "docs/internal/f03_evidence/advQ_f6_big_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/advQ_f6_kernel.lean", + "mode": "100644", + "gitBlob": "a59b280a8c99d56e3ff461de4ef9806b330edc7b", + "rawBytes": 4837, + "rawSHA256": "7BE21820D2483D7B75F459677099707442B060785091E170928EACBAD4E4D0FA" + }, + { + "path": "docs/internal/f03_evidence/advQ_f6_raw.lean", + "mode": "100644", + "gitBlob": "c38707ce61f21fe83d707507fb80ac77bce4af3c", + "rawBytes": 6464, + "rawSHA256": "E565576531BCED3A0A9E1FDCF2931C527B1CD57E9BD851DEFF51A633DA431340" + }, + { + "path": "docs/internal/f03_evidence/advQ_f6_raw2.lean", + "mode": "100644", + "gitBlob": "0e596d955a76cf82964c65790e39f4859eb52cc6", + "rawBytes": 5929, + "rawSHA256": "B4BA1AD0AB3A74CDE1EED6B982CB1E2BFF429C87131E5F2B91ABF63449DB703F" + }, + { + "path": "docs/internal/f03_evidence/advQ_f6_raw_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/advQ_f6_thresh.lean", + "mode": "100644", + "gitBlob": "7972ff5e98acfb9c7bceeac63fe82ba972dc7e9f", + "rawBytes": 2116, + "rawSHA256": "3D4357C219271EC21C19DB4B7B25CC34D159338DB00122FB54C22D4B9D8141F7" + }, + { + "path": "docs/internal/f03_evidence/advR_f5_addr.lean", + "mode": "100644", + "gitBlob": "73f5b7b97de436e1a9db0850587de7b823b648df", + "rawBytes": 3238, + "rawSHA256": "69D3D1B255B255158C6AC0C9FF848401D86993428994AAED6C18586F7853671C" + }, + { + "path": "docs/internal/f03_evidence/advR_f5_cut.lean", + "mode": "100644", + "gitBlob": "3f46f1cd63e0e555bed66c964d29db2bb2974e05", + "rawBytes": 7478, + "rawSHA256": "DC651FB6E64D5E3F4B005E0036B6EDA1AC919A0C4B5F8805077A3938BFA1EF1A" + }, + { + "path": "docs/internal/f03_evidence/advR_f5_cut_out.txt", + "mode": "100644", + "gitBlob": "d145bdcb9a2dae21439f9c608b761d4466dcbd9b", + "rawBytes": 5201, + "rawSHA256": "AFFFD96E20C852404A847866774C32F05EFB1D163BB4630F0FE125ADAD312026" + }, + { + "path": "docs/internal/f03_evidence/advR_f5_root.lean", + "mode": "100644", + "gitBlob": "1fef6d2c53949e0c93bd8697924c76bde67426bf", + "rawBytes": 3938, + "rawSHA256": "62E0DC3FF361937800FCAF38278D99A5E7F7D6592601D8540B8742DEE0A648CC" + }, + { + "path": "docs/internal/f03_evidence/advR_f5_root_out.txt", + "mode": "100644", + "gitBlob": "23891c08a675dfb5331ec29475071d84636d8bb2", + "rawBytes": 1308, + "rawSHA256": "52979171305096FD4E93E6A4455FFD2BF97B12EAA6C278D57AD65530576725AF" + }, + { + "path": "docs/internal/f03_evidence/advR_f5_vac.lean", + "mode": "100644", + "gitBlob": "9fe3a02cc20c3cb1c0f2273e4467036bf4d98ab4", + "rawBytes": 2642, + "rawSHA256": "A70CCD6266E84C543E763F8966A2B5188E163DFCFED86CC98474C9FD562383F4" + }, + { + "path": "docs/internal/f03_evidence/advSZ_axioms.lean", + "mode": "100644", + "gitBlob": "11fd9c54ea0e05083c52ebec3192d127cf851901", + "rawBytes": 3344, + "rawSHA256": "3D5D9FB2C3D4CDD9DB6272AC8461B824A5FB412B14A634B7EAD754287F0B6AFE" + }, + { + "path": "docs/internal/f03_evidence/advSZ_big.lean", + "mode": "100644", + "gitBlob": "06f1dd062fc3cddda08eeafa9e612c4a62783b96", + "rawBytes": 7205, + "rawSHA256": "BEDE7F4A12E2E1B6F723110AF755AE6B730361998B0FACD1C66D32A036D6D786" + }, + { + "path": "docs/internal/f03_evidence/advSZ_chk_rank.lean", + "mode": "100644", + "gitBlob": "52f6541e19a13fc5e6d6281e118b61230b4cca30", + "rawBytes": 3206, + "rawSHA256": "BEE74772A7B66255EB93360ED1B57B27057544DEC535819ACE6685B679C24DC5" + }, + { + "path": "docs/internal/f03_evidence/advSZ_chk_size.lean", + "mode": "100644", + "gitBlob": "59c5228b77235e4db6bb17ae8684c0f6ffda136a", + "rawBytes": 9503, + "rawSHA256": "B27B0E8F4FE02D983FCBF17E93B9DA4309111E7D14B4D206855D0FFE2549EDD9" + }, + { + "path": "docs/internal/f03_evidence/advSZ_ctrl.lean", + "mode": "100644", + "gitBlob": "4491f9aad117d87266730dd69c346d7617534806", + "rawBytes": 3172, + "rawSHA256": "C84D2A1D30EF36C2C3CC3123106E8DC008706FE995DEE80C8849E00F2F106BD2" + }, + { + "path": "docs/internal/f03_evidence/advSZ_decide.lean", + "mode": "100644", + "gitBlob": "ff921260c68b763e38a9b3dc5f7f9255bbc3721e", + "rawBytes": 2927, + "rawSHA256": "230471E703A359AA798B3497D72F94D984B16C8006DBA12A9F320FC245FB4286" + }, + { + "path": "docs/internal/f03_evidence/advSZ_decide2.lean", + "mode": "100644", + "gitBlob": "0932787e4989c02452026081cde1259dab03325e", + "rawBytes": 2699, + "rawSHA256": "6109040B4CF2333057D5A1614BF4B03EE07580829B0DAD92EDBA748FFFB8AD81" + }, + { + "path": "docs/internal/f03_evidence/advSZ_decide3.lean", + "mode": "100644", + "gitBlob": "87eced826ecdcae9fdc864ad807f71722816fdf2", + "rawBytes": 2678, + "rawSHA256": "5B89AF0BC36A649777345CB7ECD171214A7599231B48A49A54170FC4B2C6DD80" + }, + { + "path": "docs/internal/f03_evidence/advSZ_exh8.lean", + "mode": "100644", + "gitBlob": "6a44c3596aa658fde7464e27735ba22d4e998306", + "rawBytes": 2189, + "rawSHA256": "E363351BB9FEDFE975F968549C733754DB0CBE0D9EB5384509818B43A2EC6024" + }, + { + "path": "docs/internal/f03_evidence/advSZ_huge.lean", + "mode": "100644", + "gitBlob": "4091faba89139b01b7fb3e30c32dc626222ba30d", + "rawBytes": 5813, + "rawSHA256": "53EA79EAE41CAF88D773744BECC8FAA9ECDB4CA4F39D27F0D1111735DA9655E4" + }, + { + "path": "docs/internal/f03_evidence/advSZ_layout.lean", + "mode": "100644", + "gitBlob": "400a2dd3852d725dd37940e2e2d1286971c43278", + "rawBytes": 6025, + "rawSHA256": "B6B76F44132CB583ADDD4E44D1AB011E725801C46E58AA2AF328C9A9FE2C0492" + }, + { + "path": "docs/internal/f03_evidence/advSZ_layout2.lean", + "mode": "100644", + "gitBlob": "4ad3086766fb97f6b7a8a47c085324d60f465a17", + "rawBytes": 5616, + "rawSHA256": "A712D57ABB8F47A6FA5E2A8429F6765B4AC5909A5798F3498CBC1FCE46E3D45D" + }, + { + "path": "docs/internal/f03_evidence/advSZ_probe.lean", + "mode": "100644", + "gitBlob": "fbf03d252cddfdd8922215f971c61107541b7f89", + "rawBytes": 2243, + "rawSHA256": "031D5386CDAFEA6A95F7A842190C951871052CAC03A3880D8ECCDBBE30D46363" + }, + { + "path": "docs/internal/f03_evidence/advSZ_sparse.lean", + "mode": "100644", + "gitBlob": "6d3f752812018adeb95546be10109a63e745cadb", + "rawBytes": 3621, + "rawSHA256": "BB053A952E8B58AC8A1423FDE25C13B62AE1C68C081F9BED4AF9F57299D7FAE5" + }, + { + "path": "docs/internal/f03_evidence/advSZ_sparse2.lean", + "mode": "100644", + "gitBlob": "297b4498c8d83f51eabff472645c6fcff5c3d7d6", + "rawBytes": 3617, + "rawSHA256": "6DE1F9F073A641EF531E46582F3DDA08F85B8373AF45E9E4D14CA745881E2F41" + }, + { + "path": "docs/internal/f03_evidence/advSZ_store.lean", + "mode": "100644", + "gitBlob": "bd303471f038211d90251e51bb8b91d78633572c", + "rawBytes": 3472, + "rawSHA256": "B7B85FB6CDB30882A72C8C98F03D3F3E08519DFC59630AF6601E768E6F4DC1AE" + }, + { + "path": "docs/internal/f03_evidence/advSZ_strides.lean", + "mode": "100644", + "gitBlob": "8ee9290ba9e454760c113332e6084ed958853594", + "rawBytes": 6107, + "rawSHA256": "BABC1C02A3BE69BAA67D0337B3AE3DEAC78538354399729719E041A5143507CD" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack.lean", + "mode": "100644", + "gitBlob": "ef03dc2e5265d857b7722c429e9d80e8b446b0c4", + "rawBytes": 8008, + "rawSHA256": "AFE1B805FE3DB50000A5B220F016825D882199E51D8EDA2F1418EF4E0B375880" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack2.lean", + "mode": "100644", + "gitBlob": "5a71be7ec0c107c481983915ee7fc9108c721e67", + "rawBytes": 6826, + "rawSHA256": "F01039D1D32283706DC3C860A8A53C6BB63EC6E034EF32F2082E5FCEF9C2CEB9" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack2_log.txt", + "mode": "100644", + "gitBlob": "28409735729251605cc1007c9d97c6145c2327c7", + "rawBytes": 154, + "rawSHA256": "1B523FE252A7A813DED19E5751628F769328C3DF4AAC868C09C763FC57C9F427" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack3.lean", + "mode": "100644", + "gitBlob": "5289bbae06043bea216ededbe9e8281fe3e29418", + "rawBytes": 8449, + "rawSHA256": "35F5B3CEACC4E89C65C58BBDB062E6F137C04DE7E806C978B761B83D827F411A" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack3_log.txt", + "mode": "100644", + "gitBlob": "eec3b9f201b9914b2409148951f5ab415b699995", + "rawBytes": 1756, + "rawSHA256": "C78BF65B7D6567A0C7E2E809FE8CF511120C2E231EA98E9B5EED7A6FFE6FA689" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack4.lean", + "mode": "100644", + "gitBlob": "f4d0f8f2432408173e780ded73389e409b108fd0", + "rawBytes": 10925, + "rawSHA256": "ACD00DAE304613FF05DC1DB415331FC5A9E0ED7CC39FE358E2319F405C0E1723" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack4_log.txt", + "mode": "100644", + "gitBlob": "0adcc14e557e451fa554713f1fbee4fe2f5867d2", + "rawBytes": 2032, + "rawSHA256": "4FAB92B64F781B45951DE881C9C1D929072D89F6360866532039B9DFE582F29E" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack5.lean", + "mode": "100644", + "gitBlob": "5f4ee86ff53c694c2dccc6486741ae2b94b252fc", + "rawBytes": 10880, + "rawSHA256": "1C4C45986A09ACA8B0048C6455FC8D26E8AE867D098F33DAEBA022648926BA8E" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack5_log.txt", + "mode": "100644", + "gitBlob": "0776b5bee5940c375d35bc98e89d698c9413f51e", + "rawBytes": 1876, + "rawSHA256": "C200B23D7E9AC23516FE4A06B336BD37E88A8962D8AE732D560CF87D358C7B6D" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack6.lean", + "mode": "100644", + "gitBlob": "893edfa680993ef27dcbb09208159c30e07742bc", + "rawBytes": 7305, + "rawSHA256": "3BCBCB3D465FEC21BEC45C598E563D4C87E067418586D014D2FB2C29EC375F6A" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack6_log.txt", + "mode": "100644", + "gitBlob": "0e0a40dcdf63ea6cde5e35767972f0df99d1c26f", + "rawBytes": 1858, + "rawSHA256": "F5CD1251FA50C3D9E171B86C9FD23B14F71AD31F5B9E622F90033F63A69FA1D1" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_cost.lean", + "mode": "100644", + "gitBlob": "7065e8ebceeb983b31f33037509ce517863dbefb", + "rawBytes": 3461, + "rawSHA256": "119E12052AE6DB2EA29B48F91BBAAAF53D186E690A8DA626800F80BABBCABACF" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_cost2.lean", + "mode": "100644", + "gitBlob": "d6c37db3e0499679e4ec1b9334cfe925d3867d35", + "rawBytes": 3082, + "rawSHA256": "5AB2D4175CDD58D4D03E6574A3E88147042D5C58AC2C3A3C5B6840A6C6BEF8AD" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_cost2_log.txt", + "mode": "100644", + "gitBlob": "4936f417a793effa6e2b439f1ed0073990c6adca", + "rawBytes": 848, + "rawSHA256": "9FFD0C739C8E4C62E71B326C1650447D79EE7386202AF2C9054FA95334447B52" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_cost3.lean", + "mode": "100644", + "gitBlob": "469ddc342689ea3712dd82552319cc031d75da55", + "rawBytes": 2309, + "rawSHA256": "719087894B25538525416479E36470294965789DB02315FA437366B287BD72DA" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_cost3_log.txt", + "mode": "100644", + "gitBlob": "4cae1deacca584b633289fe9a73ec72887ea4b26", + "rawBytes": 818, + "rawSHA256": "18904F5683AA4498F2F15933A3DC5795C3F3E1EE52062176A903418320A30262" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_cost_log.txt", + "mode": "100644", + "gitBlob": "090c111c5323c1231366a9f52ab765521da07b44", + "rawBytes": 1423, + "rawSHA256": "C2E7AE10F25CA4D55F80EDA510C58B93F2C8DBFC6B9EAA24F06C55968699B763" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_diag.lean", + "mode": "100644", + "gitBlob": "c720d7d98c00b8da12c38d72a54099d8dfcadb5e", + "rawBytes": 1365, + "rawSHA256": "4B33FBB409CBA895D77F3BCBD7D1C18A259C2B8F214E9FF1891C42A9445D8980" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_probe.lean", + "mode": "100644", + "gitBlob": "afc0226aefd0c5f7df48e26f8a39f3f8bd340b4a", + "rawBytes": 2606, + "rawSHA256": "9E2F7132F6938D86D6E5DCDDB2C6C80752EB5E28F976729ED58C9BBD5BD42D3F" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_probe_log.txt", + "mode": "100644", + "gitBlob": "87d643f0ae0a4d836a154c666814f69e115fbe41", + "rawBytes": 497, + "rawSHA256": "9503178276B9A55ACAF054F957A1C9A597AEB1FCE359F88158F30D0F8D86C03B" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_time.lean", + "mode": "100644", + "gitBlob": "5692578e457e7231676cc20b97c715bda15f3205", + "rawBytes": 2522, + "rawSHA256": "E0AAA845F678834F1D8BAFBA9A52E59D261585C66797A96C083B4D5C13ADBA5D" + }, + { + "path": "docs/internal/f03_evidence/adv_f2_bridge.lean", + "mode": "100644", + "gitBlob": "ce3f026d15e5bb973dea1aeadb73ae51e90debe7", + "rawBytes": 5250, + "rawSHA256": "50E52EC28270573FBFD975879414BF33F8F8262425029E257687B0348FC25326" + }, + { + "path": "docs/internal/f03_evidence/adv_f2_nonstore.lean", + "mode": "100644", + "gitBlob": "d806cc2ed59e15e3014390a0b36e2a2eae089614", + "rawBytes": 4732, + "rawSHA256": "9927255460E4554F48BF483B466FCE7E329F446977015CD39D31C21CB73D0B39" + }, + { + "path": "docs/internal/f03_evidence/adv_f2_reach.lean", + "mode": "100644", + "gitBlob": "7468b985be07efa2347431285c21c33d0ca49436", + "rawBytes": 5647, + "rawSHA256": "F2514A5F08A05F691EA27B9F45630732DEBF8621521EDD2CCC1CE17335185037" + }, + { + "path": "docs/internal/f03_evidence/adv_f34_attack.lean", + "mode": "100644", + "gitBlob": "b7ee196406f9e23a8ec4f39e5f1f8280d4864791", + "rawBytes": 6936, + "rawSHA256": "EE417757DCD423AF0981E4316C4A3E3BE7E7BD47D23369AF794764BB75CFCB7F" + }, + { + "path": "docs/internal/f03_evidence/adv_f34_attack2.lean", + "mode": "100644", + "gitBlob": "5d3fe92753e2ac740e2344e17fe03465b3473bc4", + "rawBytes": 5172, + "rawSHA256": "20757C750C71EEBEC51A09EAFA78836AF13BF779184B9B0E19C0B466DB9F5DE2" + }, + { + "path": "docs/internal/f03_evidence/adv_f34_density.lean", + "mode": "100644", + "gitBlob": "9ee50adae44e409dfbd40963172aa84f06717b48", + "rawBytes": 5446, + "rawSHA256": "3CA82F2168389671A5C948D0614CDB9DB4B70CA9AD6400BFDC4472D85CA58CFE" + }, + { + "path": "docs/internal/f03_evidence/adv_f34_density_out.txt", + "mode": "100644", + "gitBlob": "cae228e346251d73adca25d6311c696f1b01bf91", + "rawBytes": 1275, + "rawSHA256": "869536B3A43BD6D0B1C71D02206EAD28DC4685981AB07BBB192F84B0B4CD7E0A" + }, + { + "path": "docs/internal/f03_evidence/adv_f34_out.txt", + "mode": "100644", + "gitBlob": "93ffe88d303e0b47b86bf8a46fe9d3a58dbe8bc0", + "rawBytes": 3274, + "rawSHA256": "8C600EC1F2DB13AC4E296026C9046C33F4DFCECFD139074D968264ED72A9311C" + }, + { + "path": "docs/internal/f03_evidence/adv_f34_reach.lean", + "mode": "100644", + "gitBlob": "31eb630c6517b8ad50ac7918a7eefa47f5396c0c", + "rawBytes": 2828, + "rawSHA256": "2DF6CB7BEB3EE14C4F666C235F83A3EAB4B97248E0B0C6EC7066F8F1AD4625AF" + }, + { + "path": "docs/internal/f03_evidence/adv_f34_refute.lean", + "mode": "100644", + "gitBlob": "c80408018f5616825b5cd00243b9b85bfc1b714f", + "rawBytes": 7257, + "rawSHA256": "D79B11F3F883BBC73EABAD102BCD05DCCB09281E7D25DDED59DE4E242A4ECC55" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_bign.lean", + "mode": "100644", + "gitBlob": "cc8df582f712480e9a720ecd70d40ad5ec5017a9", + "rawBytes": 5279, + "rawSHA256": "D73855ACF47E9824BCB7EDD9954B8F6A8F6EBBBAB5BFA54ABABDD2B33FE42A69" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_bign2.lean", + "mode": "100644", + "gitBlob": "562510a4f4e84d2b8524274938db6faed42e1e25", + "rawBytes": 5292, + "rawSHA256": "525BD12787316583B2E81C00A0246FCD10952D7CA927C052D0EFFA3F6A217B68" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_fulltrace.lean", + "mode": "100644", + "gitBlob": "fa3fd8108015f3b9dc84d60666687f1992bfbe3a", + "rawBytes": 6097, + "rawSHA256": "35136691B981601D49E721CB3ABAA03CB5FD80F63A65F17E878C8D37DA661F49" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_fulltrace_s.lean", + "mode": "100644", + "gitBlob": "c759d0fe400750f44d4350f07e04f9f650c6dc7c", + "rawBytes": 6090, + "rawSHA256": "2753620A7A2AF10EF52EFDD79D2727BC595C03D07C01C5AD23197E88A60C72E4" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_leafvac.lean", + "mode": "100644", + "gitBlob": "e2ca9442e955844ae3756da9765540748f1b6779", + "rawBytes": 6662, + "rawSHA256": "C4E081289AFB2CBF45CD6440CE4BCB731193B5C05B939A8B373C40A427C8A427" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_leafvac_out.txt", + "mode": "100644", + "gitBlob": "e7bfe7f6ad5c936a963b5680ba6d73c42f091d6f", + "rawBytes": 8800, + "rawSHA256": "77BD455E13B16E310B5185CD16B52B6FF0D6FE97B2685FE74BCC61F3BE9D366F" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_off512.lean", + "mode": "100644", + "gitBlob": "c47494d36f0b80b448f885b4087e46ae2d393f6c", + "rawBytes": 2166, + "rawSHA256": "CBFA26D6C0198544AE27C8695FF9E3990F6D92839FBFB9372EDCCAE1BA629519" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_offsets.lean", + "mode": "100644", + "gitBlob": "dde1c1693ff694c5760ce59bed02f5aa87cc68e2", + "rawBytes": 6403, + "rawSHA256": "09276AF3393F2F958DB3BEDFDFD38D825255C5C8E5628DF90BCB3DB073C4711E" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_offsets_big.lean", + "mode": "100644", + "gitBlob": "5cfe77bb262f39deff282ed4ea1cb4a450c204ff", + "rawBytes": 6411, + "rawSHA256": "200332316AB3C364F897578950F9ABA3D4C7232E7F8D72FF219E9C151C1CB65F" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_sweep.lean", + "mode": "100644", + "gitBlob": "468501e354f740fac5707daded0094a497a9f5bc", + "rawBytes": 4967, + "rawSHA256": "6709633E705AA539189CA7275C26445F05059EAADA75C2EE05260466DEEA7622" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_sweep_s.lean", + "mode": "100644", + "gitBlob": "a3da65ed76ceadde09615e2745e538cd20ab1995", + "rawBytes": 4941, + "rawSHA256": "9A5F7837FDFE19BAED5745A955492074ACE5F6B5017FF62353DF365F14144958" + }, + { + "path": "docs/internal/f03_evidence/atk_crossshape_big.lean", + "mode": "100644", + "gitBlob": "a2e4af929807b383a30cf22ec0cf6c0db1763209", + "rawBytes": 2575, + "rawSHA256": "5EA5EFB7CCF4503EB6ABCD83A6434EAFDE38B709D74CE3F841C5C7395CDDF5E6" + }, + { + "path": "docs/internal/f03_evidence/atk_crossshape_lite.lean", + "mode": "100644", + "gitBlob": "f27d423126edbd06a3d262f3febb246d6c91a84a", + "rawBytes": 1268, + "rawSHA256": "F574EF8A142D5E144FF6AC585A07BD599CFA9A524DF69ED818BFA54B5E37B2AA" + }, + { + "path": "docs/internal/f03_evidence/atk_frontier.lean", + "mode": "100644", + "gitBlob": "d6d3fcdbb0841fa9e861d430ccb59e9c49ea9b48", + "rawBytes": 6516, + "rawSHA256": "C8BC01583CB6E42030F05B4C6EDC62AAC8F12426906906E8BB27E023B7AE32C0" + }, + { + "path": "docs/internal/f03_evidence/atk_frontier_out.txt", + "mode": "100644", + "gitBlob": "ff4796c75fd34868d2c1414697d6f2c6b903f881", + "rawBytes": 8615, + "rawSHA256": "55B1227A8027D7902ADF5EF92575F972F31524E9AFF94164227701D72E800B72" + }, + { + "path": "docs/internal/f03_evidence/atk_guard.lean", + "mode": "100644", + "gitBlob": "58c350e22d246bc7216fb7aee6af6e9ff900ba87", + "rawBytes": 1095, + "rawSHA256": "8333E3DF8C169D83D80D15D275C0981EB629B82CE1FD53F1D6AEE8006372242C" + }, + { + "path": "docs/internal/f03_evidence/atk_lengthonly.lean", + "mode": "100644", + "gitBlob": "c25b1479720b1d899268da2189ae22949bb72c46", + "rawBytes": 2896, + "rawSHA256": "2C3107FD1DFF8C383B79388112D664A029DD913021A186F0CCB0A014E45111CB" + }, + { + "path": "docs/internal/f03_evidence/atk_linchpin.lean", + "mode": "100644", + "gitBlob": "fdaeca8c6b6dbe798a79172aa7220dddbe909e45", + "rawBytes": 8771, + "rawSHA256": "2A71020C34E62B369225C997CBA34BAFD713CA1A61917EB666E290ADCDAF5046" + }, + { + "path": "docs/internal/f03_evidence/atk_linchpin_out.txt", + "mode": "100644", + "gitBlob": "e59677e40021e324c8807e5fa1507ea7281dc290", + "rawBytes": 5870, + "rawSHA256": "E1C52D2378792F9AFE4220EA81A2C8962936E81013B31FFDE53C79F9F8F14F53" + }, + { + "path": "docs/internal/f03_evidence/atk_paths.lean", + "mode": "100644", + "gitBlob": "64dde886a22309b6aa5787c8fd1593b5e11fb8dc", + "rawBytes": 5578, + "rawSHA256": "269218005EFB0467CAC80E56A3FE4AD62066DB623881E1FA1F43E79C74278F3B" + }, + { + "path": "docs/internal/f03_evidence/atk_paths_out.txt", + "mode": "100644", + "gitBlob": "4847fad7938024eb1845042418b9e11b44ed64b8", + "rawBytes": 16931, + "rawSHA256": "3E22F9058195FC1203DD9D5CA706B395BE310955957DCBB2CFBF37485D20F8AC" + }, + { + "path": "docs/internal/f03_evidence/atk_sizeonly_eval.lean", + "mode": "100644", + "gitBlob": "e7428fe7e3c087bc21424aa80eb209a28ce483c9", + "rawBytes": 2669, + "rawSHA256": "03AD661C712E20D03BAA5381949D3AED6C6CFD138385F69F0A2990D6028B1AD6" + }, + { + "path": "docs/internal/f03_evidence/atk_taint.lean", + "mode": "100644", + "gitBlob": "44fdf1b596615d3dbad8952bfba4655248d18538", + "rawBytes": 6960, + "rawSHA256": "1E5F7047CBDE50615B372D07E138CC4FA713823CC5258C7D0AA1168A941BFC01" + }, + { + "path": "docs/internal/f03_evidence/atk_taint_out.txt", + "mode": "100644", + "gitBlob": "598102a099c916b944845993c7c86ca4e6f845ca", + "rawBytes": 3540, + "rawSHA256": "14E8FA27B8AB71462064A8BAC599FEF2BFCA93DDDD3A2AD00C7DA3408698AAD2" + }, + { + "path": "docs/internal/f03_evidence/c06_comp_antivac.lean", + "mode": "100644", + "gitBlob": "2f97fcfb8f38f24e64d78c5c57c8b23031f5d0d3", + "rawBytes": 2313, + "rawSHA256": "0A1B36E6F54014C0F48DD31507C4BCBE5D5B53614667AC13D04A8B92C2E7952D" + }, + { + "path": "docs/internal/f03_evidence/c06_composition.lean", + "mode": "100644", + "gitBlob": "348134a02687f616ba2643900887f253f39d4694", + "rawBytes": 2501, + "rawSHA256": "7562D98D3A17F6C7D3F38D90B2A0504540B01F83BE01077374F3BF32D36C13B7" + }, + { + "path": "docs/internal/f03_evidence/c06_f03_final_check.lean", + "mode": "100644", + "gitBlob": "034321cc0fd222658d34ad102a7ad0afbdb40ecf", + "rawBytes": 4036, + "rawSHA256": "FCF978516EBA22ED0563AEF720D30AB2354BE18455EFD182F7ACD2AC2FCB82C0" + }, + { + "path": "docs/internal/f03_evidence/c06_sourceinventory_check.lean", + "mode": "100644", + "gitBlob": "eda401aea5c91bdfda2801c66042087f321b9a4b", + "rawBytes": 1471, + "rawSHA256": "21725F258A614369613052F0DC472B30E5C4030C065DDB7D3E51C7D2A57C3805" + }, + { + "path": "docs/internal/f03_evidence/dpR9_f34_attack.lean", + "mode": "100644", + "gitBlob": "dbdee3e0ba4ad3880071da0e486bb626e5d454f1", + "rawBytes": 7402, + "rawSHA256": "6FE38F8BF3264838E475D4AADA116B88A82D93040E1C6F7FD0950C19628EBDF4" + }, + { + "path": "docs/internal/f03_evidence/dpR9_f34_regimes.lean", + "mode": "100644", + "gitBlob": "1266b9e1c0879378aabbda28209ccb968973f978", + "rawBytes": 2391, + "rawSHA256": "CC941A4DBB8CF9065194847A4754B782F308E57FAF5165A94F2E3B6963FDF122" + }, + { + "path": "docs/internal/f03_evidence/dp_cross_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_branch.lean", + "mode": "100644", + "gitBlob": "7220b65503936692061aa131eed911eba2e38eb7", + "rawBytes": 15399, + "rawSHA256": "E3676DB775BF5C4ED007FB071B656988C26B0895A3B4655D03EA98E86BACFBD2" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_branch2.lean", + "mode": "100644", + "gitBlob": "f8a5061654ee226d903079eda97be37743edef20", + "rawBytes": 12946, + "rawSHA256": "4B73DCF6934DCF8F918C1960BC13445E315C18ED09E65F856D9ED2BF8CB59B2B" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_branch2_out.txt", + "mode": "100644", + "gitBlob": "9d0d1fc9931dd78984e8d67bc627fdeac1b606f7", + "rawBytes": 22614, + "rawSHA256": "7637F1BD959813CA9217E5FE660EE603D345F59EACABA72DD30626B7BE0A44EF" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_branch_out.txt", + "mode": "100644", + "gitBlob": "12e06a862cd7caa3ebc8e49488d1ff13ab44a503", + "rawBytes": 12335, + "rawSHA256": "7EEAE522AEB9E55A47DC9C6615463D20DFCE7188D1FDA9D974D6686FB70B3204" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_cross.lean", + "mode": "100644", + "gitBlob": "1552e98131b1c0d3a06c81fdaf54d32a21bd52b3", + "rawBytes": 4673, + "rawSHA256": "24AFE12DFE1CDF881C3F53A803308D76621A9CB2ECDAF1363EAABA616DEE9590" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_cross2.lean", + "mode": "100644", + "gitBlob": "811409c44a1b63f3457748256a67e16db9059c68", + "rawBytes": 3947, + "rawSHA256": "16D75CB57208CB4381E732EA228F668968D43B2360B71A4F78CB7B3F00E9A2F3" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_cross7.lean", + "mode": "100644", + "gitBlob": "afdeb218825eb427e72f0df2f5a0a293ed00d89d", + "rawBytes": 2010, + "rawSHA256": "62B14CB14B45942744032E54218D29552EE755C07CE1FED57DCD6231BBB12139" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_cross_small.lean", + "mode": "100644", + "gitBlob": "56d69c962521cec866a30f2b68ed882c4fce58dd", + "rawBytes": 2238, + "rawSHA256": "52DB3D4660D9B1B389A887CD3295BB35CA5C43B9290EE9B025E5735F4C93641B" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_div.lean", + "mode": "100644", + "gitBlob": "3c785e707e976d6d3ce332b0b468f2fceef02075", + "rawBytes": 12292, + "rawSHA256": "9A87571C206083C495961798E4D3616AF3B4241C34EDA5B63951C0020322CDA9" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_div_out.txt", + "mode": "100644", + "gitBlob": "f3bcb53b5c2857526566ba8a49590e33fa920971", + "rawBytes": 23143, + "rawSHA256": "344FF32991D9ECB2A1553454488A2A2E66F176AC8306A8E730340733A6CC8CA2" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_path.lean", + "mode": "100644", + "gitBlob": "bd227cbd4aacfb635eee3a57e4c45b558b83c918", + "rawBytes": 3202, + "rawSHA256": "EEB04F999A9AFFD8E89337CB070B277D5A330B14B3B56A9325D73D1DEA353E82" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_path_out.txt", + "mode": "100644", + "gitBlob": "c455a263894c2bb5ff68a81a2aff32d44759e5e3", + "rawBytes": 11821, + "rawSHA256": "ADEFEC0ECCB0564B977E26680F4BB13B6D8F0D2F42F0511927ACEEF1FE20E947" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_rankfields.lean", + "mode": "100644", + "gitBlob": "ea62f45de157913b4e5abeb59c3642895bb7d67a", + "rawBytes": 2885, + "rawSHA256": "F2CB4DE4A8BE830308ECEA8AF21791B4E0210E4F14453BA8144A3D152D2C260B" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_size.lean", + "mode": "100644", + "gitBlob": "8feca10a722aae6c6dd168714202beaeb5ef165d", + "rawBytes": 8706, + "rawSHA256": "667322712B50A6F5728E9552BC24A029B47C79FB18E1B3700AA1BE7A31D54870" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_A.lean", + "mode": "100644", + "gitBlob": "7b8eeef3b13060b3a8e9fecd1704287b924048ae", + "rawBytes": 4423, + "rawSHA256": "BE1A9179BE11F57AC33E709D1FD0C514370ACE66252C7778E385A41E2C79B735" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_A_out.txt", + "mode": "100644", + "gitBlob": "5175afdc0e54f2ee4c3b62f3aa39dfbba9460a94", + "rawBytes": 627, + "rawSHA256": "066AFF6CB1CC35105E83C4EEC97D6CF7F09DA39BE565DB3E55E83F683B309C46" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_B.lean", + "mode": "100644", + "gitBlob": "c21fa704517e1d098f9b6c51f8d7d660ccd576e6", + "rawBytes": 3763, + "rawSHA256": "10D971DEEE48DABAFFA54924E3DF70A66B572224312D08C90BE6960E6840C2F5" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_B_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_C.lean", + "mode": "100644", + "gitBlob": "e448fbd2f4da3c9238f736909030d5722ed75501", + "rawBytes": 4009, + "rawSHA256": "9B9AC6D036CC9E9FFAEF2CD8512BDC5574786435263A464FB462E47A1CC7C70C" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_C_out.txt", + "mode": "100644", + "gitBlob": "8a531b130c650c9aa117412c8371c83abe06cf06", + "rawBytes": 5379, + "rawSHA256": "BABB25927D442DB2609995AD73AFA4BCEE0F7A78967EE2649299516BBA04BA24" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_D.lean", + "mode": "100644", + "gitBlob": "f82da2852577b4ab389edc53ca5fb795e15c8cfb", + "rawBytes": 4440, + "rawSHA256": "34A73593037E0DD184F45B4B0FB65041AEEB476407B186FC60365FD13AFFFD79" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_D_out.txt", + "mode": "100644", + "gitBlob": "44f84f6f85b0d82fbd1b9ae9954f28f85bddb9a1", + "rawBytes": 5186, + "rawSHA256": "688EE8A5A5F5CEF088C77A63F0112FCDFF5F4F9510356D59C78056B0E78E44E8" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_E.lean", + "mode": "100644", + "gitBlob": "d83d4414bb176462f528c3241e1a11e037871e19", + "rawBytes": 3864, + "rawSHA256": "B1F43DC1DD3C8ECFD57C23C9094351E81DE065C509A2FEE45A707E0BB913A29C" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_E_out.txt", + "mode": "100644", + "gitBlob": "77a43175d4be4d32e746aa2c161d0868d35518c0", + "rawBytes": 3338, + "rawSHA256": "E80519DCD3EE1457F32623F220F7726339270F714EBBE917BCD2EF9B09E5BABE" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_F.lean", + "mode": "100644", + "gitBlob": "2979430ea3033b5bfd0b4f49f11df5d6394282f4", + "rawBytes": 3381, + "rawSHA256": "1315D7FF8CACD60D494C734A87888D4D71552B4FDEA27E1A78E21E66D13EAD1A" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_F_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_G.lean", + "mode": "100644", + "gitBlob": "d91d0c2099dad6f253c786be9d2a4b0f89b070bb", + "rawBytes": 4108, + "rawSHA256": "4C6E970429F82FBC05201D8F118DC5F85F19A559D8BFB06CBC3B0B9FCA0ABD52" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_G_out.txt", + "mode": "100644", + "gitBlob": "c0d5b944d21325f0d059eb90f4b21dffbdbf47dd", + "rawBytes": 85, + "rawSHA256": "C3F33A8FD37784904EA1D7584B8F911520A3C7522FD7D34BE134A513EABCAE7F" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_smoke.lean", + "mode": "100644", + "gitBlob": "de38926d0df08a6b633adc6d2751908cbc8e9420", + "rawBytes": 1424, + "rawSHA256": "084FE3008E9C7C954201C9BA4EDE36F4EF2A882F37ABB98FBD052652F8BEA985" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_sweep.lean", + "mode": "100644", + "gitBlob": "42239a927db37d998c97c50f274462e24f33078a", + "rawBytes": 7022, + "rawSHA256": "2D24D94AEF9B456FD894A00DCB71EDF3FCAEE34AD41B59447384C1002061C445" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_sweep_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/dpx_a3_out.txt", + "mode": "100644", + "gitBlob": "a2e34e9e65f9afe3bb9789afe4e23a303f3fd5e6", + "rawBytes": 255, + "rawSHA256": "7BE6A7EDE7C0882317216D26EB0264F301C2837304532F2882707F937AD48110" + }, + { + "path": "docs/internal/f03_evidence/dpx_a4_out.txt", + "mode": "100644", + "gitBlob": "781126d79d4c919e8a0463cb1e425a8ff80e0515", + "rawBytes": 176, + "rawSHA256": "A756DB83B4865ECC2E0CEAE93D90C1BE205F5C579A8E6CD1F7FEFBAE269ED583" + }, + { + "path": "docs/internal/f03_evidence/dpx_f2_attack1.lean", + "mode": "100644", + "gitBlob": "80b6b8bf9afd7a921c20ff5eb079f2cc0b805110", + "rawBytes": 4731, + "rawSHA256": "B608353BAAA3DD577B33A6E81816B121883E2E78CFD3565A73757D5A9A1402CE" + }, + { + "path": "docs/internal/f03_evidence/dpx_f2_attack2.lean", + "mode": "100644", + "gitBlob": "973a4dad3922541f2ad624169b55442da78fe0ed", + "rawBytes": 5940, + "rawSHA256": "E218A0E43CC0D5ACFA7385FDE6A0407E99BC1EA92ADEF35E472B33C5C867D15F" + }, + { + "path": "docs/internal/f03_evidence/dpx_f2_attack3.lean", + "mode": "100644", + "gitBlob": "9d8e741d66840318b4eb006588a15896c46d8f85", + "rawBytes": 3717, + "rawSHA256": "7819DFB47CC9B60E1B1C1572A4FE2837E07560449C5AA63EEA9668C1DD382E85" + }, + { + "path": "docs/internal/f03_evidence/dpx_f2_attack4.lean", + "mode": "100644", + "gitBlob": "5469b47074ee4a9cfc94c325e592fb9ff98b6da2", + "rawBytes": 3301, + "rawSHA256": "F5909F163270669E0143BD4115D50077AC86B0FDD85BFC2547472E6E261ED776" + }, + { + "path": "docs/internal/f03_evidence/f03_F1_addr.lean", + "mode": "100644", + "gitBlob": "fe95008406fd8c717300af406f4991540049b27d", + "rawBytes": 1623, + "rawSHA256": "B2BBEE3870CFFD11A8B806395325150366990F5DAEDDD1F689BFD3C288E2695D" + }, + { + "path": "docs/internal/f03_evidence/f03_F1_exp.lean", + "mode": "100644", + "gitBlob": "c858176729826a7f86e27808ab2ee6c77106085d", + "rawBytes": 4963, + "rawSHA256": "467411CDCAA0AB0AA18648AE000CBAFF9E60B5825A847D4EBDF677E7A2A031F9" + }, + { + "path": "docs/internal/f03_evidence/f03_F1_exp2.lean", + "mode": "100644", + "gitBlob": "e02cc128d8dafe4e80300a7a25d1acbe72235361", + "rawBytes": 3670, + "rawSHA256": "9A76EA26952635C6FD9F6E3058B90E309AE62C7A8B3753BA572E45C71395E04D" + }, + { + "path": "docs/internal/f03_evidence/f03_F1_exp3.lean", + "mode": "100644", + "gitBlob": "5ac47b2615857dd898aa715091c953afc50ee6e4", + "rawBytes": 4156, + "rawSHA256": "4AC29311D71D30DAE497BD8430E787363547AAB99D3C494B5365E9296E74393B" + }, + { + "path": "docs/internal/f03_evidence/f03_F1_out.txt", + "mode": "100644", + "gitBlob": "665c0b498e86eedcd33480a0c933a8ffa2d5fe37", + "rawBytes": 763, + "rawSHA256": "24FDCD4D940624FD07717F69BF1295A4E1D9A25EB91BE3923CE7F1EEB98CBB97" + }, + { + "path": "docs/internal/f03_evidence/f03_F1_rankleaf.lean", + "mode": "100644", + "gitBlob": "042dd31f38cc540b1eef33834f40792424cc4738", + "rawBytes": 3547, + "rawSHA256": "4ED355EF4760220681BC962ACE60DFD5B8AFC80C6CD5BB2521961DE408BFD2D2" + }, + { + "path": "docs/internal/f03_evidence/f03_F1_thm.lean", + "mode": "100644", + "gitBlob": "09b68dc798d6966c22163270676f26746a6728de", + "rawBytes": 4159, + "rawSHA256": "6C71CAD4F9970E64E5008690F1ABD9F7364FCD6AB24472A6FC043C7A7298486C" + }, + { + "path": "docs/internal/f03_evidence/f03_F1_tiny.lean", + "mode": "100644", + "gitBlob": "099fede6238d5a6577c03b71fd0f5cca51f3f62c", + "rawBytes": 1123, + "rawSHA256": "06A0A4770B7109F7572B28302F71745C6BF960B7F829FAD9A5588372E31C3716" + }, + { + "path": "docs/internal/f03_evidence/f03_active_regime.lean", + "mode": "100644", + "gitBlob": "4b3dd02584af7008b31f3115dba6010a75f862e8", + "rawBytes": 3999, + "rawSHA256": "6B6FE026376A699C71C5CE09DD6CC4CB82DBBCF1C45D82C388782F2C984CDF8F" + }, + { + "path": "docs/internal/f03_evidence/f03_channels.lean", + "mode": "100644", + "gitBlob": "e5adebe754a27016f8771b5d4912848b3a4de59c", + "rawBytes": 4500, + "rawSHA256": "2AF4F79114AC6BCF303F780F10B9D989CBFED69A5518F4518081ED0A65FB59EF" + }, + { + "path": "docs/internal/f03_evidence/f03_channels_out.txt", + "mode": "100644", + "gitBlob": "6c36a456dc19315e32eeeb2f790097a55578154e", + "rawBytes": 1275, + "rawSHA256": "84F8270B146980FF5449407E83BDFF3912C8132072C3C9901262DEA156F17E2F" + }, + { + "path": "docs/internal/f03_evidence/f03_crossshape.lean", + "mode": "100644", + "gitBlob": "eb75f88b15e2d50e5265f62a55de00283fe87370", + "rawBytes": 2553, + "rawSHA256": "FB252ED629102963EECE560B3C0C3A34B6A6D28E2B1C0B5C9FD6DA2CFAB95327" + }, + { + "path": "docs/internal/f03_evidence/f03_crossshape2.lean", + "mode": "100644", + "gitBlob": "33f1bef50891549ddddf7ee22585b60d1b1ec6ca", + "rawBytes": 4420, + "rawSHA256": "4D7A42DCAF2B6A5CCDA439DA1CF73876DECB2DEFBA5D03617A58BB73A3C93418" + }, + { + "path": "docs/internal/f03_evidence/f03_f2_antivac.lean", + "mode": "100644", + "gitBlob": "7de89bebbed5180d65aa0179d6dbdcd1693d459d", + "rawBytes": 4155, + "rawSHA256": "2120BAC991A75C52D4389BF8B9D4A95DDBC0484FDD98CEEC76E000780D3CD5E8" + }, + { + "path": "docs/internal/f03_evidence/f03_f2_axioms.lean", + "mode": "100644", + "gitBlob": "97e131b0f97049da6305ec78a385342f53984f8d", + "rawBytes": 7325, + "rawSHA256": "3BF69A5E58DA9869673963AF233DC889C546AA8E8A3B93084407F9E9F9348F4B" + }, + { + "path": "docs/internal/f03_evidence/f03_f2_parents.lean", + "mode": "100644", + "gitBlob": "db8f52eebbab986e1ccb8d0649e388251f981da8", + "rawBytes": 1861, + "rawSHA256": "61EB1EE480148299CD6F8D294A6A78703D22EA881AE41A5EFD536204FAF2248B" + }, + { + "path": "docs/internal/f03_evidence/f03_f2_path.lean", + "mode": "100644", + "gitBlob": "03ea09fc507dd6fcb57a87a0af67bf4aac7edc77", + "rawBytes": 2164, + "rawSHA256": "8FF5B98BF88BC682594EC92E15A1D46272AF9584B98EE9694A890AC218B94CBF" + }, + { + "path": "docs/internal/f03_evidence/f03_f2_rankgeom.lean", + "mode": "100644", + "gitBlob": "65d4b6b88ba6be0a9b45317406183396ef93ba56", + "rawBytes": 6932, + "rawSHA256": "9CE9C2F0910C51BD24E6098884EB39F21A1DE6E57C9A87B2FC13FEF4A0EF0424" + }, + { + "path": "docs/internal/f03_evidence/f03_f2_segments.lean", + "mode": "100644", + "gitBlob": "0449a72bc695623267bee384af310856f09cfb1d", + "rawBytes": 2920, + "rawSHA256": "156CA2DBD8A0F05D7B532377771ED4D03D4B85395ABFB4B9A978AC929208E408" + }, + { + "path": "docs/internal/f03_evidence/f03_f34_binders.lean", + "mode": "100644", + "gitBlob": "9489b1fb7aa4790215fc38c09547d6b525026c8d", + "rawBytes": 1901, + "rawSHA256": "EDBEFC26C92467A5E4D45F5574EF5D091E450B793CB7E11E522A5EB8D303016B" + }, + { + "path": "docs/internal/f03_evidence/f03_f34_ir.lean", + "mode": "100644", + "gitBlob": "4a0274ad4bee6f5dadaff710691bc90dc7d46b17", + "rawBytes": 1444, + "rawSHA256": "8790411CC51CBA2B7DC3BF1AC6955E43089EEF3DC00F54990FBF1D2EA1D2A12E" + }, + { + "path": "docs/internal/f03_evidence/f03_f34_overhead.lean", + "mode": "100644", + "gitBlob": "4c6e7fa6bb74dbb2a90d2f9d74f207ec6c941c10", + "rawBytes": 4523, + "rawSHA256": "812190DD2E343E1261DF21CA1C2FA7450EA72FEE8564504C67CEEC0B4165F97A" + }, + { + "path": "docs/internal/f03_evidence/f03_f34_reach.lean", + "mode": "100644", + "gitBlob": "5d4bd56cce3c0bca06eb008becf0b5ce30ccd3bb", + "rawBytes": 3642, + "rawSHA256": "E086ECC745815754F5E109C41A167D191177F390EC3563EDA67E00B9C5BF6B99" + }, + { + "path": "docs/internal/f03_evidence/f03_interior_geom.lean", + "mode": "100644", + "gitBlob": "bbbc40c93d2ee4efbcca8fca1f57b62907e6ab32", + "rawBytes": 4487, + "rawSHA256": "0783D8EE32AEA6522F7175EFAD08419A471268038B451FD9F20400ED67BCC374" + }, + { + "path": "docs/internal/f03_evidence/f03_inventory.lean", + "mode": "100644", + "gitBlob": "783a3928c07ee4f069196d863f0db3ac0e69875a", + "rawBytes": 5418, + "rawSHA256": "9DEEAF33D994FD1DC74A5DB8D4A1C0613ABC5175E3D0456EB258CF3B9753652E" + }, + { + "path": "docs/internal/f03_evidence/f03_inventory2.lean", + "mode": "100644", + "gitBlob": "ec44b986b684c2ba1e72111140b0175d3e4e0403", + "rawBytes": 7292, + "rawSHA256": "089622DCBA16FFBA40600EC79F8F20DB988E51B34D17776DC0B9F2453BBC6800" + }, + { + "path": "docs/internal/f03_evidence/f03_inventory2_out.txt", + "mode": "100644", + "gitBlob": "f6c6dcbeac2767ddb228b31047834ad285fd0744", + "rawBytes": 4884, + "rawSHA256": "B7853677D2D0BC40420BEDE0ED3255A15A21B3FD5059E5AA4F2DFD37942ED950" + }, + { + "path": "docs/internal/f03_evidence/f03_inventory_out.txt", + "mode": "100644", + "gitBlob": "a6fae513c50cf3f369c91ad0a2aa04d18b16c878", + "rawBytes": 13069, + "rawSHA256": "24940C9D7D405D7605DC4BC8ABA41384FD21DA63C6B12A4B6065613177BC3AD4" + }, + { + "path": "docs/internal/f03_evidence/f03_lca_leaf.lean", + "mode": "100644", + "gitBlob": "a42e2d4e526580a24b76205f770d606b292beb4c", + "rawBytes": 3393, + "rawSHA256": "7A5607FCE727ACFBF5FCC862519EF2A9AD9A580B9718E46D6D1DDB925D2612F2" + }, + { + "path": "docs/internal/f03_evidence/f03_lca_min.lean", + "mode": "100644", + "gitBlob": "47a15334946e6e35551c57ecf9bf4cdde1e82093", + "rawBytes": 2651, + "rawSHA256": "FD261ABDBEB58BDC55B579343087B818FB3DE1A21C5E0C5AA57CCCA317E62445" + }, + { + "path": "docs/internal/f03_evidence/f03_lca_min_128.lean", + "mode": "100644", + "gitBlob": "47a15334946e6e35551c57ecf9bf4cdde1e82093", + "rawBytes": 2651, + "rawSHA256": "FD261ABDBEB58BDC55B579343087B818FB3DE1A21C5E0C5AA57CCCA317E62445" + }, + { + "path": "docs/internal/f03_evidence/f03_lca_min_256.lean", + "mode": "100644", + "gitBlob": "6eedfcbeacfa503d07c1e803b844dafea6051647", + "rawBytes": 2651, + "rawSHA256": "D6FA4D50F083C572FE32C50EC8BCC6C201B59A2706BF05BF1AE34F2EB39EA878" + }, + { + "path": "docs/internal/f03_evidence/f03_lca_small.lean", + "mode": "100644", + "gitBlob": "27b5b63e006b34ebfc7aa25013245d66b34316c6", + "rawBytes": 3385, + "rawSHA256": "7CF60BC044344BD1FDA6497FB4AB81E5E0550650C7BBE5312FC161175E798C14" + }, + { + "path": "docs/internal/f03_evidence/f03_longflag.lean", + "mode": "100644", + "gitBlob": "36e5677773418bdffaccf5346afb686107c38a1c", + "rawBytes": 4431, + "rawSHA256": "3C72F2C3C8E6279D99EEE4593EDC0D5C34540C607CA37D9F91460B0D8D76E9CC" + }, + { + "path": "docs/internal/f03_evidence/f03_probe.lean", + "mode": "100644", + "gitBlob": "5e08bbe10c33e807533a3f86506a8c9a0ee2e03d", + "rawBytes": 454, + "rawSHA256": "07BB8CFDD6C17D901735C9C00F484EB2A5142DCC547E58893F2EBC46DD7FC8EC" + }, + { + "path": "docs/internal/f03_evidence/f03_regimes.lean", + "mode": "100644", + "gitBlob": "38b85bba93964ff7280ff90cabfe99d2f85d426b", + "rawBytes": 3928, + "rawSHA256": "EABF83B15B44F8632B96C0DE7A4C75FB1A8277E812F255243BB3D9C23CFEFE50" + }, + { + "path": "docs/internal/f03_evidence/f03_sel_n128.lean", + "mode": "100644", + "gitBlob": "30fca7bbbf98422021821312656c1fa1564bfa8a", + "rawBytes": 5138, + "rawSHA256": "9A5A5BE37C438B10C400333EFFF52E97FA604DC451A762B7F23DB441D08C81FD" + }, + { + "path": "docs/internal/f03_evidence/f03_sel_n256.lean", + "mode": "100644", + "gitBlob": "7ae7cdf9d3446020818d51ead1ac499f216ead6b", + "rawBytes": 5138, + "rawSHA256": "6F6E8ECF80EA3541A5D9B3B6EEE5C229B509085C8279DD4C391F9B54597AB8A2" + }, + { + "path": "docs/internal/f03_evidence/f03_sel_n512.lean", + "mode": "100644", + "gitBlob": "cf4e16759c4e9211d6a7465e959ea4b8038308f5", + "rawBytes": 5138, + "rawSHA256": "346DE79677AA63E6AE5C66CF3E0F37E7D839A360C13EEFB14B03F007D930C23A" + }, + { + "path": "docs/internal/f03_evidence/f03_sel_n64.lean", + "mode": "100644", + "gitBlob": "5371b6a8a539d651914b941bd98b81d16616e8b2", + "rawBytes": 5137, + "rawSHA256": "9CE2AA8B1430A1FDAB315E44253F1971F9E0BFD4B253E9AAC6409316B97433D7" + }, + { + "path": "docs/internal/f03_evidence/f03_select_leaf.lean", + "mode": "100644", + "gitBlob": "332e818a483c3c4c647117e64040103086cc563f", + "rawBytes": 5145, + "rawSHA256": "AB974A1ED7C7433B5291B30A2A1CCC34455DABA3D98CB24564A0B2C7CE735FD2" + }, + { + "path": "docs/internal/f03_evidence/f03_select_leaf_n8.lean", + "mode": "100644", + "gitBlob": "1926fe2339d94da67c9ab5fd603c5105ed3f2029", + "rawBytes": 5136, + "rawSHA256": "527D203149A86C13CD1012B3504355426B7252FD2443F61D90173CC89D124F37" + }, + { + "path": "docs/internal/f03_evidence/f03_superlong.lean", + "mode": "100644", + "gitBlob": "33078301253b2114dde1d46402ab02524deb2081", + "rawBytes": 6095, + "rawSHA256": "84C5D3614BF005FD5E39D2624C7674EE0A071E02131EB9BF534A50054BEF22A2" + }, + { + "path": "docs/internal/f03_evidence/f03_theorem_probe.lean", + "mode": "100644", + "gitBlob": "a40b95b2d71715c239aa559c5cddff51d6b85c31", + "rawBytes": 5483, + "rawSHA256": "E6854514164FA743F37529760F52EEC7CBB7974D27FE9086B6918FE1D910A3A7" + }, + { + "path": "docs/internal/f03_evidence/f5_big.lean", + "mode": "100644", + "gitBlob": "0497bc80351badd31e79b2f6323482e682a21dc0", + "rawBytes": 4394, + "rawSHA256": "6A70C05D49A97CDAEE6AD98D1B07E5CDF12BCA535FB06C92096746E0A5A569E8" + }, + { + "path": "docs/internal/f03_evidence/f5_big_out.txt", + "mode": "100644", + "gitBlob": "ba01b9dc8b276e8a93f411cdf80689b4ac7f7d3c", + "rawBytes": 2208, + "rawSHA256": "540C082AAE24F5CFFE326D1FC913CA69E9A3808D9B3ED91EC30BB629D9B275C7" + }, + { + "path": "docs/internal/f03_evidence/f5_callers.lean", + "mode": "100644", + "gitBlob": "5e33d2175ebe11156f7c079953a982e8b2c4aa59", + "rawBytes": 4289, + "rawSHA256": "9B76A8EB662BAC79D6E16C30290077FD9B96C6BE6556EF947DD8AC7B5407B1DD" + }, + { + "path": "docs/internal/f03_evidence/f5_callers_out.txt", + "mode": "100644", + "gitBlob": "4d7345fb66a280a6e6154addb9bea4c920dd0a19", + "rawBytes": 17460, + "rawSHA256": "4C8B8E4938FFD567A9C59F214A3C1FF31ABE3ADCABD785AB5E9FEB2F8847F85B" + }, + { + "path": "docs/internal/f03_evidence/f5_exec.lean", + "mode": "100644", + "gitBlob": "bfa31907bd1d9b921ba6b420afe08fbfa97ba70a", + "rawBytes": 4210, + "rawSHA256": "317675D693B55A28BBA97E18A28851E81365398C7EF592F12810F8A77CBEB4CF" + }, + { + "path": "docs/internal/f03_evidence/f5_exec2.lean", + "mode": "100644", + "gitBlob": "7d08b1d97db34699fd49f5c1994e88b8fc9918cc", + "rawBytes": 3429, + "rawSHA256": "07C92D730E1AB45FC5CB89786ABF0E845439D0BD20E4797BCF05D2B75D4BEE87" + }, + { + "path": "docs/internal/f03_evidence/f5_exec2_out.txt", + "mode": "100644", + "gitBlob": "20194e78b5b81f9f3beb7dc54f3f1b06831405b6", + "rawBytes": 1892, + "rawSHA256": "D1425FFE7C3B699FC5EC709B7792F8539CB9928A5CF3D854F4104CFC9AB4DA17" + }, + { + "path": "docs/internal/f03_evidence/f5_ir.lean", + "mode": "100644", + "gitBlob": "30c1a460fb58e66fc44ba3ae698fc2d197394e5b", + "rawBytes": 3485, + "rawSHA256": "F02C499EBA77BDF2C8B49133914322C681107649AE2BB9237D5686B8D2D30A0D" + }, + { + "path": "docs/internal/f03_evidence/f5_ir_out.txt", + "mode": "100644", + "gitBlob": "e15b7435d9a722d70c90e3daecf4d34567f49520", + "rawBytes": 1383, + "rawSHA256": "47DE9E5862FC60913939B78694B963A1320E64BD7ED7DF93DB654E091B514DB8" + }, + { + "path": "docs/internal/f03_evidence/f5_irdump.lean", + "mode": "100644", + "gitBlob": "6785d35fe058b51a25dc01aebdf49b81d3f99235", + "rawBytes": 1469, + "rawSHA256": "FC930F6F46C87B6377264645F455CE2E17DA0C6224BCEBDBBCB48D8C9C909A90" + }, + { + "path": "docs/internal/f03_evidence/f5_irdump2_out.txt", + "mode": "100644", + "gitBlob": "163e2ed966a04181124298bb1e910739de6d7a0f", + "rawBytes": 11490, + "rawSHA256": "05522143B255326C82F74B73CDFCCEDF00A80BEF8D206E14D7FBA02D050EBBB7" + }, + { + "path": "docs/internal/f03_evidence/f5_irdump_out.txt", + "mode": "100644", + "gitBlob": "67787ae9fa3412120eababd75db80416ca05d43a", + "rawBytes": 9393, + "rawSHA256": "7978DB838C50AD9DDCC6A33042AEE99FF2691B293464BFE267D4940C31D3771A" + }, + { + "path": "docs/internal/f03_evidence/f5_irpath.lean", + "mode": "100644", + "gitBlob": "73a3d1ef6bd977f1ace93e94f601b83cf793dbbe", + "rawBytes": 3530, + "rawSHA256": "3A90C0A59480C275FC19AC6B909AA67B5C7C2029919470568FE6FDF4373D78F0" + }, + { + "path": "docs/internal/f03_evidence/f5_irpath2_out.txt", + "mode": "100644", + "gitBlob": "93106df0732ca5c5cb52baac5c7d8a04bdb7ed4f", + "rawBytes": 15806, + "rawSHA256": "102626723D15C2A38B802E3FED38A28AEDE36BC08F731C717B673B3F3D5E2032" + }, + { + "path": "docs/internal/f03_evidence/f5_irpath_out.txt", + "mode": "100644", + "gitBlob": "74b1754797e56dbc388b92584826028967ee9272", + "rawBytes": 6022, + "rawSHA256": "B9F8E9875EBA9EE3A4FB4618E453279B008565F01B0B2865EB3B3B7E574A2B2C" + }, + { + "path": "docs/internal/f03_evidence/f5_lemma.lean", + "mode": "100644", + "gitBlob": "80124f4651a810c6d5e4312cd2fcb70dd8b59952", + "rawBytes": 5008, + "rawSHA256": "5F0F2ABD47EB14E69E4A7534738E02BD5BFF169214848FB02E4720885E360072" + }, + { + "path": "docs/internal/f03_evidence/f5_probe_api.lean", + "mode": "100644", + "gitBlob": "ec80405988a4491d58a13a7de7a6fde25754593f", + "rawBytes": 482, + "rawSHA256": "D6E0E6DCA6591BE76AFEA526017B65D0EA0EE0D04955FD034ABB5CED09AD9168" + }, + { + "path": "docs/internal/f03_evidence/f5_probe_api2.lean", + "mode": "100644", + "gitBlob": "d909f7ed95447f006f33f3421e1c7d7e04bd6875", + "rawBytes": 173, + "rawSHA256": "B1557D922083C2F7B5BD6A9471ED5528504F01A2D8AAAF39CD1F872B9BBF8CCE" + }, + { + "path": "docs/internal/f03_evidence/f5_probe_api3.lean", + "mode": "100644", + "gitBlob": "ed55b160447844d334d004606a69920a62458b78", + "rawBytes": 86, + "rawSHA256": "ABE18C884DB8B73A7039F9E3488FA185DA43D0532A8580C7E4C63A594E7CE979" + }, + { + "path": "docs/internal/f03_evidence/f5_subgraph.lean", + "mode": "100644", + "gitBlob": "d4290a61be01c8a96485eb686adfcffde6546334", + "rawBytes": 3226, + "rawSHA256": "B942B1A2116605858F9F138CBD8018E0F3002E96A5AA7ED1BC45EFB6436813F2" + }, + { + "path": "docs/internal/f03_evidence/f5_subgraph_out.txt", + "mode": "100644", + "gitBlob": "1f73429cec2046ddf711e228354e4f4b2a411c41", + "rawBytes": 13185, + "rawSHA256": "1C4B62DEE61AE6735C71284137B55071CD4BF69AAD337F7BEB4A4EC51CA86645" + }, + { + "path": "docs/internal/f03_evidence/f6_bits.lean", + "mode": "100644", + "gitBlob": "c2d68ed0efb2fd549428d231b0cce9fd10d9ee67", + "rawBytes": 5230, + "rawSHA256": "813F4E832E343A0BCB08B566D769CEB1281696398762B24A69EBC763E1DDEE3A" + }, + { + "path": "docs/internal/f03_evidence/f6_bits_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/f6_leafL1.lean", + "mode": "100644", + "gitBlob": "8671df42044ffbacb365c86963b4c275bcf6090e", + "rawBytes": 7097, + "rawSHA256": "330B31B3BC95DA93D03BF511D8B1427D711A37430AF4A8FFEC6375A97F012D11" + }, + { + "path": "docs/internal/f03_evidence/f6_leafL1_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/f6_proj.lean", + "mode": "100644", + "gitBlob": "3717dfca5e83ebe3b229fb4d95d1912a76a33dd1", + "rawBytes": 3205, + "rawSHA256": "290C1663501829EEC6D5DA38CA8DED67D1F4ED0921C54848C0450275DD302D59" + }, + { + "path": "docs/internal/f03_evidence/f6_regimes.lean", + "mode": "100644", + "gitBlob": "fdd6dd93b2843b05f57142abf2ff7bdba222b365", + "rawBytes": 4873, + "rawSHA256": "13085CF745918220641A4D26EBCB3E7C94AA32BF1A31B7720E5B8B4FB80451C5" + }, + { + "path": "docs/internal/f03_evidence/f6_rfl.lean", + "mode": "100644", + "gitBlob": "c22f5c8a8bc9f7db571b239ec7c47a44cca12fe8", + "rawBytes": 2185, + "rawSHA256": "A1343E4871B1206BF49C538961244A4E2EA3C75B5D230D133355E44FF23FCF18" + }, + { + "path": "docs/internal/f03_evidence/f6_rfl2.lean", + "mode": "100644", + "gitBlob": "70184be4f0f248776c39e53053e2e44a352abc57", + "rawBytes": 1247, + "rawSHA256": "C69F62DD8F0DC5854D425DEEA8B12F6CCFD89DD35E68717FA8F536E04E3B380F" + }, + { + "path": "docs/internal/f03_evidence/f6_rfl_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/hdr_f34_ax.lean", + "mode": "100644", + "gitBlob": "9bf2309ed6e32cefb04b0613d0bfeebb44a6dbf5", + "rawBytes": 3873, + "rawSHA256": "41AA69E1ADC1EA1FCE304190F054C9815819709355A807F0C1263A8A8C7A494E" + }, + { + "path": "docs/internal/f03_evidence/hdr_f34_thm.lean", + "mode": "100644", + "gitBlob": "c4c9f4d2716d0b5852fe19a2b1141e07c5a67005", + "rawBytes": 3683, + "rawSHA256": "DEDC76ADB09CFEE0E59333E8B6DDA34FC7FC043EBC0C0E7ADE69D0585527BE56" + }, + { + "path": "docs/internal/f03_evidence/hdr_offsets.lean", + "mode": "100644", + "gitBlob": "772b563dbf86cd2a7b039673b63fcd371f386cb7", + "rawBytes": 1319, + "rawSHA256": "D524C6FD0C6B65A033222F34E2CA9B95EA36E05E30A9CB9D66817BF7F386D655" + }, + { + "path": "docs/internal/f03_evidence/hdr_scalars.lean", + "mode": "100644", + "gitBlob": "e59d99ee50c2e11b8c17d0136d69683b67d97cca", + "rawBytes": 3252, + "rawSHA256": "4EF456FFD923B83C1116DF75F43649D3896FFA4ED86DE4BFD95BD4A9579EE229" + }, + { + "path": "docs/internal/f03_evidence/hdr_scalars_out.txt", + "mode": "100644", + "gitBlob": "5f3eb5a09adb65cdda6c7e4376c786340b3f3f6d", + "rawBytes": 2951, + "rawSHA256": "4890EE0AE3938D0295286D82B17F4B89FA1DB0AEF16C70623F1121560A30B8CB" + }, + { + "path": "docs/internal/f03_evidence/hdr_schema.lean", + "mode": "100644", + "gitBlob": "805b61fd500ea4901c226dc14bcadc5438ef95d8", + "rawBytes": 4421, + "rawSHA256": "D54AAFCD32A0F0A08CC613567C084B035359427DAD9CBE21C7B5CFD42ADB45FD" + }, + { + "path": "docs/internal/f03_evidence/hdr_schema_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/hdr_seglen.lean", + "mode": "100644", + "gitBlob": "dae0b5dfe5ac59951e432167fe86c2464e69ac5e", + "rawBytes": 3727, + "rawSHA256": "0DE7625F56D03D997D8FDB4D91EDF3FD19D0680C062E23F835C88B89E44152BB" + }, + { + "path": "docs/internal/f03_evidence/hdr_seglen2.lean", + "mode": "100644", + "gitBlob": "1fd2b2e52ffcd96a7150bc68314d978d6135e140", + "rawBytes": 3425, + "rawSHA256": "252C1A8DBECB1355EC5CEBDF292F9A0478DE57EC7F6E188FE2E58B96DF81D2E8" + }, + { + "path": "docs/internal/f03_evidence/hdr_seglen3.lean", + "mode": "100644", + "gitBlob": "c58539bb5b291777c377fde1a237c1a41792f105", + "rawBytes": 3452, + "rawSHA256": "896D31245CA12CE438EFE3DF409DCBE1354728E553FBF2EE593437A4120A7591" + }, + { + "path": "docs/internal/f03_evidence/l2x_l2_crossblock.lean", + "mode": "100644", + "gitBlob": "b4413cf9afdd28aa1100ba33af9098eb880495e9", + "rawBytes": 37772, + "rawSHA256": "2F6794C883C636D715F92C9541BDB1AA88C87AAE116BD29C11AF7B92561724F0" + }, + { + "path": "docs/internal/f03_evidence/l2x_t4_capstone.lean", + "mode": "100644", + "gitBlob": "9853ce2593e9b5229606ca8c20e22bd493375b89", + "rawBytes": 63283, + "rawSHA256": "CB046722A7492DC69C1EC4ACF8D43A93E440255C46D1D0C9248DA9F3241EDE84" + }, + { + "path": "docs/internal/f03_evidence/qz_int2.lean", + "mode": "100644", + "gitBlob": "8d5d27cd93e1c6f3fe3eeb7b5368c1f1c50bd558", + "rawBytes": 3269, + "rawSHA256": "58D0B95673C711FDC4AA8AEBC8B85378121F9678F9AA357438455D304F501E44" + }, + { + "path": "docs/internal/f03_evidence/qz_int2_out.txt", + "mode": "100644", + "gitBlob": "7fd17bb50da1cdaf9d8486481d4341a5c4cc77cc", + "rawBytes": 1419, + "rawSHA256": "A5325F98D2EB5C0B166DD1FC5BFBD568C1990F2F921DA4CB59E1E9A60C84D7B1" + }, + { + "path": "docs/internal/f03_evidence/qz_interior.lean", + "mode": "100644", + "gitBlob": "357bf73daa9de5f1c568cfd0b386725277b6db82", + "rawBytes": 5953, + "rawSHA256": "1F11D08F9E6DF252B475EE65F45336AA105F9BFA982804714FD5120BFADD2A63" + }, + { + "path": "docs/internal/f03_evidence/qz_interior_out.txt", + "mode": "100644", + "gitBlob": "31196019932a80cf35393f245e25bd901646c846", + "rawBytes": 318, + "rawSHA256": "A357DCFF5D8D24A42D99DF7F953D386E7162FFA77F4D33686A9E22F6A6BE00F0" + }, + { + "path": "docs/internal/f03_evidence/qz_mech.lean", + "mode": "100644", + "gitBlob": "0893b968ac272932af2970ed4104776f6a479523", + "rawBytes": 8325, + "rawSHA256": "A1513D0B146BFDFE5A4F67106C98B74D840FDA151449511886E0ADF51396455C" + }, + { + "path": "docs/internal/f03_evidence/qz_offsets.lean", + "mode": "100644", + "gitBlob": "f4c2930ce4e7b877ab28bac9136ad4c30b9d1a3e", + "rawBytes": 6013, + "rawSHA256": "DA4A9D7D17D32820530259ACF60087C94C4C1FB54657DE80A4ED8183DFD96397" + }, + { + "path": "docs/internal/f03_evidence/qz_popcount.lean", + "mode": "100644", + "gitBlob": "cd3be9c108bebb6003adca644cc8c206273e983e", + "rawBytes": 2249, + "rawSHA256": "FEC09D8422664441C1762E181384FB41224171B8A7E7D24DD409F91F09CC4F2E" + }, + { + "path": "docs/internal/f03_evidence/t1_c06_verify2.lean", + "mode": "100644", + "gitBlob": "84304e4d585f2549eb6e1712054f8a246bdad6d0", + "rawBytes": 14160, + "rawSHA256": "FF5C6486B74A4633D61AD8120F1DF04ACA0D6BAE33764D4807A9EBC98B2F8446" + }, + { + "path": "docs/internal/f03_evidence/t1_readprogram_core.lean", + "mode": "100644", + "gitBlob": "7e5e1851eb13c9a1854fc037d57bfeaabd69cea2", + "rawBytes": 2572, + "rawSHA256": "72DD83DEF761F62F0CD6FDB8BC27887D4BB79A3A22278DB87DC6584076887F53" + }, + { + "path": "docs/internal/f03_evidence/t1map_layer2.lean", + "mode": "100644", + "gitBlob": "5f873a222883ccd63aad70cad11fca8e4224cf52", + "rawBytes": 11131, + "rawSHA256": "A0DD737A57CE39218B2DF4BCD3DE87125ECB6DA9095B41EFD9B1B82FDFC1E3F9" + }, + { + "path": "docs/internal/f03_evidence/t1map_obligations.lean", + "mode": "100644", + "gitBlob": "8056c5290f89d73830111c9aca683cb150c8c6f5", + "rawBytes": 7826, + "rawSHA256": "7FC0CB5C4E37AD602555505B60E7F1545D49D112D182434845F82D553A970518" + }, + { + "path": "docs/internal/f03_evidence/t1map_route.lean", + "mode": "100644", + "gitBlob": "09bd3e69dbdc6c7254f3c0c5f04ce11d372b6572", + "rawBytes": 4141, + "rawSHA256": "9EA9C2AD2D43A9EDF775A8B5B3FA5AAA0A22AAE15B7D611DDE7ABF56CA67B0F9" + }, + { + "path": "docs/internal/f03_evidence/t2_l2_selector_sameblock.lean", + "mode": "100644", + "gitBlob": "d08c8d26c33644d10eb3f1c7f8d5e162934b4459", + "rawBytes": 24660, + "rawSHA256": "05D87090ABE7B05A3327384F4A53BC7A22CB2D66B0CE3B4BCF5E5DB029F59160" + }, + { + "path": "docs/internal/f03_evidence/t4pub_audit.lean", + "mode": "100644", + "gitBlob": "e5793847f92b1f2789aecab22523516c9e7ed090", + "rawBytes": 83344, + "rawSHA256": "E6B61FD59CD36369F05A884E1E9280979B15132D4184A5D1FE0DD23BEF2503CE" + }, + { + "path": "docs/internal/f03_evidence/t4pub_public_entry.lean", + "mode": "100644", + "gitBlob": "a37e36481d35e44e985b319b5ed5ae0228ad4019", + "rawBytes": 77302, + "rawSHA256": "64B9A67209449F6CA0921FC74713AC12A776943058E3CE9C6619308C49F59C90" + }, + { + "path": "docs/internal/f03_evidence/w2_l2_l3_interior.lean", + "mode": "100644", + "gitBlob": "56545e891420ab77683e01cf43ec9d7deb18cc46", + "rawBytes": 47927, + "rawSHA256": "631D9D5FE11A515DE500C4BF0FCD4BEA09FC16809F8EEEAA7B7767966004AB9D" + }, + { + "path": "docs/internal/f03_evidence/wq_branches.lean", + "mode": "100644", + "gitBlob": "a462d271c3a74b24a266199079f7fe6a179364f8", + "rawBytes": 4531, + "rawSHA256": "9832F911566E06191FCE1F7381760928312C51193F69CC621442B17C99171120" + }, + { + "path": "docs/internal/f03_evidence/wq_branches_out.txt", + "mode": "100644", + "gitBlob": "d123b254e7edef8fccbc4bfeb037e656e724a223", + "rawBytes": 2795, + "rawSHA256": "224646A2E624F7448486CBB14CAEE72ECCFA755DD6CF56F4FF88140D3F7BC5B6" + }, + { + "path": "docs/internal/f03_evidence/wq_checked.lean", + "mode": "100644", + "gitBlob": "f8f1567aab48bd05beac97dfc7c87338222b47f5", + "rawBytes": 4720, + "rawSHA256": "67AE1E9655F3B5F550E8D7208C11D3618BFFB8A038C5C85D0E4F283FA5D07681" + }, + { + "path": "docs/internal/f03_evidence/wq_checked2.lean", + "mode": "100644", + "gitBlob": "71188940371a4f662b56312130b33d6c66ea6ce3", + "rawBytes": 5591, + "rawSHA256": "F095B01B77EB28DBF70E3252BCBBC48FAD1688AE083E7B69AFF96C2CC8A6D183" + }, + { + "path": "docs/internal/f03_evidence/wq_checked2_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/wq_checked3.lean", + "mode": "100644", + "gitBlob": "d39bb0a960ab2a53c6c8f3cf18772e6997d2687f", + "rawBytes": 2602, + "rawSHA256": "17B5A551BAC25C43E866C73A332F8E74C148FCC4A3FCAC7E49FC2324B387DF2A" + }, + { + "path": "docs/internal/f03_evidence/wq_collapse.lean", + "mode": "100644", + "gitBlob": "3cff617de194f3726122079ed60b791cbb178141", + "rawBytes": 5844, + "rawSHA256": "A4D5586FE84E4703714FEAB6B7D524753D352CCEFAE26ECF39A5F60406CA1C14" + }, + { + "path": "docs/internal/f03_evidence/wq_collapse_log.txt", + "mode": "100644", + "gitBlob": "0fb4f17846405abae42e640476cd0743ce51d3dc", + "rawBytes": 1443, + "rawSHA256": "5D9543C8C0490E79E5D7E4D614EF5A9E09B95E6D598592DB3300A7C1F6EFA086" + }, + { + "path": "docs/internal/f03_evidence/wq_collapse_out.txt", + "mode": "100644", + "gitBlob": "0fb4f17846405abae42e640476cd0743ce51d3dc", + "rawBytes": 1443, + "rawSHA256": "5D9543C8C0490E79E5D7E4D614EF5A9E09B95E6D598592DB3300A7C1F6EFA086" + }, + { + "path": "docs/internal/f03_evidence/wq_extrap.lean", + "mode": "100644", + "gitBlob": "4e1a8f81f7cf0bb1ebeeccdcd311cdeeddbb03df", + "rawBytes": 2469, + "rawSHA256": "F427A2B28415ED299A5B86F855655141BEACC75B67F1335EC14A1DE587167C08" + }, + { + "path": "docs/internal/f03_evidence/wq_extrap_log.txt", + "mode": "100644", + "gitBlob": "0cd66bc2dc647588151825dde6a3e98e362d5497", + "rawBytes": 1240, + "rawSHA256": "7EE572D596211234D260452AC67695E72CFA585A65904FC7D587D3295456572B" + }, + { + "path": "docs/internal/f03_evidence/wq_extrap_out.txt", + "mode": "100644", + "gitBlob": "0cd66bc2dc647588151825dde6a3e98e362d5497", + "rawBytes": 1240, + "rawSHA256": "7EE572D596211234D260452AC67695E72CFA585A65904FC7D587D3295456572B" + }, + { + "path": "docs/internal/f03_evidence/wq_longfront.lean", + "mode": "100644", + "gitBlob": "715737df3df482e603c320b08133b20a6ba83967", + "rawBytes": 7122, + "rawSHA256": "F244273C60F92A2D826B6A42738F619556BF8CB7746A4476A79641AEE4405C17" + }, + { + "path": "docs/internal/f03_evidence/wq_longfront_log.txt", + "mode": "100644", + "gitBlob": "42eb5b8133f13fe8e06b4ec2e3f0dffea71cd3ac", + "rawBytes": 8462, + "rawSHA256": "DEC58C8C7F66109663DE0CAD2E339F1B704B3E7F47304586FFFC59F06B9E1B83" + }, + { + "path": "docs/internal/f03_evidence/wq_longfront_out.txt", + "mode": "100644", + "gitBlob": "42eb5b8133f13fe8e06b4ec2e3f0dffea71cd3ac", + "rawBytes": 8462, + "rawSHA256": "DEC58C8C7F66109663DE0CAD2E339F1B704B3E7F47304586FFFC59F06B9E1B83" + }, + { + "path": "docs/internal/f03_evidence/wq_mismatch.lean", + "mode": "100644", + "gitBlob": "0aa0c089b80c62f6929969aef66097321f1f57e6", + "rawBytes": 5680, + "rawSHA256": "00838213F9EAB6DC51BD98CA6F8A15199565D019F21B1289ECA1155119422291" + }, + { + "path": "docs/internal/f03_evidence/wq_mismatch_log.txt", + "mode": "100644", + "gitBlob": "b2e43246214b29336f78c7df3165c65dd62b340f", + "rawBytes": 424, + "rawSHA256": "B750B6858C0CA552647FEF31E6F89932C6E908B999BA6176C310E744DEE55E5C" + }, + { + "path": "docs/internal/f03_evidence/wq_mismatch_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/wq_regimemember.lean", + "mode": "100644", + "gitBlob": "4535f5df9f0448a8b907c788fc33571a6b3b28dc", + "rawBytes": 5280, + "rawSHA256": "059333FE2D9EEF1D906991ABDF5CC3F0565573308FAA5D1A586E70BF1AFDDFF6" + }, + { + "path": "docs/internal/f03_evidence/wq_regimemember_out.txt", + "mode": "100644", + "gitBlob": "f6a1b783eb4c357ed1d9841448ad7bc9c7367a7d", + "rawBytes": 2177, + "rawSHA256": "2BEE1FEA839F1F50FF218641A286A90C247AE5BEE6811117A63F0BC9D1148F56" + }, + { + "path": "docs/internal/f03_evidence/wq_sens.lean", + "mode": "100644", + "gitBlob": "6e4143d4fa343f9a4856b75c8176a3402ec68b92", + "rawBytes": 2935, + "rawSHA256": "F4F0273F22676C6799DCCE30616ADEF75229E465205CE63F8CC318C31FA327FC" + }, + { + "path": "docs/internal/f03_evidence/wq_smoke.lean", + "mode": "100644", + "gitBlob": "3265600418e221b59cbe5e3fed563595a88ff605", + "rawBytes": 1459, + "rawSHA256": "6ACFF6A4DFFC7E05C95F2C4B143F13A0D31ECE267D0D8F127BE53437E1D70D0A" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_a.lean", + "mode": "100644", + "gitBlob": "156af0058260edf382e8735c4a211bf11f574713", + "rawBytes": 7123, + "rawSHA256": "1ECE28BC27659F94E89D659919498F465A659E071957F2BAB9A7E5FC35D629C5" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_a2.lean", + "mode": "100644", + "gitBlob": "ff5e0c5cb303041e136b0726da99035cb5297772", + "rawBytes": 6581, + "rawSHA256": "F93A8F51C794C447966BB867D64AB4714158F417C4E46CB0125737DB0570E3E2" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_a2_log.txt", + "mode": "100644", + "gitBlob": "8c0b068c596cedb7691bdc2115012ed738ae10ed", + "rawBytes": 1568, + "rawSHA256": "D286701517FEBEEF11A1793146098C1988A74F44156C5009F8FB66301B44371F" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_a2_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_a_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_b.lean", + "mode": "100644", + "gitBlob": "db4df154bac5195905e33d61e136cf539439cb99", + "rawBytes": 4505, + "rawSHA256": "B854AF791E6A3502E9EF0AC6CC7A586F515DE4347A5DD85F422A406ACBA5A625" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_b_log.txt", + "mode": "100644", + "gitBlob": "ac95899c085c5f1e74e81dd09518e37c3aec55c0", + "rawBytes": 110, + "rawSHA256": "4F0B9AFDE1DD8EF28A97106418D093891B2DD456600185AD07A26B75EFEE53DF" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_b_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_big.lean", + "mode": "100644", + "gitBlob": "799596eadc4bdf80176777ea1764ecd880c073f3", + "rawBytes": 4517, + "rawSHA256": "38F8CB62BC35111CF3EDB9AD36EA09429D605D3E42968635BFA85BC0D942ED14" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_big_log.txt", + "mode": "100644", + "gitBlob": "67b38de33dbc11f0df0daaab99983e9ddbd2f2f5", + "rawBytes": 47, + "rawSHA256": "CD431BD6EAB1AFC189996103EB8618BC63BD0011CF10D73B2C9A14662F03A120" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_big_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/wq_thresh.lean", + "mode": "100644", + "gitBlob": "31711fe4452df471ffa21014e32d0375f2537de1", + "rawBytes": 5393, + "rawSHA256": "52E0095B21B5D4E0F4335AD1C720CCFCBF2CBE717033454709E3A79504B98D80" + }, + { + "path": "docs/internal/f03_evidence/wq_thresh2.lean", + "mode": "100644", + "gitBlob": "09a6aadeb60a8640dd77ba206e4e7a7071a0881e", + "rawBytes": 2336, + "rawSHA256": "29B0B34760FEA04B957596C2D2DFBB9944067511507751E984274EF599F44095" + }, + { + "path": "docs/internal/f03_evidence/wq_time.lean", + "mode": "100644", + "gitBlob": "3adea40fea9430f513db739c554841fc24249fb1", + "rawBytes": 961, + "rawSHA256": "CA5DDEBADD082318A6A5C3D5E56FC7DA45D1D363F19A428861DDDA2DD5CED30C" + }, + { + "path": "docs/internal/f03_evidence/zz_blind_diff.lean", + "mode": "100644", + "gitBlob": "b5d90987a13c90a2b2f45656c1d5cba911b8efe0", + "rawBytes": 2277, + "rawSHA256": "C10520EA13913CB583840A6C1C814429366FCB6B0C9B79F7F23C6814BC203659" + }, + { + "path": "docs/internal/f03_evidence/zz_blind_elim.lean", + "mode": "100644", + "gitBlob": "dfbccf01062c03244099186fb73d5d98d984017d", + "rawBytes": 7111, + "rawSHA256": "560C5B8ADF710C4BF453867D1A4229378D15A531B499DE87E5E80D7703639D96" + }, + { + "path": "docs/internal/f03_evidence/zz_blind_elim_out.txt", + "mode": "100644", + "gitBlob": "ae5b87cfb1999fa8175ff9f354065c3a099f0709", + "rawBytes": 22198, + "rawSHA256": "17F3EA3FB57FBABEE3676304BD0C5F58E4409D0FB6853CDCD36758FE2231C0C5" + }, + { + "path": "docs/internal/f03_evidence/zz_blind_invisible.lean", + "mode": "100644", + "gitBlob": "c342506905e21c51315fbf28b95ea84c8995edff", + "rawBytes": 4339, + "rawSHA256": "0E519A145FBBE318A05080CFDD2F116CA0110ADAAF4C08E36480E63475644D6F" + }, + { + "path": "docs/internal/f03_evidence/zz_blind_invisible_out.txt", + "mode": "100644", + "gitBlob": "2558921679801824c8e3d60e97f415ce3836d2fc", + "rawBytes": 5666, + "rawSHA256": "2ABA2832A7378EB42FFA1105E8E78E44EF43E0CE2ADBFFBDD7C1461A6003E86A" + }, + { + "path": "docs/internal/f03_evidence/zz_blind_modes.lean", + "mode": "100644", + "gitBlob": "abddb928b720d2fc1f02dd54a4253c36a27df7f9", + "rawBytes": 6662, + "rawSHA256": "E69C1A28202794B6E6C28D217A9585DD91D903551F50D81B8785A1B1CCD4C921" + }, + { + "path": "docs/internal/f03_evidence/zz_blind_modes_out.txt", + "mode": "100644", + "gitBlob": "1f9aa1ce5c41ad176f1c1aef8f01225021c13b51", + "rawBytes": 1132, + "rawSHA256": "45E751DA968F7A4A92EB124311EF3770A46616E6325D14EEEA556B6C178AAD13" + }, + { + "path": "docs/internal/f03_evidence/zz_blind_rev.lean", + "mode": "100644", + "gitBlob": "66fd0ed69c81b5a92a42c4d7659a13c75b6fd7a8", + "rawBytes": 6624, + "rawSHA256": "1326B9233CD7B439D78EE8A7D9D44CBB662F16D58985E2908C62733E2E62C6A9" + }, + { + "path": "docs/internal/f03_evidence/zz_blind_rev_out.txt", + "mode": "100644", + "gitBlob": "bf8ecb27cc308791dad4088e1860c2de7c9a682b", + "rawBytes": 6744, + "rawSHA256": "1D7F93E5FA1C03B5FB8EF2D3DE92A1DA8DAC2FAC2E846CE720DBB6364E97A063" + }, + { + "path": "docs/internal/packed_query/PQ1_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "d49e00a7c4838ba66d9ac9685abef7ec25598d04", + "rawBytes": 47712, + "rawSHA256": "E9045CBBE821ECC10187FD06BFFA024E69BCA9DC76C93578F271A33D47D55C48" + }, + { + "path": "docs/internal/packed_query/PQ1_CALCULUS_MATRIX.md", + "mode": "100644", + "gitBlob": "7499ee1923d5447d61a5d562816be1dc4f834d15", + "rawBytes": 10206, + "rawSHA256": "28270074AFD2964440C24B5A70C36656949D561A61201C212E319E40DF304A40" + }, + { + "path": "docs/internal/packed_query/PQ1_CALCULUS_PROMPT.md", + "mode": "100644", + "gitBlob": "d65f1754227c5ceb2e4c9bc3a30ecef9765d0b9e", + "rawBytes": 6946, + "rawSHA256": "3660477F7B9CA7B25BAD6C50626B9915CBED798ED81C0A9C532AEFE8D46912BB" + }, + { + "path": "docs/internal/packed_query/PQ1_CALCULUS_REPORT.md", + "mode": "100644", + "gitBlob": "7f213c2e8a8df16b13d354fb5396f67071f19cd2", + "rawBytes": 16173, + "rawSHA256": "2E6311896FD3DE13A687A3B43D4853642AC04A2179D8EB5D05F99DAF8057D943" + }, + { + "path": "docs/internal/packed_query/PQ1_COMPILER_MATRIX.md", + "mode": "100644", + "gitBlob": "ca6341967dde11922e43b89673e58acbbf65e0a8", + "rawBytes": 12970, + "rawSHA256": "0DB706AE9C0BD18E51C1BD83E2FAB6425D696CD81EC9A11E60A696FA66C210C8" + }, + { + "path": "docs/internal/packed_query/PQ1_COMPILER_PROMPT.md", + "mode": "100644", + "gitBlob": "9ff8cda9170d7e94bd7c070c69193548fd57b56f", + "rawBytes": 7174, + "rawSHA256": "7333C26E9D2E6979B63F3B63085CD910D705DC239D82046FDE9F6EF3A6EF443C" + }, + { + "path": "docs/internal/packed_query/PQ1_COMPILER_REPORT.md", + "mode": "100644", + "gitBlob": "9ce167073696a052118107c3bfa3b58ff4281127", + "rawBytes": 18792, + "rawSHA256": "9C325166B6645726F9C76325580DA55AEFC2274766FA5F5E2D3C25966D517B7F" + }, + { + "path": "docs/internal/packed_query/PQ1_CONTINUATION_AUDIT_20260911.md", + "mode": "100644", + "gitBlob": "7dfa53241b60d4517e93ab49d42bac0f2a75c5d1", + "rawBytes": 18939, + "rawSHA256": "4CBB80DFFF4BDF33FC857004DFDD94ECD1D62814FE1268F6BD0A08509B808D5E" + }, + { + "path": "docs/internal/packed_query/PQ1_COORDINATOR_ACCEPTANCE.md", + "mode": "100644", + "gitBlob": "9bb5d43e7bb67d8a447ebe683f31860f380c87c7", + "rawBytes": 14134, + "rawSHA256": "C1FD55B51457E89F8F46F8EA13424F3D2B26C8CD95FE45362A22CFA368C9390D" + }, + { + "path": "docs/internal/packed_query/PQ1_FRINGE_SAFETY_MATRIX.md", + "mode": "100644", + "gitBlob": "c1a481c9026907c9488d274d66742be8ea3237d0", + "rawBytes": 13359, + "rawSHA256": "08E5F53F226840D68BA243EFB013A65ACF0DD9FC5B22C5150A3FD78F070B9006" + }, + { + "path": "docs/internal/packed_query/PQ1_FRINGE_SAFETY_PROMPT.md", + "mode": "100644", + "gitBlob": "5e1836b2b16f3d3da0c4dd8dc48eac44c1f033ac", + "rawBytes": 7434, + "rawSHA256": "8F5482648C701350AE2D38B5C8C38FBFDD054BE4ED7CCCA2F3EE0E789AF8B3A9" + }, + { + "path": "docs/internal/packed_query/PQ1_FRINGE_SAFETY_REPORT.md", + "mode": "100644", + "gitBlob": "ebb751059b9f144ea22f34ebc71b6935cf525159", + "rawBytes": 26960, + "rawSHA256": "ADD862CC9A746E4DD4FCDC9D6CBE9BACEFEF598BC9D15F485AB648083A3A9656" + }, + { + "path": "docs/internal/packed_query/PQ1_INTERIOR_CANDIDATE_MATRIX.md", + "mode": "100644", + "gitBlob": "bf5833efa949b8b2fbe9e19bce18647709d16147", + "rawBytes": 21548, + "rawSHA256": "C04900132448055926F4AC21EFE96A6F68A0D7AC5C6437EB9CFCAF4290C38A05" + }, + { + "path": "docs/internal/packed_query/PQ1_INTERIOR_CANDIDATE_PROMPT.md", + "mode": "100644", + "gitBlob": "7a32b274722ba7ae1d64bf26c16c5ec3b9269cbb", + "rawBytes": 9322, + "rawSHA256": "58762A10341FE9251721D3EF49349C854F37340D868C7B34FB5A729F947924B7" + }, + { + "path": "docs/internal/packed_query/PQ1_INTERIOR_CANDIDATE_REPORT.md", + "mode": "100644", + "gitBlob": "0dfdebbd3d8fa2612fcb86cad6dc722336c0e931", + "rawBytes": 17883, + "rawSHA256": "A93310A7DD3AB42154A47620A91E130F50C21CE0029E18D1512DBF2DBADA4AD5" + }, + { + "path": "docs/internal/packed_query/PQ1_INTERIOR_SAFETY_MATRIX.md", + "mode": "100644", + "gitBlob": "55985de18b41d8f3faa1dfc2fe26d5eb1a5c3e03", + "rawBytes": 14258, + "rawSHA256": "FF1D6698A3825E270B29478BB85E0E355D36330A07F5F25AB004F0CD1287831A" + }, + { + "path": "docs/internal/packed_query/PQ1_INTERIOR_SAFETY_PROMPT.md", + "mode": "100644", + "gitBlob": "20ab5873f389eda7f17ba2f07e609222edafe4b4", + "rawBytes": 7417, + "rawSHA256": "9852763D4D2DD75D50F8E245E78314FF1DA4EC3252EB53D00BEED80CBB456E28" + }, + { + "path": "docs/internal/packed_query/PQ1_LOAD_SAFETY_MATRIX.md", + "mode": "100644", + "gitBlob": "f7d1db209f9d6881becb829282d07f8e5c267662", + "rawBytes": 14193, + "rawSHA256": "5D065A6ECD97EB4F5314C3BCD6EE71A4FE560A4979383F50C1C9AC0F25D5062C" + }, + { + "path": "docs/internal/packed_query/PQ1_LOAD_SAFETY_PROMPT.md", + "mode": "100644", + "gitBlob": "64ebc2996a01f3d364f78ff9bcb41244d8860e68", + "rawBytes": 6822, + "rawSHA256": "651E99C38D12F1CE0E4AE4168BD939368B5584B7459926BDC9433B5F88962A40" + }, + { + "path": "docs/internal/packed_query/PQ1_LOAD_SAFETY_REPORT.md", + "mode": "100644", + "gitBlob": "0b40cc7ee506c574414b57a0c29a2771822ccd73", + "rawBytes": 18443, + "rawSHA256": "EEC357153E0C787B52DFFBABFAC4B7D790415A75D6611A17AB309B9816A52B49" + }, + { + "path": "docs/internal/packed_query/PQ1_LOCATE_MATRIX.md", + "mode": "100644", + "gitBlob": "d5f92c16a43a73216f953f4c52e879e021702bf2", + "rawBytes": 12658, + "rawSHA256": "241979F668395E7D970F21BDC2F6204617DD9A7471A733E1D7BDAE0229AE38CC" + }, + { + "path": "docs/internal/packed_query/PQ1_LOCATE_PROMPT.md", + "mode": "100644", + "gitBlob": "21af554a383e9a860da359ee7e81252852089ca2", + "rawBytes": 7430, + "rawSHA256": "8FF76786C878D9C98D32A9EC0F4B53A1747F264372C74A0C8DB0BAE67DAE9395" + }, + { + "path": "docs/internal/packed_query/PQ1_LOCATE_REPORT.md", + "mode": "100644", + "gitBlob": "650c00512242e125e3909d46f47302830d598d12", + "rawBytes": 13885, + "rawSHA256": "F8B8926F322D2BD0D4A8A2B749026631FB386431A328DFA3934B8E33163680F5" + }, + { + "path": "docs/internal/packed_query/PQ1_LOGICAL_SPAN_MATRIX.md", + "mode": "100644", + "gitBlob": "11f2c86fd20d6601b98a11499e6865caf6c1f642", + "rawBytes": 16343, + "rawSHA256": "8AFC390E2E932A5C759FA9909F9CE1905D14A9492736949F1DD4DF069704F3C7" + }, + { + "path": "docs/internal/packed_query/PQ1_LOGICAL_SPAN_PROMPT.md", + "mode": "100644", + "gitBlob": "e736aea7770042f4912bc95eba769f013dc7266b", + "rawBytes": 7443, + "rawSHA256": "D6DF64EE82819B246918C0E9515FCC2A59B417FF2B7973CC72D7D8E5459843FE" + }, + { + "path": "docs/internal/packed_query/PQ1_LOGICAL_SPAN_REPORT.md", + "mode": "100644", + "gitBlob": "f7301043413cd355d2ba4161eb51151ef20e463e", + "rawBytes": 12880, + "rawSHA256": "68215D91FB55C69EAEFC0BFE2307CE71CF21E23B3FAB00088CE558E1CBF7890B" + }, + { + "path": "docs/internal/packed_query/PQ1_MODEL_AND_PROOF_DAG.md", + "mode": "100644", + "gitBlob": "c2529c547e9f3d40f36131b18b61c769ba1afe2e", + "rawBytes": 8139, + "rawSHA256": "0D484A3520831346C9C71822A3C378D4B1A0A2B4E7796332B7849A9FE6C9B655" + }, + { + "path": "docs/internal/packed_query/PQ1_QUERY_SAFETY_MATRIX.md", + "mode": "100644", + "gitBlob": "4be2096b3246af25351767af95abad5b41bc2569", + "rawBytes": 11702, + "rawSHA256": "DE0310EF3D2E918F6BF3405BC033A5F54AF478B34E50B043A1E738791B0A65E0" + }, + { + "path": "docs/internal/packed_query/PQ1_QUERY_SAFETY_PROMPT.md", + "mode": "100644", + "gitBlob": "b7f8ee3b36b0f5737922579d2155e8df0d739e2c", + "rawBytes": 8511, + "rawSHA256": "E6367A8E0F9F5771AF38A0DDA2BB730DAB5EEF9BF57F04C30671B6C165F0BB31" + }, + { + "path": "docs/internal/packed_query/PQ1_RANK_PROOF_MATRIX.md", + "mode": "100644", + "gitBlob": "cd5b24afe9f035664f45075fea158ca1a822843d", + "rawBytes": 17006, + "rawSHA256": "BE669EEA3534F49557EB7E884E1D12BAB15DF204F6834EF18FE8DE30D47031D7" + }, + { + "path": "docs/internal/packed_query/PQ1_RANK_PROOF_PROMPT.md", + "mode": "100644", + "gitBlob": "8d50811ba44e49e37d8d51eba8a55567c032e816", + "rawBytes": 8311, + "rawSHA256": "6F2A2F67FC6C9A484DF5454AA4829C695D9A57759EA3C3C091970CC5EA23D4CA" + }, + { + "path": "docs/internal/packed_query/PQ1_RANK_PROOF_REPORT.md", + "mode": "100644", + "gitBlob": "59c6a465c4c3c8879bc83123f04403e6d15766f5", + "rawBytes": 11905, + "rawSHA256": "8CA7FA347A9408023DDB50D0812F933BF53088001AA3C8BB16E69CF70C6D3F8B" + }, + { + "path": "docs/internal/packed_query/PQ1_RANK_SAFETY_MATRIX.md", + "mode": "100644", + "gitBlob": "865adf10e226b5a8e89d212d42ce8d92b301cf23", + "rawBytes": 13659, + "rawSHA256": "3717C1552A1E815912D359C1DBB0E2E82DB129D56866F9B9A581D2BF1AB68FE5" + }, + { + "path": "docs/internal/packed_query/PQ1_RANK_SAFETY_PROMPT.md", + "mode": "100644", + "gitBlob": "019f4b2f5466a9d23b2e8efcb9cf35db076c610b", + "rawBytes": 6694, + "rawSHA256": "4D3260A3A206D665E4EC9A26DFEED2D20035F07E8758D31F2B2365B9F1DFBD77" + }, + { + "path": "docs/internal/packed_query/PQ1_RANK_SAFETY_REPORT.md", + "mode": "100644", + "gitBlob": "162d6b05ca77522b4ef3f33e3f0de6794bdc3471", + "rawBytes": 34791, + "rawSHA256": "D8A04B76F040366BA52DC18982872FB2D0076C54AF0D7CA0451F418319A9A20A" + }, + { + "path": "docs/internal/packed_query/PQ1_READER_SAFETY_MATRIX.md", + "mode": "100644", + "gitBlob": "13d6f93a3bdfc1001bfafea03d78976e4475fe07", + "rawBytes": 14991, + "rawSHA256": "EF7EBD2EDF9DE2AC7E19ED24D6E125862EAEA3FD9D73B336FDB4EF64099ADCC4" + }, + { + "path": "docs/internal/packed_query/PQ1_READER_SAFETY_PROMPT.md", + "mode": "100644", + "gitBlob": "8c92eac6024cc6b1b069a6e52eec263f20d478ba", + "rawBytes": 8348, + "rawSHA256": "E05457E0485A08CC233CFF160F2BF35C0AC9ECE7F75FD32A2ADA811613F6A16E" + }, + { + "path": "docs/internal/packed_query/PQ1_READER_SAFETY_REPORT.md", + "mode": "100644", + "gitBlob": "6fb4f29022244e8d8618d71e6e939e358b18725b", + "rawBytes": 16403, + "rawSHA256": "5DA7013165D2E8FA768E4E8B720A7911F48B85EEEBD37FCAED4B0281DCFB511A" + }, + { + "path": "docs/internal/packed_query/PQ1_SAFETY_MATRIX.md", + "mode": "100644", + "gitBlob": "5e9020c691c78b8e1874124c1596ebe96b3132f4", + "rawBytes": 13788, + "rawSHA256": "2F3E9AAFB9BA4BB768A1F2D5922867A9574861B4EEB3C60D9B6DFEC0D6C5D2A9" + }, + { + "path": "docs/internal/packed_query/PQ1_SAFETY_PROMPT.md", + "mode": "100644", + "gitBlob": "a7f7c4428f9b29f044a9f9b925cb2f77b8d14ecb", + "rawBytes": 6776, + "rawSHA256": "0A811DAE7269A0DC850F1CA504EA1E5DC982FCAC7D565806270A60967B6A853B" + }, + { + "path": "docs/internal/packed_query/PQ1_SAFETY_REPORT.md", + "mode": "100644", + "gitBlob": "f1a77d387d1d1d8c6153de08c8844f3e5f31f745", + "rawBytes": 19959, + "rawSHA256": "E48166421AF238635E31E86445EEA5CE7A07B4A7C153F5C4D18F6DD7D2E91AE4" + }, + { + "path": "docs/internal/packed_query/PQ1_SCOUT_CONTROL_PROMPT.md", + "mode": "100644", + "gitBlob": "117e3b4deea78463604ab5d87172e7f8d5f26665", + "rawBytes": 4752, + "rawSHA256": "DA6366BD7A35E4AC956CDA221CB5954B796D144D3B2FB1A9A5F3C60141CD702D" + }, + { + "path": "docs/internal/packed_query/PQ1_SCOUT_MEMORY_PROMPT.md", + "mode": "100644", + "gitBlob": "af706c9efd3c056cde15d388882f8c8863f9d47b", + "rawBytes": 4471, + "rawSHA256": "86C2690EBD7C6E54971A2A80175034B708E6FA6453EE1CAB3E2B61FA279DD555" + }, + { + "path": "docs/internal/packed_query/PQ1_SELECT_PROOF_MATRIX.md", + "mode": "100644", + "gitBlob": "b319481fa6e815287d758cea2c68e69c53d420f9", + "rawBytes": 20822, + "rawSHA256": "384094C13DA955A6D9FE7776A57E9C09A98DD0263A2127543F26C0FAC398073F" + }, + { + "path": "docs/internal/packed_query/PQ1_SELECT_PROOF_PROMPT.md", + "mode": "100644", + "gitBlob": "d363a1eb11a9c2a6cc48cb92f7e48af1e2da38de", + "rawBytes": 8311, + "rawSHA256": "A6F262915C579E5DA632200138AD5239373B395BD82E4F91165479D6AFD1B6EF" + }, + { + "path": "docs/internal/packed_query/PQ1_SELECT_PROOF_REPORT.md", + "mode": "100644", + "gitBlob": "d13d929fb066c7cc1fe4d4e06e44250a5b793598", + "rawBytes": 13634, + "rawSHA256": "B357BD67BF7420233C4C2FDF68A1D6A24991020BA048500660B0AB9CAA0A3278" + }, + { + "path": "docs/internal/packed_query/PQ1_SELECT_SAFETY_MATRIX.md", + "mode": "100644", + "gitBlob": "c2977a1e49b80f43f7ef4080af21405d706da20a", + "rawBytes": 27631, + "rawSHA256": "1D376AFEB2FBADE82B58F67C15C8DD2D95E3AC840884C09D1D0FD6CEA9E6EA37" + }, + { + "path": "docs/internal/packed_query/PQ1_SELECT_SAFETY_PROMPT.md", + "mode": "100644", + "gitBlob": "5fb75dfae88a292ae40da193438307090e01e0c4", + "rawBytes": 6967, + "rawSHA256": "DDB29AB58E22AE76EB966D6983504B5197F03DCDC3CFA867A51962A1F2E1FC50" + }, + { + "path": "docs/internal/packed_query/PQ1_SELECT_SAFETY_REPORT.md", + "mode": "100644", + "gitBlob": "0b28955ca38ad7a963307ed669c168b8465403fc", + "rawBytes": 10974, + "rawSHA256": "125BEA3E2589CB556DAADDADE31F4B909D593DBB0C373E756411BA74160CC8B6" + }, + { + "path": "docs/internal/packed_query/PQ1_SETUP_MATRIX.md", + "mode": "100644", + "gitBlob": "51cc65369f443d5594f3e8d25989bd4e506595b9", + "rawBytes": 15160, + "rawSHA256": "5DABAFF48F2E952FF42D31E9BE0E9654FA905E8CFF0EE7D1F49F88818B0FAF89" + }, + { + "path": "docs/internal/packed_query/PQ1_SETUP_PROMPT.md", + "mode": "100644", + "gitBlob": "0103507552f7c5fa6f05b0aac1b354cf36321fb9", + "rawBytes": 6238, + "rawSHA256": "F9E0304B95219AE40EAF839B1C98CF9C9C1A0E9B16649B73B4E9C2754481248D" + }, + { + "path": "docs/internal/packed_query/PQ1_SETUP_REPORT.md", + "mode": "100644", + "gitBlob": "378699114923e5c02b9d2fc00be6a5e21da1901c", + "rawBytes": 8323, + "rawSHA256": "03BB82397A6D6A5917FACAC71BB00E051CEFE1CA2298989AB758254F5B1A0DF6" + }, + { + "path": "docs/internal/packed_query/PQ1_SOURCE_INVENTORY.md", + "mode": "100644", + "gitBlob": "02fe5c84bbd50e78e00ac52e2a717fe985ebeece", + "rawBytes": 7143, + "rawSHA256": "5B07395933DE75678BCA9F2FABE42F63949E27994AA9FF6F3973A66F35FCD6B7" + }, + { + "path": "docs/internal/packed_query/PQ1_SPAN_ASSEMBLY_MATRIX.md", + "mode": "100644", + "gitBlob": "ce6b994a0310d634745b4b0c3987531191583486", + "rawBytes": 17581, + "rawSHA256": "8DE87DEC805A31AB7815968A1E4EBDA0AF76AAA4F19CEBA5551E55D8F1E3E32C" + }, + { + "path": "docs/internal/packed_query/PQ1_SPAN_ASSEMBLY_PROMPT.md", + "mode": "100644", + "gitBlob": "bf687762c4c2125a6470a5906501e29e67482bdb", + "rawBytes": 7392, + "rawSHA256": "44A8A6F58BF4CF5282AC89B80D46B28DBFD12EBC4108DFA5BC251973E01493FD" + }, + { + "path": "docs/internal/packed_query/PQ1_SPAN_ASSEMBLY_REPORT.md", + "mode": "100644", + "gitBlob": "bb463938cd6a6a8d827a0949448783c42161e546", + "rawBytes": 13371, + "rawSHA256": "FFF6A3F404E506D2F7AFE1C29DF7FDF331A63CFDD720850E70FA29287FC864A7" + }, + { + "path": "docs/internal/packed_query/PQ1_SPAN_MATRIX.md", + "mode": "100644", + "gitBlob": "863a43610bc481325a398e1f416a162c903507ca", + "rawBytes": 15781, + "rawSHA256": "F7CC8E7FA8AFB6C4A2EA067F888F318D6FC93D666744D1F28C5234EEC9915D0E" + }, + { + "path": "docs/internal/packed_query/PQ1_SPAN_PROMPT.md", + "mode": "100644", + "gitBlob": "b57550c81e534c29e8c456e4c7e4b2b186201eb2", + "rawBytes": 6941, + "rawSHA256": "E77950A68BAB1D572B1171DD4950AD243DDEBEF5B87429F9F90DF2AEF0171E5A" + }, + { + "path": "docs/internal/packed_query/PQ1_SPAN_REPORT.md", + "mode": "100644", + "gitBlob": "2ccddc96cebbd3380297457f5b976fa42ef82ac8", + "rawBytes": 11489, + "rawSHA256": "3B7327C6F3ECE0F16909099B6D978B0ED10E0E0753B6A3BDF60C1FD7826ADE13" + }, + { + "path": "docs/internal/packed_query/PQ1_VALIDATION_PLAN.md", + "mode": "100644", + "gitBlob": "b14a64c1bd8a595bdec301768fabb807f67c76c9", + "rawBytes": 21486, + "rawSHA256": "19E58D6FFE48EBEFAF4A80E7A3EA9C56B53429B0839CC71B667013C01F8CB3A2" + }, + { + "path": "docs/internal/packed_query/PQ1_WIDTH_MATRIX.md", + "mode": "100644", + "gitBlob": "402dd21d065be5bd0d570038066d4fb42b5cfbb5", + "rawBytes": 12742, + "rawSHA256": "0BC62713892B85337359E33B9CD138CBD642EAC5C3CCA522BC8C310DC142FAE6" + }, + { + "path": "docs/internal/packed_query/PQ1_WIDTH_PROMPT.md", + "mode": "100644", + "gitBlob": "6a497241f03f7e8e6b689c5e469236acdec612df", + "rawBytes": 6376, + "rawSHA256": "6174BBFA2DE26E83F3584B9F20182F9A37178570A6EC35ECF1048534CF6196C8" + }, + { + "path": "docs/internal/packed_query/PQ1_WIDTH_REPORT.md", + "mode": "100644", + "gitBlob": "881e14b2a7063ad103a26bc6dbfb784bef864a63", + "rawBytes": 8189, + "rawSHA256": "6313FFF421F5AB80EB27DF92488445A26391C9F376693D6BF22751A54F82C111" + }, + { + "path": "docs/internal/packed_query/RC6_SOURCE_SYNTHESIS.md", + "mode": "100644", + "gitBlob": "ff522886495a8a000691fef69201a7af4ed60efb", + "rawBytes": 8121, + "rawSHA256": "CA924475DA674923EF364684FFD712D3D55ACE726C70CADDF7140D8DD8C151CF" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/.gitattributes", + "mode": "100644", + "gitBlob": "41378e904c4e2223772820f0bd21d409c48a53e3", + "rawBytes": 229, + "rawSHA256": "1914CB5D7D14A932FA54941A9AA497F6059361E5C4011A18E1E52DB94D2B4FD5" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/ASSESSMENT.md", + "mode": "100644", + "gitBlob": "57f6c8b014617cec4194848588d5a36ecbd08195", + "rawBytes": 13392, + "rawSHA256": "BF8F4BB30728365412C70563FD3BF9F3646267FA71D12286E9E9F80EE8CFD287" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/CONTRACT.md", + "mode": "100644", + "gitBlob": "09f16c2aa95093874c4083a8ed53de13341866b7", + "rawBytes": 4924, + "rawSHA256": "16DD79CF147AD1CD871D748FB6961FF72F2136A473DD15133BF5251CCBC4D105" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/CheckMachine.lean", + "mode": "100644", + "gitBlob": "1df3778afc40208e34e5763593918c7772efdc7c", + "rawBytes": 5870, + "rawSHA256": "207D314AFF59552C725AB54F9E20573C62E17696C4A4FFB9C368EF682DABD6E5" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/ExportFixture.lean", + "mode": "100644", + "gitBlob": "097d348bc0a070c0553d7125e64e1008263f5203", + "rawBytes": 15764, + "rawSHA256": "FEAE2CCF257629A89BB0567D7F2CF8143BF3366CDA0AD84B12DC239A19E013E7" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/README.md", + "mode": "100644", + "gitBlob": "e77ed169f020cc5cc33aabe28599e20ddcceae70", + "rawBytes": 1259, + "rawSHA256": "29BB54823BF6168908DE2943A19069C5FF61348095FFC32F30880F79BA0E1364" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/compiler_checks.py", + "mode": "100644", + "gitBlob": "b0224c35f879abf79a3d4fe548eb8a773ba56089", + "rawBytes": 838, + "rawSHA256": "286504CFB9D199AE70B7BB3E14763CE6DB05C0ADDF94AC35C62B86A51D2ABFA6" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n15-comb-vm.json", + "mode": "100644", + "gitBlob": "b4927d1dbde70bf221d0359c44aaf57c447d7d1b", + "rawBytes": 41372, + "rawSHA256": "1F5C36CA27753655F06A91D3C0F8A4DEC10E285536690A1984F30FF1F7D10BFF" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n15-comb.json", + "mode": "100644", + "gitBlob": "13a1d094a587553e5ffaa5bcf782fb02a424de7b", + "rawBytes": 84059, + "rawSHA256": "A5EA4B84C31832F8F2303882E2668A016787B6B46E2362C52F08C310FABD5361" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n15-zigzag-vm.json", + "mode": "100644", + "gitBlob": "96136bac482e8e401e4edd82b01918dd59fece59", + "rawBytes": 43930, + "rawSHA256": "2EF8BD8B76F6C5A50740890E0F74293DBA02F5742DCEE10DC0A7F8BA1784AB2B" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n15-zigzag.json", + "mode": "100644", + "gitBlob": "72b885b6c4e8251b5fbd6f9d1ad8e85b26eedcae", + "rawBytes": 89986, + "rawSHA256": "2DB0A1EEC22EB2C3ED5C0A1C44117FFC4138A4474844542E500CC252EA0E2173" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n16-balanced-vm.json", + "mode": "100644", + "gitBlob": "6bc956f7b3f2199588556233e196939da09a5422", + "rawBytes": 42736, + "rawSHA256": "A215C657BA75F04DB4EA95173858C233DEA1D7B8D963CF61D6DF1141FC84BED0" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n16-balanced.json", + "mode": "100644", + "gitBlob": "4713f39ae6c8344a622652812eac069cccdd0f8d", + "rawBytes": 88013, + "rawSHA256": "9C18600312F9C0C2ABF95DE57B935518257FB0A222CF4C0CB2DC088C2DC18C0A" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n29-zigzag-vm.json", + "mode": "100644", + "gitBlob": "aa8f3b502eb0437d94457cd2f93533df85840a39", + "rawBytes": 45389, + "rawSHA256": "959455F0D722993E7920EE789A059DF7CDDB3A67962FFF3BC74907750256742A" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n29-zigzag.json", + "mode": "100644", + "gitBlob": "96c6566a0fb05e60104cc9c3a9db1652fa71112d", + "rawBytes": 94411, + "rawSHA256": "D56FB364F993F90240D32470E76FF1D4BFD97162F89C424F35621BB66F49926F" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-ascending-vm.json", + "mode": "100644", + "gitBlob": "f14a9e5a3c333700b025ef763b790ae0db2d6eef", + "rawBytes": 36788, + "rawSHA256": "826407F5B41E4B28A4A367B46805D174182FB0F4EC6B5426E3323783C3D5F5ED" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-ascending.json", + "mode": "100644", + "gitBlob": "74a101ccb72cf8d49908942381f092b5b8fb3995", + "rawBytes": 73036, + "rawSHA256": "79A3F29ACDE6BE9432C9BD9913A80213B33695CDEA33956AC52F1EACF0C54C5A" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-balanced-vm.json", + "mode": "100644", + "gitBlob": "454967f733d16a0cb0bfb79ddb98b3d409f1caf5", + "rawBytes": 38132, + "rawSHA256": "76D8C34BE4EEEF22409DE10FC65E06E6CFECD8B22A810A2FDF245CF0C0511BCE" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-balanced.json", + "mode": "100644", + "gitBlob": "280e991c92e2ec84e860010dddab4d55bd565871", + "rawBytes": 75738, + "rawSHA256": "437D9512D3452AA753791CBC1FEB5F6850C0162729B932327B8D57C8D68CB697" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-descending-vm.json", + "mode": "100644", + "gitBlob": "845867277bf3864d2e3664166c78c80ec1f3c3ce", + "rawBytes": 29344, + "rawSHA256": "328DFED4A208734E0F8C3F84D858B58A54A1DDAFA9CFD2028E0E12438D940DCC" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-descending.json", + "mode": "100644", + "gitBlob": "ac136cd74146687a1ff910541d466b539657cc3c", + "rawBytes": 65253, + "rawSHA256": "F9E6F7D9156FF62FC43D22983BA44128780987863C232EA8449A40404A0DDCC7" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-invalid-vm.json", + "mode": "100644", + "gitBlob": "2cc6f558e44b83ed38ec903c98a96d43482441ae", + "rawBytes": 830, + "rawSHA256": "B681CF928040B6A7615186842B2949E9CF7A1095E96422212429A875A06EEFAB" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-invalid.json", + "mode": "100644", + "gitBlob": "da97512696bcbb14a1ac1c1c93aa1d05f2769766", + "rawBytes": 7279, + "rawSHA256": "613B3C9FAB261B1DB929F0C8C3821562309143F3B5129800DE91CC828A019CBD" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-ties-vm.json", + "mode": "100644", + "gitBlob": "243d3be0d57a69487740bd9de0a543a0f33c12be", + "rawBytes": 36783, + "rawSHA256": "C395D330C116B63D206652C5A88349DFCC2AB31845D45A061D0C0850A03455C4" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-ties.json", + "mode": "100644", + "gitBlob": "08f5a983b2d8f7fe75b55f7fba38269f8f1523ef", + "rawBytes": 73031, + "rawSHA256": "A14E1B5353FE132EB435D2AFA06DC82FD7B6468D4AD6522B6CF65FAD93234AF9" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-notes.md", + "mode": "100644", + "gitBlob": "07c6d573c1dda8f7b769f553c9923e85904b0264", + "rawBytes": 7091, + "rawSHA256": "C9FC8654209725E1F8CA34A6C37202A69A6C23BE8B5BDF8DC719B2454A03F8CD" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/lca-interior-spec.md", + "mode": "100644", + "gitBlob": "621b43bfefe90cc473a56022d5f95ba8890ec4f6", + "rawBytes": 16013, + "rawSHA256": "EDB7599808C25B8A5CF603CBF7A5145B3851495DD18F90307D30185D541B6A3F" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/lca_interior_program.py", + "mode": "100644", + "gitBlob": "25334ca80c2e1c36e177d98669f1fcb7722d7b7b", + "rawBytes": 9390, + "rawSHA256": "8030779301E802313A7E7FD5EE6E7DB8BF8267C811FC1E6B07B02E634F4EFA7B" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/machine.py", + "mode": "100644", + "gitBlob": "5522c467fd54f4be69abe5aaa2157a3089503a97", + "rawBytes": 15425, + "rawSHA256": "730EF56FD1E8365A41C954FBA46881EB450E1BAB6918C2E831C6545E860979BF" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/manifest.json", + "mode": "100644", + "gitBlob": "14faf12bf2b9720039031c1fa75332e392d8a309", + "rawBytes": 6198, + "rawSHA256": "83D296A47D365E6710B6C8CB6253BFD9A32C185A3E778F4C194B6F492D28F073" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/package.py", + "mode": "100644", + "gitBlob": "d8c7413f7bfd38725f4eaffe2ad43f4f3a95d76c", + "rawBytes": 957, + "rawSHA256": "85D37ECBD2BAA282ABD1F9F99BAF52C1C673A3E71018B10F41FE893E9AA850C9" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/physical_program.py", + "mode": "100644", + "gitBlob": "5b8814d628e1db14abf95aeeb5a6f6da6454fae0", + "rawBytes": 1599, + "rawSHA256": "9015D68AFDF3DBE03245734B554B6155502D626E9C3224791AB7A52622782D19" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/program-n15-source.py", + "mode": "100644", + "gitBlob": "ef1cca46d3c4547fe385e20b8201eb713cabda90", + "rawBytes": 24964, + "rawSHA256": "74AFDFBA8C4E549A3BC0A0F9C2231DD6CA5811552DE0B56D5DFCEF6B16D16540" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/program-n15.json", + "mode": "100644", + "gitBlob": "920c3085d0838e685672ccfc30dc4eb67f8035cf", + "rawBytes": 154507, + "rawSHA256": "77AD0F860FBA8D04BB3B6A4DAA595A5F05C974407087B8691E6AA04B9DAF5249" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/program-n16-source.py", + "mode": "100644", + "gitBlob": "6486930abe79985096b578a41963553294709148", + "rawBytes": 24965, + "rawSHA256": "3B671EAB457DC3ACC4E8E1A8F94A7AED0F19CF24F5835DC8B2672AA913F5F8CF" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/program-n16.json", + "mode": "100644", + "gitBlob": "9f896d976449a8036dd49e78bef5726ea5b448df", + "rawBytes": 154520, + "rawSHA256": "AFA03B191E9FF6BFC5C60BB1E343A57E9F5E9FD1DB7BA2D785D7112B6E63FB32" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/program-n29-source.py", + "mode": "100644", + "gitBlob": "0fd47ac45d09b4b2503796a52c5e474dce312795", + "rawBytes": 24973, + "rawSHA256": "00C1885BA71646AEDA265B28F70C781F786E41BDF8A98F5D5648A97D9B96D1F5" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/program-n29.json", + "mode": "100644", + "gitBlob": "df1eeffc0037293600fcab33d713b6ffaf56e8f9", + "rawBytes": 154529, + "rawSHA256": "A2DC5E9764B4B39911C8474CE7FF709027191B82B4A23567C0F370AB7E9B529B" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/program-n9-source.py", + "mode": "100644", + "gitBlob": "cf5dc3aaba827860b0e2f58ac6b7aadbbf4849a6", + "rawBytes": 24958, + "rawSHA256": "95B95A22F63BC06157A9E3CCAE93B6148B352A04CD03591E213827B39062EB1A" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/program-n9.json", + "mode": "100644", + "gitBlob": "2b0f4bc1894092fe5ad5f9f909da09db3865017e", + "rawBytes": 154489, + "rawSHA256": "9EE640E68601B47BE82417621C557C688A4BBAA0B1BC061A9E43FA2DA0309AB6" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/rank-select-spec.md", + "mode": "100644", + "gitBlob": "49d1c45d9b7ba099e14729defabefd6bded8e986", + "rawBytes": 17432, + "rawSHA256": "2EA0AF303B6FD3FCB8A2BF69783EC2F39D952D4A07B80572645A2A93BE024C1C" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/rank_select_program.py", + "mode": "100644", + "gitBlob": "5e6c77604a1d3921bf6338375627df33c438b825", + "rawBytes": 5473, + "rawSHA256": "346CBA19724CF066E79E2A45A722C465DBA8A7AFE97432EEA0653DE2970C8166" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/reproduce.ps1", + "mode": "100644", + "gitBlob": "be869496aa4854c3bb3cce54f83fda7504e3a770", + "rawBytes": 2197, + "rawSHA256": "BAF93F3486F80AF5D2F41BA406DDB897D65A2755748410ED019B2BDD4AAC8859" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/reproduction.log", + "mode": "100644", + "gitBlob": "532a3c8409f61357e8933f8850295a78af4396c0", + "rawBytes": 3735, + "rawSHA256": "E4F48B76BD4736CB8548CD710A5924FADA593AF7872DAC34DB1FBCE1457713B0" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/run_experiment.py", + "mode": "100644", + "gitBlob": "4ac681a72a72878860db797990c0e54c0686c1d8", + "rawBytes": 6952, + "rawSHA256": "7F057D55DA6B3678D8195EA0923858BDA6A2DD03B7C58C5392CA28818A3AF61F" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/validate.py", + "mode": "100644", + "gitBlob": "d6f86885f09568f6265c67c731e1e2b5014e08de", + "rawBytes": 3818, + "rawSHA256": "F1EC1CD52ED7CB4F836F8DBFE7547AC3304D93524665D5C660F582FE27DD264F" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/validation-results.json", + "mode": "100644", + "gitBlob": "ea24b62d6fe4cef99d47386d3061f1ce37e21e11", + "rawBytes": 7441, + "rawSHA256": "DD1079A76552172AA9546539E577983B1701553C5997371590D98FB5671A2BEA" + }, + { + "path": "docs/internal/templates/AUDIT_PROMPT.md", + "mode": "100644", + "gitBlob": "91631d91a01a21027654855bbb3a8699154df7ef", + "rawBytes": 6422, + "rawSHA256": "ABAC66980E1B9B93A86A64DCAEA851448ED3EECF19CAF23CD683DEBD2CF79375" + }, + { + "path": "docs/internal/templates/COORDINATOR_HANDOFF_PACKET.md", + "mode": "100644", + "gitBlob": "a3c5e31e1a42f727a9f675a12b7cc00a9372e1c9", + "rawBytes": 1806, + "rawSHA256": "E5148D09DA3465530BB143E69A2CEC623B49C70D48D3D8ED3B9577A0390EE736" + }, + { + "path": "docs/internal/templates/COORDINATOR_REENTRY_PROMPT.md", + "mode": "100644", + "gitBlob": "2b9038c3be299a3aacde24f8021ff7d50cbe48a1", + "rawBytes": 3262, + "rawSHA256": "1FDB73903A8E70C206EFAB2CB669435BF758A2A1D76ADC336C802A82E96BAE38" + }, + { + "path": "docs/internal/templates/PROOF_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "6571abf14bebe279b8f1fdfe17b669d07f98a999", + "rawBytes": 6141, + "rawSHA256": "774909BA0467EEC29303BE6F160123828AF02329EAB2ADC5663719166C016671" + }, + { + "path": "docs/internal/templates/WORKER_PROMPT.md", + "mode": "100644", + "gitBlob": "d77902361cf2931f97053fcf734cf1e0d1a4f877", + "rawBytes": 19040, + "rawSHA256": "AB4B8B3391A45420BAB6E92CC60D00D1164B50769F527F5D77E755A61B966256" + }, + { + "path": "docs/internal/wf3_attack.json", + "mode": "100644", + "gitBlob": "91bfeafaf704b1875be745242e73ca5dd1389b11", + "rawBytes": 36004, + "rawSHA256": "F26087549E6AB0B5A8A43423474F42509CCA2720DE93ED761840DD02660B44E6" + }, + { + "path": "lake-manifest.json", + "mode": "100644", + "gitBlob": "c84e20fca6ea6816a0b342ef8cabf5aa2b203c35", + "rawBytes": 114, + "rawSHA256": "779633B5A9F128F713A68C5A788A50C6B86D558551215B5D046647E692AD046F" + }, + { + "path": "lakefile.toml", + "mode": "100644", + "gitBlob": "b0e72516918125c22272b36c360db7f91182ade5", + "rawBytes": 1176, + "rawSHA256": "B47C7ABE3955D1A2E9BA51A4C71FC2E7961423D2BF5F3856F79A24BEBC8BDD50" + }, + { + "path": "lean-toolchain", + "mode": "100644", + "gitBlob": "b9994064fbbb081ca94a50384ff5951b50ea5b42", + "rawBytes": 28, + "rawSHA256": "AD3E6363C78908C80953282BAF57162702F1134173A5247AAD3DBFEA108A525F" + }, + { + "path": "native/packed-rmq/.gitattributes", + "mode": "100644", + "gitBlob": "ec999e9d630559366ebf50cd5fa969bcdd39a652", + "rawBytes": 326, + "rawSHA256": "1A8252F52CC8EAAFFD8E07ECFC651E5A4DD81B8CBC1F4E3CAB030A0B48809778" + }, + { + "path": "native/packed-rmq/.gitignore", + "mode": "100644", + "gitBlob": "99d2bb15a12368587abd95bf1db11297137741fb", + "rawBytes": 17, + "rawSHA256": "6192C78B3A190E1DEAE3B9235FBA123041714EBBB86B43CCB858BA34B26994D5" + }, + { + "path": "native/packed-rmq/Cargo.lock", + "mode": "100644", + "gitBlob": "583bd4fdf5e8f8c35d88a25c04587ed34eca6fb2", + "rawBytes": 154, + "rawSHA256": "5A59DA0864CAB8E739DC408245DF7BF5ED4BC7AD3A11FAF2962C3DECFF1C8AAC" + }, + { + "path": "native/packed-rmq/Cargo.toml", + "mode": "100644", + "gitBlob": "b7e787faaed137e63b87613b78d5d765f179d86a", + "rawBytes": 381, + "rawSHA256": "3F6DB12831D88D60F418F8AB93D943487A6346C29E6475BAE50CD4A0953A7930" + }, + { + "path": "native/packed-rmq/README.md", + "mode": "100644", + "gitBlob": "9fc8d90f186e2068a639fafe8267da8ab345a2b4", + "rawBytes": 10013, + "rawSHA256": "5CFB39FE2A33D4A9F6F95FED9A012DBC8E47D3B437908495080B6CBF74A6151A" + }, + { + "path": "native/packed-rmq/examples/lifecycle.cpp", + "mode": "100644", + "gitBlob": "cdafcd82a1eb825730a201c65d868bfe843f400b", + "rawBytes": 7661, + "rawSHA256": "D0C35278DE1A959D8058AB9D3AAEBF7BA15BAAB8313A263B6303655C2E864F07" + }, + { + "path": "native/packed-rmq/examples/native.cpp", + "mode": "100644", + "gitBlob": "1ef6703ddca42866c500502c0eb97e150cdfc354", + "rawBytes": 7428, + "rawSHA256": "A5BFE471012D24A68BF743F2EC76F141F5B7731E66F7002A6F2127485FBA3FAB" + }, + { + "path": "native/packed-rmq/examples/route.cpp", + "mode": "100644", + "gitBlob": "c33afca71427dbc6d3974469aac56a0109cd5b4d", + "rawBytes": 1207, + "rawSHA256": "5A83460269C79D8288982D747A0020F0CC7F47C9C1230759708E14041D5EFC1C" + }, + { + "path": "native/packed-rmq/fixtures/canonical-cross-cell.fixture", + "mode": "100644", + "gitBlob": "ec6fff340ddacb7469351611c7890d05d249fb5d", + "rawBytes": 14859, + "rawSHA256": "DE8CB638266AD0D5FDF3F62F511990E9D4A4D6C5311E10A79BD70F1A949A960A" + }, + { + "path": "native/packed-rmq/fixtures/canonical-interior.fixture", + "mode": "100644", + "gitBlob": "aea1778195914584f82491739c67ffb8bd845f9d", + "rawBytes": 13223, + "rawSHA256": "4DA0FC04DFA2E12C70D109BEF89B973F2D82225B1CAAC01F47FE969D5F3EEB66" + }, + { + "path": "native/packed-rmq/fixtures/canonical-left-fringe.fixture", + "mode": "100644", + "gitBlob": "3d1acc9848dd0f3c4c06805d4ac8a03561e05ade", + "rawBytes": 13226, + "rawSHA256": "E947CA28C98A87953B31E7D1F95DD8A1808BE1BAE2EA7AA67CD7186266D1D7ED" + }, + { + "path": "native/packed-rmq/fixtures/canonical-rank-final.fixture", + "mode": "100644", + "gitBlob": "799d3941237ce7363f52cc4e1157b361dc4d3f03", + "rawBytes": 13218, + "rawSHA256": "53781774F1B5438C2593FA960858197927AB746C137F672DE972C96DAE916CF9" + }, + { + "path": "native/packed-rmq/fixtures/canonical-right-fringe.fixture", + "mode": "100644", + "gitBlob": "381022decc3c27a41f268d5f9e95de790d2f1342", + "rawBytes": 13228, + "rawSHA256": "A30BB0C905F87D3BB4FB0008B4BC894358F4782023D412DB24ABBD16FA87937A" + }, + { + "path": "native/packed-rmq/fixtures/canonical-select-left.fixture", + "mode": "100644", + "gitBlob": "7e84cc59736508cf331b4e9ceaf542cff7916cd7", + "rawBytes": 13211, + "rawSHA256": "03DDD5A11F37D1DB2A1562FB03CB2DF8DD7CB392654E01CD3F4839A15090FE6F" + }, + { + "path": "native/packed-rmq/fixtures/canonical-select-right.fixture", + "mode": "100644", + "gitBlob": "0213cae9330c9617e1ea32c1be06da1d70a3e621", + "rawBytes": 13217, + "rawSHA256": "9A518E610469A3B05BE1D91D628EC64E8553692C070BDA77283137B96346208E" + }, + { + "path": "native/packed-rmq/fixtures/manifest.json", + "mode": "100644", + "gitBlob": "300c5ac9d05e9b9a5d092eb0db5e980ca62edb83", + "rawBytes": 3112, + "rawSHA256": "B744C146C889896DD14BADB77BBEE53CCF4ECFE6764AB338811853347AE341B0" + }, + { + "path": "native/packed-rmq/fixtures/n12-adjacent.expected", + "mode": "100644", + "gitBlob": "4da0aed54809c29c1e1e91cb900ebad1d752b86f", + "rawBytes": 3884, + "rawSHA256": "E2834D14FF9BA5977CD31869623B91D2E573D8B6117889D2E0F768F21BBCE34D" + }, + { + "path": "native/packed-rmq/fixtures/n12-adjacent.fixture", + "mode": "100644", + "gitBlob": "c781c859d0b49eee8797c76e7480b5f690b87a50", + "rawBytes": 774, + "rawSHA256": "159719FFDE2DEC626239D410671AE0CD4F91833AC5E8214DC7CB9C7633B0A50E" + }, + { + "path": "native/packed-rmq/fixtures/n12-interior.expected", + "mode": "100644", + "gitBlob": "8d9d893c6e992890608244e59b8ab14a605dfc23", + "rawBytes": 4737, + "rawSHA256": "380E25EC977E4234A02184451F9F96E462431BE4262F8EF3F3358F7061E65A95" + }, + { + "path": "native/packed-rmq/fixtures/n12-interior.fixture", + "mode": "100644", + "gitBlob": "5a87b6aad2091d277c31aae86d2829437d4311ff", + "rawBytes": 775, + "rawSHA256": "26C204304B119A98EFDB099AE830440127FCFF8E5AD36422A7ABA6B7583A4234" + }, + { + "path": "native/packed-rmq/fixtures/n12-same.expected", + "mode": "100644", + "gitBlob": "f818662c6209284f12895ead51ae2b81f2ea859b", + "rawBytes": 3324, + "rawSHA256": "A3FFCF6BF9FB995BD765A902EEE65FB1DE70EF52BA5CF9BBB3A032F3C1E1C2D8" + }, + { + "path": "native/packed-rmq/fixtures/n12-same.fixture", + "mode": "100644", + "gitBlob": "56968c9c6cf2f64a77521f388083493cf474dc45", + "rawBytes": 775, + "rawSHA256": "254604DEEE28105717BC31744D14B9442D1AF3A34828BEDA2756AF0D8BFE9930" + }, + { + "path": "native/packed-rmq/fixtures/n9-corrupt.expected", + "mode": "100644", + "gitBlob": "50d2bca892cd47813918b23cd3af35b8aad2c5a4", + "rawBytes": 1059, + "rawSHA256": "237CCC8507B3AB49891946D6129E46EEC1D4C98B74D5C19033D10F2ECD17370F" + }, + { + "path": "native/packed-rmq/fixtures/n9-corrupt.fixture", + "mode": "100644", + "gitBlob": "384116849c9c24deba70d1021efb596bc49971b6", + "rawBytes": 720, + "rawSHA256": "C4BCA82BBE201FBD8319B1DD24A0582633600D8C8F6E1B4DB57D8AC425F1CF76" + }, + { + "path": "native/packed-rmq/fixtures/n9-empty.expected", + "mode": "100644", + "gitBlob": "0af2b219746cbf7556f1b20517705beb04e68d68", + "rawBytes": 17, + "rawSHA256": "3F59B43485A5E120ACBA4A6C65BD9BF938601835359C6E8DF83F311E17273FA1" + }, + { + "path": "native/packed-rmq/fixtures/n9-empty.fixture", + "mode": "100644", + "gitBlob": "efe7705885f1abf3a0e1f9ad612668c2dffc8ecb", + "rawBytes": 720, + "rawSHA256": "63E4B303AC9D518F2672B187BE9F3AF9E51C65E1EC4E03F8A9E342A78A685785" + }, + { + "path": "native/packed-rmq/fixtures/n9-full.expected", + "mode": "100644", + "gitBlob": "c958c4a1eccd095386f03a5300190e1df62767f9", + "rawBytes": 4516, + "rawSHA256": "FC25F556CD4C4E5804AB580A3FB8B184D98F72CEE207F4C4829EDD412F418A56" + }, + { + "path": "native/packed-rmq/fixtures/n9-full.fixture", + "mode": "100644", + "gitBlob": "6374a623f176ff84fe3830e4021a68bad94750b9", + "rawBytes": 720, + "rawSHA256": "70216D5E6F5CA5769EBB8D7269DA9B74ED867D7B4B7F9B2C4AD7603AA513DDC1" + }, + { + "path": "native/packed-rmq/fixtures/n9-missing.expected", + "mode": "100644", + "gitBlob": "2f6fe97da1271f08c387699644a859d73789c226", + "rawBytes": 26, + "rawSHA256": "D658EFEEED82848B94A085B2F3CDE29FE5E649449694A422FD6CEB9CF26366EC" + }, + { + "path": "native/packed-rmq/fixtures/n9-missing.fixture", + "mode": "100644", + "gitBlob": "1266c004970a521f3435400330656ce554731715", + "rawBytes": 18, + "rawSHA256": "08637CDED478315C117052EEF8A3D2FD8A37E972A202A68AE033B168ECA3E6C4" + }, + { + "path": "native/packed-rmq/fixtures/n9-range.expected", + "mode": "100644", + "gitBlob": "5ba4ab99feebe0bfdfe4490a0986a0aa9fbe2aea", + "rawBytes": 17, + "rawSHA256": "DB477A96C823BCF48B468FD1BCC4CA95804504EADC69991F4E39DF56D05A8E54" + }, + { + "path": "native/packed-rmq/fixtures/n9-range.fixture", + "mode": "100644", + "gitBlob": "9aee57b4585b027343402c31b859e6e13b778150", + "rawBytes": 721, + "rawSHA256": "5FB5C9F9B1785A5F873248F7BA1AB7E11048757C0BF3B88BBD97ABB47329409C" + }, + { + "path": "native/packed-rmq/fixtures/program.txt.gz", + "mode": "100644", + "gitBlob": "fc36d7beb7bd7fb9f75e762163999d8bd34e1687", + "rawBytes": 1008972, + "rawSHA256": "13EE9E81E17DD25D5F25546B72762A038886AE7545031FAF51DC2757E666C011" + }, + { + "path": "native/packed-rmq/include/packed_rmq.h", + "mode": "100644", + "gitBlob": "c69c5a5072646271e455ede3863cbc68fa47508d", + "rawBytes": 2936, + "rawSHA256": "E2DDB51D62B2CBAB79E0A64803F38343F4E73D66C91327E55D708CF47A3C993E" + }, + { + "path": "native/packed-rmq/include/packed_rmq_lifecycle.h", + "mode": "100644", + "gitBlob": "b88d89ed5abb950f473e00495eb415e34a606aec", + "rawBytes": 11394, + "rawSHA256": "791910DE0CDE090ADD04B2D144E5A2E12081CF4CAED81E8AB98FEBC7E76C499F" + }, + { + "path": "native/packed-rmq/include/packed_rmq_route.h", + "mode": "100644", + "gitBlob": "b92bdd54ca70913bee97167909d8118e6429c595", + "rawBytes": 1061, + "rawSHA256": "57B8D5524BE0B479AB65706E0D009DFA9F47DCB5CBAFD90FEFA27833539A6E13" + }, + { + "path": "native/packed-rmq/lifecycle_shim.c", + "mode": "100644", + "gitBlob": "34e2d53fb3f795139c0df38fc7efc9ee06df5382", + "rawBytes": 41735, + "rawSHA256": "3B3ECA3FE1E789034E1B0C1A0CB881E15CE6443363E7E397D1313FEF909ACDE1" + }, + { + "path": "native/packed-rmq/native_shim.c", + "mode": "100644", + "gitBlob": "db1e22fdf3b50763f95f699fbb521f1ac0b824ae", + "rawBytes": 3692, + "rawSHA256": "0D395279A803AB9FB796BB1176F5376F59CBF887E0414F09AF4D376A78F89780" + }, + { + "path": "native/packed-rmq/packed_rmq.def", + "mode": "100644", + "gitBlob": "cbf10b820efc18352d419ffbabdad6afc84309d8", + "rawBytes": 256, + "rawSHA256": "1FDE85FF9210ABD57407803250A4348B6F919187D387B0368E76BFA2B4CFB1B9" + }, + { + "path": "native/packed-rmq/packed_rmq_lifecycle.def", + "mode": "100644", + "gitBlob": "a170df0d1148daac3caade4e6b3d8d8318ccb914", + "rawBytes": 654, + "rawSHA256": "6F9CB164758FA15552739E498FA34779137F11CF380298ED508232482C2EEFE3" + }, + { + "path": "native/packed-rmq/packed_route.def", + "mode": "100644", + "gitBlob": "36b303757a541f05bf30142c38170ceaa3ca0c9b", + "rawBytes": 117, + "rawSHA256": "AB40183B646A3AD96727F41555EED46C8E381EFF9293FB922FA9264F310845E5" + }, + { + "path": "native/packed-rmq/route-registry.json", + "mode": "100644", + "gitBlob": "ae692b2bf1ad61f7897677ca482b3fb5b9299753", + "rawBytes": 4324, + "rawSHA256": "33609A968052FB37894CACD9721BE12AD1FBAFF0BF332A0287CD1AA38622F539" + }, + { + "path": "native/packed-rmq/route_shim.c", + "mode": "100644", + "gitBlob": "e54b29b4f8a3df6654df0d34df13a87ea86e573c", + "rawBytes": 1580, + "rawSHA256": "24FFA6075DFE6D0C1AFCD89096A60306B794A7CF29C1D98A85D49B4E9B66149D" + }, + { + "path": "native/packed-rmq/src/lib.rs", + "mode": "100644", + "gitBlob": "0811bfde8b13442e4932623c004446ecfadbdd25", + "rawBytes": 2702, + "rawSHA256": "755DB6898E9FD6D843C290AA48FA19591B1BEC6B4BCE966103E121B7DF21E573" + }, + { + "path": "native/packed-rmq/src/lifecycle.rs", + "mode": "100644", + "gitBlob": "8a9fcfea775ee186436006cdf74e6defad94cc40", + "rawBytes": 18498, + "rawSHA256": "19EF29EF8A6A4DC49276F1E0587819CC9317CB1AA778AED194BD13006F0AD2E1" + }, + { + "path": "native/packed-rmq/src/lifecycle_main.rs", + "mode": "100644", + "gitBlob": "9e7d25ddf1a87385e8d15e1454a997c14cd57607", + "rawBytes": 3926, + "rawSHA256": "576FC2EE813ABA8779B276182AE431DED2F111A49C3E7031149BF42A99715033" + }, + { + "path": "native/packed-rmq/src/main.rs", + "mode": "100644", + "gitBlob": "5d6477d1c053b7d825a962a90c09740b6c8182fa", + "rawBytes": 782, + "rawSHA256": "09D2A564311B22309DC0D9E972043124485C47BEA302FCFE8D34373AF7388BED" + }, + { + "path": "native/packed-rmq/src/native.rs", + "mode": "100644", + "gitBlob": "2274667fdbc986a76091c2469fa37b99afe64d28", + "rawBytes": 5211, + "rawSHA256": "82E7DEF4F6F67FBC52D0829FF82BA67082D7E68FC8B7A6938EDA41802AA1BDE7" + }, + { + "path": "native/packed-rmq/src/native_main.rs", + "mode": "100644", + "gitBlob": "bb457d349d8ae70dfa4d1441c7fa431d1407b582", + "rawBytes": 2910, + "rawSHA256": "3251E67EA8339FF7E5339B78A025308B0D031348BA844BDCBACA9C56CFAF1E22" + }, + { + "path": "native/packed-rmq/tests/lifecycle_owner.c", + "mode": "100644", + "gitBlob": "d621e1b20700adfc718258dde392f1a3597ead8a", + "rawBytes": 48070, + "rawSHA256": "0CD522806030BDDB51BE7F55B4B8C006612C59A3D168815ACCFA34B9AD635DED" + }, + { + "path": "native/packed-rmq/tests/lifecycle_rust.rs", + "mode": "100644", + "gitBlob": "dcdf5e5f3e4a26b0b5620b88df5899432e597a00", + "rawBytes": 5436, + "rawSHA256": "D825DE27E65CA7C0BA872B1B3100D6DF9D98DC895F85A0CC2B7B81E7C50C850E" + }, + { + "path": "native/packed-rmq/tests/lifecycle_storage_probe.c", + "mode": "100644", + "gitBlob": "1dbf0fa0b34b77f7aa6e2af120d6a3f816c3edc4", + "rawBytes": 14720, + "rawSHA256": "5F32F4A91B21697F86B4F2FEA855CD050E59E330CE6C6FFDA28898353B66D7B1" + }, + { + "path": "paper/.gitignore", + "mode": "100644", + "gitBlob": "5303101f1cf6c4745bafdd80e1261823420ecddd", + "rawBytes": 150, + "rawSHA256": "448507AF277485B91566F6098AF6079E1854D56AE00D3F3E1952FA31C3A517EB" + }, + { + "path": "paper/EVIDENCE_MATRIX.md", + "mode": "100644", + "gitBlob": "bff00359697fa4895fdd9086a086226dd5bf5fea", + "rawBytes": 23874, + "rawSHA256": "C55119C91F4481688F83ABF8133470A753BA497DFA14F9D026DE6D3E6D0B56D7" + }, + { + "path": "paper/NOVELTY_LOG.md", + "mode": "100644", + "gitBlob": "b8a17d33c984b6a311f2af7da988c28d2f32d261", + "rawBytes": 101342, + "rawSHA256": "3CA0111F985E15FFFFBDEA6304EF13D46B4818B05C490AC361DD531E7D7BD509" + }, + { + "path": "paper/README.md", + "mode": "100644", + "gitBlob": "5197d6ee8425962a8be7360096401a918287edec", + "rawBytes": 15433, + "rawSHA256": "B318A0087D82514E71938B04282F407357F43198D8D0F3AE379CC1B238E09A9A" + }, + { + "path": "paper/RELATED_WORK_LEDGER.md", + "mode": "100644", + "gitBlob": "74c56d2bb1dc3be0ce924ec4a521f44b17ab4a10", + "rawBytes": 21862, + "rawSHA256": "5A901CCEF1EE753FD7882254F056488A2F322BB25F15750789E1CDF75882BE71" + }, + { + "path": "paper/THEOREM_LEDGER.md", + "mode": "100644", + "gitBlob": "2173cff1fe884f3f2d6bfccce0e96d3efdf1d4c9", + "rawBytes": 43742, + "rawSHA256": "32A299E6094F7CDE4E65AF5E23F17A50146DD83BB3B505D11DB95F89164C206F" + }, + { + "path": "paper/WORKLOG.md", + "mode": "100644", + "gitBlob": "845f9621da12e9c4f19da7a407366e1a95c482f4", + "rawBytes": 18045, + "rawSHA256": "C2D3E7EDD1097047E2D318359AA00F3ACFD206DC2D9280484DF2348D544D7C8F" + }, + { + "path": "paper/check_citations.ps1", + "mode": "100644", + "gitBlob": "8517110484e0a11edeb0a1ee8523c68005b07061", + "rawBytes": 30833, + "rawSHA256": "7A7A4A3C4C62E826A77E954E1BC4D97207BD4364B950B5F58032D906D1A9624F" + }, + { + "path": "paper/check_paper.ps1", + "mode": "100644", + "gitBlob": "6d728f1d58747b02a659281f6e6df48d5a97459a", + "rawBytes": 39497, + "rawSHA256": "C7EFA32146415426E691AC673963E36D35E96D8DCBDBF04DC01A262B0861B26F" + }, + { + "path": "paper/references.bib", + "mode": "100644", + "gitBlob": "2b70ba3c49f42ca53e8a257792103a4781dbefe1", + "rawBytes": 12993, + "rawSHA256": "DA043B74A42C7B05F4DE31EDF2EF9297677642EC7089489216894D43ACD8C248" + }, + { + "path": "paper/rmq.tex", + "mode": "100644", + "gitBlob": "5e8b9d2f6b4f533332d52748338e2eeb4fb15828", + "rawBytes": 67318, + "rawSHA256": "3D46820F764594E34703A4C546B20867013A127AF96FA91C679DF627D855BFFB" + }, + { + "path": "scripts/.gitattributes", + "mode": "100644", + "gitBlob": "0a5b864e5c92c10da85b2f61f939cc1d50b460de", + "rawBytes": 748, + "rawSHA256": "7C4B1F2664E8E60ECB8C7FA4E0663F58C240891B96A9EDBCB69D41E26B62BE33" + }, + { + "path": "scripts/archive_axiom_check.lean", + "mode": "100644", + "gitBlob": "ec6adbb7aea3d241c5dc864a6911602b06bba0c6", + "rawBytes": 945, + "rawSHA256": "2CA5126392155285E8236B3BC0316DA0609CCE711B3647D500D046910B0D13AB" + }, + { + "path": "scripts/axiom_check.lean", + "mode": "100644", + "gitBlob": "5efb115e73bc90c11bfb39eef5493dd64e2e1213", + "rawBytes": 112880, + "rawSHA256": "EC45BA8EB324FE514D5919B0295C295FF7C8B8906117E6B9F96CA48BFBA0D4C2" + }, + { + "path": "scripts/bp_navigation_axiom_check.lean", + "mode": "100644", + "gitBlob": "4e8a2da0dc129314d5eca7761a623c8d4d18e7be", + "rawBytes": 3660, + "rawSHA256": "51036FC6B7C924283865D5DA7E76F2E29869685AD83025060B6E7554D270F637" + }, + { + "path": "scripts/claim_drift_policy_regression.ps1", + "mode": "100644", + "gitBlob": "6fd6dc4d2463851666b49f2c7e4a00ea1e4fe3bb", + "rawBytes": 68061, + "rawSHA256": "6746AAAA408194889D451DEEE348072CF53BDA5920318CD228AA7A45835DFC77" + }, + { + "path": "scripts/claim_drift_scan.ps1", + "mode": "100644", + "gitBlob": "62badf7e071447a3f3a3f8db0d47a3970b918ad5", + "rawBytes": 19319, + "rawSHA256": "5310DBA1242B3ED4A0B054A15B1B6911C056C228B2711F3D958EAB539BB3F6F7" + }, + { + "path": "scripts/constant_sync_check.ps1", + "mode": "100644", + "gitBlob": "85a6d18537eb3fd96edb00c29b413be2490120c1", + "rawBytes": 23256, + "rawSHA256": "78273ED1D7EAFCF991882804C761E458C53090EDA2AFE1A9CC25970EDF1A4506" + }, + { + "path": "scripts/design_decision_check.ps1", + "mode": "100644", + "gitBlob": "f3352f2312b746a698b411436d3f126b970b9781", + "rawBytes": 17247, + "rawSHA256": "1099C55F3112CF3D7B93033E5A666A3E9E1C707BA09ADB1F71EE69B8039EC4AD" + }, + { + "path": "scripts/design_decision_check_regression.ps1", + "mode": "100644", + "gitBlob": "fcb65d9709e2cfe15389788a9fc1bdf73e2abee0", + "rawBytes": 70080, + "rawSHA256": "BC866C3CEBE236FA304ADB1DCF4DD2DDBF9A9708C83D60A16EF274C93E7393F8" + }, + { + "path": "scripts/eg_cp_final_falsification_replay.ps1", + "mode": "100644", + "gitBlob": "2e30e5870acec557766a8223b97d9f106e265d84", + "rawBytes": 40608, + "rawSHA256": "0A1CC091C304238C24D5AE1F955511C19440B40E443612B47094230B95C488D3" + }, + { + "path": "scripts/eg_cp_stagea_replay.ps1", + "mode": "100644", + "gitBlob": "a5744329b0bbdfb1e599d24d9a36b92a3fb5c045", + "rawBytes": 45432, + "rawSHA256": "ADEEBA662C1FB668862DEE64653F35DAF9FBF1553262A0BFB9734D1C73F52A1E" + }, + { + "path": "scripts/gate.ps1", + "mode": "100644", + "gitBlob": "3bf1baa224b2507cda8bddb3206de89d7265c073", + "rawBytes": 37829, + "rawSHA256": "CED6ED7DD975FFBADE7211B8F82DE1AFC78F3DA69A0E2EC706EC5A545A41DD95" + }, + { + "path": "scripts/headline_axiom_check.lean", + "mode": "100644", + "gitBlob": "1b4b1c780289f7a381d803aa1b64f0a871ed614f", + "rawBytes": 41098, + "rawSHA256": "9DB73B697645B7C92F460AF642A61E9D19DDA97225960D8E7A7FC548BD6B9A49" + }, + { + "path": "scripts/headline_check.ps1", + "mode": "100644", + "gitBlob": "145b9c5d0517fa690fd272739638296a112a73c9", + "rawBytes": 1394, + "rawSHA256": "D3A19639864A95AD842AED6D94EF4D1AD1F36C8A83577F2FCE2B78969C853C7C" + }, + { + "path": "scripts/host_shell_path.ps1", + "mode": "100644", + "gitBlob": "4beb65a1cdde891603cb6842df269ef6d26dcee6", + "rawBytes": 3467, + "rawSHA256": "47D2F37A0CDE2920D08608702F22BEEE7C1340AC8548368E9289BC08A410AA56" + }, + { + "path": "scripts/hub_axiom_check.lean", + "mode": "100644", + "gitBlob": "829bf6e09aca9566bb6c803e9f35c52d8dc446ef", + "rawBytes": 2521, + "rawSHA256": "BB36646C35B4118FA5284D933DE154836718CBAAC95E80A2BA1D66592AEF96EA" + }, + { + "path": "scripts/hub_closure_lint.ps1", + "mode": "100644", + "gitBlob": "d08d6467b30ad88630a45f1f892db4b93fb2723e", + "rawBytes": 8495, + "rawSHA256": "241FDF677E4CE5AEE12CBA99D940A6F1C06E08A32B80C86454278F54A9DAF200" + }, + { + "path": "scripts/independence_check.lean", + "mode": "100644", + "gitBlob": "adb72eeb5cd46a8027b4a2f305dc7a691321034d", + "rawBytes": 10685, + "rawSHA256": "290BCB30D4284E3D132B2CF6FAD04B3FE0C32795C44F9A1C5015B538A9686033" + }, + { + "path": "scripts/ledger_decl_check.lean", + "mode": "100644", + "gitBlob": "704ae9825822e0f2e0b21fb9932e7a6fbc655d65", + "rawBytes": 8133, + "rawSHA256": "50DB7F0F27CFBADE83B6CE8ABE46206F540AE67890CA56497CCBA8095B72916A" + }, + { + "path": "scripts/lifecycle_contract_integrity.ps1", + "mode": "100644", + "gitBlob": "a75884897c856177f180e90c359c9d2d2ba0ed5f", + "rawBytes": 8781, + "rawSHA256": "F582FDC21665307B946B41F17EEB95C9BBE96DB7B025FDE6CC0D7141F5C4A9DF" + }, + { + "path": "scripts/lifecycle_dependency_README.md", + "mode": "100644", + "gitBlob": "76cb916bb762b33c16433e84c081f23205cac5f4", + "rawBytes": 5500, + "rawSHA256": "E5A65E69E7D337B11906CF1A5F1A91C15E53D7BC0C1707757AEAA1A01C4A8105" + }, + { + "path": "scripts/lifecycle_dependency_cases.json", + "mode": "100644", + "gitBlob": "57f1d4427f09299814542172b93fe164c098fbea", + "rawBytes": 38490, + "rawSHA256": "003343871E23C93DF874A960A8AF60AE7A8A2E615ADB05B6E581DC4407A1C84B" + }, + { + "path": "scripts/lifecycle_dependency_replay.ps1", + "mode": "100644", + "gitBlob": "2218a00913f0dd8865cd298d81279b0f41b1e998", + "rawBytes": 20989, + "rawSHA256": "4BF287CF5E0715DBE2413DE0E842E21781A38D51A94DA5873E1CF8A8972003FB" + }, + { + "path": "scripts/lifecycle_inventory.lean", + "mode": "100644", + "gitBlob": "aede16830f7cfcf79c8121fc354f31e2ebf0686d", + "rawBytes": 3790, + "rawSHA256": "A6D2C6B8AFA097BA21A5BBB11F529F375E4B1CC5A087F58AB0B143B924790001" + }, + { + "path": "scripts/lifecycle_native_build.ps1", + "mode": "100644", + "gitBlob": "6999611765409cf8dae62193da18f736dd606cab", + "rawBytes": 24962, + "rawSHA256": "4D76D604C626C6FDD3F45C167814557C85C294BDC5314007DAB6DC9805254929" + }, + { + "path": "scripts/lifecycle_native_cases.json", + "mode": "100644", + "gitBlob": "8acb56da0b992dc90b71070763428a6a064201fe", + "rawBytes": 22091, + "rawSHA256": "9DC72366B51592F18DC50E52D2B799C736DC047E6166538A0A880192062985FD" + }, + { + "path": "scripts/lifecycle_native_identity.ps1", + "mode": "100644", + "gitBlob": "9bcc52579d4b5c757784c8c4c8f7597f7bfb8e60", + "rawBytes": 9060, + "rawSHA256": "0E13FCB128193D895D5CAAA94D3BF3ECED511910360E524D8D5C17B3A3F7365A" + }, + { + "path": "scripts/lifecycle_native_replay.ps1", + "mode": "100644", + "gitBlob": "58727f3b01e8bd84a77882903b4060ef5d9557d1", + "rawBytes": 19362, + "rawSHA256": "D7643A9C31E4DC14BD6B469D8742D35CCB0AD1FFD930275FCF18999ECDB1B716" + }, + { + "path": "scripts/lifecycle_provenance_contract.lean", + "mode": "100644", + "gitBlob": "f7962d23c57e778daf937a7280e48c5ce5518b64", + "rawBytes": 5660, + "rawSHA256": "767743A4DD79B34377F5F5550BAB88693DF4A966826B02DE7AEDDA78043FD020" + }, + { + "path": "scripts/lifecycle_validator.ps1", + "mode": "100644", + "gitBlob": "6034e73e8214d0701a6429a4cbde0df9b2ecbc68", + "rawBytes": 8079, + "rawSHA256": "60655B5ECC0AA79E4FB11871C6FD802B57B29AB81491D577F7828F5052CABF63" + }, + { + "path": "scripts/lifecycle_validator_environment.ps1", + "mode": "100644", + "gitBlob": "6204df919a21f2c40d8c3d9f213e675d152a88c3", + "rawBytes": 2071, + "rawSHA256": "2FB2C4D95EAF3F6633FFAA60413D3D798B26E5BF8B4E712E6A254E293E4F9F19" + }, + { + "path": "scripts/m1_certificate_mutation_regression.ps1", + "mode": "100644", + "gitBlob": "2404417ed8dd5790b0b75a7952d906d8644e215b", + "rawBytes": 69107, + "rawSHA256": "9B8FF36330DD2D3C87B24A50196ACEF6303DEF9D71723ACD6140C8D7A69FB811" + }, + { + "path": "scripts/make_audit_packet.ps1", + "mode": "100644", + "gitBlob": "2bdfc822c43061f49f10793035150eb6d075d763", + "rawBytes": 3398, + "rawSHA256": "1E3FF7BC49ACCC5016F750C36F5B32B5E0257F9C34685822A809E833B3363753" + }, + { + "path": "scripts/owned_process_tree.ps1", + "mode": "100644", + "gitBlob": "71b2704e9b77af3b55d4b97c626207013938b5b0", + "rawBytes": 47060, + "rawSHA256": "6690AD4F9E3AEE9596E53E89D3D242E4BE59C0A04733BC50184AE35B292FF90E" + }, + { + "path": "scripts/packed_bitvector_allocation_consumers.lean", + "mode": "100644", + "gitBlob": "2e31e7c41041a53a62634361d940209d3005adc2", + "rawBytes": 2349, + "rawSHA256": "11625C223A9EA1952FE664DFEE7D8DC9C2C3CE798A6C74A39CCD24ACC42D08DE" + }, + { + "path": "scripts/packed_bitvector_axioms.lean", + "mode": "100644", + "gitBlob": "92d7736811aab1c75e7417cb5b88dc721a53218f", + "rawBytes": 955, + "rawSHA256": "505072CA4722C123F65C7184855813AD75C4208763F696222B9127C955C0C145" + }, + { + "path": "scripts/packed_bitvector_crossing.lean", + "mode": "100644", + "gitBlob": "6227be6e6866f6ce75d3a3f9ab5cfa694482f7e1", + "rawBytes": 3638, + "rawSHA256": "33FFD328EBC0F80EEBEA279B4904F804D5A54E1FE5CBC2C4A017A75807FE279D" + }, + { + "path": "scripts/packed_bitvector_exceptions.lean", + "mode": "100644", + "gitBlob": "931ed6a7e4261c29b278b62652d5df81f9a59903", + "rawBytes": 14618, + "rawSHA256": "DC3A964CDE6DE9AC1222761BFFB89B3D6D783708D3661DE20EF9EF77134E136F" + }, + { + "path": "scripts/packed_bitvector_exceptions.ps1", + "mode": "100644", + "gitBlob": "8dda71bd5763e9e2c9f741e83d2e46d52638e8df", + "rawBytes": 11128, + "rawSHA256": "F16EDBFC6578043DBAD17BEE9F97FD2B1A569E2BBBBA622958F1F65195A7BD64" + }, + { + "path": "scripts/packed_bitvector_machine_controls.lean", + "mode": "100644", + "gitBlob": "b44cf08967fccc4a4a457f91aa74130c554dc2de", + "rawBytes": 9929, + "rawSHA256": "F8F7ECBB3C6AF7023B9F5FD69E9034EFB48C1EF29449A288C2395B7B363C2DC5" + }, + { + "path": "scripts/packed_bitvector_machine_controls.ps1", + "mode": "100644", + "gitBlob": "8a32f2afed7f1f181f8e64006379fc5929d40b5e", + "rawBytes": 10320, + "rawSHA256": "19299CD26FDC0050605D8054DD2608723DB95E76682EE8F2DDC4A1347AE71F13" + }, + { + "path": "scripts/packed_bitvector_normalization_consumers.lean", + "mode": "100644", + "gitBlob": "f309cbb54fc9ae6a051bc59eaf51e4c04b328d11", + "rawBytes": 1115, + "rawSHA256": "CF7C09F2CE8DF5D364933FD0BD982BC1835610F5D2B6CCAEBE0EDD6374C529A2" + }, + { + "path": "scripts/packed_bitvector_probe.ps1", + "mode": "100644", + "gitBlob": "865e3d38ff8a19904f9bf1fe23b1a9664c4626eb", + "rawBytes": 2384, + "rawSHA256": "FE126C3906CD65BA3AE65EE773EE1B818CD86564CB7190DB837151BD0D10A06D" + }, + { + "path": "scripts/packed_bitvector_public_controls.ps1", + "mode": "100644", + "gitBlob": "3fdb45ab92074cf1a215212951cf3af6ce2ee671", + "rawBytes": 31987, + "rawSHA256": "CF2D7C080AD7F4ADF42313C693ACF474CF87147DE1FCAF93A31AA164994BA085" + }, + { + "path": "scripts/packed_bitvector_selector_controls.ps1", + "mode": "100644", + "gitBlob": "db6f8cca8452005208bd62b779eaf47e2045c26f", + "rawBytes": 4287, + "rawSHA256": "601BD8289E805E9ABB2B09607C02FD2AA36428F7EA7FB5767B812BC3B578739D" + }, + { + "path": "scripts/packed_bitvector_validation_controls.ps1", + "mode": "100644", + "gitBlob": "94d9831d869ff73950972ac853267a0f5e583432", + "rawBytes": 7561, + "rawSHA256": "FA3E2C3A7F6E329417CB854F8B2B841B543479478B2FB346314F71E84F0818F0" + }, + { + "path": "scripts/packed_native_binary_build.ps1", + "mode": "100644", + "gitBlob": "05f3961aa8e9ad141a5dec2857d2d534c9b14de9", + "rawBytes": 9141, + "rawSHA256": "7FB90CC8AF87AD01FD250E8D9A253852E5A954FEF0E5FD8E7B48F06DBBFDAB87" + }, + { + "path": "scripts/packed_native_binary_cases.json", + "mode": "100644", + "gitBlob": "a5f65a46d14eaf9f39a1c6b6c8bdd31801cf7eb6", + "rawBytes": 133238, + "rawSHA256": "2D38A1002C1E8A72DF5E164144EC4E8F5410511F2C585831AEFBBC0D1BD4C637" + }, + { + "path": "scripts/packed_native_binary_controls.ps1", + "mode": "100644", + "gitBlob": "9d4ff7d086c611efa400879235b6d5961a4149e6", + "rawBytes": 20304, + "rawSHA256": "EDEE71ED973FFF4BC860E1258C6B7FED315FEE43218179C800407998AAD58104" + }, + { + "path": "scripts/packed_native_binary_replay.ps1", + "mode": "100644", + "gitBlob": "fb33e0f29e876a7ab90d57eccc1f69b5cd09b55b", + "rawBytes": 20983, + "rawSHA256": "36774810EB0BA670594D11D11DBD22924032CE8F67554027B5ED5F02CB80DCF6" + }, + { + "path": "scripts/packed_native_build.ps1", + "mode": "100644", + "gitBlob": "8c138c52ba1363bc07b5e5b15b71af882159473a", + "rawBytes": 7888, + "rawSHA256": "4DD02865B2965BECA93E506BB65CA452A867A4DDB047BA9E8A7A4A01B49E751E" + }, + { + "path": "scripts/packed_native_cases.py", + "mode": "100644", + "gitBlob": "ca521d5e9714902f57f0092ce49f36f550155169", + "rawBytes": 54317, + "rawSHA256": "C6AF8167DCE972FF220FA5D61B1D528109737FA9BC9D0A7AB625AB06B0391A4C" + }, + { + "path": "scripts/packed_native_command.ps1", + "mode": "100644", + "gitBlob": "e83f9970bcb1c8cf8d2e63bc66bcc446b39cf22a", + "rawBytes": 1612, + "rawSHA256": "AFB87A955A63408F5E6E4BFAA32A99FA0BE62B16AB81D79EF27654B3B1C31A1E" + }, + { + "path": "scripts/packed_native_contract_cases.json", + "mode": "100644", + "gitBlob": "b4b94a4d978a2eedbcd50c1594858f244ae3c847", + "rawBytes": 64731, + "rawSHA256": "6E0C8E5A73F7DE47D14F7298435E7F72F2AC82A5881AEBF3EFFE0388CBF48E2C" + }, + { + "path": "scripts/packed_native_contract_replay.ps1", + "mode": "100644", + "gitBlob": "f376637c88af8f6786c51ab95124cf5414daff19", + "rawBytes": 20036, + "rawSHA256": "AE8BC171667857E693D58E74626D425AB5C7F8AB43BDA4D6996A6FF92C8C3687" + }, + { + "path": "scripts/packed_native_controls.ps1", + "mode": "100644", + "gitBlob": "229125631b7387950501a9a080e8ff75cd4e80ed", + "rawBytes": 16520, + "rawSHA256": "CB54568CDE80171F868C5D0252EB31C2C5952D1C7EBC586FCA78771C9CADBA9C" + }, + { + "path": "scripts/packed_native_final_types.lean", + "mode": "100644", + "gitBlob": "e71c26b9cdecad4c16713f3b3d2a5017add4e2d1", + "rawBytes": 493, + "rawSHA256": "CF8239C7CE04A72D87843D4BC1D95FAB03B01DA909F747DC65B1EE880FB7B3F3" + }, + { + "path": "scripts/packed_native_hydrate.ps1", + "mode": "100644", + "gitBlob": "8fc2df5271e2d765fc14545a426bc68d43982945", + "rawBytes": 15523, + "rawSHA256": "9E98F0DB4395BDEBE953720140E1BBCC81352EA8A57A649F227CF74D3CD93D83" + }, + { + "path": "scripts/packed_native_identity.ps1", + "mode": "100644", + "gitBlob": "06fec4b50c714cdc473e0fa9167e837c2d0ba295", + "rawBytes": 18289, + "rawSHA256": "A21F67E2EDF49C8E218C657E73967E920EFB85FF025476E01BD04A83CA50B17A" + }, + { + "path": "scripts/packed_native_identity_controls.ps1", + "mode": "100644", + "gitBlob": "e50b0016308af3f6913067f82f5867d2598c1332", + "rawBytes": 5402, + "rawSHA256": "7FAB648DF5CB39FD7EDE63F7E5E4C1D053F2568FF5E55709DF376D4F9E742F91" + }, + { + "path": "scripts/packed_native_identity_v3_controls.ps1", + "mode": "100644", + "gitBlob": "954ea8efbc031540d851a9465cec044cac49b3de", + "rawBytes": 14096, + "rawSHA256": "D8C9C5209D2E4FD738D9F89208A3AEDAB5FC35916A9F8220CCFD94E94422BBD1" + }, + { + "path": "scripts/packed_native_image.py", + "mode": "100644", + "gitBlob": "9c08992a13a23e91694459d0a7e8a0720dea5e16", + "rawBytes": 5140, + "rawSHA256": "29766C6DD5BA76E7BF6FF22AADB6872F7B69AD07C35DDAC79A99B6E5D73ABE98" + }, + { + "path": "scripts/packed_native_lifecycle_integrity_check.ps1", + "mode": "100644", + "gitBlob": "54a46986100f39ff0aaf0f3e02a6bb18e7d76977", + "rawBytes": 7857, + "rawSHA256": "4DBDE3FF1B030829C89DE70EFFD12D959404181A545117ADD11AC869BE0E426A" + }, + { + "path": "scripts/packed_native_lifecycle_storage_replay.ps1", + "mode": "100644", + "gitBlob": "9dbcb0e417544b5044d9d76568d431e5f6003299", + "rawBytes": 44594, + "rawSHA256": "C35BB6D38EB54562CB1E650D437D0914DE72852594DFDB865DB04E24104AD345" + }, + { + "path": "scripts/packed_native_lifecycle_stream_check.ps1", + "mode": "100644", + "gitBlob": "b131230876d9f34cd17fef819aec5f780f4960c1", + "rawBytes": 11222, + "rawSHA256": "71084788A6FE3E5662E187E82F74F078C65FC2F9425ECC9A0C23554BB2E641B7" + }, + { + "path": "scripts/packed_native_route.ps1", + "mode": "100644", + "gitBlob": "9c923afd07d68aa31a36ec875495a8c2b7a31a0a", + "rawBytes": 13622, + "rawSHA256": "8E935824C5A2A01450B7AFFA2E14CE9AA3BAF6C503F1FD423BD249987EB32724" + }, + { + "path": "scripts/packed_native_types.lean", + "mode": "100644", + "gitBlob": "b7e86c11ffbc964b4944fb85a7f6f2f219ab4177", + "rawBytes": 2576, + "rawSHA256": "1E4612ACB570649D8163F684E8F92B7C56056D1A04D1B1AE3592213C08885712" + }, + { + "path": "scripts/packed_native_validator_controls.cases.json", + "mode": "100644", + "gitBlob": "d4024eb6d0e6487cb598cc4c228750e6f13ff4ba", + "rawBytes": 9532, + "rawSHA256": "60D07EC27D7854FEB107CE8A1148F382F17F882CD8F2F18427FBD8BDE8D755EC" + }, + { + "path": "scripts/packed_native_validator_controls.ps1", + "mode": "100644", + "gitBlob": "a7beca1726e99c5d78d4d5e6f4fe71007b6d89e8", + "rawBytes": 13716, + "rawSHA256": "719546F3020562C86DE8169CAA17FB1AB0580255E7E9FAEC4DA3BC70D62BAF9F" + }, + { + "path": "scripts/packed_native_validator_import.lean", + "mode": "100644", + "gitBlob": "1bad2e5002a84aa9a2e9ae1ae0828c3cf67a17e5", + "rawBytes": 327, + "rawSHA256": "1C1B1F8229A2F1B564E9AB5A5A255D9334FEA044E2900D1948E228960B16C6AC" + }, + { + "path": "scripts/packed_native_warm.ps1", + "mode": "100644", + "gitBlob": "845d3ffb5d863e926ab6c67bccd03ab24169da6a", + "rawBytes": 4822, + "rawSHA256": "B891DF9382EDB15BA1CD8E7A513D0E9E7006719771534B6B13DABE3097716ABF" + }, + { + "path": "scripts/packed_optimized_axiom_check.ps1", + "mode": "100644", + "gitBlob": "a7b702b2df4d8c584448076f5d05b0970f8da353", + "rawBytes": 4142, + "rawSHA256": "AFE0FB40ABE0DB38CC002B702A795C3E85096FC448F04AF979FD4B9BA7FA7224" + }, + { + "path": "scripts/packed_optimized_axiom_union.lean", + "mode": "100644", + "gitBlob": "e333a4cd1665817af0ffd2eef7e0f4131d84ca63", + "rawBytes": 10580, + "rawSHA256": "D0A44ECD5F2851661A3036B641FBF42BB6D10F1ACD55A96C3879D86DFB6FC041" + }, + { + "path": "scripts/packed_optimized_axioms.lean", + "mode": "100644", + "gitBlob": "84376e2c104630d0ffbecc4bea354f8f781d9112", + "rawBytes": 9870, + "rawSHA256": "FFDEDB3F171A347E47A84D3064C7F5E146F9E270FD02FBBE719D2D325FFDC908" + }, + { + "path": "scripts/packed_optimized_build.ps1", + "mode": "100644", + "gitBlob": "6f5dcec5d0d49cb0dc280604cf0aab7116e6419f", + "rawBytes": 4701, + "rawSHA256": "56160475202428B1D1FD7A25190743E1EDA3A0FCC2CD98FE568C388E32ACBE6D" + }, + { + "path": "scripts/packed_optimized_certificate_replay.ps1", + "mode": "100644", + "gitBlob": "e1b38040f24b8c227afc486c63c745b2bb61303c", + "rawBytes": 40661, + "rawSHA256": "A37CA628267371275F200C0A0BCE8DB9DEC9663BA1FFDCE76BB9509C259FD33B" + }, + { + "path": "scripts/packed_optimized_replay_profile.ps1", + "mode": "100644", + "gitBlob": "5100f8031169156cc6dfe67e342812b6b26b5556", + "rawBytes": 21746, + "rawSHA256": "AFEBD785F9B38FE08E2652CCF53197180EE4E3BBE088C25545F84663CB573739" + }, + { + "path": "scripts/packed_optimized_replay_regression.ps1", + "mode": "100644", + "gitBlob": "481cb96714d463fedb3b59107b9f2fe3d50e7896", + "rawBytes": 26660, + "rawSHA256": "B88F91393FCDE7395CC1E0B2634C572F8FBBC4AA162F0ADA08F87A7146ED72DD" + }, + { + "path": "scripts/packed_optimized_runtime.ps1", + "mode": "100644", + "gitBlob": "aef90cc789ec25f265d2c645b1d39fcaa4e319b9", + "rawBytes": 25286, + "rawSHA256": "394AA523ADC06D1602CE6F97E7446CDAA2CD36929E96F8D1E80D5564C25A57BB" + }, + { + "path": "scripts/packed_query_inventory_check.lean", + "mode": "100644", + "gitBlob": "6665a12079277057fd63ca483e080ce05e23df2b", + "rawBytes": 2900, + "rawSHA256": "BBDD774E8FFEF0E82857350FC918D2CA11D1BAD2E56E1809E0E2D301BC2D5E2E" + }, + { + "path": "scripts/packed_query_replay.ps1", + "mode": "100644", + "gitBlob": "c006567c7aba8a736eca5e92986224ff5ccebe8f", + "rawBytes": 51332, + "rawSHA256": "9D119A4406057E0A34BC89A2DFCC3FACF98EAFFBE8CB410065FD170C3A3AC1C6" + }, + { + "path": "scripts/paper_topology_lint.ps1", + "mode": "100644", + "gitBlob": "6c2174705132dbb8672cc8feca90fcb38967a64b", + "rawBytes": 39461, + "rawSHA256": "8BB5604311F569334F7EBCF9BDC76BD1115604EFE735BC3C097508283A14D876" + }, + { + "path": "scripts/paper_topology_lint_regression.ps1", + "mode": "100644", + "gitBlob": "f0c6c17858fc09fd29cd5fd31080ec1eafbaf65b", + "rawBytes": 23673, + "rawSHA256": "A51F7025D2F1AC7001605C74B7961724AD770ACD0A64569C03B681BB6FAF7F24" + }, + { + "path": "scripts/preprocessing_builder_check.lean", + "mode": "100644", + "gitBlob": "4f3570cbd8ae3220f784b5c5a2f3abf46c8bc088", + "rawBytes": 34095, + "rawSHA256": "FD38D26CC5E165DCDE1DB860C35892F9BED798277DDB989E7E6251E6CBA4AE49" + }, + { + "path": "scripts/preprocessing_builder_firewall.ps1", + "mode": "100644", + "gitBlob": "27c45086a1ed82531dddb3782624844694e00b3e", + "rawBytes": 10591, + "rawSHA256": "658118E815D994BABAEF68E383A385DFF6B8732100726B27463260B29C73ECC8" + }, + { + "path": "scripts/preprocessing_builder_gate.ps1", + "mode": "100644", + "gitBlob": "79044f143123f7540c9de91a75ced935140f63e3", + "rawBytes": 7676, + "rawSHA256": "DBDBD15332577C6226DC639FF7A79D76B38BC0E3717314EE340198D9C4E6D787" + }, + { + "path": "scripts/preprocessing_builder_replay.ps1", + "mode": "100644", + "gitBlob": "4885ebe233eb6bc3f09a467da74244c2c29a3d68", + "rawBytes": 58256, + "rawSHA256": "A1A1427531BE41317F232CCAF7D73481E4C96B57ACA4D585FF451149E04C4006" + }, + { + "path": "scripts/preprocessing_contract_check.lean", + "mode": "100644", + "gitBlob": "c71b2e6cdf8f6ae58e6cd57a2b470ca63cf78d02", + "rawBytes": 10146, + "rawSHA256": "F2D4D89FC175A0DBB16764A0FFA0B67BEBB413732F20036F590AABF9E2559EE9" + }, + { + "path": "scripts/preprocessing_contract_firewall.ps1", + "mode": "100644", + "gitBlob": "63b8fb96dfcaf7475d47abd8a2a6f02f5b727310", + "rawBytes": 4456, + "rawSHA256": "88255EC83F8F319A909FBB5D98DAF0E8DFDB1A68FC0F15C72FD8A986723B48FE" + }, + { + "path": "scripts/preprocessing_contract_gate.ps1", + "mode": "100644", + "gitBlob": "f83d41824db3d785e65fd83cf9bbf6de9dfd1d70", + "rawBytes": 3783, + "rawSHA256": "707A4D82544AB476D00F103FA780A7B803EECA63B078BF3BF86C97FE27EC1C39" + }, + { + "path": "scripts/preprocessing_contract_replay.ps1", + "mode": "100644", + "gitBlob": "593f4f1a935c4fb8ca8ab31b8c9c772265a9b559", + "rawBytes": 32111, + "rawSHA256": "12BB6E8A802F9A60151B75609E182002EA2D70582168980A7683EFF64DFB6322" + }, + { + "path": "scripts/preprocessing_spec_check.lean", + "mode": "100644", + "gitBlob": "9a74c2b2c7418345c797d40081c0f8c3e8979ea1", + "rawBytes": 42504, + "rawSHA256": "3E4E62DCDC61319B7AE9F33DB691857075FED0DC1C8EF11CC0116990E022129D" + }, + { + "path": "scripts/preprocessing_stage_check.lean", + "mode": "100644", + "gitBlob": "c91f5adb1d18e08b235bf4a1351892a495a01a09", + "rawBytes": 316353, + "rawSHA256": "A312530C7CAD2EC61E2AAB220BDF3D3333C92B80FEAA8E26A6F9CD405C7E0E4B" + }, + { + "path": "scripts/project_skill_preflight.ps1", + "mode": "100644", + "gitBlob": "090b205b5b292b5c1565da86ea27e69fe5b78f0b", + "rawBytes": 7551, + "rawSHA256": "3DD5B60E7C1C08102485F9D25A18647C643BF0CBD4BC00D57A01B8558B7E8FB2" + }, + { + "path": "scripts/project_skill_preflight_regression.ps1", + "mode": "100644", + "gitBlob": "95d142911cdd960f6172c74e33ac0ed79ec27037", + "rawBytes": 8250, + "rawSHA256": "F1F7646BE10E0E20BC05A3F75CDFF9EF04EDA859473319BB6D03735FDDE334C2" + }, + { + "path": "scripts/rank_select_axiom_check.lean", + "mode": "100644", + "gitBlob": "2067eadc2a6898174cb1e5c296bc78542089280d", + "rawBytes": 28465, + "rawSHA256": "5E5A3D0FF05BBBBC07CADEAF63A77E58C0CE98E4F827CC601C47AFEA8F2586BF" + }, + { + "path": "scripts/reproduce_artifact.sh", + "mode": "100755", + "gitBlob": "726f7e7f7790786309c3891263f836eb9025d4a2", + "rawBytes": 3313, + "rawSHA256": "A3A98FFC9F9C096AD3724947DFF96B3E456CF7B553AD8C3951BF850F6C8DFCE4" + }, + { + "path": "scripts/review_wordram.ps1", + "mode": "100644", + "gitBlob": "a290108523bd25b7cf2fb72169c30734743c2441", + "rawBytes": 1588, + "rawSHA256": "6303E50B700F0119BB1E1BC455706C11F17753F51260C4FCDB42D4C3368CB566" + }, + { + "path": "scripts/shim_lint.ps1", + "mode": "100644", + "gitBlob": "e521b5491aca0c310ca7aec8b42be32cf1f3069e", + "rawBytes": 1440, + "rawSHA256": "FB970BF0EA46BCBACE5C6D64314F96F4B64E7817EAD8C0D05883ADE4CF1A7AC5" + }, + { + "path": "scripts/succinct_cost_lint.ps1", + "mode": "100644", + "gitBlob": "f857e99bcd1d58d51dde42f5e5fd715abbd6ed88", + "rawBytes": 1910, + "rawSHA256": "9838CD745B6EAAAFC6F9110827B8815D94A02D76CBB806638942180BB2B30811" + }, + { + "path": "scripts/tag_annotation_check.ps1", + "mode": "100644", + "gitBlob": "d7767fb1330e2545ceae77f8d0f2753f15c6caf1", + "rawBytes": 10420, + "rawSHA256": "D712E33694609F72E64632D58F02A28B8A9BBFB21508C28EBBFCC1292CBF4EC9" + }, + { + "path": "scripts/union_find_axiom_check.lean", + "mode": "100644", + "gitBlob": "ea0f009480c0660d8521925695d88a354b39f0dc", + "rawBytes": 23011, + "rawSHA256": "36B0CCC2A56F344639ABB2EC26948114AFE7E238824CFD544CD119D5DEAD5DF1" + }, + { + "path": "scripts/variable_payload_axioms.lean", + "mode": "100644", + "gitBlob": "75739ba081dc4b7122b8005845c5eb0e7ec3ef76", + "rawBytes": 1877, + "rawSHA256": "6C1A1ACD79D0E218DC27C4B4330CD67C296F022795E3BF567221813CB61C65E6" + }, + { + "path": "scripts/variable_payload_build.ps1", + "mode": "100644", + "gitBlob": "d7e12dd66ecb97e460d53bf06f0c320092d946bd", + "rawBytes": 6712, + "rawSHA256": "B87170FB5780DFE9D503B04E11A2EA31C03C0746ABB278F350949A4061E93ACD" + }, + { + "path": "scripts/variable_payload_contract_check.ps1", + "mode": "100644", + "gitBlob": "bf91c9afbfce0910fce98d874f620925b47d769c", + "rawBytes": 12385, + "rawSHA256": "5504E3E41000F9E91EB12853A34DB02C52B928D65F118A8B699893EA917AA0D2" + }, + { + "path": "scripts/variable_payload_generic_consumer.lean", + "mode": "100644", + "gitBlob": "0bc23412318dc5c0741255f92cb6c0abdbfb3cf0", + "rawBytes": 2648, + "rawSHA256": "ED02747BDBFB75E82782616361C7F3C365362C88B70D3E252FE6ADF05F49D3A5" + }, + { + "path": "scripts/variable_payload_inventory.lean", + "mode": "100644", + "gitBlob": "c946c5fea2cd687d3f60be948c1400686cef795b", + "rawBytes": 5638, + "rawSHA256": "3C6BE8C594634D8B59BC315AB991D934938DF787782403F78C1BC2D43509ED7A" + }, + { + "path": "scripts/variable_payload_replay.ps1", + "mode": "100644", + "gitBlob": "3d56f627e52e25ed56b05a5d119ee725401e0a38", + "rawBytes": 28041, + "rawSHA256": "21278EEB94044B85529A6C28B4F4009800AA50A31DD8371EE71A61E0751A6CD1" + }, + { + "path": "scripts/wordram_axiom_check.lean", + "mode": "100644", + "gitBlob": "130176585c08cbd74c3801077de417efd19228e8", + "rawBytes": 42031, + "rawSHA256": "09439193560121CE14C42666023B8847ACE7643152C179835D5BF063E01558BA" + }, + { + "path": "scripts/worker_prompt_preflight.ps1", + "mode": "100644", + "gitBlob": "e3335a3648ac36cb656366cd7827e1d55c30612e", + "rawBytes": 23117, + "rawSHA256": "C0C68D7D78480D50644AA8C29352E77DFD12F4B0CED3CACAF955A63CCBBF2A40" + }, + { + "path": "scripts/worker_prompt_preflight_regression.ps1", + "mode": "100644", + "gitBlob": "ab6f1709a5303d40a008c5de18a42f81e0ad514c", + "rawBytes": 30419, + "rawSHA256": "B38C72C838D82C8FFCC7B96007CB1FAD4CB6C83D7F313485EFB66A82A2813CAA" + } + ], + "initialMaterialization": { + "files": [ + { + "path": ".agents/skills/rmq-audit-prompt/SKILL.md", + "mode": "100644", + "gitBlob": "7d6e7d91d8d564b49381cf138de17e79d8dbcdb3", + "rawBytes": 7761, + "rawSHA256": "B9251C2FC767B062C619F7A4F1F374BBCF68754D20AD4C86C36D7025FDDE40FB" + }, + { + "path": ".agents/skills/rmq-audit-prompt/agents/openai.yaml", + "mode": "100644", + "gitBlob": "f69fd9e873460adb911115421689c7a6dc07e85c", + "rawBytes": 249, + "rawSHA256": "6EA8CE45A5160862C6646748EA359571F9FA40724705130DA060A9BF86C8A12B" + }, + { + "path": ".agents/skills/rmq-coordinator/SKILL.md", + "mode": "100644", + "gitBlob": "33333638703f8f1871156df1de1706fd23971511", + "rawBytes": 34066, + "rawSHA256": "7F8A7515709636F103FFCE5FEAAFBB5DE6287485D5E1C76D1D9B17541640B357" + }, + { + "path": ".agents/skills/rmq-coordinator/agents/openai.yaml", + "mode": "100644", + "gitBlob": "eccfe94be283ac1bf6fff0f7637da61764702a5f", + "rawBytes": 365, + "rawSHA256": "9DA8E978450241010880DC28E5CBDE5CBF0EC46AEFA07AD1ADEDD18874FEB2A9" + }, + { + "path": ".agents/skills/rmq-proof-sprint/SKILL.md", + "mode": "100644", + "gitBlob": "bfc615ac32c4b737b34b21dab2f2d0dab672fabf", + "rawBytes": 10289, + "rawSHA256": "945A6BDD960A377B13FACC3D83F1DD78D40431027F17B35AD5A8A582455C1E9C" + }, + { + "path": ".agents/skills/rmq-proof-sprint/references/COMPLETION_GATE.md", + "mode": "100644", + "gitBlob": "b39ada83794b428be7184e0c633d3c1f2359f604", + "rawBytes": 31640, + "rawSHA256": "B760F0DF4F3C2B5949352FF926D672CFC4D04AFA43916218C5D207ED8F294330" + }, + { + "path": ".agents/skills/rmq-proof-sprint/references/KNOWN_FAILURE_MODES.md", + "mode": "100644", + "gitBlob": "dd32a880681871be6bb855f71809a8711c051a84", + "rawBytes": 22689, + "rawSHA256": "5C005D0611182863E39F4897B89F66F842DBF4956B208942EEC1E95F694C9ECD" + }, + { + "path": ".claude/skills/rmq-audit-prompt/SKILL.md", + "mode": "100644", + "gitBlob": "12df22787fb2239d3375a44c3c6fed1aba213a99", + "rawBytes": 1175, + "rawSHA256": "34A08A144703633031BE7BCC97C09F5754C74526A077ED07925F64369CEA9AFC" + }, + { + "path": ".claude/skills/rmq-coordinator/SKILL.md", + "mode": "100644", + "gitBlob": "9cab66de6ee49d9c3d027f643a2fe7a00b6b9470", + "rawBytes": 1599, + "rawSHA256": "54394177DBE1F39DFC3230813737588F2A819DD9CBDED6E18D6A5F30C57582D8" + }, + { + "path": ".claude/skills/rmq-proof-sprint/SKILL.md", + "mode": "100644", + "gitBlob": "c662632d335d3fca5a2c75db15e455f3f725d886", + "rawBytes": 1339, + "rawSHA256": "EC1A2AB7DDA9106ADC446D91637F8B23205275AFF7951F062E34D46B22ADB920" + }, + { + "path": ".codex/agents/rmq-frontier-explorer.toml", + "mode": "100644", + "gitBlob": "f54ef34cece2fd9d2fcaa5d80e534a0f5cabdd76", + "rawBytes": 964, + "rawSHA256": "D66EAD12F9F150ED7D9F2F57D083996EE35BC9E7C8153981C71365843E551C34" + }, + { + "path": ".codex/agents/rmq-proof-auditor.toml", + "mode": "100644", + "gitBlob": "65f377ee0a6421e9d90746f3a77bb65d60cf9d65", + "rawBytes": 980, + "rawSHA256": "E7048894E4907017AC30EAD0FF3CCF2A45D1937A3786366DAF833A6D931D6626" + }, + { + "path": ".gitattributes", + "mode": "100644", + "gitBlob": "97bb4605994f95b9537c5101f6e8ebc04f28db46", + "rawBytes": 2651, + "rawSHA256": "EA89E2A9E267B015CB36B496862CADE043E11BBCBC5F0155867AD2CA76D76D13" + }, + { + "path": ".github/ISSUE_TEMPLATE/audit.yml", + "mode": "100644", + "gitBlob": "5889caf0b7108144faa4745dfa07f9f6e915b037", + "rawBytes": 942, + "rawSHA256": "21F3B3CA815BC0D3A5A9A99757B3DE1F362C6F9D3845E7F62CFF94DA00A43EC8" + }, + { + "path": ".github/ISSUE_TEMPLATE/worker.yml", + "mode": "100644", + "gitBlob": "805bca44e1e6cf9651d5b852e7ecec70619a21f5", + "rawBytes": 1069, + "rawSHA256": "67244747915328742FA4E60A6A5B788AF9BEEC99106AB01E5767F5890B23C3D5" + }, + { + "path": ".github/pull_request_template.md", + "mode": "100644", + "gitBlob": "94d0423b1e267753e1914ce39242af5037d2a897", + "rawBytes": 583, + "rawSHA256": "65626244603557A30398F495C22FBD400B2CE08B0818FBAC94E0CCBCBD33FE89" + }, + { + "path": ".github/workflows/artifact-repro.yml", + "mode": "100644", + "gitBlob": "fbf428a2ac5d61f18aaa9561bfb5c7f986f67490", + "rawBytes": 2512, + "rawSHA256": "28F486036AF3A54A7EFA779083E8F9FD24DF134290740DB76DCF57DCBC9896B4" + }, + { + "path": ".github/workflows/ci.yml", + "mode": "100644", + "gitBlob": "6c4ffb3a4cb78445018f5f20b837fbcebab71962", + "rawBytes": 7319, + "rawSHA256": "13530E6F68D1F227C15D1C1CFB03FA5682A61FF48F2ECCA8A4706AA9B92EAF2D" + }, + { + "path": ".github/workflows/release-artifact.yml", + "mode": "100644", + "gitBlob": "16cff4ba7fddabe6238878cb4985ea1c0a8189a0", + "rawBytes": 2657, + "rawSHA256": "F9B3D23371D036A81021287D2DD1ABB2A4FA3E418738CB41D61A5045DCF2EAC9" + }, + { + "path": ".gitignore", + "mode": "100644", + "gitBlob": "488f3de89e106041cb078900c50b77ac5051eaf5", + "rawBytes": 621, + "rawSHA256": "49D597D1E8070A701CA1258753583D528EF183FE8D7F6AD7F4DFAE3DA10E102E" + }, + { + "path": "AGENTS.md", + "mode": "100644", + "gitBlob": "84dfcce40ad902fb3a11fea8d37f8664812ab9da", + "rawBytes": 10445, + "rawSHA256": "B057081A28A8B8BEDBDD8D0B33F2D311BD9DBA4591D7DB4764924BF267D1192E" + }, + { + "path": "CITATION.cff", + "mode": "100644", + "gitBlob": "514a6954dc371219dce5500545553f401e180fc2", + "rawBytes": 709, + "rawSHA256": "354676E89ECD2E3F4E9DF1C91F1B1910ABE43E434CFEA9F2792BE504AAE9DADE" + }, + { + "path": "LICENSE", + "mode": "100644", + "gitBlob": "67ec935563b584f1b6821d6122cc2aee79f7968b", + "rawBytes": 10613, + "rawSHA256": "D470BCE9F61C9F29FB6C6048A496A337B1F0C688217BED9E266017748D8BBD29" + }, + { + "path": "README.md", + "mode": "100644", + "gitBlob": "0b0521c844890d7628a7ced6108022e109d81f70", + "rawBytes": 33813, + "rawSHA256": "D2B55F25DF211647AF32323B167790791E3031ACDC2F5B5082439E4220C9C3FA" + }, + { + "path": "RMQ.lean", + "mode": "100644", + "gitBlob": "cdc7d2282a5bfb547c55960f54f89e198dc03c47", + "rawBytes": 6849, + "rawSHA256": "DB3B465F5FDF14F03D1B637F2AD76610FFAC8BDCA855FDEB201806EEA4E72EEB" + }, + { + "path": "RMQ/Archive.lean", + "mode": "100644", + "gitBlob": "cc4d7de492a35594c0e9c872102cb328964d5e06", + "rawBytes": 121, + "rawSHA256": "06BB171FB4B694E3D86582F94B6446FE88CDBEEF7C0EB1DECBB6646B0D60ACFA" + }, + { + "path": "RMQ/Archive/BPSpecializedCapstone.lean", + "mode": "100644", + "gitBlob": "9e4dd55c36468d16c10d573913eef33afcb78cc8", + "rawBytes": 589, + "rawSHA256": "98E4EFCCBDEA73FCD6F473360DBBE573D04ACC342F8DB3FE0E90EDB67C767E74" + }, + { + "path": "RMQ/Archive/SelectCompatibility.lean", + "mode": "100644", + "gitBlob": "e4b53c95fc68b4e962f495ed1da1d64f7bfc7cd3", + "rawBytes": 748, + "rawSHA256": "FCF3F44AD517C6D8B231D3DF9BA629C5C3D1489FB7813F90301F4CEFD7786FAA" + }, + { + "path": "RMQ/Archive/SelectObstructions.lean", + "mode": "100644", + "gitBlob": "4e54d93533f255a62ff05980d106a3f0874a6180", + "rawBytes": 4888, + "rawSHA256": "345120256155E07DEA1780B2C5340A20B8FC0CD47D46605761BF51ACC8EAC007" + }, + { + "path": "RMQ/Core/Amortized.lean", + "mode": "100644", + "gitBlob": "3704e354f66031252aa77745cb9b5b8c0e815ddc", + "rawBytes": 3560, + "rawSHA256": "F728A46FA03CBF2B7E527B695D1DDA37CD06A1DC820E9031523027E86D3B8FC4" + }, + { + "path": "RMQ/Core/AmortizedSequence.lean", + "mode": "100644", + "gitBlob": "985dccf1078f47ea9f94bad6f5387fe076023107", + "rawBytes": 5593, + "rawSHA256": "D32A05363608E5AACAC83535279368672F1F86C2BC1A6BC800E283F924062A94" + }, + { + "path": "RMQ/Core/BPCloseNavigation.lean", + "mode": "100644", + "gitBlob": "8ef2dc65cf9ce155f87c9577a6c4a6529cff329b", + "rawBytes": 397, + "rawSHA256": "9137D0EB03BE2137A7DFFDAF6C305041BF504684C818E96E6524F2F7D988F068" + }, + { + "path": "RMQ/Core/BPNavigationPublic.lean", + "mode": "100644", + "gitBlob": "7521c7796b0b2ef1096573c1a77ea3a56213da79", + "rawBytes": 71180, + "rawSHA256": "24592ECEB6BFD4A7B337234A0176ADB57FF70EB9E25654D0CC37D38803B01DBC" + }, + { + "path": "RMQ/Core/BPNavigationRAM.lean", + "mode": "100644", + "gitBlob": "93a78d77cea669c0448ad684d68a8bd785a51332", + "rawBytes": 117209, + "rawSHA256": "2116D4244AE2799B51ECED28D7EDB798069C785C45D1DBBFE1777409E26BC9D2" + }, + { + "path": "RMQ/Core/Backend.lean", + "mode": "100644", + "gitBlob": "98ef173870adf0f499dcefb7d70d3dddb557f8e8", + "rawBytes": 2179, + "rawSHA256": "8D911857ED6E9669936D5F8818149E23EBF4874C2C508D63CEEA889660ACC751" + }, + { + "path": "RMQ/Core/Cartesian.lean", + "mode": "100644", + "gitBlob": "2d3aec25e13ffc53227babb8aebe865327d1f1a6", + "rawBytes": 58487, + "rawSHA256": "A0C175425B7DF234F8CF59E177B36E3ED593D81D78337D40E6E2ED74028D9580" + }, + { + "path": "RMQ/Core/Cost.lean", + "mode": "100644", + "gitBlob": "1b6e0c28eb22efa8fdeb2a08a84e18abe6652f7d", + "rawBytes": 4898, + "rawSHA256": "887CDCCA893969756F6B7F785E1CA2249106F215A4155C6BA6FE714A6373BAA4" + }, + { + "path": "RMQ/Core/CostKernels.lean", + "mode": "100644", + "gitBlob": "ce894658ca90684799a4bf544b082848df05b9b3", + "rawBytes": 9261, + "rawSHA256": "E0576CAEF6459D8518A086AE1C83089B5482818E3DE1991B143061F28254D5E3" + }, + { + "path": "RMQ/Core/EncodingLowerBound.lean", + "mode": "100644", + "gitBlob": "62d880a3df139ac6e74bdacdfa5834141034efc3", + "rawBytes": 75412, + "rawSHA256": "BA555AADFA7F3AB3BF0B8DC1D09E093A33DE6A4747DCE6BA707FA68BCBAE61E5" + }, + { + "path": "RMQ/Core/EncodingVariableLowerBound.lean", + "mode": "100644", + "gitBlob": "5104dde50c44670ed460d841ec8bb893beff3b62", + "rawBytes": 14505, + "rawSHA256": "6659E77713800E028DF7904370FA868C1C5AE6C7FCF7B641884DAA9ADE595FD5" + }, + { + "path": "RMQ/Core/GenericSelect.lean", + "mode": "100644", + "gitBlob": "ec79f7bdc908086b1b32da0f7a1c7f22ebbc8f0f", + "rawBytes": 839, + "rawSHA256": "A228C7410792CBB98960E95888098D7967A189C6BD51E240FAC42290D422661A" + }, + { + "path": "RMQ/Core/GenericSelect/Arithmetic.lean", + "mode": "100644", + "gitBlob": "4855508e65a7b1168ab49870ad8556c8255d13a8", + "rawBytes": 7120, + "rawSHA256": "188659DFE14431FA924C60BE82D03EE1733CFC01AC5E5DB046FAB129DB4B88AC" + }, + { + "path": "RMQ/Core/GenericSelect/BPCompat.lean", + "mode": "100644", + "gitBlob": "358fe47e00c50073e52ccb18c46994b89212f986", + "rawBytes": 818, + "rawSHA256": "6E381A9CD5D679327AA67704A6F6E967A9F83DB61DCBDBD1E3E2BA8B919689F7" + }, + { + "path": "RMQ/Core/GenericSelect/DenseEntryTable.lean", + "mode": "100644", + "gitBlob": "a4d2da7e6a6897390570ad44b854c6f762f2e182", + "rawBytes": 24752, + "rawSHA256": "9AF07D6EC8A806E0F7966D3F62801989F8E7DEC84A20C245A9A80555F0655EAB" + }, + { + "path": "RMQ/Core/GenericSelect/DenseWord.lean", + "mode": "100644", + "gitBlob": "618fcc69f88be89e2a5ea7e59549c756ff460aed", + "rawBytes": 2843, + "rawSHA256": "771195F6125E8DE11C24F1F94876B620151CD4A2EA86DB3464E0C9E6E26FA728" + }, + { + "path": "RMQ/Core/GenericSelect/Directory.lean", + "mode": "100644", + "gitBlob": "b632c1770b65bf4ef4b139c433e437be340bce98", + "rawBytes": 12532, + "rawSHA256": "1B99217374A50A1DA29B9E2625D8884F89B1EF255FFF3EC643A32DA58CE246B9" + }, + { + "path": "RMQ/Core/GenericSelect/Entries.lean", + "mode": "100644", + "gitBlob": "dc70a09554c3d831ae2de40c29ab3ff8b4906328", + "rawBytes": 4640, + "rawSHA256": "AE17F58FF740414FE9DFB6DF59B1EE92D2912A26E50D0AB042DD26C813C341F8" + }, + { + "path": "RMQ/Core/GenericSelect/Family.lean", + "mode": "100644", + "gitBlob": "d2fe2f2f01bd208df25762624def8d2a7939a633", + "rawBytes": 14943, + "rawSHA256": "982BA48D8EB6EE8271FE6037BD0A84A0920AC1A5CFE6076B8800211EAA0F891F" + }, + { + "path": "RMQ/Core/GenericSelect/FlagRank.lean", + "mode": "100644", + "gitBlob": "d40802621c488d33f427b05b9de54d67a22721d9", + "rawBytes": 34185, + "rawSHA256": "25EF697C1D68E47DEAD370FFF58717279317E3BB7B5103CD9A5FD8E71896359C" + }, + { + "path": "RMQ/Core/GenericSelect/LowLevel.lean", + "mode": "100644", + "gitBlob": "b5ca40073719b7f43d03d42e9a197b04fcd8a8ee", + "rawBytes": 541, + "rawSHA256": "D80DC849E26E30EB31487C03865098CD582A62E89EEB2BCD7CAE1020AB306535" + }, + { + "path": "RMQ/Core/GenericSelect/Params.lean", + "mode": "100644", + "gitBlob": "f0030b8340bdf8f8fc00fbddd525c902d1945b11", + "rawBytes": 2278, + "rawSHA256": "05F8E4CB75A07792F6B51E5F561EE5E20EEB8F7F51EC05664CDDAF0E55440EA1" + }, + { + "path": "RMQ/Core/GenericSelect/Primitives.lean", + "mode": "100644", + "gitBlob": "430d6b28f7a2fd4868074b50d9a3a6a0cd8583ce", + "rawBytes": 39274, + "rawSHA256": "EAF0C05A429B425A40E8CC77044F268BC8FF36F8B9BB648473D6576F53DF6840" + }, + { + "path": "RMQ/Core/GenericSelect/RAM.lean", + "mode": "100644", + "gitBlob": "6143b2e670e3e52ea8bb0410c0f116d6375827b4", + "rawBytes": 111264, + "rawSHA256": "FEE4D7BE36077D93F928716E4909B4773F818CE39FDA17BC17E85E944EC2892F" + }, + { + "path": "RMQ/Core/GenericSelect/RAMStoreParam.lean", + "mode": "100644", + "gitBlob": "524d591d01fb49113f5ce05070aca9df74234d2a", + "rawBytes": 64263, + "rawSHA256": "F17C7F141928ADEA7320B3187C98F2983B34E3D95B9E6F629860AB4C1313A277" + }, + { + "path": "RMQ/Core/GenericSelect/RelativeSplit.lean", + "mode": "100644", + "gitBlob": "1d7334f67412184204726f60a24436837518b64c", + "rawBytes": 2281, + "rawSHA256": "89E4188223B34F322480147FE5EA4D57542E79A00763408B2EC45D4C80DD9C36" + }, + { + "path": "RMQ/Core/GenericSelect/RelativeTables.lean", + "mode": "100644", + "gitBlob": "cf79740ad57e99750245bd1afb2547c015ae5fd5", + "rawBytes": 59093, + "rawSHA256": "7131A37475059E917D114531BA34726E1C34432BC9DF271D56C166370DC9F1EC" + }, + { + "path": "RMQ/Core/GenericSelect/SelectFacts.lean", + "mode": "100644", + "gitBlob": "69abcd54c8c260281e7431f7a2ae1ce6e95f6d66", + "rawBytes": 11804, + "rawSHA256": "DF6E9CB61E7FEEE0659B62960379FB8CD851B6BD914347A2D3BD06785CF93C69" + }, + { + "path": "RMQ/Core/GenericSelect/SelectSource.lean", + "mode": "100644", + "gitBlob": "e0834e880f064703ecdc4fbc9c8f2de3ed36187e", + "rawBytes": 1220, + "rawSHA256": "222526C0D6D8AD56EB1E4FD5678111471961A6D3674614790BD5ACE58098D57A" + }, + { + "path": "RMQ/Core/GenericSelect/Slots.lean", + "mode": "100644", + "gitBlob": "497af76a21b762d2a87e55293fc25ec9b1e34bab", + "rawBytes": 44242, + "rawSHA256": "AE96B766A1D0CF34CE468B3EE9C9FDF82195AE25FA4ACA41E150AE426FA59051" + }, + { + "path": "RMQ/Core/GenericSelect/Source.lean", + "mode": "100644", + "gitBlob": "88bb4ce92623fdc5db9f69de83706910710d9cbd", + "rawBytes": 105875, + "rawSHA256": "D1A404009FB648D1F256AFB0EFC396594C00B6E0EC85192F978B16BC0F08932E" + }, + { + "path": "RMQ/Core/GenericSelect/SuccinctSelectLegacyNames.lean", + "mode": "100644", + "gitBlob": "76baf3b2d1231a390ef2a9c819946a08189ee0ed", + "rawBytes": 1492, + "rawSHA256": "B35DF308CC58F983D936656E5546E4F3F8328A61EE4C0466546351C289754DB6" + }, + { + "path": "RMQ/Core/GenericSelectBPCompat.lean", + "mode": "100644", + "gitBlob": "15f8de2b5c4dba9092ccecea79a131dc170de41c", + "rawBytes": 248, + "rawSHA256": "0096C7B78A76989DA01890B14D0DA27FCE77C507C98470A50D99A3A8BE8350ED" + }, + { + "path": "RMQ/Core/LCA.lean", + "mode": "100644", + "gitBlob": "e86dbb789225380edd59586ffb1f81b4d5a84333", + "rawBytes": 117400, + "rawSHA256": "E981D40A5C3429A6794BD7857AEB01A0B49653F869C1139232AFB8766F1B053C" + }, + { + "path": "RMQ/Core/ListLemmas.lean", + "mode": "100644", + "gitBlob": "3ab20ea828a62409ec2516003cc39c9b5510f9d0", + "rawBytes": 313, + "rawSHA256": "E4DF7A2D19754BC5BA77BA05235EC72E839DF226B00D4A38BAEB452B46ECA1FA" + }, + { + "path": "RMQ/Core/LowerBound.lean", + "mode": "100644", + "gitBlob": "4b308477d25958476ff640ae5cc1eda1b3df7333", + "rawBytes": 12042, + "rawSHA256": "FEFE56A46F206F5233C7E4B9EDAFC6BC1FA5CB0E04B03494FB94D9D0DFD6DF56" + }, + { + "path": "RMQ/Core/Microtable.lean", + "mode": "100644", + "gitBlob": "f0e39fe25cad9b55bdac752574bac6d70970aaa0", + "rawBytes": 19165, + "rawSHA256": "7AC16582B05226A39314CB12CF4032394BCC9802E01867697E1271BBD9C21A80" + }, + { + "path": "RMQ/Core/ModelHub.lean", + "mode": "100644", + "gitBlob": "bf6c5e4300c8d3815814f5ff468da5385a03dae1", + "rawBytes": 464, + "rawSHA256": "2C91A59EC51E3EB161AE15D288047E1F3F38BC06477E085BFBBA2F906FD200F4" + }, + { + "path": "RMQ/Core/PayloadLowerBound.lean", + "mode": "100644", + "gitBlob": "a00aab777e13c1f7d67e893508f78d74b31cb73c", + "rawBytes": 12120, + "rawSHA256": "24523EC8D3DD5859738DDBDF69BCC14C41FB0E21D7175ADDD494072FFF1BCA55" + }, + { + "path": "RMQ/Core/PlusMinusOne.lean", + "mode": "100644", + "gitBlob": "29e44ad0a9c66950a2a6ddfbc1a42687aaac2d75", + "rawBytes": 14979, + "rawSHA256": "F66CFC4256FA0F3806E4C64EB3DC530E9675A86F3D1C3082AF349DFA9A3F74EF" + }, + { + "path": "RMQ/Core/RAM.lean", + "mode": "100644", + "gitBlob": "6c9a930e494d4c2112a6bd7dbd6aa95abeb0295b", + "rawBytes": 10331, + "rawSHA256": "208E621844CA2A0F5CA73312B3C5688406AFD330EB753506987DAB603AADEF4F" + }, + { + "path": "RMQ/Core/RankSelectCompressed.lean", + "mode": "100644", + "gitBlob": "e609b2f644140f270d1875020f323dfbf9ac345d", + "rawBytes": 360, + "rawSHA256": "11D0D018293C63D496D63AD37894FBBCA663F27F3CFD30A4EF1EFA09D0DB3160" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Base.lean", + "mode": "100644", + "gitBlob": "22ab0b7d6c41db5320c3d91e6a007f7538681fcf", + "rawBytes": 827, + "rawSHA256": "36CB6AD2FECCE3695A8E0F87320242FBAB50D20FCC42EC0195CC51D57EC75462" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Base/ClassLengthEnvelope.lean", + "mode": "100644", + "gitBlob": "8651d57e6b4262fa5ac4546f84e4ecf38688d168", + "rawBytes": 153950, + "rawSHA256": "2AC9C81E77D27600B7644A1BFA17ED953C137F02959A1AFE527A559835BC48A9" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Base/Core.lean", + "mode": "100644", + "gitBlob": "3cd18bfd1c25963d345fbdee25e005e2eec06c55", + "rawBytes": 550, + "rawSHA256": "AC0DE53341B4D67BECE40494CA9A9416A36038CBD129DD0A1E1EA05F6835475A" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Base/Core/Auxiliary.lean", + "mode": "100644", + "gitBlob": "cc18ceacf6a66be1c6d2d75980679f6dcdd81348", + "rawBytes": 69320, + "rawSHA256": "CCE12C6C94E7EBDFE0FB64F708A16BCD2B84D0F2A2C809EE8BA6CF1C7EC424D0" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Base/Core/LocalRRR.lean", + "mode": "100644", + "gitBlob": "9496ba796fad7a2aadd7f98f97f0d93b77ca97cd", + "rawBytes": 59358, + "rawSHA256": "50F1D1031DD10306E438F130B1BA5E5D2F253897C8DDF27953FF770D17DBCF03" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Base/Core/RouteTables.lean", + "mode": "100644", + "gitBlob": "577f926ab19d6689054059ecd0e1b03eadc4a758", + "rawBytes": 49233, + "rawSHA256": "3ED334F08EC484BE5EEC2C012D67B6A306A505C9F0910C843A9A6C0D7106B31E" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Base/Core/TableBacked.lean", + "mode": "100644", + "gitBlob": "d975ef5eec7d5a381c053450bf3a0cbace0677da", + "rawBytes": 16926, + "rawSHA256": "60E223DD682C54C30D901467314C2E8F2D7B98F52CD8D33CFFE88B3D887F40F7" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Base/DecodedRoutes.lean", + "mode": "100644", + "gitBlob": "8d06a25419649be8d5c658a9e34444bdbaf73d2a", + "rawBytes": 67525, + "rawSHA256": "FCF7FFDF75AE228285F008EBA348B62E76A077BFBE390126C1F9B561C6B99EC3" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Base/LogChunks.lean", + "mode": "100644", + "gitBlob": "94b2467a07ae01c0d3077ad61cd54961d8ed96f1", + "rawBytes": 46397, + "rawSHA256": "339E8D1A5F129BB37B21FC8BE317CE95889BCD9006D6FEC6356185192023AC42" + }, + { + "path": "RMQ/Core/RankSelectCompressed/FixedWeightCodec.lean", + "mode": "100644", + "gitBlob": "e153398d3d9587948b2e34994eba6bfad3201bb0", + "rawBytes": 24068, + "rawSHA256": "8A6448A5E6FED38C083C2D6A31D5F052779BA4A010C965D75E8BFC38D28220BF" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Readback.lean", + "mode": "100644", + "gitBlob": "a7a40db75b200737879a6dc09bd6108274167493", + "rawBytes": 27080, + "rawSHA256": "DD8432ABDB30B392AB4AFBA052017850E3364ACDD936D9AC0813C52B10250BD6" + }, + { + "path": "RMQ/Core/RankSelectCompressed/TableRAM.lean", + "mode": "100644", + "gitBlob": "b3b08991fede6db7fde13baca0367df234e7089e", + "rawBytes": 85137, + "rawSHA256": "F14EA19D2F1BDC5140AA3A95D62C02188783BC57D66DC96D0D133A3143DC8B0B" + }, + { + "path": "RMQ/Core/RankSelectCompressedSplit.lean", + "mode": "100644", + "gitBlob": "f6abb9d96c94ea64613f74c0433dc998e9910e65", + "rawBytes": 59934, + "rawSHA256": "4D5001E41E3BA858364FF364CEC7141694B000E27BEB49C5EBA2CEAFB1E60A38" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLog.lean", + "mode": "100644", + "gitBlob": "467c8aac4109a2bd257dd8f7133fce8654f5bbd9", + "rawBytes": 107461, + "rawSHA256": "8375A9291724F3CD2D1CED79BC2D0CEBC647BA4F31697D29C0AB7B4FA777AA42" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogDenseWord.lean", + "mode": "100644", + "gitBlob": "f4db180de198d9fb24403776b5b4d7b59bd16d3d", + "rawBytes": 37815, + "rawSHA256": "AE50D15C00085E4CF939493556D9EDC36FE968F3578AEF69D563419DF93677B6" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogDirectory.lean", + "mode": "100644", + "gitBlob": "cdc590a21c0f9d56b6f6fdc9d915c07afdd52b55", + "rawBytes": 14899, + "rawSHA256": "D103BAB037ED5384E9AD67A7C75C1413CA12E69DA133D9DDCE50B504421A1269" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogPackedClark.lean", + "mode": "100644", + "gitBlob": "3a217cfe12c7b35da0c4e8cf370ac0067988035a", + "rawBytes": 22634, + "rawSHA256": "6680BC3363BA3FDD53CC969009A01C4B3798087D8EAC6625FA5F8259E12C3482" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogRAM.lean", + "mode": "100644", + "gitBlob": "7caa006d57460f179eaecd9cdcdfcf4c05bd8231", + "rawBytes": 693, + "rawSHA256": "4E88202592D1D079AA9D28C42791BBF6465F25B0B8FE7354718D1780A31F5BFA" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogRAM/AccessRank.lean", + "mode": "100644", + "gitBlob": "8b27619a1027a8431d92efddd4fb7d1098a6d5c8", + "rawBytes": 39877, + "rawSHA256": "3534BAAA57F6F89890190A834EC525DE855F7E5386D39BE34E84E6277ECC1914" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogRAM/BoundedProfile.lean", + "mode": "100644", + "gitBlob": "368fc337f12cd550ba386228aad635850e563003", + "rawBytes": 30376, + "rawSHA256": "252DAB632AF6357420D51FDF067D011455A8CB4D8E898D3D1432543973DA2427" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogRAM/GlobalStore.lean", + "mode": "100644", + "gitBlob": "95e117cb569058c6602ebb529dbaa7ecbe2905c1", + "rawBytes": 40797, + "rawSHA256": "73233117828F3F68E73A9C08956E72E4824081224DF65E55D3F93B2B8C2716CF" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogRAM/Select.lean", + "mode": "100644", + "gitBlob": "73e0e1d7098280b56444bf910b29d1e21c129de6", + "rawBytes": 96209, + "rawSHA256": "5FE065F75FB55FFF37BFCACE55E90BEA77AA803EF7216AEBC61E47873E130553" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogRankRoute.lean", + "mode": "100644", + "gitBlob": "33789cb8f370c331d331b3118d3db10837e9831c", + "rawBytes": 42290, + "rawSHA256": "E1DA9E164906D33E64E07896828D2C03EDC87C04C19694BF95DC52FDAECB856B" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogRoute.lean", + "mode": "100644", + "gitBlob": "8b225e804ae9de091c31b44a8ea1a133d7b0f7e8", + "rawBytes": 18358, + "rawSHA256": "350302F2CF8791098F6083D56BAEACF54E65030E0487780258CC237FACD7C12E" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogSelectRoute.lean", + "mode": "100644", + "gitBlob": "27af0637e8c7a4617d0d321192302abbd6ff3b2f", + "rawBytes": 10533, + "rawSHA256": "5B65A9ED62DA564C7E6C601EFD9134E87AF3FF82ED2C3F9B96576FCBCC826977" + }, + { + "path": "RMQ/Core/RankSelectPublic.lean", + "mode": "100644", + "gitBlob": "9c2179edebb3576efcd0c23ead4b9734328f8d34", + "rawBytes": 302, + "rawSHA256": "D7EDC9A444DF1B31DD630D149DC8CE2CFF83C1AD95ED139B3D808C1C7B7D5CBE" + }, + { + "path": "RMQ/Core/RankSelectPublic/Capstones.lean", + "mode": "100644", + "gitBlob": "7ace87b3d6e1aa7a7e0e0e0a74e335b2ebf5add6", + "rawBytes": 11344, + "rawSHA256": "09E4A34ADB9CC435C429975C40CDB8EF888C3B3D295C67D710A9BB82E4D152A4" + }, + { + "path": "RMQ/Core/RankSelectPublic/FixedWeight.lean", + "mode": "100644", + "gitBlob": "ab55aa2ca31745f3c2e70f48163b18838886c4af", + "rawBytes": 53031, + "rawSHA256": "50C7FA4C967A673A432C3154F291F5C821635B6740FF3FA6B2D86BDA7F953057" + }, + { + "path": "RMQ/Core/RankSelectPublic/Profiles.lean", + "mode": "100644", + "gitBlob": "46b3035ef581885e273b55aed6e7a2a845e84034", + "rawBytes": 127952, + "rawSHA256": "686C599B3D6854203036BDBAFBCA4655B37DA84DBF88DCB6DE5A868FAF465F5D" + }, + { + "path": "RMQ/Core/RankSelectPublicRAM.lean", + "mode": "100644", + "gitBlob": "e3339975d1c04e4165975d275c47b9d2c4acdf76", + "rawBytes": 62840, + "rawSHA256": "4D75C1AC9E941C4610555AEFE5E26FBB7E2C0CD714037A4617A2EAB32E806F1C" + }, + { + "path": "RMQ/Core/RankSelectSpec.lean", + "mode": "100644", + "gitBlob": "6d8ccaf62462655b0b0ce282e0bffd442b43c7a4", + "rawBytes": 11211, + "rawSHA256": "2D48B2089432B601337E7FDB6CF9B081D8382A44019068D5DF64FBC4867DBCD1" + }, + { + "path": "RMQ/Core/RankSelectTwoLevel.lean", + "mode": "100644", + "gitBlob": "8c220cfa8ac8d84aa69fe5607a6209f4135868c4", + "rawBytes": 10352, + "rawSHA256": "D8B45961567F50A3B679DB7CA454E717F105BCA4E931D7C9E1515E852D36BB22" + }, + { + "path": "RMQ/Core/Recursion.lean", + "mode": "100644", + "gitBlob": "dbd658aa8a3aaea0951902588e2325c74f318984", + "rawBytes": 17263, + "rawSHA256": "80ECADD010103A8197C845C285199186341F627FA266CC7B4491BFCCEB155B85" + }, + { + "path": "RMQ/Core/Reduction.lean", + "mode": "100644", + "gitBlob": "0ecc969d61e989643fb8dbbc3ec3f6d05e7a7446", + "rawBytes": 11885, + "rawSHA256": "A15808CA01F085C691CC30F73EEEB88E8AA858670D4BF0B707F2DED1AA1791EF" + }, + { + "path": "RMQ/Core/Refine.lean", + "mode": "100644", + "gitBlob": "ec8239cabaf375f3bfc214b6cc154c641403bd65", + "rawBytes": 7088, + "rawSHA256": "75953F297DE26411AF75EA9BE3CDBF2FD6D0403EE0AE88E3310DDCD5ABBBEB2A" + }, + { + "path": "RMQ/Core/SampledLayoutBudget.lean", + "mode": "100644", + "gitBlob": "e58a66eb35ef0936413b31ee3ad8736c87dbc136", + "rawBytes": 4929, + "rawSHA256": "B3F7627EF1903C5C590A405146C53A5B07469D5E45D59CA5A56D097FE07CD4AB" + }, + { + "path": "RMQ/Core/Schedule.lean", + "mode": "100644", + "gitBlob": "fcced7cb3c1047680835b2abce5f872d82112f3b", + "rawBytes": 1629, + "rawSHA256": "7361D7F853F3DFCE417A22B3BA4703D032E21F3F8789A8A2065E2FDD1EA847AB" + }, + { + "path": "RMQ/Core/Shape.lean", + "mode": "100644", + "gitBlob": "61ed0680524d79d62b059a447638f9ae944996f9", + "rawBytes": 72219, + "rawSHA256": "A29366B989E786A5C762764C2DA1FFC9DF1487BE212A113A122384D9A1E2C863" + }, + { + "path": "RMQ/Core/Spec.lean", + "mode": "100644", + "gitBlob": "603ca44bc712453e67d902798e74a78b702520e5", + "rawBytes": 8783, + "rawSHA256": "D32B9EF9873E9C9D8E2AEFE1227770F2B565122FAE01C0AE86737FA750F74AE3" + }, + { + "path": "RMQ/Core/Succinct.lean", + "mode": "100644", + "gitBlob": "b460c95c2bf20dc03edeab6d265a88d8c0d057c4", + "rawBytes": 51368, + "rawSHA256": "C81AF4978110198561B109893832045509D8C8846CF2FCB179C809B5BA67E74E" + }, + { + "path": "RMQ/Core/SuccinctClose.lean", + "mode": "100644", + "gitBlob": "8ee061df2db2a1ba62edd7511ec3c9ec60d4385b", + "rawBytes": 560, + "rawSHA256": "D0DCF4A2D323A65FE03D901AD6C37189281522A75DF01447B2C9CF9FDE56718D" + }, + { + "path": "RMQ/Core/SuccinctClose/BlockLocal.lean", + "mode": "100644", + "gitBlob": "569a5cc3c03291b3a3cc5ff0e5217932bf95ba96", + "rawBytes": 37150, + "rawSHA256": "818D93BC4665385FD6F5E45431DFC783E1A1D0860DCA35DCB9B75EFCDB5F0B62" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe.lean", + "mode": "100644", + "gitBlob": "458aa665971c7c7cffe71f26d48f3de64623621e", + "rawBytes": 332, + "rawSHA256": "47F178B980D4386FA297A3BC8352F5D8FFD73AE9CA5C8E5CE8C5994FAC04F6F3" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/EndpointMacro.lean", + "mode": "100644", + "gitBlob": "34089d1d97e38401562fef7d6699888830fc1d8f", + "rawBytes": 340, + "rawSHA256": "466D70E742C3B92EE02833F796B1776DDFC3BEA4CF487F0EB2F1734B48005732" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/EndpointMacro/MicroCodebook.lean", + "mode": "100644", + "gitBlob": "38329d0ad318d0ac3bd93d2803b32a8d5c4a9674", + "rawBytes": 67344, + "rawSHA256": "3E9DFFFD9C463376798509E1E88919A47EA52C39D7DF18D8369996954929BF04" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/EndpointMacro/RangeMacro.lean", + "mode": "100644", + "gitBlob": "40b4e597a0fa852cfa830f4ad71348cc20997da1", + "rawBytes": 326, + "rawSHA256": "F9E7C1471B2167BDAF3D049E187224E27AAB87971C3404C5F17298C55E0A99D9" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/EndpointMacro/RangeMacro/Concrete.lean", + "mode": "100644", + "gitBlob": "0e3f3210b373d23d4be91110331678bebcbca06e", + "rawBytes": 11573, + "rawSHA256": "1A72C3A22D9EC67B1F7D728E4E369E0AF4CC33384C8922583A971CA4224E74B2" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/EndpointMacro/RangeMacro/PayloadMacro.lean", + "mode": "100644", + "gitBlob": "1d699ea46e1c0b615a8e680572994b2f82cc4d66", + "rawBytes": 104028, + "rawSHA256": "9FA35FD83C7F46FBA374B549AE1F85F2733A2409FFB03B9CCBEAFCC6510CD08B" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/EndpointMacro/RangeMacro/RangeTables.lean", + "mode": "100644", + "gitBlob": "8e0b0bc90120bfa202a46739c3cfc6c9da91dfd1", + "rawBytes": 14161, + "rawSHA256": "C036F7B736ABF755A8B8D9B1A02CE5810AD441CDAC7F546993F8D5B5AF63F041" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/EndpointMacro/RangeMacro/RelativeMerge.lean", + "mode": "100644", + "gitBlob": "8f06664a417869aac1f4733bc3a24dcf86683f35", + "rawBytes": 3278, + "rawSHA256": "ABDEAEBF1C169C5EDE34EF2323C2C942D26C8052BE68C6E1E21D2FE0A86C09EF" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate.lean", + "mode": "100644", + "gitBlob": "5ca201264fc579ddcf4fdb1f1e96f2656450fa3b", + "rawBytes": 365, + "rawSHA256": "948813C73489C2642729997DC9AB448EB8FCFB70966A9F6307783F4DE5434BCC" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/Candidate.lean", + "mode": "100644", + "gitBlob": "e067e2942b2e845c872886763c774a430ed029ba", + "rawBytes": 18447, + "rawSHA256": "C843AABE9ADCA16A463EFC1307CF629604470E8847D3591131EC29784D4C6D83" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/InteriorDirectory.lean", + "mode": "100644", + "gitBlob": "6d74a5b2a8e982ae5e3d109657ece0b849c9642b", + "rawBytes": 512, + "rawSHA256": "92A2322E6DD91D8D2718E65F52B5DAC2572C142297501F0DF3882BF84534BC16" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/InteriorDirectory/Base.lean", + "mode": "100644", + "gitBlob": "89e5bda6d58ebf50e115591781fb84f8d7717b23", + "rawBytes": 197085, + "rawSHA256": "65522F59E57BE29618BCA88A624F9A867C8DE02469A42C526B48E087751391A1" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/InteriorDirectory/SparseLevelWidth.lean", + "mode": "100644", + "gitBlob": "b7826b9550926e5f60fa1c482c195cbf88180202", + "rawBytes": 98312, + "rawSHA256": "9902C625271049BC410B6CDE11CE8212A7451CD483133D90B199E87225F87875" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/InteriorDirectory/ValueDependency.lean", + "mode": "100644", + "gitBlob": "19a52aca2b9587c515cbca9a96c78f666ce32ac3", + "rawBytes": 57308, + "rawSHA256": "B10110A3A0231D1FAD754A830EE0397A55ECB894C16B0864B6DD8A0B6F607D2C" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/InteriorRAM.lean", + "mode": "100644", + "gitBlob": "4a14369e2544e5fee6537b1af15bc939688d2326", + "rawBytes": 138383, + "rawSHA256": "E6850BE91B2120958019452EE26658AB2AA13CDAFD42BDDE649B6BA177EFD956" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/LocalGlobalSparse.lean", + "mode": "100644", + "gitBlob": "ba73eba0435506a003eb8171f2c583b46a3fb887", + "rawBytes": 62216, + "rawSHA256": "B2A3B8866E5FCB52CC5A0884B22AFBE6DE2B74C92CED3D36B6F5C1CB8D29EFA6" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/RelativeScan.lean", + "mode": "100644", + "gitBlob": "398eab70ba29652f9b277543cc3dfbac7a0ab143", + "rawBytes": 19800, + "rawSHA256": "AD29744DA234215194478A2D8D0F2BF31FCCA119E5E9C9554A11970F2C9E0B21" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/TwoLevelCandidate.lean", + "mode": "100644", + "gitBlob": "6878e676d40435e66576dc18f81b5e09a6a88776", + "rawBytes": 30465, + "rawSHA256": "6900B5DDEB67DF79BA9A1A2B39682FEFCD9EA975E2E408ECD8291316748D15A8" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/WordReads.lean", + "mode": "100644", + "gitBlob": "021cc54525f70430c4674b5647a5c53390fbb37d", + "rawBytes": 21966, + "rawSHA256": "995F2E38D1F5C43FCAA1E4815FD2235EA481F7DBDCFFE3738EB5CFF7BACC37F6" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/PrefixRange.lean", + "mode": "100644", + "gitBlob": "951d7577d4c570889876a04d516e57c45815cb95", + "rawBytes": 361, + "rawSHA256": "A0FED5EE46F3152D63EF42F8791D802FA34CCF8AE9D4A98A3288DF1425302B0D" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/PrefixRange/AnswerSemantics.lean", + "mode": "100644", + "gitBlob": "e6b9080d609b8d54ca9bc056365ded1d4051c7b1", + "rawBytes": 38669, + "rawSHA256": "148B0E1DB197AADFD8F0927A82A89195D5F066F98B8BFF31C92718DCA1D66A9F" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/PrefixRange/LocalSparseOffset.lean", + "mode": "100644", + "gitBlob": "583fe8753c3a91d74ee1d15df25a77282eea79f3", + "rawBytes": 23523, + "rawSHA256": "717A2514A0255D9994D780C87E0BA952D193EE791EFFAFF440D194438765B82D" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/PrefixRange/PrefixArgMin.lean", + "mode": "100644", + "gitBlob": "e268cad4f307f063a6e39181e05282cba91dbf26", + "rawBytes": 19463, + "rawSHA256": "02EAC18E6679B60A7A78BA101C39E3269C18EAF8202178B3C0335441FE548CAD" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/PrefixRange/PrefixWitnessTable.lean", + "mode": "100644", + "gitBlob": "bd8dda3d4b12d29c9d9c32f9196c52203ea4618b", + "rawBytes": 11747, + "rawSHA256": "07538D0E27689BCB02915F5101ED158B5258A168ABB172F35DE0CF5733C2B56B" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/PrefixRange/RelativeSummaryCandidate.lean", + "mode": "100644", + "gitBlob": "2cc25fc32a01faa71ec17aafd5ce1b83a9cb7891", + "rawBytes": 24349, + "rawSHA256": "4092148FDDBF60A1F481128DC96EFFB2FABD121CAD14F8EAA0142DDF6F30ECAA" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/PrefixRange/SparseArgMin.lean", + "mode": "100644", + "gitBlob": "d8b7cc5835d0c4500800542e8c5aebd35b589c01", + "rawBytes": 26488, + "rawSHA256": "BD98AF45F9D43B75768E23013EAEC66400850215124102C7720BE4CA115A774E" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/PrefixRange/SparseLevelTable.lean", + "mode": "100644", + "gitBlob": "442916dd0d855afedf97f6017e8b34852462c5f8", + "rawBytes": 10643, + "rawSHA256": "15E23994297D09D37CABDCFB2277BC8F819FF76C307636AC6E3889C1B7E61043" + }, + { + "path": "RMQ/Core/SuccinctClose/RangeSummary.lean", + "mode": "100644", + "gitBlob": "3a7d2c6565961a4df9bbc04d8b5bc8b600a54f6d", + "rawBytes": 40726, + "rawSHA256": "4DBE30022D3066FB44C1405D2C52FD8D4469537B6DE0C589DB6F99FBABB9A7EE" + }, + { + "path": "RMQ/Core/SuccinctClose/RangeWitness.lean", + "mode": "100644", + "gitBlob": "e8d520c51bf1d0499d6b1e7187e4cb7b18833313", + "rawBytes": 53161, + "rawSHA256": "4A9EF0FAD0B84ED02F55A1313353375F5159322DA5B159DBC6081E8781F378DC" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro.lean", + "mode": "100644", + "gitBlob": "0ebcb3785a41601599b63b4c16236b0d9f88afcd", + "rawBytes": 421, + "rawSHA256": "9F55F443ED0234E9C509664F31CC90884C455C2783491FDB6EBA058FDFCD27EC" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/AbstractMacro.lean", + "mode": "100644", + "gitBlob": "f63c676eb883768f42e5432b28ffc9a6dc552bc8", + "rawBytes": 15565, + "rawSHA256": "4A368521FB415863E5FD77A7B0F4ED83CBD49983DBF4A7CD4A2B6921A0407553" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedFringeChunks.lean", + "mode": "100644", + "gitBlob": "337c4fc4d45377dd66c7fe7cd4d5bd32cad7dae8", + "rawBytes": 82770, + "rawSHA256": "7D3C02BF0F79FF53008D322C7FB92A99449252AA1303FB539222BB4F0B75CC6A" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedFringeSpace.lean", + "mode": "100644", + "gitBlob": "b87d4da61d9c810c3e475605e42fcf5946208bb4", + "rawBytes": 3057, + "rawSHA256": "9ABA710A3CF3DD8B830A03FAFC7643D79DD30EBB97E2CEB2DBEE8A432001CB0C" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedFringeSubstitution.lean", + "mode": "100644", + "gitBlob": "9fe5a3eb571d91f005766ad73b2173fb3e38d34c", + "rawBytes": 20474, + "rawSHA256": "A76B18F22F18D2F26F60136ECA544921FC6177B55718E092D6C92A74071D9BEB" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedFringeTableFacts.lean", + "mode": "100644", + "gitBlob": "7d65c1129bb43803addbb4d3097b159258eb25b7", + "rawBytes": 10551, + "rawSHA256": "CD0E8F62E7AA6F58EFF3CB7C937F2025B98D99AF5798C7B8EC55676224670744" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedFringeTrace.lean", + "mode": "100644", + "gitBlob": "acebacbfdaeea14d8de6d8c48749a36c37c76e23", + "rawBytes": 74753, + "rawSHA256": "3958821F9FFB5FE5A3E51664ECF50191AF3BC27FEF1303BCA27565D772B61E26" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedFringeWiring.lean", + "mode": "100644", + "gitBlob": "1a8f2906dd8980e5a3ce9693a46571f3cf22dc67", + "rawBytes": 32250, + "rawSHA256": "BE36BA283C012EA66699A85AACC45D435465BD6C535F6BD142F53A231BF2C117" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedRankSelectLeafTrace.lean", + "mode": "100644", + "gitBlob": "b60987b668c0877871ba2532f19897ca768d506c", + "rawBytes": 75619, + "rawSHA256": "418AAB560F5E0A6DB37CB4D5B3245D44580BE8004ADCC3A98528DEC598B87C96" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedRankSelectLeaves.lean", + "mode": "100644", + "gitBlob": "48ed35549651e348dd1502afb76b6aaf5ce6c66e", + "rawBytes": 29199, + "rawSHA256": "4964AD5844644F486DF44F75ABC31862DFFD3BE4A507B503E120A615657BB418" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedRankSelectTrace.lean", + "mode": "100644", + "gitBlob": "8c068a82ac6e13bc730681d1f078847bf1972e9d", + "rawBytes": 29916, + "rawSHA256": "D22D91D49051A544BC511FBB7D0663069323F41BAD782B092B147185707FB595" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedRankSelectWiring.lean", + "mode": "100644", + "gitBlob": "a943e146c835d31a5155737dee16d32fabcf96a2", + "rawBytes": 47685, + "rawSHA256": "E4CB679DBA4B995B33C411A7FDB49859C4DDA0B2D4402ED14C8F673F072D9570" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedSameBlockChunks.lean", + "mode": "100644", + "gitBlob": "aaa722b010cef2771317068ced8e16557af7f4db", + "rawBytes": 12425, + "rawSHA256": "F3E233EDD10FC8DE7098ED037A3A173A3096FB026043F6F81E9AA83F09D34470" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedSameBlockSubstitution.lean", + "mode": "100644", + "gitBlob": "4057bf9cfd07a629cf2772ca6984f442b3837841", + "rawBytes": 9052, + "rawSHA256": "CAA29118F8302CD07D50B7E824AFCC30A31C58991446DE9AF841CA99DA7B8C77" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedSameBlockTrace.lean", + "mode": "100644", + "gitBlob": "4ef06fd441d354b64d2da5f679cb6485c7d7a36b", + "rawBytes": 28767, + "rawSHA256": "F68059B658962AA7D00942DA93B27415B19D2D04A9D6E5A1614706A914D37373" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedTableRegime.lean", + "mode": "100644", + "gitBlob": "d6684eb8056439c13952a82b6cb6082dc3e4971d", + "rawBytes": 14583, + "rawSHA256": "5988A169FA0AFF43326E67252A63FB2C714AD4B2716A0D0F042E409027D38A08" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedWordChunks.lean", + "mode": "100644", + "gitBlob": "8f90421bcd0ce9c9837dab054b49fbdfe30a01af", + "rawBytes": 52061, + "rawSHA256": "32AFF7472532A2CD3FDBD8DEECB92148466ABBA6780CEAFF695BE52F83F467C8" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/CompactEndpoint.lean", + "mode": "100644", + "gitBlob": "bbff25d0a619aa246633377df0af032e4b837aad", + "rawBytes": 24687, + "rawSHA256": "383F30B3C6662F9C455632E6AE96F5935ADCA6EB65D25642676139DB08681761" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ConcreteDirectory.lean", + "mode": "100644", + "gitBlob": "895e3ae4f2c67e5eeee01ff85e6b658dbdb50d7d", + "rawBytes": 104087, + "rawSHA256": "823081F1FF979F77970BA2477CD9F9F5BB6E1255EA15129C061B726BA62CB7CE" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ConcreteDirectoryRAM.lean", + "mode": "100644", + "gitBlob": "15d6269a84fd881fce67bb18f5eb89421c926369", + "rawBytes": 179195, + "rawSHA256": "0CED594DE17F432C8FDB3BBDFF926FAF26F051BCACE6B9EB5040D70A91172E49" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ConcreteDirectoryRAMStoreParam.lean", + "mode": "100644", + "gitBlob": "3ad2cb80ea2286de321d1f174d12e0ee913bf4f4", + "rawBytes": 215174, + "rawSHA256": "074AE2026220430F9B6D00805FC51BA46917C8C0C50FD599A777245E029CC31E" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/EndpointCodebook.lean", + "mode": "100644", + "gitBlob": "c626e0488bd823c04db0105bf7890c5a0d269978", + "rawBytes": 53366, + "rawSHA256": "5029E982326AB8DEA8D0E0F22B0A29081F2D802B2C78770E5D7584158BDB66A7" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/LocalBPDecoder.lean", + "mode": "100644", + "gitBlob": "faa3508bc4cd4f0d8c17bd3a1a053e25dba3237a", + "rawBytes": 108893, + "rawSHA256": "54CAD93011FDA3A464BE6F93D102332A375712E3993E4A8380D88EDDBE5F5B8A" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/MacroMicroFamily.lean", + "mode": "100644", + "gitBlob": "d2307e9ccf38c3e0b99460c7ec3e8c95660f82ee", + "rawBytes": 38377, + "rawSHA256": "9D3CEED171681840D7A81D65E2D6507AA1C8922C4A268DA9EB4AB0253C01E642" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeSummary.lean", + "mode": "100644", + "gitBlob": "da0cefdd39bace8e0df283f1724e58eef71ed8b9", + "rawBytes": 181993, + "rawSHA256": "14346D7A6E5C881DA559C423A53CE82170EE2A78D77F7ED31282671504AF034E" + }, + { + "path": "RMQ/Core/SuccinctCloseProposal.lean", + "mode": "100644", + "gitBlob": "156bd6b2cfa097f0ca2aa474ddd6369fd0a06246", + "rawBytes": 37352, + "rawSHA256": "CFF28161C7CDEF76F9A9C4B2164F101DE8702CCAE68312DC7DA0CA36E47C3BAA" + }, + { + "path": "RMQ/Core/SuccinctFinal.lean", + "mode": "100644", + "gitBlob": "dfcc8f94113a9e2a11682d603aa0481d9e7f4e27", + "rawBytes": 112899, + "rawSHA256": "372A0C59D175950DC6111ACBD1E6E71FF8B913B2738912220CCB17D4C08BCFEC" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/AnswerValueDependency.lean", + "mode": "100644", + "gitBlob": "bd1b0038ef759d56c0535e90e5458e366937873d", + "rawBytes": 37376, + "rawSHA256": "98337D3B6531ADC12573115FB89A70A37C73135D0E66FAF8777A9EBBAC691F6B" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/ChargePolicyDependency.lean", + "mode": "100644", + "gitBlob": "c94c4983db7afa7b34705e9d1572a5f073b15a15", + "rawBytes": 7656, + "rawSHA256": "963C8592FF3ACE70EB6F32367B1367197608B0C52C94B78D8CB645A33025B443" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/FlatPayload.lean", + "mode": "100644", + "gitBlob": "abecf3e426f2672be5abe200d8fc55c50a61ae66", + "rawBytes": 114145, + "rawSHA256": "104480BB2E138921504FB96DEB7153D11B603DFA4085FA1DDE36B274244A07C3" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/GeometryClosure.lean", + "mode": "100644", + "gitBlob": "38a83b01367b56e5ed6e639efe5b96b1960f9ac8", + "rawBytes": 78203, + "rawSHA256": "67907F202156D3D0583041E4508D3BC33A57623598CB59A57407C41B02D3DDCB" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/Address.lean", + "mode": "100644", + "gitBlob": "ebc70588aeaa33d3acb15aef4d2dbba378589ce2", + "rawBytes": 3578, + "rawSHA256": "6E8F3EC58E4A1C7588FF98C425CE71098916932C5E8ACC26E244C8EE5426A119" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/Boundaries.lean", + "mode": "100644", + "gitBlob": "8914eb883e911674243db83f287d573cd8f562a1", + "rawBytes": 16584, + "rawSHA256": "CCF5D924505569FE557DB6BF3B6974ADA7322393C215656AB0D48DD35C5C5BEF" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ExecutedUniverse.lean", + "mode": "100644", + "gitBlob": "c8158a39d161b6941804c5b0287f835f6dd8ca01", + "rawBytes": 13274, + "rawSHA256": "F2A04D822F298BBCEBDF7D00CB27CD8E8CD5D018B3B888D23662FEB133A194D3" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/Header.lean", + "mode": "100644", + "gitBlob": "7b7e7d04457b10a1b73ee1ae21e7cf8fd1e5587d", + "rawBytes": 10048, + "rawSHA256": "2711A6F855F3A6D83C053B7C32C0A42F4940793266A44959FD804D9886644A2D" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/Memory.lean", + "mode": "100644", + "gitBlob": "a6d761a0d22a890996cedb8ed0a179544e356363", + "rawBytes": 11186, + "rawSHA256": "64F8BF4F8FD67CE1ADA3635CFA5608BE6F9235CBF3A502342C475E65A1EDDEDE" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/Payload.lean", + "mode": "100644", + "gitBlob": "e3b05f37485fdd5e846d1cb0690bc93fc166dfc9", + "rawBytes": 3060, + "rawSHA256": "500E2ADE7D46B6F9C884EBE06D19C031C1CFE7A75852150E3EC50C449CA54808" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/PhysicalRead.lean", + "mode": "100644", + "gitBlob": "4c7c769d3e78c70cd88bf8cd5dfd324a55cd3c7e", + "rawBytes": 20896, + "rawSHA256": "BB56CEF34E6E743B4CE522AFB8C85882D992E0C6C2128EDEB5C71970001724EA" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/Probe.lean", + "mode": "100644", + "gitBlob": "61fce2cf25b936c5d64b446e3159285d823d4a26", + "rawBytes": 36670, + "rawSHA256": "34E468F86DD5C6A35C83B4A5B36E9E217F4661CD94BA219709001C207473709B" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReadProgram.lean", + "mode": "100644", + "gitBlob": "d79bc285b16c4bf26708d2239730bc919479e9f4", + "rawBytes": 109273, + "rawSHA256": "391D87D69679A4D9A263AF6193DFDD1DF0979541C8B5805569B6215E3998BE15" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerArchitectureCapstone.lean", + "mode": "100644", + "gitBlob": "0ff047d065b64bb1ad7f1076b014d31f233cfe36", + "rawBytes": 45254, + "rawSHA256": "4B0BA7708F943095D030448F3FB5B439AFEEFDE0155CF4DD15F037A48E33D7E1" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerCapstone.lean", + "mode": "100644", + "gitBlob": "fd70769b0e7440d6a39dd2c969a40d1a0d8d3441", + "rawBytes": 147820, + "rawSHA256": "81EEA178FCA3BCA16139111DB452247ADDF1CDF1F823164D693A9080558C2394" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerCloseGeometry.lean", + "mode": "100644", + "gitBlob": "f947fbf9bcb771769babd6e44d94ea637aea8b64", + "rawBytes": 6388, + "rawSHA256": "B0828658CBD2453B7BC4178EC859D9C9C77006899C3B20195131F6CA8D8C270B" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerCloseRead.lean", + "mode": "100644", + "gitBlob": "91af3069b59c18350b04a8fa78eea04a5f3c77f5", + "rawBytes": 25600, + "rawSHA256": "E3377018D62A378D745B2402AE46BD61382A10D7F6B490727659E6F0724DF399" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerCloseWidth.lean", + "mode": "100644", + "gitBlob": "b8c35e4f11885d78d98697223105f935d8e71c55", + "rawBytes": 9430, + "rawSHA256": "E69298E7D3C8167609C2D74387D5482198F9A6CB783955BB6C6FF0F5BB20768E" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerClosedGeometry.lean", + "mode": "100644", + "gitBlob": "18ca8fdaae1cef137138d1f48ed864c30f7d18fd", + "rawBytes": 21018, + "rawSHA256": "3F97100E132680EA8F901884AA383532031224F99DEA4255AB807E8E20B677AE" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerComponentAccess.lean", + "mode": "100644", + "gitBlob": "04881332b811821d2846d80c027281b47982dee9", + "rawBytes": 26856, + "rawSHA256": "35DD259730F4861FA6A3B7CF01AF9E9C5B8D4BDB2F0F2F2C214236B7D7585336" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerConcatIndex.lean", + "mode": "100644", + "gitBlob": "af346375821b8054cbc818a9c3b8d17eb2f8bfe2", + "rawBytes": 2676, + "rawSHA256": "B7417D93358DED4340DF33CE8A04C4C4C925E54937789CE214488E0C940504D7" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerController.lean", + "mode": "100644", + "gitBlob": "bbd7a6b591a02a8674711a4b1aba44f272437b3b", + "rawBytes": 18511, + "rawSHA256": "AD9943085CF3E19D2F72129D5832AF1894C183229CD468DC6EECDBEC06572C4C" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerControllerAtomicStateProof.lean", + "mode": "100644", + "gitBlob": "57f72f0fd426bd60288c273b5124194363c55e85", + "rawBytes": 80787, + "rawSHA256": "32F77AC4A2E5CD72610FFB19D2F120AA9250D6F22F44A0CDAE825CC5238F8CEE" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerControllerInteriorStateProof.lean", + "mode": "100644", + "gitBlob": "a86164d6d74f777e78ff6dd7e49a334821ef57be", + "rawBytes": 169358, + "rawSHA256": "04C50199443EF903CB2A0394B47DF18CDBC2FCE75893FFD33B34CA0817C95064" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerControllerProof.lean", + "mode": "100644", + "gitBlob": "5948c993ad3ea8d877f524b1248c3f50e302eee1", + "rawBytes": 267859, + "rawSHA256": "1225A5D847B0F3D4D9653A51DFAA39A51A744A13D524261236286FC98E993401" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerControllerStateProof.lean", + "mode": "100644", + "gitBlob": "444998dad04b49577dc4eeef976dbb6591894a4b", + "rawBytes": 666290, + "rawSHA256": "1370F7C9761438A5A552B7D14AE408F680C77A5FEFF90F8BA96ECFE904CEBF58" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerCrossing.lean", + "mode": "100644", + "gitBlob": "c7153e9b189d8b8d4f18752dce746780f4a999bc", + "rawBytes": 6949, + "rawSHA256": "003BE10AA05F2B025F83ECE30EC7A91A4F092CA9179B5FF2EF33CEB433A2AE28" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerEntryAddress.lean", + "mode": "100644", + "gitBlob": "c0b2838b27f82f08f95aba2060a66495802103b7", + "rawBytes": 4461, + "rawSHA256": "41E67F063A92159E64467A56FEF20828AD65E8AC585A53CF815812177B96B214" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerEntryChunks.lean", + "mode": "100644", + "gitBlob": "0d00015db8fab7b4f74fb96e4cd1090d1d8bc69e", + "rawBytes": 5696, + "rawSHA256": "9B365EF07A62FE3D989C3EDDA7119D72D765B9676C88A40FDF258D12460A4FD9" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerInteriorCount.lean", + "mode": "100644", + "gitBlob": "60256fe7847d3d4a67cf7caefe13b77e3f5ba021", + "rawBytes": 5697, + "rawSHA256": "4F07D21A9FB1C6799131C4D4F778616A60BC18CCDA0B42C4D27251663F2731E3" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerInteriorProtocol.lean", + "mode": "100644", + "gitBlob": "d2854754dc95a9e31e51dc195a241b71fedd1632", + "rawBytes": 18142, + "rawSHA256": "AC1ECA986A2411B88393C5006C89CAAEBA97C86CEBD0B4AB67A8CD958547D159" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerInteriorRead.lean", + "mode": "100644", + "gitBlob": "8e9c438fed0647458f7a1327f75793606863a0da", + "rawBytes": 67674, + "rawSHA256": "074780F3536806DE36BC094BDA66AC0448529992E5C406F85824C63EDD75B1DF" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerInteriorWidths.lean", + "mode": "100644", + "gitBlob": "e1f31da3b9d75d7e39a15c9e737fb1ae35ee7572", + "rawBytes": 4120, + "rawSHA256": "F08390B3A3C5ACF0036DAFEAD1A6384607317681C31299E7B4225971EAF43B7A" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerLcaProtocol.lean", + "mode": "100644", + "gitBlob": "dfbb331734acb2caec2ac0a93bd3dfd2ad808a59", + "rawBytes": 14664, + "rawSHA256": "B06E4D6C57BAFA21EB75F76AF099B18BB975FFACE9025F3AB5F7EA2EF8016D7A" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerLength.lean", + "mode": "100644", + "gitBlob": "f90134ab632650a472376a717a16f42da3126eba", + "rawBytes": 9730, + "rawSHA256": "3589BC63E435F307A5A6457DA7043DCA5A2AF9DD4018F615EBED4A194C1068CF" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerLogicalLowering.lean", + "mode": "100644", + "gitBlob": "2761635255e7ecd0fc21657ed9b13671ea95e97d", + "rawBytes": 17195, + "rawSHA256": "CE1F85F0181467AC28E431DF8BE90010649FDB541038278A20D29D82CB3DB895" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerLogicalProtocol.lean", + "mode": "100644", + "gitBlob": "e7ae736b75083987ba8bab9145c3b869e87b107a", + "rawBytes": 21803, + "rawSHA256": "E9169BE01037693A6893CB46E5F99E4AE8F2AA79C415F0C9D2BAF0098DA19BB7" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerLogicalSimulation.lean", + "mode": "100644", + "gitBlob": "a6cc3b1e1af37c9bd8823575a2d393b043723491", + "rawBytes": 321234, + "rawSHA256": "7F2F353F7D53ED1E0BCB0D963A162193B6C87C912A8D80D5FCC683E0BA06E5B1" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerMachineWords.lean", + "mode": "100644", + "gitBlob": "9a99e1ff78af3cef013b8d6aff6337c7629edc95", + "rawBytes": 5023, + "rawSHA256": "63AAE89D756E47255AD8821B336B3D3D2FE1607FC03C7771F2B36C6A35BC400A" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerMemory.lean", + "mode": "100644", + "gitBlob": "ef3f7d4ea754abd4c0c3546cf1b2b4d36b8465b9", + "rawBytes": 8450, + "rawSHA256": "B25D62BCBA1BFF603EE1E364B8EA355A36010906D159927AAC800EB1145179F8" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerPayload.lean", + "mode": "100644", + "gitBlob": "0159323644e76ef425870fc819603dd8edd3e2c2", + "rawBytes": 3868, + "rawSHA256": "F383AC00585EF7389C72610BA44E2941F45F6B6E9CC13AD6FA39EDDD38B4C75C" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerPhysicalRead.lean", + "mode": "100644", + "gitBlob": "1986df34c14482836893e4d7bb3e8a9edf74e691", + "rawBytes": 17684, + "rawSHA256": "4C773AD3FA0EEC82DFABBE8F142A07AD583B4DBAE9455ABFD57CC593D1AB833B" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerProbe.lean", + "mode": "100644", + "gitBlob": "58bdcf99bb16576ed803a67f411a4d6eeb039bef", + "rawBytes": 24594, + "rawSHA256": "01280EABBC2CDB4BB38E1EA22E3A55E6C64FCB9EF8AC4723D11BC26215317BBC" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerSelectProtocol.lean", + "mode": "100644", + "gitBlob": "3081c1fb9cfc055c075aa6a3e2f35b00df976799", + "rawBytes": 15312, + "rawSHA256": "6BF0867042F07B9A4B8A26EF8AC83E5144C0A533932F10EA9E747BBC010F0A3C" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerSourceAddress.lean", + "mode": "100644", + "gitBlob": "0c5dec614ce2126b39c673cfe8b61701120ceda1", + "rawBytes": 15768, + "rawSHA256": "93EB4EF3697DED2867172D7E46E690550EBFFBCBC3D9003CA83863C2115DD9BA" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerSpace.lean", + "mode": "100644", + "gitBlob": "c7057764aa6b1f8c1a82e343d9009bd13ac4003e", + "rawBytes": 4177, + "rawSHA256": "56918F51DBDE05F1B69E449A6E41E944D706A65F2423D549426A3037B2D76BBF" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerSparsePrelude.lean", + "mode": "100644", + "gitBlob": "c87a9c2b16b7c2d97aec3ac36819b9f239edbc7b", + "rawBytes": 48493, + "rawSHA256": "3A99BA036F6651EEE2A0823DBF2A6BAC365D5D6AB78A52949DDA0D480ECE8DA4" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerWholeProtocol.lean", + "mode": "100644", + "gitBlob": "5cf50ea9ff605f87dbb030434272cdeaa8d47778", + "rawBytes": 7961, + "rawSHA256": "492436C51E2CAD4EFC13AB2B6D20704492780EEDB5F2B4BD9E3213F0331E045C" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerWidth.lean", + "mode": "100644", + "gitBlob": "2fae800525e8c8369c4e5074ff62847daa53251e", + "rawBytes": 8932, + "rawSHA256": "07F0A4D08CA3A599BD1DA8D747CB7298376A74DC24D8F722B411B41AD64E16D6" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/SourceFactorization.lean", + "mode": "100644", + "gitBlob": "acf7bb30e858cbe32c1647db2af04c03fdba6c2e", + "rawBytes": 54824, + "rawSHA256": "04500A8A27354B5B2A19BE2DB4067ED56D85268A8D266E4F411A82E7B9F4C693" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/SourceGeometry.lean", + "mode": "100644", + "gitBlob": "93255811da5f1425eee0de3d6be09c573f502090", + "rawBytes": 24195, + "rawSHA256": "99CCED87772781D6C4311F92831277DC08BB5481EF411BEF24DB8A5A0AA351F6" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/SourceWords.lean", + "mode": "100644", + "gitBlob": "e789fa5ca1abc60baa34da12545a4807bae30a6a", + "rawBytes": 46805, + "rawSHA256": "901CBE8A30F7FFA92AAD48F3DEB7E01B5384CFB17A7B912D32D999FF020B5F23" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/Space.lean", + "mode": "100644", + "gitBlob": "bf01a751a9fc492cbcc559889ebf88d1ff8df654", + "rawBytes": 7427, + "rawSHA256": "E128DB764C24210CFB01CA197CAC427EAE126DD743D5695F580C414071791FE4" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/WordWidth.lean", + "mode": "100644", + "gitBlob": "f2d02a7e57e5a2d64df9b137ab6c60c70ae729c9", + "rawBytes": 15289, + "rawSHA256": "462C7120F2480CEC505EB53E2F6F49FEADFB92EB968504912B1D9ADA086992A0" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/RankSamplePresence.lean", + "mode": "100644", + "gitBlob": "27de147785acd15a0ab9e6d982df9fefb76ad088", + "rawBytes": 3533, + "rawSHA256": "7CCDE8F52D75AB0F61EC809847DED226C93E3F167C35522E8E923ACA4DB1446C" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/ReviewerPhysical.lean", + "mode": "100644", + "gitBlob": "2bb6feeb97019a0272d2187731525a38a46ff935", + "rawBytes": 109271, + "rawSHA256": "0E506752E7843836CE715C57287CA3FC016D7CBB13E817C77A8DE6AC9D27DDB1" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/ReviewerReachability.lean", + "mode": "100644", + "gitBlob": "fb7118cf5d3290ee506d7db8a6fb79746449458f", + "rawBytes": 2229, + "rawSHA256": "AEEBF633C95249B42363291497FAB824930FA00389B218CC5E7F3C611E564B92" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/ReviewerReachabilityLong.lean", + "mode": "100644", + "gitBlob": "bba67f1127442705e77960222ad8e04a7712a0a0", + "rawBytes": 45733, + "rawSHA256": "564D7071713BD24A65324FC2BA323F652E3D446FF893D580878C27E4CC12F17C" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/ReviewerReachabilitySmall.lean", + "mode": "100644", + "gitBlob": "304a27908f4baf09a2296ec2223248a0636bf69f", + "rawBytes": 181933, + "rawSHA256": "E025FBCDDA65DF5DBEB9FE83F06F4E482F42207ED938C64F83FD1A9E12827C2E" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/ReviewerReachabilitySparse.lean", + "mode": "100644", + "gitBlob": "4e7f89b5ed2ab1c410f802fd6514737fd1f733e6", + "rawBytes": 52496, + "rawSHA256": "D9C8B7D2C3FA7D8412E2752F773AEFB3A92A3B107A9094F1D50B65860C1B4C11" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/Segments.lean", + "mode": "100644", + "gitBlob": "6810dd6d61d2abcccfd7ba66275cfefbe08da882", + "rawBytes": 13423, + "rawSHA256": "F99920A82633074FF9018646D221154B2D23CEBEF860A3BA3FF09164D0ABAC81" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/SourceInventory.lean", + "mode": "100644", + "gitBlob": "f5bcc60a95064495ad4c1281f0514fb225cf393e", + "rawBytes": 29029, + "rawSHA256": "5577B4EC99644DBD95E5BAFA326559DC039CEA3A33398B108AD51FAA949EAE04" + }, + { + "path": "RMQ/Core/SuccinctFinalModelAdequacy.lean", + "mode": "100644", + "gitBlob": "3825f4a6f4f69bdeeb96bd9eff39f9bdca45929c", + "rawBytes": 64523, + "rawSHA256": "C86323DB215E020CB46B88B2D92BAFF8DC210D8270E2B821B60EACD22F3E11B4" + }, + { + "path": "RMQ/Core/SuccinctFinalRAM.lean", + "mode": "100644", + "gitBlob": "0322bf5a41be302b34d896d0af4376e6cb99a186", + "rawBytes": 477273, + "rawSHA256": "86E5424B05BD18A81BAA544C4A0E1638B536A6B4A6FF3B7FA818E61297D3FC33" + }, + { + "path": "RMQ/Core/SuccinctFinalSemanticProvenanceAdequacy.lean", + "mode": "100644", + "gitBlob": "f5e97ca118f226b3a0b59b10b7f05112923065a7", + "rawBytes": 9411, + "rawSHA256": "9587364B193C18AFD385CB821F1E28E2048D7DD2011BC420D5A53817E99A1BB7" + }, + { + "path": "RMQ/Core/SuccinctFinalStoreParam.lean", + "mode": "100644", + "gitBlob": "14c0afabd2a1805872f5cc4bc7e82f872f5396b4", + "rawBytes": 177042, + "rawSHA256": "466DF9555BAB1EBE77567DC6D269C2DE7F73C421BD78BE15C0271B0D292C4636" + }, + { + "path": "RMQ/Core/SuccinctRMQ.lean", + "mode": "100644", + "gitBlob": "4feda48014aa356025889981762b78e31ed9f899", + "rawBytes": 478, + "rawSHA256": "73CA46469D58DD6C83A1D98E685D96C8BF148EA64192D6BC194C81592B5158E9" + }, + { + "path": "RMQ/Core/SuccinctRMQClassic.lean", + "mode": "100644", + "gitBlob": "01b511aad872612ce166c1d0d96d6081ba59b04a", + "rawBytes": 76386, + "rawSHA256": "07D34D2D79DC23B04235802D61ABFF2695F521131D0816304E79B3C1C6ECC177" + }, + { + "path": "RMQ/Core/SuccinctRMQClassicProvenance.lean", + "mode": "100644", + "gitBlob": "a37ca75cd7669238e05f4d19ee139e1242dc0940", + "rawBytes": 526, + "rawSHA256": "8E287FE880C7D032C577A1A5A3EFF2EFD7CA0474775F8B8206FC5557B9C9323A" + }, + { + "path": "RMQ/Core/SuccinctRank.lean", + "mode": "100644", + "gitBlob": "ba1ba86a9ab526bbcf5746c4c5400c57dd73062c", + "rawBytes": 85740, + "rawSHA256": "164F2C7BF988559DB4EFE7FC8C933E91DB66737C9C6F0297D6993831FFFF335B" + }, + { + "path": "RMQ/Core/SuccinctRankSelect.lean", + "mode": "100644", + "gitBlob": "82ebfd14204b919f3141fd7362afea7e1871756a", + "rawBytes": 401, + "rawSHA256": "6789432B6E1C59B2ECBCE3E5FC1DECF5A7CC2D82B4FD3A4DEAA98FDFB7D60FE3" + }, + { + "path": "RMQ/Core/SuccinctReduction.lean", + "mode": "100644", + "gitBlob": "94a75f24fa25cdc5426d5cfea4a1cef25b403804", + "rawBytes": 6584, + "rawSHA256": "966B4471C7205B46BBF1C318CD0EB72839AF33C4A787C50F1F08BF3CE5057B1D" + }, + { + "path": "RMQ/Core/SuccinctSelect.lean", + "mode": "100644", + "gitBlob": "dfce8f0617117c1b293fe9bc9da81c2c3c5bc182", + "rawBytes": 513, + "rawSHA256": "77AF4C71D354803BA080F4C07CB78112BD1AB5EC5EFE9B245596C75682F027FF" + }, + { + "path": "RMQ/Core/SuccinctSelect/AsymptoticFacts.lean", + "mode": "100644", + "gitBlob": "58c23a12a99c3fdad48652701c7715352d22b0f5", + "rawBytes": 4446, + "rawSHA256": "8E628E9C4A94F239AC78157F9A2874E5596B5C8E9CF37E765968CA1382086BFB" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect.lean", + "mode": "100644", + "gitBlob": "c5fddddf9a85fbce80438ac2b74c69c0bccb267b", + "rawBytes": 313, + "rawSHA256": "90E100621F7052B4545C153A3F97CFFB273CFA3EC8DB909885091DEB69CCB658" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/Basic.lean", + "mode": "100644", + "gitBlob": "69853b8a71f3024992567c410d0f005b53679e33", + "rawBytes": 11068, + "rawSHA256": "B845BF8D2D94D1C92BAD544D5A1BC8AFD7F13F2D2BE451D370D36CA3E20D0283" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/BuiltRouting.lean", + "mode": "100644", + "gitBlob": "2e109af66d7cd139b59c7dddecc8bb567f1f2e39", + "rawBytes": 288, + "rawSHA256": "6D7093C011DB8B7172463714B57556CFED2F22D19528002936DC67008748DFCE" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/BuiltRouting/FlagRankTables.lean", + "mode": "100644", + "gitBlob": "3360f878dffbc4661b1b8fd24ffdaf1de3157c12", + "rawBytes": 38260, + "rawSHA256": "F4AC00DF7B9C78AB09B9962F7A18D9AAB68A6FA1B6AC152D7E2C7258276EE069" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/BuiltRouting/LookupDense.lean", + "mode": "100644", + "gitBlob": "b02bdd80627bdb720b4d1a6fa1e6841f64dba8c0", + "rawBytes": 69962, + "rawSHA256": "29FB384ACE2DB0C5716E07211E52707345DA8E9E492A9030155EA419900A3B47" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/BuiltRouting/RelativeEntries.lean", + "mode": "100644", + "gitBlob": "5ddfae27199921e419672c3c37648fc808086f07", + "rawBytes": 34046, + "rawSHA256": "125C26C48D1BF6FAEC9D2F22AF23A171A3920F803C42F502692FA1D649B22361" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/BuiltRouting/SlotBasics.lean", + "mode": "100644", + "gitBlob": "e469e746c7765371ff3872d3fadb052529fd6a94", + "rawBytes": 21244, + "rawSHA256": "F71F91BC5CC954EC2BD4B979837F1D6D2E7924AEA42AF76B495F1867A3BAEDFE" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/BuiltRouting/SpanBudgets.lean", + "mode": "100644", + "gitBlob": "19c93d634b808f142daa3a4efb7931cd1272adc3", + "rawBytes": 48486, + "rawSHA256": "393E33B53C6311FB5982839D0A1ADF4B89F470A893CDA779AE98FC053C590A6B" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/BuiltRouting/WidthBounds.lean", + "mode": "100644", + "gitBlob": "f08f6a261fa432eba35412a6e569ee797dc0ead9", + "rawBytes": 24531, + "rawSHA256": "0F179C2CD32543C45759957FFD726E426400954F8A045D1C0AC880E3AD55B955" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/RelativeSplit.lean", + "mode": "100644", + "gitBlob": "3f863a3f82dc237bed13456dc9750261189dc191", + "rawBytes": 63699, + "rawSHA256": "9AC682EA9A955744E44E79235112FC7609BCAABE6AF3F04DBE63E6BF50631BF1" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/SparseExceptionCloseData.lean", + "mode": "100644", + "gitBlob": "8a10e10b09ba760fedef5f0459192f379f72053c", + "rawBytes": 291, + "rawSHA256": "4CC881E966D4FBDEB725E2810718338464741C339F934AECC09AA747796AE482" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/SparseExceptionCloseData/BuildProfile.lean", + "mode": "100644", + "gitBlob": "506da76c581dbd3d93c2a06769ca4f0c51b07390", + "rawBytes": 21950, + "rawSHA256": "5B43A04B43B22E69ABAD58A00394A6F54B519B84E9938473638A2CFB6D4609C4" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/SparseExceptionCloseData/BuiltExact.lean", + "mode": "100644", + "gitBlob": "b0e90c53da64b634b5783d591d375096aadc27e4", + "rawBytes": 52144, + "rawSHA256": "D1FA216A2236B3DD3CA6924373AF9A93D0644DEA9BCB338F2BCDA18C76C3DF36" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/SparseExceptionCloseData/DataSurface.lean", + "mode": "100644", + "gitBlob": "44cbd5a1e69af52a787b564b488eadf01bfa3a27", + "rawBytes": 37534, + "rawSHA256": "42ED0155C69A52FAB233C97D370FD8D94A112497E527AF21A4C5AE08C56D02AB" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/SparseExceptionCloseData/Obstructions.lean", + "mode": "100644", + "gitBlob": "a5ee14903331f8ace20f90bb2eebd0fb573ec24f", + "rawBytes": 14078, + "rawSHA256": "F8A9EFE1125544E95CDFDF72D1BE46E215E2F470298C65DE5F47E1868D4EC837" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/SparseExceptionDirectory.lean", + "mode": "100644", + "gitBlob": "283fa43325de9f3385663ccb1f3b8c589a9da1b3", + "rawBytes": 12680, + "rawSHA256": "60CE8CB87F721A02EDCAB06CE16FDD164C276C93E393D51A911CB5E8D35E6A7E" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/TwoLevelObstruction.lean", + "mode": "100644", + "gitBlob": "3291b9b7af347fb9bcf5217442a2908e96d8f8d0", + "rawBytes": 10997, + "rawSHA256": "E77B820C1C3505CECB3F9DA5A8DAB6E0CAC55CA7DE6CD9C0F00787931E0F696F" + }, + { + "path": "RMQ/Core/SuccinctSelect/DenseLocalTables.lean", + "mode": "100644", + "gitBlob": "fa88b2ae3d53b69e2573977945f5e8004a6aa479", + "rawBytes": 29803, + "rawSHA256": "EB63021D1866BF0F9A621270FCFBB0D43FD5CAC72FEAAEC230D3CA0FB57245BF" + }, + { + "path": "RMQ/Core/SuccinctSelect/Obstructions.lean", + "mode": "100644", + "gitBlob": "5e798a009b817f5af9daf132d5eafe0374b29646", + "rawBytes": 4942, + "rawSHA256": "793840F544CF0BA04FDE983E19CD19FAB4B37FB86DC3E0442B0EE4B399599F30" + }, + { + "path": "RMQ/Core/SuccinctSelect/TwoLevel.lean", + "mode": "100644", + "gitBlob": "bb789ffa7b1fc5a667e4dd38e6899d35d98fbca3", + "rawBytes": 308, + "rawSHA256": "016C04966B6641D8DD2011856D1BC953F5A8769C2808B7EDA81416E94B8DE74E" + }, + { + "path": "RMQ/Core/SuccinctSelect/TwoLevel/BPCloseNavigation.lean", + "mode": "100644", + "gitBlob": "06db1a1962d39a7591b7f59a7b17210373382ffa", + "rawBytes": 31111, + "rawSHA256": "4BEF79B1C636F11DEFE0A48035461C25958A4B203F3D2C6BF04B1D3E812A825E" + }, + { + "path": "RMQ/Core/SuccinctSelect/TwoLevel/ClarkSource.lean", + "mode": "100644", + "gitBlob": "a12c8e170af24ae46ec589a1c17875fdd19a610d", + "rawBytes": 40412, + "rawSHA256": "5BC9B60B0A33EE3CE6ECF02A9E6F4B05A8D308FBDC1A83905110F78FE598ED86" + }, + { + "path": "RMQ/Core/SuccinctSelect/TwoLevel/RankSelectAdapters.lean", + "mode": "100644", + "gitBlob": "a2ae1db530305b1a4c0e850d4a5a5c8723fdc18a", + "rawBytes": 48810, + "rawSHA256": "4EAEF65F1BF992E99862E839C2B66EB928280812FE696A29F3C53593CEE51C61" + }, + { + "path": "RMQ/Core/SuccinctSelect/TwoLevel/SelectData.lean", + "mode": "100644", + "gitBlob": "9d472b979908fb983b5e298edf46d9508d5b10bf", + "rawBytes": 44328, + "rawSHA256": "9D53AA16D945BE4AC2EF041AD3850F7150FEFD99B7696A0CB75AA38B4246092C" + }, + { + "path": "RMQ/Core/SuccinctSelect/TwoLevel/SelectSamples.lean", + "mode": "100644", + "gitBlob": "3517212958a3693e10dad86c687190413d6074c5", + "rawBytes": 18838, + "rawSHA256": "03B22A47CCA422EDA459FAD2B14EFF1EE8FA822F0D54B254A72C7D6AE9A8A329" + }, + { + "path": "RMQ/Core/SuccinctSelect/TwoLevel/WordExact.lean", + "mode": "100644", + "gitBlob": "581f2c827a37acc6eb74bdde22cf1e37168b7394", + "rawBytes": 52552, + "rawSHA256": "C50B1CF6D8B98AE698918955B84EE490DF1BDCC662B68B5B0E8A3441AAD9BC22" + }, + { + "path": "RMQ/Core/SuccinctSpace.lean", + "mode": "100644", + "gitBlob": "d783c95f6cb3df03726974799c3c5c45d4a9eeb5", + "rawBytes": 973, + "rawSHA256": "2DB86CA92D7EFBEB75B4DEB59A039ACA1E1C9DFE9BD597330A814568A12D7FEB" + }, + { + "path": "RMQ/Core/SuccinctSpace/Asymptotics.lean", + "mode": "100644", + "gitBlob": "af612389cd21990dd0ef4d9bb01d463acde8ed16", + "rawBytes": 26945, + "rawSHA256": "39493F9BD2B86C041ED7471C310244E4FCED9DE831C566A8FEB8593EA783FFCE" + }, + { + "path": "RMQ/Core/SuccinctSpace/BPAccess.lean", + "mode": "100644", + "gitBlob": "b62d57c1c04c29150f263d9b1447997524213fff", + "rawBytes": 52646, + "rawSHA256": "F79B2360503863665F30953566AEFF88BAC736063F725C599858460F13F344DF" + }, + { + "path": "RMQ/Core/SuccinctSpace/BPCloseLCA.lean", + "mode": "100644", + "gitBlob": "9d66a2f1e072b06b6b04f4b04dc595f8d8266e44", + "rawBytes": 17239, + "rawSHA256": "00C85BEEA48B2DFA4BEFA8A3DAAF70ADA06F876B71F7DAE6CC185FF47DC465AF" + }, + { + "path": "RMQ/Core/SuccinctSpace/BPCloseLCARAM.lean", + "mode": "100644", + "gitBlob": "ac21de8f4ba5461e8c51097d651d57d947a70c00", + "rawBytes": 5072, + "rawSHA256": "776D7F64C12CF9F6515D121FECFAA28C963887C0C9DD34E834CFC9B2FEF3C1DF" + }, + { + "path": "RMQ/Core/SuccinctSpace/BPCloseLCARegisterRAM.lean", + "mode": "100644", + "gitBlob": "8607c7e164cc3a9c302d141c2d4c92d68473a72c", + "rawBytes": 4528, + "rawSHA256": "B0A06AA49AFCE16A491B65A4CCEF84B0C406C00DA2C6E66A2470D1326C6C65E4" + }, + { + "path": "RMQ/Core/SuccinctSpace/BPCloseRMQNavigation.lean", + "mode": "100644", + "gitBlob": "e8e8389d7d3dd442a58b134b84a568e1137e08ce", + "rawBytes": 59260, + "rawSHA256": "9F7FA7CCDDB6F4106559D483EA35313BD1AE34B00F27259723DA6AD9E4A1AB55" + }, + { + "path": "RMQ/Core/SuccinctSpace/BPCloseRMQNavigationRAM.lean", + "mode": "100644", + "gitBlob": "42ba05060237de74f6921164e0078bba0e446a04", + "rawBytes": 16474, + "rawSHA256": "11541F260779F41468BECE8C941B16B6ED06AB32487AEEA9F916279DC36248DE" + }, + { + "path": "RMQ/Core/SuccinctSpace/BPShape.lean", + "mode": "100644", + "gitBlob": "b83298be618d812bd3d7e0c313fd98f1a57734f3", + "rawBytes": 17600, + "rawSHA256": "633C2CFCEE96751D7CB84B5492A16E1DE3A79B7BE4904C799188363D5B75A00F" + }, + { + "path": "RMQ/Core/SuccinctSpace/BroadwordRMQ.lean", + "mode": "100644", + "gitBlob": "84c7b31c15a4ba1eab3737e7331847b69ee04677", + "rawBytes": 21930, + "rawSHA256": "FB21261792E59FEC4A48350A968076CA8E45454F7F7CBA32EF36538DB5F163AD" + }, + { + "path": "RMQ/Core/SuccinctSpace/MachineChunkedTable.lean", + "mode": "100644", + "gitBlob": "26a623359419bf1491798cfcd9d1bc4155c3ddd5", + "rawBytes": 19547, + "rawSHA256": "CA5804E728E7CCB5AEE8C8BC2EBC220D5E7AE27A5BD286599337BC6EB682576A" + }, + { + "path": "RMQ/Core/SuccinctSpace/MachineChunkedTableProgram.lean", + "mode": "100644", + "gitBlob": "7466cf23d244db2b6e548a2fc4a9cdd4d8958aee", + "rawBytes": 21392, + "rawSHA256": "E8BAA33AA98DBBC67CD12E033B85DA1BC0B3A46303938A6A47A400C5FE34FB80" + }, + { + "path": "RMQ/Core/SuccinctSpace/RankSelect.lean", + "mode": "100644", + "gitBlob": "131618d64c79cbb4ad657ed53afd65e367b63a11", + "rawBytes": 54995, + "rawSHA256": "8DDB5D45C8EA60413EC5A0478C968895172406E855A4B1E5BB8405ECFE66B4A4" + }, + { + "path": "RMQ/Core/SuccinctSpace/RankSelectRAM.lean", + "mode": "100644", + "gitBlob": "3eb3b4e8c0607c54848dfb03e6ec3ee597132240", + "rawBytes": 19827, + "rawSHA256": "42CE073D6492EE4FAD5E45A3D41F26B73BBE6493B33ACC189AEAB8681342F0EE" + }, + { + "path": "RMQ/Core/SuccinctSpace/SelectSamples.lean", + "mode": "100644", + "gitBlob": "10cdeafad9e07c0b8a476be754f2128e85c5198a", + "rawBytes": 26310, + "rawSHA256": "62B18FA9CB7301DAA61490224C65068A38B3FB10D48B9E9FEF57359194B23495" + }, + { + "path": "RMQ/Core/SuccinctSpace/SelectSamplesRAM.lean", + "mode": "100644", + "gitBlob": "1cd7e04d03968c80346d1fe316f6e1c07ae29720", + "rawBytes": 6806, + "rawSHA256": "4931E8C80A9490DF33ADD8DE32ED3DE84041FB16A7E01B8031F400C44C01AFF4" + }, + { + "path": "RMQ/Core/SuccinctSpace/Tables.lean", + "mode": "100644", + "gitBlob": "6c88706b7cc13246ecb83ca81e057c35bf31f12f", + "rawBytes": 21024, + "rawSHA256": "5676C8B39B17EB0C183C9CE7C7E5B7210CEB947182D44933355A24BFB34A3BBF" + }, + { + "path": "RMQ/Core/SuccinctSpace/TablesRAM.lean", + "mode": "100644", + "gitBlob": "27090541304ff011ec275db5059355b5adb4cf57", + "rawBytes": 11069, + "rawSHA256": "6E5E99094B6B9D4C273AF2A6D3988C7627FEACC8EE0F75ADABB2652FAD4322BE" + }, + { + "path": "RMQ/Core/SuccinctSpace/WordStore.lean", + "mode": "100644", + "gitBlob": "3c07a23045937c7ad80fdcc7803ec009555f119d", + "rawBytes": 26560, + "rawSHA256": "E508F5EEBA21D642E94D391B29E0DA85228A941539C341BCC97B333D2A23BC34" + }, + { + "path": "RMQ/Core/SuccinctSpace/WordStoreRAM.lean", + "mode": "100644", + "gitBlob": "c23a0e494a12689299f48c09d65cca477bebf609", + "rawBytes": 4183, + "rawSHA256": "E73D6D9DB3D61E28CFA9F108E23C97E8CA3C7176A59C28E14B91C320574EA5C3" + }, + { + "path": "RMQ/Core/TableModel.lean", + "mode": "100644", + "gitBlob": "9fb40d4a2f2c8d1045b991d639359c00d4a1adae", + "rawBytes": 7753, + "rawSHA256": "B015B94A0B2E130B6E6ABBB44415868B824AD5242148D614355E580EFA5D8159" + }, + { + "path": "RMQ/Core/Window.lean", + "mode": "100644", + "gitBlob": "d8cfc10c688f5193eb862f900103c5335cd0658d", + "rawBytes": 4323, + "rawSHA256": "C135E68A11AF7FF52623A7CCD8439330A93D5758B2E548330889BBF04B08432C" + }, + { + "path": "RMQ/Core/WordRAM.lean", + "mode": "100644", + "gitBlob": "611e796270c9413f36f1ed40842118b5641f5d1a", + "rawBytes": 53644, + "rawSHA256": "7A47CED349D84C379135918115E3A0424B1DE2D9F4DDA0BB774FF42A94A174A9" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/AccessExecution.lean", + "mode": "100644", + "gitBlob": "e2069d581b36fbf2393dc27f75ba14df24b40df9", + "rawBytes": 2350, + "rawSHA256": "966E88F15B6CED25C337F4614B774FE85AAA0358E44F7EFDEBFB5BE0A0087300" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/AccessProof.lean", + "mode": "100644", + "gitBlob": "6152250b759c657f138216585a314614e3ee289b", + "rawBytes": 15716, + "rawSHA256": "0077FE19D2E693D7F02936FDB4A9592D68B9E67AC1FB9A1E905D361F1DB30DE2" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/Allocation.lean", + "mode": "100644", + "gitBlob": "e51fcf76f8884a8ccf440e199b8d30d1cc8218a7", + "rawBytes": 3101, + "rawSHA256": "B4DE6C3B923589A2AA890399D7D0B8236E3C46E1608ADE74F8CEFE65B60F392B" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/AllocationFacts.lean", + "mode": "100644", + "gitBlob": "56b5fb206f1faf1eb5014a9f24d3fc6ef896ca0b", + "rawBytes": 5997, + "rawSHA256": "F189969208B13333219EE460DB8581D43BABB88F18480C68A37F47C070801623" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/AllocationLayout.lean", + "mode": "100644", + "gitBlob": "b8d3e4fd9a544e7e50ba8ac7aa7d8b36da6c203d", + "rawBytes": 9104, + "rawSHA256": "EDE611982080F8600CE5F59BE89D8D331DC7920855F55B969A66F39C60E99ACF" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/CanonicalLimits.lean", + "mode": "100644", + "gitBlob": "7e8242cc21cc1b621bfbd990c5f7f4900fb714d0", + "rawBytes": 4764, + "rawSHA256": "1B0B761C9A42D0CE4C3EF3972B3EB43E3FE02BF56B9D3B7D501D23067C4D5A1F" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/CanonicalMemoryBounds.lean", + "mode": "100644", + "gitBlob": "364db7641887acb7b5170996dae16aeeaa3219fb", + "rawBytes": 24957, + "rawSHA256": "182406E5BCAD21C8EF5EE236B92F3EBB63441B8DEECB15B9E46019CB8A97AA21" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/CanonicalRankAccessSafety.lean", + "mode": "100644", + "gitBlob": "ecb32418258e80e9ab11fa8e4e76c37e22b70557", + "rawBytes": 12856, + "rawSHA256": "1C39E9D0A2637C45B7306DBD5077DD2319BA2F6C2AF7CA43D0DE189F9BBAC03C" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/CanonicalSelectSafety.lean", + "mode": "100644", + "gitBlob": "4864b9eaf10566dfceb4bb5921cab056281bbe44", + "rawBytes": 12395, + "rawSHA256": "FCBC3B363E47BC16298DEDBDE693921EC4CA45672753AD564161807D6CE7D753" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/CanonicalStoreBounds.lean", + "mode": "100644", + "gitBlob": "51cf5724de9260ab9009443a697b05bea3d6a549", + "rawBytes": 6254, + "rawSHA256": "1209D9A14B0B92D5CCD6455197C57189903CF65C1502BB049DF25CA4472038BA" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/Capstone.lean", + "mode": "100644", + "gitBlob": "8184759bbac7eb8b54cfe5acea62c9b86cb8211b", + "rawBytes": 11412, + "rawSHA256": "1C6CD0A85B77FBA7706C77DA87DE358808A24FA661D5635A3C4B3BBF96005D69" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/ChargedSetup.lean", + "mode": "100644", + "gitBlob": "35117138a48053376485d68acede42d8d6d2d96d", + "rawBytes": 13339, + "rawSHA256": "21440D54C844202F5AF6816C5BFD1DFBE07EFA18ED23A7C546F8BF29948476E9" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/CompleteLayout.lean", + "mode": "100644", + "gitBlob": "19ac167e084b45596766e61a49d2f8197f882ce4", + "rawBytes": 8778, + "rawSHA256": "E2C61B99E504E99940B3D63645F62CBE805FF21FF4B28473C1DE7646E08803DD" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/CompleteReadStore.lean", + "mode": "100644", + "gitBlob": "052c94c46807ae43f0863d75055c1799f732f768", + "rawBytes": 3348, + "rawSHA256": "3A8A6F6F57CE5C7368C8115D4A95521DBC92FF25934BF9B5CD8D8A31AB92FD46" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/CompleteReader.lean", + "mode": "100644", + "gitBlob": "21731c25e9198d0e3c786d24a85acdfebede937f", + "rawBytes": 6971, + "rawSHA256": "53926E3596E4C98A76D939E14CFBB26BFC939950E7A25CB774FBDB0617F73055" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/ControllerInterface.lean", + "mode": "100644", + "gitBlob": "2a665f4fac1fd416ef2212bd006ffbe86a8ad469", + "rawBytes": 3906, + "rawSHA256": "14F14B5A78FC77DB768536BF78DA47CB60922364538859535198C1E440B30981" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/DescriptorReader.lean", + "mode": "100644", + "gitBlob": "6fd93bc362f340f31f2ba08bfe8e886c2df197dc", + "rawBytes": 3796, + "rawSHA256": "A85C55E8962F8F9F78E0FB00EDD81ED9DFF7E870792F62830DB6CADB54F45108" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/GenericRankProof.lean", + "mode": "100644", + "gitBlob": "aaf46b982c21755434366b0b05a410e74f7c2727", + "rawBytes": 45313, + "rawSHA256": "01544E3B71EBCB90B7ABF34F8C241BA6ED6F7954027C3E22443AD9AC65192F94" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/GenericRankSafety.lean", + "mode": "100644", + "gitBlob": "cef3ac8de0fc6addc06a24a662a44073649ee1f0", + "rawBytes": 50086, + "rawSHA256": "46D1C897F34BA42A3DA76B5B9876D3C7CE46D05A63950FE9E1F2F9E513D3B4A5" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/GenericSelectProof.lean", + "mode": "100644", + "gitBlob": "be500e482a5ba36a7d4f851987805547695b3a95", + "rawBytes": 96314, + "rawSHA256": "07D1090314E454341CCECBEFB74009600C9AFB40A812DC218C6810C450790EA0" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/GenericSelectSafety.lean", + "mode": "100644", + "gitBlob": "ee7dcf3531c1f4107818aae0c84c5844402f47f2", + "rawBytes": 105343, + "rawSHA256": "DE8C9B1CD5C13C0B4D630839872DE55542116046EBDB4CC9B823C53B59C5B678" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/InterfaceProof.lean", + "mode": "100644", + "gitBlob": "1d24385ecf3d73b29084a6be08380c36a757ddba", + "rawBytes": 3974, + "rawSHA256": "9B04897F77EF88A00B85F71BD7A43119572157F9266E74DACEFB726856D431CF" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/MemoryLayout.lean", + "mode": "100644", + "gitBlob": "3918218d1ae2dc3be48f1a99f6d8803294635e05", + "rawBytes": 15097, + "rawSHA256": "2CB94877358664BDC93234128FE2115B626C10442AEC87C9429A89395B0D6A24" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/Metadata.lean", + "mode": "100644", + "gitBlob": "2d3462a49e9f2899c5ee46b44f9d7d702a11ce3c", + "rawBytes": 4117, + "rawSHA256": "CBA9B8CC9B574EC9D66FA4CCF8E4CE277BE6AA864B68BCFE6B9AAAB7AE955720" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/Normalization.lean", + "mode": "100644", + "gitBlob": "17c5b788d2cf3c8019439bc73d7df303680bdfa9", + "rawBytes": 7993, + "rawSHA256": "BA10A82917C9914E0BB11F619A15A51CFC65E2C0842C066F372339C77FF5F9D4" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/NumericReader.lean", + "mode": "100644", + "gitBlob": "82acb93da4d1fce444286f3a07f5e01f09e6c848", + "rawBytes": 20770, + "rawSHA256": "7E2CC443F2DE7351112460B7C2B0699C2879B51E760DEC3261B055790133897D" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/NumericSafety.lean", + "mode": "100644", + "gitBlob": "9e70908570f1ead32aa97ccda0395c03ebe11a63", + "rawBytes": 23639, + "rawSHA256": "621FC88A3FD86C8188A3074608CB254FA1D507CC4482F21C9EA13F8888A02C92" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/Observations.lean", + "mode": "100644", + "gitBlob": "a408a2f1c45f508ce1446c24c686f68ca5a1d246", + "rawBytes": 2369, + "rawSHA256": "76B7CAE29F31ADDEDD6A90D0FD80BA52FB62F26A6FEF02D94BA41FD731CE880B" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/RankExecution.lean", + "mode": "100644", + "gitBlob": "40d01f3f91ea03cb75cd8bdee49b0d9f2a6c89ca", + "rawBytes": 7591, + "rawSHA256": "BD4BDCDE4443E60E624DCEB0CC87673CF51321AD277DADE3A33DC898559A3B7F" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/RankLayout.lean", + "mode": "100644", + "gitBlob": "a456427bafe46356e63fead72ed0be7f191ca13b", + "rawBytes": 9815, + "rawSHA256": "7A5756940175BD775A0F4F0928EBB01F222C7C8DB0461CB12C74770A6F8D629B" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/RankSemantics.lean", + "mode": "100644", + "gitBlob": "bed0b99b8f005b63887a1f8a09a37367bfec998b", + "rawBytes": 6212, + "rawSHA256": "9AC0B86BC1630635EAA63A3DC3C3889206A0FDFB0205DD86C36ECF7F5516AB7C" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/ReaderGeometry.lean", + "mode": "100644", + "gitBlob": "b7c518be92f7ed1283500a8bffe98f08e64ef680", + "rawBytes": 4774, + "rawSHA256": "F8FF6C3B35B86208E3C56B09FFA5CA1113FE17650F98EE51E8EA5D9515394133" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/ReaderInterface.lean", + "mode": "100644", + "gitBlob": "143ce2d70af8c7016a83c216a7b037a3fa37c129", + "rawBytes": 4462, + "rawSHA256": "ECD8043060AAE4A3F753B81ADCFE47F9E22B2914744DB6686ABBFB18A218A210" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/ReaderProof.lean", + "mode": "100644", + "gitBlob": "55242103f2a899c21839f90ad71e212f20481cf3", + "rawBytes": 5436, + "rawSHA256": "99773E1BA134E76C19A774433D54E1C26A281421ECABA099F7F019EC4A083921" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/RegularLayout.lean", + "mode": "100644", + "gitBlob": "e8d03a2b9a35f9897b9fef3280ce9261d6707eb7", + "rawBytes": 10776, + "rawSHA256": "172ED0F83F0D8E63136F7A3063F8EDC009F71D57C4BF8B1D311067F1AC53638C" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/SafetyInterface.lean", + "mode": "100644", + "gitBlob": "9cb438ac74ec077fe7a2a852c5ab08f0ffd20fb6", + "rawBytes": 6230, + "rawSHA256": "9BD0732D2863E80F4311D92C75366A0F280B7EBB250D51C32F66DA4540766CD5" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/ScratchFrame.lean", + "mode": "100644", + "gitBlob": "d54970423e9f276e955835c299895dfef93e159f", + "rawBytes": 4640, + "rawSHA256": "0EB35B270F66D55C250D9EF6DC46D897F7AFD1AA8E07D5EA40A6EB2D7784905A" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/SegmentMap.lean", + "mode": "100644", + "gitBlob": "8b4ebc1d1ed74b2da293dac729a1feb0c5446e7b", + "rawBytes": 7460, + "rawSHA256": "8F9454FD730B9B857A99BBC33530DAF23E2F185AC66E21CC0845F29742C55B41" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/SelectExecution.lean", + "mode": "100644", + "gitBlob": "c46372d8a9a31d28740d4726e6f54fdf07884725", + "rawBytes": 6519, + "rawSHA256": "580DB81FDE442C341332A1185FD524C2925E45744F1B6918447D915E1E3FD4D0" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/SelectExperiment.lean", + "mode": "100644", + "gitBlob": "5a65069626ce5b7547792f31cfe8a123a1cceaeb", + "rawBytes": 6301, + "rawSHA256": "156744CBE4DEC77C874114E10408820F7B107B86D5635068D6B855B8363AF0E8" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/SelectSemantics.lean", + "mode": "100644", + "gitBlob": "29d6bb1f9682d8819ed84536100a9f1af47ca418", + "rawBytes": 21230, + "rawSHA256": "D950323B3DE006F320335F68AF96BE9F8A7D50A425EDDB35B493EFA2AB8DD3A2" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/Source.lean", + "mode": "100644", + "gitBlob": "612b69d1f71358b78578cc7b96199810446564c7", + "rawBytes": 3605, + "rawSHA256": "8277F15D876437BD6C35835C57C9332E839AAA94EA63EC8A9F10B8BC661D1074" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/Space.lean", + "mode": "100644", + "gitBlob": "0895c7a92874e4059d8a2447916f28720fada803", + "rawBytes": 5575, + "rawSHA256": "DBF34F5508AC1A1FC57F722DEF6A4724B6B495B5416AE2A9970179E5780BEFC1" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/Width.lean", + "mode": "100644", + "gitBlob": "9e45fbe78a222bbb7eb2b966d571d2fe35adbfea", + "rawBytes": 1589, + "rawSHA256": "873FE2E55102BEEB0E5B0450E86BF83CEF569303EF76C93D9B8AFC7A26860556" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/WordBounds.lean", + "mode": "100644", + "gitBlob": "6ff6d508b93db01d2bfea818c49ce0e12cd22b24", + "rawBytes": 4605, + "rawSHA256": "756AD2CF263E310966CEE28F214B0190B3F748365C9D5B6E808D1BD994956AB0" + }, + { + "path": "RMQ/Core/WordRAM/Construction/ArrayRun.lean", + "mode": "100644", + "gitBlob": "505dbf020aea20a8bf4dc7f02f1722b07debbe89", + "rawBytes": 24346, + "rawSHA256": "DEF5837D2C7462CDF5A331B4CEA13EC27C65AF128316A7092567744FEF4A610C" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Access.lean", + "mode": "100644", + "gitBlob": "145f909dc08d08b555e1e499f55149b0f23ef058", + "rawBytes": 12186, + "rawSHA256": "A62C60C1031DD01AD496E42765963A8C69CC1FF6C7734E828201AFD03261E4AB" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Cartesian.lean", + "mode": "100644", + "gitBlob": "16cf799f4c650787fec347ca899349e390f592ea", + "rawBytes": 3335, + "rawSHA256": "EE2EEC58420DE15782A7DEE29F66F90484232DFCBB9F99A3E08973E6253813C9" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Emit.lean", + "mode": "100644", + "gitBlob": "fbeb1c355f39a903580efa19f4b83ac12c17b23e", + "rawBytes": 3220, + "rawSHA256": "DFB36F53C9F3744E56FEA7A8D34D23680F834CF795250D5756BB1A1FE51240BA" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Finish.lean", + "mode": "100644", + "gitBlob": "0d5575362987f6425f727854759eb467ec795023", + "rawBytes": 3658, + "rawSHA256": "B65120BB381931C47FC42FCBC40627F487F61F8ECE7F99A8D459E83D52B5B3C1" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Geometry.lean", + "mode": "100644", + "gitBlob": "3e3851b52e0b643f2ecf52dc97b983b0c7634513", + "rawBytes": 6708, + "rawSHA256": "99422E111C8A1CCCF692A246ADF20A8CEF0DD88DD6889DC583592EC14891D088" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Interior.lean", + "mode": "100644", + "gitBlob": "17cbd5c3a9f7556f05165065bbfad8581638234f", + "rawBytes": 8981, + "rawSHA256": "43C7D5815CD3C71E94DEBBB35C8B1F8A71E83DF944F5F130B008B708A161FDC5" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Micro.lean", + "mode": "100644", + "gitBlob": "d39904de90bc94dea340d874afea7ccc07fecec2", + "rawBytes": 5052, + "rawSHA256": "88AFA5C11C4706A392ED51EDD517571B6888650D20BA4063B84C200594950703" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Output.lean", + "mode": "100644", + "gitBlob": "4a8f9d1dc8b6335a28782fa658d2a910d0dd991c", + "rawBytes": 11449, + "rawSHA256": "F7C2890C942159EDCCAD5D7D12D2A4A00F87492DDAA8870B00E2107CE8BF5D23" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Program.lean", + "mode": "100644", + "gitBlob": "019a5da76784d78a0298872da1e377ee8131f663", + "rawBytes": 3408, + "rawSHA256": "451AE09FA62D30B89B0CFF174E977259FBA58FD3D96D535CAA4D59129CAF436C" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Registers.lean", + "mode": "100644", + "gitBlob": "8500679c3f9a3da2ab373dae74d332dfc2d99dae", + "rawBytes": 10675, + "rawSHA256": "995F80DFEE6AD0A9844B0AA752FF84873BBF79D064D96DB2840772790A645684" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Calculus.lean", + "mode": "100644", + "gitBlob": "8257561b1a47bd49fe64a4c2d560b83a65f28f5a", + "rawBytes": 34685, + "rawSHA256": "88296C2AC88169D656A07C254DF0F2F79C67E8CCC8A7809F66669CC6A4AB3FA6" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Capstone.lean", + "mode": "100644", + "gitBlob": "13f6615354b75df44312ef078d2d09c6914a4bd5", + "rawBytes": 8479, + "rawSHA256": "3B794806DBA32D3B59950705185CA8D3C57F470DFBF4D3ADDA5564746D857833" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Compiler.lean", + "mode": "100644", + "gitBlob": "895f2975970ae1258554358413955f82936ee6aa", + "rawBytes": 31031, + "rawSHA256": "A3A98226A10866B775AB45E6BE9F50AC016826F4B9565F9E8926BE3E35A2E65D" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Conservative.lean", + "mode": "100644", + "gitBlob": "001346d022f7acbd204e247937449bca0b3bf911", + "rawBytes": 7706, + "rawSHA256": "3C2ED59F22C42CA83774BCD96F92FA8EEFF604DB2A6B5F338AD4615BF8F54B9A" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Contract.lean", + "mode": "100644", + "gitBlob": "ff5e08816a561f3667bacf057ff1a89e1f66de06", + "rawBytes": 2872, + "rawSHA256": "93E6C1A264C2BE7F5DE3D9CFCCB5B7AAF10C28DC3F6F6C51385DCDADDECC6FD6" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Controls.lean", + "mode": "100644", + "gitBlob": "8ea487ac1a97b3af7f9b08b457cb74f39b551746", + "rawBytes": 5475, + "rawSHA256": "580FECAC1C2FEA11AB8EE0939082AA69981017E3225CB630B1937431D5A768CA" + }, + { + "path": "RMQ/Core/WordRAM/Construction/HeaderUse.lean", + "mode": "100644", + "gitBlob": "13ca961f29518163ce004905b6f32ef3b829ad96", + "rawBytes": 8270, + "rawSHA256": "2645AC2122F304B26DE7630C1E441346F1E6D8659C8D5F4DAB47C356A01CD8A5" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Input.lean", + "mode": "100644", + "gitBlob": "53afec2a48fbd6ce18622153c468926591b53d82", + "rawBytes": 7558, + "rawSHA256": "B8311F6583D9A108324A952CA01B23C701682E6C16A83B908CF0932BDD6D78E0" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Loop.lean", + "mode": "100644", + "gitBlob": "ca054024193bbcf5c932b632cf74305257cb20de", + "rawBytes": 6376, + "rawSHA256": "4EBA2279F29B509FBEDBE7E668D236A2A9F61C0ADE5D7E604915B4FEFD5AA6DA" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Model.lean", + "mode": "100644", + "gitBlob": "d1687b7cebe1278482801cd8c390bbb77bd8b3a9", + "rawBytes": 4743, + "rawSHA256": "601630664B80C2EB0C26778A1AD2982BC4E0D3B59C43B5E349321998CB11DA7A" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Primitive.lean", + "mode": "100644", + "gitBlob": "7f44d513249a2e4650a8af799e87cc32238741ff", + "rawBytes": 7450, + "rawSHA256": "9D296EF6A7D08CBCBCAD7E262430F466FB9BF41021C55CD1997D2E8F92B77A69" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Program.lean", + "mode": "100644", + "gitBlob": "6cc79066cfbc9e2b5e80b98a49dc044abb9fcba1", + "rawBytes": 6741, + "rawSHA256": "5817BB879D48FFBA924D8662DF22FA5F6A3DC62E0B0BBF884CBA79AA0316DE0E" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/AccessEntries.lean", + "mode": "100644", + "gitBlob": "01837bd03186249cb9953c317a2cd605c511f3fc", + "rawBytes": 51749, + "rawSHA256": "362E9BECCBB7A11BA120DFA4134CA2A4BCFF322C068596EA48751D7775DC19F6" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/AccessFlags.lean", + "mode": "100644", + "gitBlob": "0480e6b7a635f7d0b59a87e32d4efbc71bb74b03", + "rawBytes": 62054, + "rawSHA256": "0C24AA03601CD4E30F5552EF508975EFFA245A2FBD576CEAF1ABD55277016C38" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/AccessHalf.lean", + "mode": "100644", + "gitBlob": "074f691965cc5a3c6cb39c871c2b9b671fdd7c6d", + "rawBytes": 31042, + "rawSHA256": "8D75996B1003644986B12D33328C99111B95DFE55C78FC8083FECE2AAAA027BE" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/AccessRelative.lean", + "mode": "100644", + "gitBlob": "e8e16e4d116f3aa3c152a36f0e89fa32210d4fd1", + "rawBytes": 48917, + "rawSHA256": "5C1170974B6CD0BDDA27732F448402D7ABF9A548406970B713434F2B36E6FD8A" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/AccessTables.lean", + "mode": "100644", + "gitBlob": "ba471626d5bf304ba5a09b2308320686bc7bde31", + "rawBytes": 57158, + "rawSHA256": "096B78F02198D730BE642E4E916BA74EEEB2252C3FDF9134CCF47E73CBF5B22B" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/BPEmit.lean", + "mode": "100644", + "gitBlob": "db372f4f5b39785e8f863b39cdf8fdfe7fefe652", + "rawBytes": 17329, + "rawSHA256": "AAC79854CCD58562096257EE5B3BF4879F90DA21E05B79125E4A13A6CC940FF1" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Base.lean", + "mode": "100644", + "gitBlob": "06c668b98b6404ebb71579461aabc5f44c8ef03d", + "rawBytes": 13701, + "rawSHA256": "53D1EA39E9880101F8A681CD21DC8766C6C384B92F1E7FEAA1F239B17BA5510A" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/BlockStats.lean", + "mode": "100644", + "gitBlob": "f8c826088c09bf35b321f06be1742383c9de9907", + "rawBytes": 45115, + "rawSHA256": "1F8D540F1BBDAE16D6E5471366E16E872CE6E26F7D3F13168D82D40C6FA68584" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Buffer.lean", + "mode": "100644", + "gitBlob": "986f07cc7788b5f493e5f9a3c8e7e4cfa3777531", + "rawBytes": 42894, + "rawSHA256": "53C4AFCFFCE034D40C1AFF30CDC2F43A9F52D82F7954C15B800088555BA83041" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Cartesian.lean", + "mode": "100644", + "gitBlob": "05f980c7f3513fd5768a096ce2bae804388ac52f", + "rawBytes": 42201, + "rawSHA256": "800DEC258F93A73E47239F40B8616620BF2DB82C03FB690E340F2E248CF67AF1" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Constants.lean", + "mode": "100644", + "gitBlob": "8c642c6672752183e00b0a9806f0e6e612e0ef64", + "rawBytes": 6561, + "rawSHA256": "C88BEB478A7DFD290F74E498B5571600F0A951A4FB43D7D523E3C5A21174C0CA" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Emit.lean", + "mode": "100644", + "gitBlob": "5f89a0f3118d7a6fc8cbb49fb9a5ff47cf113bbc", + "rawBytes": 32918, + "rawSHA256": "00035A07F35101CEC056DDA45A45EE1986E91615AD81B0BEB4269C8FF0FD3971" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Exact.lean", + "mode": "100644", + "gitBlob": "4840b7ead4b2abdf9531648f49ef4384b3ec4a4d", + "rawBytes": 14919, + "rawSHA256": "E643891EC57618CB046B81BA332750091A9407A466427946EE48B06B99E138DA" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Finish.lean", + "mode": "100644", + "gitBlob": "3d62e6a32cc3cd3f3b31e6eb2adccb49619816df", + "rawBytes": 22409, + "rawSHA256": "CC9997DF8AC50F00557E500B5DB5D09A14442163B0E32488F1A3CF201BDDF497" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Flow.lean", + "mode": "100644", + "gitBlob": "5b8b1e08a88ee7bd583c40ff5792c37b34b51caa", + "rawBytes": 13046, + "rawSHA256": "4CA5C92D0DF1C65E92D241A083CDAD3AB0ECBED50CAE1CFF904C20C42EB91830" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/FlowFacts.lean", + "mode": "100644", + "gitBlob": "3d92bd8c5eef589d94a2e38ab83bae2452f0b1ec", + "rawBytes": 27076, + "rawSHA256": "3DA76A721A7C033D2DB86879ACC53A5738F8CD6B60D8A8743E1AF8F3E5D5E5C4" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Frames.lean", + "mode": "100644", + "gitBlob": "ffcfb45e9fd1b5441cd8dd05d29c760d7937eac3", + "rawBytes": 56185, + "rawSHA256": "0F9A820BF49F974D802C4222212A5FB571A859825A285CE2F9C2BC16AED30E80" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Geometry.lean", + "mode": "100644", + "gitBlob": "a74cd94e6d049ed9b12fc4fac1535131c4529339", + "rawBytes": 23265, + "rawSHA256": "3FA714FB27852A50D19011DEC0EFA377F88BBC74CD251034FDAE1B6DD46B1439" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/GeometryBank.lean", + "mode": "100644", + "gitBlob": "48b76d907ee3eeb605855f1940e13ccc9e9e5208", + "rawBytes": 72212, + "rawSHA256": "81A4E60A32563A6FC29B48FB090FE28DCE989234FDE270AF1CD80017787A9613" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Interior.lean", + "mode": "100644", + "gitBlob": "c0c71cb5f624edbd0607da0e8e550315c89deb82", + "rawBytes": 9298, + "rawSHA256": "C21D32BD43EB0B8D12711A74032C44274AE18F5F5A7CC017A9439F1705E2E208" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/InteriorClose.lean", + "mode": "100644", + "gitBlob": "1f633a2344e545dc723a6ffa4b0855a763e6c58d", + "rawBytes": 32686, + "rawSHA256": "9C5EF1100271195F71E0786CD9BB6E07AFFDF4FCCA0D47AD340484302D55D72F" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Leaf.lean", + "mode": "100644", + "gitBlob": "e917618efae25460f79263037ca9ceed34144d5c", + "rawBytes": 2716, + "rawSHA256": "AD992B6F2E15387555B6718457E335DFED1BCEDDD9206B9EA249CF91479C8C76" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Leaves.lean", + "mode": "100644", + "gitBlob": "d599e95e8b939db0c5f9efe7be22337ae3d2475b", + "rawBytes": 10981, + "rawSHA256": "7D41252DDA2325AE1336459D2C14CD21B1A46EC3705E9457C7E244E6033E4ED9" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Lift.lean", + "mode": "100644", + "gitBlob": "7e2963703b3b912f6bf4ce3a20e6019f0ead7d92", + "rawBytes": 5822, + "rawSHA256": "327FFDA34FC73C4812141188719E79285294DEFAB6ECEFAEA56835DE332295F6" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Loops.lean", + "mode": "100644", + "gitBlob": "c247da9e5cde757bc27ac8bc5b14f6db55a18732", + "rawBytes": 22381, + "rawSHA256": "628CF71605058ACB3AF40C134F0EACF70E7A25BAE890F3AA6604C2708423B5EC" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/MetaBounds.lean", + "mode": "100644", + "gitBlob": "b76ca524951c026fc5b9a5027d5cdd3840bd51d5", + "rawBytes": 19752, + "rawSHA256": "C4461877876E35B3F594305DF1FA7A7C8E04737ECF851DD63E9235EE87121407" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/MetaChain.lean", + "mode": "100644", + "gitBlob": "2bead3b749b076a551b28989a2fd578ab50783f1", + "rawBytes": 78471, + "rawSHA256": "37467F7D8F8FBE88A33A9551F14CD9181865B42AB3E41FA53C1F5ED443FBCD1C" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/MetaSteps.lean", + "mode": "100644", + "gitBlob": "e251fec241f0c34334a989cd9d2611baf54d7fc0", + "rawBytes": 70136, + "rawSHA256": "9046F2772C770052805852FAC57F154C99A0977A25697ED85805123C8670C59D" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Micro.lean", + "mode": "100644", + "gitBlob": "1afb5d412836eaa7ff10c909e2705fe13120cc6f", + "rawBytes": 37006, + "rawSHA256": "DCCBD07C037F2141225602AECF74756982A3E042DE3E49DFCF6D59B31A472C07" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Output.lean", + "mode": "100644", + "gitBlob": "83f3ba46e1003b126802a9ee173a70ba79754685", + "rawBytes": 58277, + "rawSHA256": "463D5728DA4F7C03BCC7A6A2825FDE0E16E0244C11BADEA3FCA68AFD2DF82A32" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Ownership.lean", + "mode": "100644", + "gitBlob": "2946170192705db1d2860979c0aa45ab7d7e5a25", + "rawBytes": 12181, + "rawSHA256": "7BB0860DEF0136514C44B8F1C4B9FFF0E75F7AB14BB92E47C47B3827702AF076" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/PosPass.lean", + "mode": "100644", + "gitBlob": "edf6f0279331076d8e2a4b09baf0d515115cedfd", + "rawBytes": 25164, + "rawSHA256": "A88CA1DE05F251C2C42D550D2724592B5EB36BD419E94926DAD671A8FD46EBA0" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Query.lean", + "mode": "100644", + "gitBlob": "553a37df6d2a2ed7617a5c5d550cc41bae33b962", + "rawBytes": 10360, + "rawSHA256": "85A8C7DAF88A6E35F08CEE29EC4A97EBD629E333DB6A2A9B946DF1DC48BFB9B5" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/RegSpec.lean", + "mode": "100644", + "gitBlob": "82298d167f2b91f9ffa7220e5d369feafb428e59", + "rawBytes": 25592, + "rawSHA256": "E0BD0D62203FBD53DF6D18C54D00A47FFB873B7D1474FE88ED7DB20F6C848A99" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/RunFacts.lean", + "mode": "100644", + "gitBlob": "4ab983a5e85dc16ea0176ff2bdc365d7759917bb", + "rawBytes": 19676, + "rawSHA256": "57B4CC8FEAB8C65C65841D0B05264AB388211E52BE2FD39C90016D04D02A16CC" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/SparseMemo.lean", + "mode": "100644", + "gitBlob": "62dafd9df10f0b3f4c82a8d8acc827f13b50005e", + "rawBytes": 67449, + "rawSHA256": "1E0A5082591CE57EF93C8FCCD2735D4E253FDE7703F41CA734BE255341E31759" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/SparseTables.lean", + "mode": "100644", + "gitBlob": "ff7510fe81a95dd7f89cab218679608bcf17bd53", + "rawBytes": 26024, + "rawSHA256": "5B0850DBBD889CB89FE506C48A69E16EB723CD829CA00889C480D8467CBA9D1D" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/StackPass.lean", + "mode": "100644", + "gitBlob": "3a9a7f7e7e325ee698cd62315efb0c4483272a4f", + "rawBytes": 24176, + "rawSHA256": "FC1B5AC801626D79AA737408B1515CA23E01CDDE703FB137EA0C1075CF5558A4" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Stage2.lean", + "mode": "100644", + "gitBlob": "964779c2d2c0494bf9daf618485653527f5daf5e", + "rawBytes": 8256, + "rawSHA256": "C34D6A2A0A28C22AE461B4FA48124A3CFD55D4BB67155EC3D5F62E3A955931A0" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Static.lean", + "mode": "100644", + "gitBlob": "7be4917accfe8859db9f9c2c530fcc2d8b31f457", + "rawBytes": 6949, + "rawSHA256": "775276DCA095B9BDB63AE9299C2AE6920DABEC05B091E67D8112D5D00A7A765B" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/SummaryTables.lean", + "mode": "100644", + "gitBlob": "3ab485ffe6ae1eda7e6022613d197f13c16eb7de", + "rawBytes": 31255, + "rawSHA256": "3F7E6BF04B9A9CD60193D0101EFF0E7B5B8D370AB8DF465E0EDBF1EDDFEF65E6" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Tail.lean", + "mode": "100644", + "gitBlob": "2751f21e327a4ab3a86a79a06d54a49c902323e1", + "rawBytes": 12404, + "rawSHA256": "965FEC76AA87BEBE5369ECFEC58C53064C1AB58C6A6CBF1CEE25909226A16137" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Safety.lean", + "mode": "100644", + "gitBlob": "02677487865e12900f10bd8fd6d1dc9dbe8a6b16", + "rawBytes": 8042, + "rawSHA256": "0556BB89B4CD4AF1026DA3DAD249A426EC501B1BF722033637674F6467147C4E" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/Access.lean", + "mode": "100644", + "gitBlob": "4eba41aaed31d816ae787a9f82702fadb7c26284", + "rawBytes": 3307, + "rawSHA256": "A9577E0A6BEB788443E1A9A2CD862980CCE8DFDC69D6242E7E4A1D4475FA8161" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/ArgMinSplit.lean", + "mode": "100644", + "gitBlob": "8447814b228abeef4546292cc974f6896d2797d8", + "rawBytes": 7000, + "rawSHA256": "00738F5E8CE9E6EBA0F191D20089818F102021BBEC71E5513CEE35D8CF8739FE" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/BlockStats.lean", + "mode": "100644", + "gitBlob": "0658f9d2f306c2373b93149cfbdc6c2efef081f2", + "rawBytes": 4724, + "rawSHA256": "DC47A17FA33EE8680C088580C5E0E0BB1768A64F7EFF470259C2E1A914ED8CE5" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/Dyck.lean", + "mode": "100644", + "gitBlob": "48d1cee1e3665a1dc2f938de06682ea3aa4f9b4a", + "rawBytes": 6347, + "rawSHA256": "75AC54D8A2D8471A41DDEE045D6537F44324D2663E279C571E9FF10C2A861844" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/Envelope.lean", + "mode": "100644", + "gitBlob": "829953667c58e03d16bdb8d5239572de8de87b2f", + "rawBytes": 22168, + "rawSHA256": "863FB13879921EFE8923330AE85382D347C709322044549A787ED4483D61093C" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/Metadata.lean", + "mode": "100644", + "gitBlob": "a9edd97d631a2e0f5412e6f56cb63af757e097cc", + "rawBytes": 54701, + "rawSHA256": "37483440B657030E28C811D6C2CF0C410C06216C70CC6DC3388858B929167FC9" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/Micro.lean", + "mode": "100644", + "gitBlob": "aa36996fec60c578fba967d9e8c53f997474b83b", + "rawBytes": 8030, + "rawSHA256": "72E352C14F60080F631B390FC5ED1ED4BB7E1D8EB6AE9513096C51072FB20632" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/OpenCounts.lean", + "mode": "100644", + "gitBlob": "67c90271e4315863aa98b0fbc902f6fb7a5147b2", + "rawBytes": 7099, + "rawSHA256": "91BA567EE52FDE9385A3CBE9E1679695EAA57DE7FE71FCE84303416F7B7F08DC" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/Plan.lean", + "mode": "100644", + "gitBlob": "43c659e113f08d7ec7598965039a952d4ee127d1", + "rawBytes": 26900, + "rawSHA256": "747C3A77DD71C36A8D354258D8B47939013C4D37E906A896BF1DDD918A4DBA42" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/Positions.lean", + "mode": "100644", + "gitBlob": "fe3fd6e9b1d1dc133c535103dfbe4533a7354692", + "rawBytes": 16672, + "rawSHA256": "6A9E1D83F2FD0978FC3D4153CF211447FD6E7098A79A4842F50F6EB364F05473" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/SparseMemo.lean", + "mode": "100644", + "gitBlob": "01bf5e7b085b92c61a29ba7581e095b4f2f8b45f", + "rawBytes": 4880, + "rawSHA256": "128CCE8EEFB880B81D90AFBCD971F97C47945CABBC859F155072D874CCE46440" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/Spine.lean", + "mode": "100644", + "gitBlob": "8d99a071326a006d5e614a539e4dc8813109ca88", + "rawBytes": 10132, + "rawSHA256": "F6DCA9CC8AAD0ED8D0FF345964144902072BB854B32BE7798A9D4E3FEA39E9C9" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Structured.lean", + "mode": "100644", + "gitBlob": "207462d7005a94286da399da474dec168f8d71d0", + "rawBytes": 16947, + "rawSHA256": "D6321BE4381E84895CC6DAB6919503951DEF71C8A153307B1575694FF61C73B3" + }, + { + "path": "RMQ/Core/WordRAM/E1DenseSelectBlock.lean", + "mode": "100644", + "gitBlob": "41ca260240960f10d902cedfbbec99d29e0b918f", + "rawBytes": 73585, + "rawSHA256": "9F032FE04340FA74F3ABD0C3FE0587E38FE7C70872FEB8639127BF3DD2BE2B59" + }, + { + "path": "RMQ/Core/WordRAM/E1FringeArmBlock.lean", + "mode": "100644", + "gitBlob": "0532dcf528d161b1269ac5efdb6135eb03ce2a1a", + "rawBytes": 47124, + "rawSHA256": "99C40C4DC753CB0C2BAF2FC85AEC1D823C62AB7F465123478F5F6C68C53EA9A7" + }, + { + "path": "RMQ/Core/WordRAM/E1FringeBridge.lean", + "mode": "100644", + "gitBlob": "c8a3dee6bed0831fcbb463c5f25a6d1992d7d3db", + "rawBytes": 17269, + "rawSHA256": "B0287F964144901282A2949DC7FDCE9B682506EFB34F0BEC15F9098A5C8351DF" + }, + { + "path": "RMQ/Core/WordRAM/E1FringeFoldBlock.lean", + "mode": "100644", + "gitBlob": "f03253656cbc4aa162005e69b0491d0ee0720ad7", + "rawBytes": 58055, + "rawSHA256": "40764E78EB45B27F4F297D5C737689F5064B01F203CCC6DC98F61D9008CF36BE" + }, + { + "path": "RMQ/Core/WordRAM/E1Machine.lean", + "mode": "100644", + "gitBlob": "5646ccb1d9d21fb561b5e624f5e451d00819fa38", + "rawBytes": 23725, + "rawSHA256": "69CC3DDEFD185F7B6E9B09B64E8B2FB0FEFBE0669210E3D17D96CA707F3E1F94" + }, + { + "path": "RMQ/Core/WordRAM/E1MachineCalculus.lean", + "mode": "100644", + "gitBlob": "18e794f2a79e78a2186c579fc0eeed0f23dc52db", + "rawBytes": 17864, + "rawSHA256": "15138768C905F6B462B52C2A128801B94E57A70411AAE7439CBE36183446FE66" + }, + { + "path": "RMQ/Core/WordRAM/E1QueryBridge.lean", + "mode": "100644", + "gitBlob": "5b1bcb4b7e80bc0b7432365a6218adfa78d186c1", + "rawBytes": 5666, + "rawSHA256": "D2581FE4A89435853E1FCF873CB3FBBC527D3B995C2EBE44D6C299E137D937CE" + }, + { + "path": "RMQ/Core/WordRAM/E1QueryProgram.lean", + "mode": "100644", + "gitBlob": "d116a384d1b0de706d680cea95cf145f76e9a31c", + "rawBytes": 24472, + "rawSHA256": "7AA365A2546AC3BF03940C922BE6D047AAE803B1A72E85E96C2A592442BA1F47" + }, + { + "path": "RMQ/Core/WordRAM/E1RankAtBlock.lean", + "mode": "100644", + "gitBlob": "00830758e171b88ac77530c2a93b526f7edadb23", + "rawBytes": 22104, + "rawSHA256": "B28CB35B0A8C39FFBE287B221CAAD7C4A860CD1B630228915E72AD381BF58AAA" + }, + { + "path": "RMQ/Core/WordRAM/E1RankBlock.lean", + "mode": "100644", + "gitBlob": "85187e40713589b82268b047441f10775724d783", + "rawBytes": 43362, + "rawSHA256": "8FD21D490A4652F799E3428AA2CDEEC28B8EB7DF14890D999B29C3F05F410ADA" + }, + { + "path": "RMQ/Core/WordRAM/E1RankBridge.lean", + "mode": "100644", + "gitBlob": "6e1eec24542ffb497076e9c497846d2906416207", + "rawBytes": 17770, + "rawSHA256": "40754A0D37317F48F88125E66E6CE207683F639BB4DDBEDDA4669D80BF1B4ED0" + }, + { + "path": "RMQ/Core/WordRAM/E1RankCanonical.lean", + "mode": "100644", + "gitBlob": "1cd734c77ca27ffe678389b575c1570a41e2a78f", + "rawBytes": 17704, + "rawSHA256": "0A056927249262FB06917370BA3BC89DADB4CE3676B37CC8275409D1164FC9FC" + }, + { + "path": "RMQ/Core/WordRAM/E1RankTrueBlock.lean", + "mode": "100644", + "gitBlob": "f27d8640fd9f6e62b5854e5b22e70273d309dcce", + "rawBytes": 37429, + "rawSHA256": "EEE41E50EEFFDB5215412F1CC70BBB0B31BC8C5B21C875B52590463303E79053" + }, + { + "path": "RMQ/Core/WordRAM/E1RouteDecomposition.lean", + "mode": "100644", + "gitBlob": "71c261dc0e05f32855566b9fb124b5ae1f351e41", + "rawBytes": 8367, + "rawSHA256": "5F3AD98AFA01B98398316B5A027907D3B6715557E83843AC0FB6D3BD0BD7BD58" + }, + { + "path": "RMQ/Core/WordRAM/E1SameBlockArm.lean", + "mode": "100644", + "gitBlob": "2bd5e5784e9d4e9fd09cb5ef059cc57363e2f003", + "rawBytes": 26223, + "rawSHA256": "8724AD3CB2A17AFFA4148C5506E2C233EB049758ED4A66D4D6B8727268FE2064" + }, + { + "path": "RMQ/Core/WordRAM/E1SameBlockLeg.lean", + "mode": "100644", + "gitBlob": "5b7082fc4756627bb019098bddb89c0059504f1b", + "rawBytes": 27439, + "rawSHA256": "1001BD1BB66BE8C612A178179FEE50D3070619617B01FFD9841E95AAA302EC9C" + }, + { + "path": "RMQ/Core/WordRAM/E1SelectBlock.lean", + "mode": "100644", + "gitBlob": "bdc243642440376d5236147633d266928129c3f4", + "rawBytes": 33317, + "rawSHA256": "E0A00BA45005BC2B83BC18FB776839CD4FC3058CE22E1D9118DF93395F65160D" + }, + { + "path": "RMQ/Core/WordRAM/E1SelectBridge.lean", + "mode": "100644", + "gitBlob": "e1299f1a9e3fb389596f3be2510b77234abb21f4", + "rawBytes": 24487, + "rawSHA256": "20101739899D2939691506FC3B453653C999A7A490899DD9805D42CDF584B602" + }, + { + "path": "RMQ/Core/WordRAM/E1SelectCanonical.lean", + "mode": "100644", + "gitBlob": "ca8fdd96a25cc68f0c9de790a276a2961520fa7e", + "rawBytes": 13074, + "rawSHA256": "5374F6652FBD35C22C98E523D71A64E02A0E6D1F26894EB5B92CE668CFAA890A" + }, + { + "path": "RMQ/Core/WordRAM/E1SelectDispatch.lean", + "mode": "100644", + "gitBlob": "8f866a3cd6043092835b6c04947c6a1337a7f12e", + "rawBytes": 96358, + "rawSHA256": "80D39B97653BE2F30988FC9BBD5BC2FEA8588FBAE952C9DB8E917A5459C7588E" + }, + { + "path": "RMQ/Core/WordRAM/E1SelectLegBlocks.lean", + "mode": "100644", + "gitBlob": "90e02d52a97f46e7e8bb9d8735f856b5483efdbb", + "rawBytes": 28145, + "rawSHA256": "33BB4C588CB7508E1FE9F1C5F2F2BEE635AE5D02C10E0A48CCB8D3DEF6C5A8A4" + }, + { + "path": "RMQ/Core/WordRAM/E1StraightLine.lean", + "mode": "100644", + "gitBlob": "4a4d841111aeab1968dca60d5fedae10d31b894e", + "rawBytes": 10359, + "rawSHA256": "CB35ABC7263CA27F93F702E0A5C110D2D6F31F1FDABAC21AA7E840E0CECAC2A2" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Accounting.lean", + "mode": "100644", + "gitBlob": "ff3d382804d84885409f7c072270bbf9a4929968", + "rawBytes": 3507, + "rawSHA256": "F57E0758F80EBE6820648E1BF71A1F810FE1D65E9814B7351713D8D00E6A0D94" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Agreement.lean", + "mode": "100644", + "gitBlob": "d6f7a480c8e604911d06ac611bb39b98b520fb2a", + "rawBytes": 20605, + "rawSHA256": "64EC32E23F112847053DCCFA29503D6889CF8F757ABEE1076915C1EAFC245146" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/ArrayRun.lean", + "mode": "100644", + "gitBlob": "58e7f35043be168daadb0230fbf8447df9e84a28", + "rawBytes": 34169, + "rawSHA256": "E9342577949EC6AF15ECE43EBAA742D30142F7B6769C8036B9E95F22D59DD0C7" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/BoundarySafety.lean", + "mode": "100644", + "gitBlob": "558706446150cab142e76a563b0fd8caaa2ffb64", + "rawBytes": 5959, + "rawSHA256": "DDD3151AE95F579BD8531DF8C8B5D5E94F8F48501E4020E85565F1DAA3FCE49C" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Builder.lean", + "mode": "100644", + "gitBlob": "54bde55b848d829e9d30dfb9ccfb1fbfc765c193", + "rawBytes": 13873, + "rawSHA256": "95E14947A06C81C42439666D59D5959B387E75CA38B8157B717E8CAF6CD55383" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/BuilderProvenance.lean", + "mode": "100644", + "gitBlob": "c81d6a1dbd4c2117caa4a7c9634dbd93bb5deefe", + "rawBytes": 13651, + "rawSHA256": "4290EDA7E8EEC442E1D823FC50A74F06AC85E6BF2C25B34E5815724C6CF81B93" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Calculus.lean", + "mode": "100644", + "gitBlob": "6fc1e652a2c20fe2393fdae68fbb580fb7703b8d", + "rawBytes": 10079, + "rawSHA256": "E962506395C90EEBA73B070A18365449F93C27CD5719A37E1D679D64FD3DF9B3" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Capstone.lean", + "mode": "100644", + "gitBlob": "9cb036d133da1bbebdfb93943dc6c9ccec62d310", + "rawBytes": 13580, + "rawSHA256": "DA6402BFBBD286831FE18237686BC01A535DBA8A35ABE92290194D15F20C3E3D" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/CodeFetch.lean", + "mode": "100644", + "gitBlob": "1b4d2c82b171845216f1cbe58ef462d11ae32ad4", + "rawBytes": 3157, + "rawSHA256": "748474489F06988205A567F63474122BB0FE1D3DC59CB51FDECF75C2B95440C5" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Construction.lean", + "mode": "100644", + "gitBlob": "bb8788cfb3ce643bfb1bd542445a1f91d6a4021f", + "rawBytes": 15250, + "rawSHA256": "BFFF5EA62F452FF86ED80C0B22B781E3D538B8511FEC9C54239A41DADB28BB76" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Continuous.lean", + "mode": "100644", + "gitBlob": "c75d2790f3c9336a9bdf8cf632ee8ac3314051cc", + "rawBytes": 12794, + "rawSHA256": "DC52EA63307898E7D00511B1CE6FFDE89641237BC94DB0F0CA207B851A933207" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Controls.lean", + "mode": "100644", + "gitBlob": "59f3749798a51b19adcc55cfae596d61b375c64a", + "rawBytes": 13170, + "rawSHA256": "207F4D5CCACA1C33143C6E457C90129AD876672BDC0786E29FACE52F434E8828" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Descriptor.lean", + "mode": "100644", + "gitBlob": "22db7d7e11e469c46f09a2032849529b8e92d6da", + "rawBytes": 15700, + "rawSHA256": "789B974B76E89264EED035DEFD97559D1E823031A19FA990EE35085436BCFD64" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Executable.lean", + "mode": "100644", + "gitBlob": "5aea1c1267ec5c3d5e7cb12f56b17f797516b417", + "rawBytes": 43297, + "rawSHA256": "7ED53FD5715A4EA1D6628AE52F626B1573B2F20BB4E6B9B983C0A2C32DE41BAF" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Finalization.lean", + "mode": "100644", + "gitBlob": "49e18b6e158ecfcd0c7247402a3502a4097a8630", + "rawBytes": 29881, + "rawSHA256": "8288249EC0341D280B3B78A23A73A34BDDAE36B2DFA345D0FE097E0E15085865" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Finalizer.lean", + "mode": "100644", + "gitBlob": "69ee3460aacba441914d77c1433eafd6ebfcd6c2", + "rawBytes": 43977, + "rawSHA256": "0AE34DD1731D0D51AF30FBAA0D26E27ABB0FB63C2F8E5D19C5543C765812354B" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Input.lean", + "mode": "100644", + "gitBlob": "2df3df361dee8c9556de50a792de6d8ca903169d", + "rawBytes": 6850, + "rawSHA256": "3B54BFBA5E08ABEF39F3C50991F2224DEBAAD792418B329C8C6CF90B8A3F21D9" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Machine.lean", + "mode": "100644", + "gitBlob": "f4dca3838293d7f94d663045d2c13c4c44fd55f4", + "rawBytes": 7428, + "rawSHA256": "BBC0E439FB2FA55AE75E440AC3A6C77E6203FC6F7B39B2CAE8B95E1ED2B8D57B" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Ownership.lean", + "mode": "100644", + "gitBlob": "adbcae8fc33a4fa670f421e7198e5f421dcea345", + "rawBytes": 6211, + "rawSHA256": "094FD2AEB50DBF66C209FE9C52ED1352E8D413205C281246FF983DD4DFF7197B" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Physical.lean", + "mode": "100644", + "gitBlob": "e6aa6e48bde045042b857da4a7c9383af37254c0", + "rawBytes": 36552, + "rawSHA256": "22DCD8903F457A75C581D771C4804CA2E5375BC1F5D1AFD539227494D6240C5E" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Profile.lean", + "mode": "100644", + "gitBlob": "7f876238f299df195f564015ade9a4b6fb91de86", + "rawBytes": 5061, + "rawSHA256": "9B2D904D9A585BC134E0D74E89E91F6FBC4B6F20F880D0AD718D9E86C7D5800B" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Program.lean", + "mode": "100644", + "gitBlob": "02f4dc48ca2a2b7e6c053d3742ac4d0e2331f820", + "rawBytes": 8412, + "rawSHA256": "BB40B5AB3B7532EA4F907BF1D174DD2DE14013C5E022454CB7C3B99CC2707DFC" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Provenance.lean", + "mode": "100644", + "gitBlob": "4c878fa3cbe5818bff3941de3f47f195e51bb7cb", + "rawBytes": 13708, + "rawSHA256": "C5AA67539106246D4461DAC3D5617C01B24730F7348B44A95F046DC031FE3308" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/QueryBridge.lean", + "mode": "100644", + "gitBlob": "54b8e510b3417e75ac20a6b3a39cc2af8e8b6c28", + "rawBytes": 8004, + "rawSHA256": "DF9AB7E58C853FC33A047B0F01BAAFCC2BC40D359657CDD1FC824DA6C0E78265" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/QueryEntry.lean", + "mode": "100644", + "gitBlob": "d385098fbb0938f83c7d6f37226b2569c8ecd856", + "rawBytes": 25120, + "rawSHA256": "5FE765C5ED664E87A9FFC43A4C00B9DC294CE6D2DD75FD6AEEC51DBD469FE25E" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/QuerySafetyBridge.lean", + "mode": "100644", + "gitBlob": "245e77ea37749b542b2a2db99ff9de33818fbd8c", + "rawBytes": 24516, + "rawSHA256": "B0324D42D7309664380842C74FBBAB479B0F20146AC32C07CF78583C96D96043" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Resources.lean", + "mode": "100644", + "gitBlob": "a23a9004547c96deb5e8384a3bc80da172177823", + "rawBytes": 5950, + "rawSHA256": "BD931D49482D8AF1BBEC8E8DD78BB7D9DCDF6FA1F65E814856A099964055EC62" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Retained.lean", + "mode": "100644", + "gitBlob": "154cedad80ea3feb1c53210581db8e5dab086fb7", + "rawBytes": 4593, + "rawSHA256": "FF6ADA49C394E940E68ECE8BDC52DC39C436CA6299837BFD9FF639EF7EE95301" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Retirement.lean", + "mode": "100644", + "gitBlob": "08495761452e2dfbec9450c6041901eaa698861f", + "rawBytes": 23754, + "rawSHA256": "248106288060C2B3316A3FC133093385E498E3775C91BC73C005136DB879FB4B" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Reusable.lean", + "mode": "100644", + "gitBlob": "2d0de18da29bab15beb0a5e8a1b18b1aa0ae60ca", + "rawBytes": 26810, + "rawSHA256": "087D46AFB3B9DA6CFD7373CF8B3C7752FB7B538B4C20942775180B1957C8FF67" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Safety.lean", + "mode": "100644", + "gitBlob": "38b82010e24f51fce11681ebc95680e92d20c97f", + "rawBytes": 5960, + "rawSHA256": "1C0F972965596DFBB631B7BD44AAEA00B1178EE9B6C40DDB7D2BD45D95F4C490" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Service.lean", + "mode": "100644", + "gitBlob": "2591a4f4b65519301bd05b9e2568a1b53bd4ff45", + "rawBytes": 8157, + "rawSHA256": "F4157493517F232A6A83BB52C87B751F6A0C2C1F9CA9C98FB6CAE036542A34E0" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/ServiceSafety.lean", + "mode": "100644", + "gitBlob": "891afe0e832c8e22493afb3c882c3aa569a12c18", + "rawBytes": 20576, + "rawSHA256": "121A2BCE2ED5BDE35BFCE6A8FE7180814531CA3C1487CC77F768993D5BEB3A31" + }, + { + "path": "RMQ/Core/WordRAM/Native/.gitattributes", + "mode": "100644", + "gitBlob": "6ed29baa59dbd6707dfd833d6fba125f605a0a68", + "rawBytes": 94, + "rawSHA256": "B551B88139A88AFD228E5532B8D82F6DF705A9B82ECE640523E3543C9B089E0B" + }, + { + "path": "RMQ/Core/WordRAM/Native/AxiomChecks.lean", + "mode": "100644", + "gitBlob": "54229006f8805c07ddadd1a13c7cca2b6a90e257", + "rawBytes": 4353, + "rawSHA256": "013D4C738E37228F323ECDD606CED8AB0B5D7E5D515225A3CFE6A8D1A2AAF379" + }, + { + "path": "RMQ/Core/WordRAM/Native/Binary.lean", + "mode": "100644", + "gitBlob": "54687742f4641fc517329a10e97575ec03fe7a0d", + "rawBytes": 25637, + "rawSHA256": "C50741D0A9AED1797919F405E8F7440410C0CD13DD2B9F299D0E6AB5E959AE16" + }, + { + "path": "RMQ/Core/WordRAM/Native/Binary/Bounds.lean", + "mode": "100644", + "gitBlob": "08c99b2453cf801c8586e792142d099342eec086", + "rawBytes": 6807, + "rawSHA256": "1ADF9BE737AD6C86AAC6E5FBA75ED3384876AA029CCEFBBD76CDA03DF70C339E" + }, + { + "path": "RMQ/Core/WordRAM/Native/Binary/Checks.lean", + "mode": "100644", + "gitBlob": "5e060cf492707eb7062963eab9fb649c74cb00a0", + "rawBytes": 12340, + "rawSHA256": "03B4786F8AB00028B09AB6270EFE3B9CF9E178E7DB4CA4D98C98D0EEBC255CAD" + }, + { + "path": "RMQ/Core/WordRAM/Native/Binary/Codec.lean", + "mode": "100644", + "gitBlob": "1ba71e9c2c9fbf454268eb21b8c4907bd8612ae6", + "rawBytes": 16260, + "rawSHA256": "E46F05148BB2F4D1D25C848EC804B0E2E0881EFB536F988A90AB9CB7371C11F7" + }, + { + "path": "RMQ/Core/WordRAM/Native/Binary/Cursor.lean", + "mode": "100644", + "gitBlob": "46b3370b0116fc071f9102c48205fdeaf151e69f", + "rawBytes": 10733, + "rawSHA256": "FA032A73E3CAAB84A874D736D26CA8B833CECC526BBC880BDF09AC8647E68F45" + }, + { + "path": "RMQ/Core/WordRAM/Native/Binary/Cursor/Checks.lean", + "mode": "100644", + "gitBlob": "6bcaf6c3ae76f7d413e7eba37f177b3c12d2e69f", + "rawBytes": 7833, + "rawSHA256": "F7B081BA8BB3A4E11FAA1AB75660D7F24613FAD1E4745FE7EDC7EA2A07F1A0A2" + }, + { + "path": "RMQ/Core/WordRAM/Native/Binary/Cursor/Core.lean", + "mode": "100644", + "gitBlob": "a8f6d49eed485b7036ab8f06c2c2e71cc6e04581", + "rawBytes": 24281, + "rawSHA256": "18F42ACEE5D218DA5CB6B787E7DF25C69C572C72551E3008D1106A6CFA660E28" + }, + { + "path": "RMQ/Core/WordRAM/Native/Canonical.lean", + "mode": "100644", + "gitBlob": "cf5aca6ff7b7554bd3d89c93c1b317015a2fd237", + "rawBytes": 6847, + "rawSHA256": "D61C7C1AA6C5FB521995A96F5EC0EBDFE8BDBE4A58CB1F6E159080E365AB857D" + }, + { + "path": "RMQ/Core/WordRAM/Native/CanonicalImage.lean", + "mode": "100644", + "gitBlob": "b3a3245bef846330952f8bd4628625ef8e1c285e", + "rawBytes": 4727, + "rawSHA256": "2A8469798F8A7700F22DA9F01AA157BFDE5F5BF7FE7282132DD53675FD74EE75" + }, + { + "path": "RMQ/Core/WordRAM/Native/Capstone.lean", + "mode": "100644", + "gitBlob": "7fe78d055cdec2f8a4bd91d068ee1a6db93220ba", + "rawBytes": 17145, + "rawSHA256": "E2B2FB55223A271B3383AACB70361D85126ABEB3C252ACB0E314467729C6FA0D" + }, + { + "path": "RMQ/Core/WordRAM/Native/Contract.lean", + "mode": "100644", + "gitBlob": "878e44a24c63ce9fb1f0712e6b9245191308a394", + "rawBytes": 13766, + "rawSHA256": "A8DB1EAAC6445F2F8490A6C344A3F573FD169D3FD7B82E6637C4947159E306AE" + }, + { + "path": "RMQ/Core/WordRAM/Native/Entry.lean", + "mode": "100644", + "gitBlob": "85c45b3d794212d40b7bdf0de43246e23c891c9a", + "rawBytes": 2266, + "rawSHA256": "ADD666450D8CF6B724F1467CC2CD4182E8B5EEFC50AE1BF369AEFC5A2A4B7832" + }, + { + "path": "RMQ/Core/WordRAM/Native/Execution.lean", + "mode": "100644", + "gitBlob": "a229ae59c36c222cedf433c8211d725cd2e7df16", + "rawBytes": 8989, + "rawSHA256": "1367785E02684C7A81C93DF9815D8B736A3490F32046619C75A1838BAF469C06" + }, + { + "path": "RMQ/Core/WordRAM/Native/Finite.lean", + "mode": "100644", + "gitBlob": "987577f5e33326093ecb0903ee5ae332e5f60a9b", + "rawBytes": 11537, + "rawSHA256": "8EDC747F2F0BBB7D4E6F6849B63869016969C4F7535D62E99A6E4D01901223DF" + }, + { + "path": "RMQ/Core/WordRAM/Native/Host.lean", + "mode": "100644", + "gitBlob": "ef898ee5cdc78ee2b4732ebe1fb0a9e52d2b3405", + "rawBytes": 2820, + "rawSHA256": "290F2DAB5985363FD2994EE3F96A21924F3EBD63F3A79A9F2E7DF476173001F0" + }, + { + "path": "RMQ/Core/WordRAM/Native/Lifecycle.lean", + "mode": "100644", + "gitBlob": "5eccad3416e7de0e87143307d8ce246962f8ec48", + "rawBytes": 251, + "rawSHA256": "1DD052446E9CEAAC61A94875F04F5746AE0E67882533AF041EE2A8A7769D9288" + }, + { + "path": "RMQ/Core/WordRAM/Native/Lifecycle/Admission.lean", + "mode": "100644", + "gitBlob": "b8ec310dd2107b761e28b271d5940c7f26e485eb", + "rawBytes": 11538, + "rawSHA256": "36BF7EB2FBC592FE178BEF884591C5962A43A34B6870405789287B4106F3E6D4" + }, + { + "path": "RMQ/Core/WordRAM/Native/Lifecycle/AdmissionContract.lean", + "mode": "100644", + "gitBlob": "39e55e326e6d8d2fa539b1101085e4450a5429c4", + "rawBytes": 8956, + "rawSHA256": "98E6CC6CA683B93EB288F692FDCFF6C63800FFF879490E2665B68FBF420D67EA" + }, + { + "path": "RMQ/Core/WordRAM/Native/Lifecycle/BoundaryProofs.lean", + "mode": "100644", + "gitBlob": "c61bd032e0caff6286a3a63b456313620865c305", + "rawBytes": 10281, + "rawSHA256": "519D089C5B26C2A75153F2C6FEE666333F921DA3766892411178B313023CC879" + }, + { + "path": "RMQ/Core/WordRAM/Native/Lifecycle/Codec.lean", + "mode": "100644", + "gitBlob": "8681132a10ab7e3a95d9236cc5067a993d4a5632", + "rawBytes": 6872, + "rawSHA256": "219669A34FA433EFE27B6CFB8E98C22813C98D96CC4E7DCD018C3F044FDF84CA" + }, + { + "path": "RMQ/Core/WordRAM/Native/Lifecycle/Contract.lean", + "mode": "100644", + "gitBlob": "23d8cdd93957c3450b5acd68b4b8df16d61bc60d", + "rawBytes": 7502, + "rawSHA256": "A61D3359B1D3066ABE8F8CD5D3F3BE3597798EA4A2D09E0CB825F9EF5ED7BAEA" + }, + { + "path": "RMQ/Core/WordRAM/Native/Lifecycle/Entry.lean", + "mode": "100644", + "gitBlob": "3cb62996781c160aebe7146a08edaea2047b1269", + "rawBytes": 8601, + "rawSHA256": "176189BA4C8218A6E8F397580230A4FA2FBDE0BE2C875741C9F7CA8D80BB0901" + }, + { + "path": "RMQ/Core/WordRAM/Native/Lifecycle/Observations.lean", + "mode": "100644", + "gitBlob": "85c734bcc05be29e390f019ba61ea6f937eb2109", + "rawBytes": 32943, + "rawSHA256": "1216FE255E14175F2EE67B2C77C28CDB0509606C3BE4B0063FD22D39867DBB96" + }, + { + "path": "RMQ/Core/WordRAM/Native/Lifecycle/Repack.lean", + "mode": "100644", + "gitBlob": "a03c06935e0957b63acd713f1ea05d5bdc2dd9bc", + "rawBytes": 2485, + "rawSHA256": "B229BDB19781AE318694FAA62A83B57802634FEC27C7EDB2D4B5899DB56B2639" + }, + { + "path": "RMQ/Core/WordRAM/Native/Lifecycle/Run.lean", + "mode": "100644", + "gitBlob": "ddfd5c22dfa2e4a744dfaca89300b155a5179795", + "rawBytes": 2333, + "rawSHA256": "FAA4FCABD70CF8462670691E43C1B0DF9FF6D7C7CE9FC19F4AC87571910FEC36" + }, + { + "path": "RMQ/Core/WordRAM/Native/Lifecycle/ThinRun.lean", + "mode": "100644", + "gitBlob": "f82d12a49b541a8ba008493e964f50c9973c1d80", + "rawBytes": 2386, + "rawSHA256": "962DD0D1B1ED610835B04BAE4A5309CC194E610F8B8200462B04EC03545E2602" + }, + { + "path": "RMQ/Core/WordRAM/Native/Limbs.lean", + "mode": "100644", + "gitBlob": "fc5ac5b4cac019a10c8c604c2d8216aede5faa97", + "rawBytes": 15313, + "rawSHA256": "06D057D0DE50E263E701D2D5FEA1A4B0E1F6C3DD9A6BFDB6F2F9EDE71A7803F1" + }, + { + "path": "RMQ/Core/WordRAM/Native/Limbs/Checks.lean", + "mode": "100644", + "gitBlob": "6b7b6bf5cd189e7bffa50eb3d282e1f5cf8ca964", + "rawBytes": 5602, + "rawSHA256": "C78560DBEB2076F12A5EFBBB3E9CF9389387CACCF7AB9A3F8C6B3B16EA3E643A" + }, + { + "path": "RMQ/Core/WordRAM/Native/Machine.lean", + "mode": "100644", + "gitBlob": "7808441654336fecb7dbc00d3c960e512f6dcba6", + "rawBytes": 38858, + "rawSHA256": "F5286E6B52A5C5A73571BBF831E7CA9C5D731F7F5998F3ABA724E17F7AB94B3D" + }, + { + "path": "RMQ/Core/WordRAM/Native/Machine/Checks.lean", + "mode": "100644", + "gitBlob": "74dcd3d152f7aaaa5ab16ebe36a3759185822f74", + "rawBytes": 7330, + "rawSHA256": "F8B62700DFFCF1BF1948EE63BE1FFCBE5A9E10757A569E3DF8A7EEC8F27614C2" + }, + { + "path": "RMQ/Core/WordRAM/Native/Machine/CodeFacts.lean", + "mode": "100644", + "gitBlob": "25413782c337fb100dfa2c8f4b0fd3d488b98a4e", + "rawBytes": 7126, + "rawSHA256": "94AA115EA137C32F0D11E3714A0E6C0ADD87165ED1306CDBBC22ECC4C0030C00" + }, + { + "path": "RMQ/Core/WordRAM/Native/Machine/CodeFactsChecks.lean", + "mode": "100644", + "gitBlob": "42fc709b74722a236fdaa6ded2ec08f758575905", + "rawBytes": 1432, + "rawSHA256": "A3AAC86CE95AF7B8F477B499D8DFD6AD8A304EDE8CEB20461054A2E0A6151ECE" + }, + { + "path": "RMQ/Core/WordRAM/Native/Observations.lean", + "mode": "100644", + "gitBlob": "b02321cd8584c6c9c0bb85f413f2349854685f85", + "rawBytes": 3164, + "rawSHA256": "BC3C825AB7598810F9506B36D0EC9F34031DF7D9715F2AB68FEDB823009679B6" + }, + { + "path": "RMQ/Core/WordRAM/Native/Route.lean", + "mode": "100644", + "gitBlob": "ed34016488095d90560f26a6fa6a91ec6d569452", + "rawBytes": 7462, + "rawSHA256": "C00240A5A2E994DD1A996C79A52FF54780A0B5A87010B3DBCF4ED3A61244A5C5" + }, + { + "path": "RMQ/Core/WordRAM/Native/Runtime.lean", + "mode": "100644", + "gitBlob": "886d698777ec9acce552a8459683cb3dfcb3dbd5", + "rawBytes": 6120, + "rawSHA256": "23EF158FCC87169566CC443401BD6842197F9373E39CF5DF172165B765FEA847" + }, + { + "path": "RMQ/Core/WordRAM/Native/Thin.lean", + "mode": "100644", + "gitBlob": "7fd0365ff4bc40be2e95386c428a1ee6e3ab3ede", + "rawBytes": 4498, + "rawSHA256": "26D984386EEA21CCCC49EBF6217CD824B7896CF98785F8F843C6AD9E2EB69845" + }, + { + "path": "RMQ/Core/WordRAM/Native/WitnessExport.lean", + "mode": "100644", + "gitBlob": "cd5a1e59c85fbb2afcb0df4c55c9455928e70e51", + "rawBytes": 13585, + "rawSHA256": "4CF5C928FCD784DF112115A8BDFF87A8CA3FFC85AF04B679E320402106466F70" + }, + { + "path": "RMQ/Core/WordRAM/Native/Witnesses.lean", + "mode": "100644", + "gitBlob": "2192ef86e5d8abdee7c7e5d8c5f3a0971bb6cbb7", + "rawBytes": 10501, + "rawSHA256": "8E732E615A9E69646AD6B6D2FDA5F632DF9826D2A22CA1B2DD71C98FF016B642" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/BranchBound.lean", + "mode": "100644", + "gitBlob": "48157b1318258ad86649efed70af04471f1f8e5b", + "rawBytes": 17543, + "rawSHA256": "64F539C5E8F0247A630B5099E6F9A0D4E8BD00F6DFC8F0073E8179CB870B66D0" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/Capstone.lean", + "mode": "100644", + "gitBlob": "7eeebe68bbd2ea3077fe825a5b01462e1b8f09a4", + "rawBytes": 7574, + "rawSHA256": "6F960B2C3D01676E2A5FE29509622B901DFA97072E2529D6D6BEFE70B3158A63" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/Certificate.lean", + "mode": "100644", + "gitBlob": "9d47713c26a491934ab17526750b08761c6afa87", + "rawBytes": 9238, + "rawSHA256": "4750350391BBCA77AF33F4952AFCD091142FA62A788841A58F03B9ED2DC40430" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/Compact.lean", + "mode": "100644", + "gitBlob": "42259f79f94c26bc4e06e89ca5c4ed4588bcbfb2", + "rawBytes": 3208, + "rawSHA256": "7BDE1173B5661A8C68ACFD13F5E9911D176CF8E55F7FBD635E8A5E5819C8DE17" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/CompactProof.lean", + "mode": "100644", + "gitBlob": "c349a1ad48cdc85169623acbe7647d43cf292925", + "rawBytes": 31141, + "rawSHA256": "54BF190DDFAA28AA410583942DAEB219937E8DB061AC4CE6CA8CF1BA201CB5B4" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/CompactSafety.lean", + "mode": "100644", + "gitBlob": "11a777f9b21b4c946b5c8d01df3aa2e953bc81db", + "rawBytes": 34678, + "rawSHA256": "6B84A73FCF1D9DDC6D5C7117EA5B55D4FCD840B6676CBAAB717FBBDD7476563E" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/CompactStatic.lean", + "mode": "100644", + "gitBlob": "b0164a73b49c8407267ff30c779fca3d39025843", + "rawBytes": 17274, + "rawSHA256": "5C5F1AB987ABE38D7BB41B93DC67BA6DCDF15C6ED805F4EB1C95037A338875A2" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/Consumers.lean", + "mode": "100644", + "gitBlob": "7a78c403e548df7ba7e7782ab081f08c4f4ad32b", + "rawBytes": 25172, + "rawSHA256": "47A1C35EC6EA7DB27A16ABE4CB282A1043EF315F54485806BF4F986E7F5D5597" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/Query.lean", + "mode": "100644", + "gitBlob": "3f1829809423696c204372ae2056348c4a7ff2f7", + "rawBytes": 9432, + "rawSHA256": "1FE89CF2B3F2833C330C91DB9C93EA35B6C37A3F98BC85A4B241D6AA63C36C05" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/QueryProof.lean", + "mode": "100644", + "gitBlob": "aeaf3b8ab78f7c316d1e6fc267447e72bf8d1daf", + "rawBytes": 6442, + "rawSHA256": "F5520F3B203A20EB8EBFACD2C0381C4EC2503DC9A975E4876B361D16D40CEB58" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/QuerySafety.lean", + "mode": "100644", + "gitBlob": "c414eb89274fd85807fcd6fe070ebfefb1a362d1", + "rawBytes": 2379, + "rawSHA256": "E546204B1380775F78A82F45BDB07616B86BACF55DD73D06FAABFE60E7DA41D5" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/SourceRelations.lean", + "mode": "100644", + "gitBlob": "089d6b1a3e9768bca1be2c60510e5570b8b0b255", + "rawBytes": 17566, + "rawSHA256": "B6CC636BFD691D18F4BDE989AFE188365D12007B68565CAC98CC3CC394E3A0DB" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Accounting.lean", + "mode": "100644", + "gitBlob": "986ef250b8dfaf17ef712c559bae6c3fce61ac5f", + "rawBytes": 2876, + "rawSHA256": "9429C3D715B22D587D4CAD41BC5F288987D1A27D51DA345ED6C6EEC85333E2CB" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Allocation.lean", + "mode": "100644", + "gitBlob": "39d65f0bc8a19dfc8467d16263bfc631e99c6551", + "rawBytes": 9520, + "rawSHA256": "7FDC39400FF3AB877BECD63D2E367E24ACE0C71F373C7F54017039EE578E7D49" + }, + { + "path": "RMQ/Core/WordRAM/Packed/AllocationLowerBound.lean", + "mode": "100644", + "gitBlob": "8806fc00da8501ed57de269a32f6f3135450f591", + "rawBytes": 26743, + "rawSHA256": "D571B5F875EC5C34BE3056841DBF90CFAF00CFB3FF4FCACEA19E1D83253D6D06" + }, + { + "path": "RMQ/Core/WordRAM/Packed/ArrayRun.lean", + "mode": "100644", + "gitBlob": "0e6484f9a5238cd7805ed31a8e406fbc9081e844", + "rawBytes": 2050, + "rawSHA256": "CD45C07C1F822C1BA57B65ACCA2F5CE916FA735B33269AFB7CEB17F4E3B9C82F" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Calculus.lean", + "mode": "100644", + "gitBlob": "1a4908d33997a2f6222a64a080d772f37ccc6a81", + "rawBytes": 17807, + "rawSHA256": "2BA830CA4AD97FE7A51A6561C5F18EAFF7D2BC4084EDD0D124FE47C41D955A45" + }, + { + "path": "RMQ/Core/WordRAM/Packed/CandidateProof.lean", + "mode": "100644", + "gitBlob": "c0d507aa3126cf91b8d4b752e0d25b4ae838e1d6", + "rawBytes": 5101, + "rawSHA256": "122EFD67E9A359275F949A85185CC45D406B6648211091A6704805C5CB3033A2" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Capstone.lean", + "mode": "100644", + "gitBlob": "4bdf1fda17b0eceee714c7719175e8357bcd3ced", + "rawBytes": 11554, + "rawSHA256": "D9C7BB7D158D54C9F221080453C58F7DA6960497D287B7ACCC39BEBB3F931A2C" + }, + { + "path": "RMQ/Core/WordRAM/Packed/ChunkArithmetic.lean", + "mode": "100644", + "gitBlob": "824723043427fc36a9a6e5c0a4ce8ca47b13bc9f", + "rawBytes": 10439, + "rawSHA256": "0F1B3DE7E3CF3DC37036335DA47FEA5F4A859E06BFBDF47314F23C6312A982FE" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Compiler.lean", + "mode": "100644", + "gitBlob": "2cd06337d200b1c778145a286d7a08146bcef910", + "rawBytes": 29873, + "rawSHA256": "C7AAA88DFB6A24099F8E7B22D7AC77942043476A47874A414BDAB58C77EE5505" + }, + { + "path": "RMQ/Core/WordRAM/Packed/DensePacking.lean", + "mode": "100644", + "gitBlob": "fc07693b13a3362e22ccb4b2b6e239d55cdf4a7a", + "rawBytes": 8009, + "rawSHA256": "75487722A3DBB6BCB3D445B0C242E8380F7B9F77A0762354D83F692CBC956913" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Frame.lean", + "mode": "100644", + "gitBlob": "da57356278dbd5a6cb1febf3d3e1cada43857a80", + "rawBytes": 3216, + "rawSHA256": "480EA8DF315B6DEE0F2048EEEAC03131368FD27EF09E0AAFA21DA2A676929939" + }, + { + "path": "RMQ/Core/WordRAM/Packed/FringeProof.lean", + "mode": "100644", + "gitBlob": "884ca054aaaaf20b33aec0afcfb4fbfd32cb8cb0", + "rawBytes": 49982, + "rawSHA256": "80E9DCC3C7410D60ED99EBEBD7F2A40D8FAF54F634BD5310F326319EBE589FBB" + }, + { + "path": "RMQ/Core/WordRAM/Packed/FringeSafety.lean", + "mode": "100644", + "gitBlob": "1bd86ca09a2d07f86886d3667bd79a9f68cc3652", + "rawBytes": 56146, + "rawSHA256": "9D582E04A68534074A62F4494969E60264102E87A554DC4C0A9328327B841F2A" + }, + { + "path": "RMQ/Core/WordRAM/Packed/FringeSource.lean", + "mode": "100644", + "gitBlob": "7865a9671d9453dc9ac8bf66af2c8642e4360f10", + "rawBytes": 8756, + "rawSHA256": "BC779A746A938C7B10FDB4B93C84003E9CA91D27FB3A3813ABDF5944920B96C2" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Guard.lean", + "mode": "100644", + "gitBlob": "8cfeba2892f8321956d799eb3514c7522bf46a7b", + "rawBytes": 5782, + "rawSHA256": "B911E50388FBDCDCD82A8E3ADEDD754473B6E5AB162A0D5D25B5C009A9160FFC" + }, + { + "path": "RMQ/Core/WordRAM/Packed/InteriorCandidateProof.lean", + "mode": "100644", + "gitBlob": "536c476bcebca4833366a5f3f0be3d5d19d4a09e", + "rawBytes": 131852, + "rawSHA256": "CE6073BE51D918B221216B6DFAD4CB913D2372E3D2F5EA66A3F09233589C4987" + }, + { + "path": "RMQ/Core/WordRAM/Packed/InteriorLocate.lean", + "mode": "100644", + "gitBlob": "2b76d6235136a8bb9afc1daac7fe67df6ce34012", + "rawBytes": 7310, + "rawSHA256": "E570243D505D2498085A4CA289DEB74E7CCC98985F08AFF7BFB9D9D3151600E7" + }, + { + "path": "RMQ/Core/WordRAM/Packed/InteriorReadProof.lean", + "mode": "100644", + "gitBlob": "e59f716c11e9cdc0b323265220e0e5633e87789f", + "rawBytes": 38897, + "rawSHA256": "922E483A25D0BB212358C7DF4285FFF17F98ACF057E6D15207796306F185A605" + }, + { + "path": "RMQ/Core/WordRAM/Packed/InteriorSafety.lean", + "mode": "100644", + "gitBlob": "9af0ede08be43082e459e6b97a578f008b5ff551", + "rawBytes": 135916, + "rawSHA256": "5D38792A31319F871C6BB9FDDE4374DF51588A78905B65E1036DC702E9B0D631" + }, + { + "path": "RMQ/Core/WordRAM/Packed/InteriorSource.lean", + "mode": "100644", + "gitBlob": "920906f499c5b95eb3c9dd5b87927924ceca09cf", + "rawBytes": 11666, + "rawSHA256": "656C25CFFD3D7BEC326CA03C9E068250B9287402AAF6091E71E5A234C0879949" + }, + { + "path": "RMQ/Core/WordRAM/Packed/LCAProof.lean", + "mode": "100644", + "gitBlob": "76f4ee5df246d48cbaebb4e7a640e4304dd4a244", + "rawBytes": 43679, + "rawSHA256": "281F6C63FDA95699292EB9EED87DCF362D3EC549D99CBCB5A0A0CFFE0CFFF058" + }, + { + "path": "RMQ/Core/WordRAM/Packed/LCASafety.lean", + "mode": "100644", + "gitBlob": "04eb3caad4c2e088e7bea13142bd6d4174d4080e", + "rawBytes": 27935, + "rawSHA256": "E0EA8687C328AEFC33CE385A53D8BBE9BB6FFEB1C974756FFAEF80E3E562047F" + }, + { + "path": "RMQ/Core/WordRAM/Packed/LoadSafety.lean", + "mode": "100644", + "gitBlob": "d072778216d7d44539636bfcb766e74213ccc57b", + "rawBytes": 42584, + "rawSHA256": "AA7F502022E29C3D10A808E68CA0C9BB1481A0032659FA3C05BBB6D860850369" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Locate.lean", + "mode": "100644", + "gitBlob": "a610d7777cb91a176575c41bc722b1bea7dc17a6", + "rawBytes": 61614, + "rawSHA256": "3220FEECE22BAEF77AB8466675B8BDE65BD3FEF3A3C3832AEB176ADB4AF81578" + }, + { + "path": "RMQ/Core/WordRAM/Packed/LogicalSpan.lean", + "mode": "100644", + "gitBlob": "e23de1a5946d8a55c17dce7d382369dd18e54c34", + "rawBytes": 28689, + "rawSHA256": "3A3BF287E8221FD1825D2205260FD7E5F02ED75FF930CEBF603FBA67420B1573" + }, + { + "path": "RMQ/Core/WordRAM/Packed/PhysicalRead.lean", + "mode": "100644", + "gitBlob": "6efea650e46a7d4b1ed36adc6483e030b4332ec3", + "rawBytes": 15311, + "rawSHA256": "49C9CE18F81B0B7A00E96C0E32F12121EE27401412146752DB845CE22581558F" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Primitive.lean", + "mode": "100644", + "gitBlob": "9ee7a8069c8e55407e4199dc620e5b8551e3093d", + "rawBytes": 7448, + "rawSHA256": "4C73250DF41AE328F6A9C6CD33FCEA48190A8A77AC81F09F1731B789D79B05C4" + }, + { + "path": "RMQ/Core/WordRAM/Packed/QueryCertificate.lean", + "mode": "100644", + "gitBlob": "23d6a4c6f83832eb2ebe83e8779f29f77df60496", + "rawBytes": 10150, + "rawSHA256": "363EEF84524D4942D755BB84176CCC843FE2169F87C8B503D52A227F1249DDB3" + }, + { + "path": "RMQ/Core/WordRAM/Packed/QueryCorrect.lean", + "mode": "100644", + "gitBlob": "c5eb674a2bbe8f2e6d600fb0f85766386d6eca04", + "rawBytes": 4565, + "rawSHA256": "F6F8066E4D71DB8298F1BD902F6ED1E98E5CB3AECF572B5996B63926B925125D" + }, + { + "path": "RMQ/Core/WordRAM/Packed/QueryObservations.lean", + "mode": "100644", + "gitBlob": "a42907e59bd5f1a9280c44a814b45cd4bae6a3eb", + "rawBytes": 4588, + "rawSHA256": "A51A79C3D201495A4538C7D04A7A35D9B3BEAC350C1BA01FC0F4C540891B4C05" + }, + { + "path": "RMQ/Core/WordRAM/Packed/QueryProof.lean", + "mode": "100644", + "gitBlob": "6bc4493a814eee485dfb7cf36da2d1c006e41779", + "rawBytes": 34048, + "rawSHA256": "868D310396B232719B24B706709C9FEECF7CF0672E1ADA87FA26578367BD9399" + }, + { + "path": "RMQ/Core/WordRAM/Packed/QueryReference.lean", + "mode": "100644", + "gitBlob": "afe47b8a32832e53701e28dc3b008f1d6d32b8f7", + "rawBytes": 5808, + "rawSHA256": "BE9C1ECA68416BF8DF4844DED3CC8D243FC2480E6D2A4834DBCBC0A276E3FBD6" + }, + { + "path": "RMQ/Core/WordRAM/Packed/QuerySafety.lean", + "mode": "100644", + "gitBlob": "64eb0bc513349545f81cbac2475f92895930a4c7", + "rawBytes": 36470, + "rawSHA256": "B2139F2396502E4E01D7F666F5B7D2EEB68C03BCBB61390AB23E2A77DE716E33" + }, + { + "path": "RMQ/Core/WordRAM/Packed/QuerySource.lean", + "mode": "100644", + "gitBlob": "077f3b3803468dd60f58736caf979b4c879a827b", + "rawBytes": 6040, + "rawSHA256": "DFCB57325902A1EEBAFABCF24FC5437AED88A2EA32DF416B5CB2BBCE98F51415" + }, + { + "path": "RMQ/Core/WordRAM/Packed/QueryStatic.lean", + "mode": "100644", + "gitBlob": "a6a6c8af4ca92fedc10bab730056c3a6d2d03513", + "rawBytes": 5433, + "rawSHA256": "F8724BBE814A5A752EEEF4C1E192698FE8E6941E776D604C10A92D65A43B3D2E" + }, + { + "path": "RMQ/Core/WordRAM/Packed/RaggedWindow.lean", + "mode": "100644", + "gitBlob": "c25aa9a82983f898417ecb1b5d9849e7713c7605", + "rawBytes": 6002, + "rawSHA256": "5520399E6DA36ED822F7F8F95505168ACB673779521A95BBF402CB7D5805BBD4" + }, + { + "path": "RMQ/Core/WordRAM/Packed/RankProof.lean", + "mode": "100644", + "gitBlob": "57d719c4b0015fa534dc2340a1c194b36861a0ad", + "rawBytes": 83941, + "rawSHA256": "52106920B98F295C699008619DE132D320A3F97258074C8027FD8F6B2D5231BC" + }, + { + "path": "RMQ/Core/WordRAM/Packed/RankSafety.lean", + "mode": "100644", + "gitBlob": "2932df9d0b444aab14914558f7425c8948c2eed2", + "rawBytes": 87035, + "rawSHA256": "BFF7F9CB3BC558EC41B0B1BC4B73C08F4F8F2ACC5DF9EB734E7FF20D9974D4F4" + }, + { + "path": "RMQ/Core/WordRAM/Packed/RankSource.lean", + "mode": "100644", + "gitBlob": "b5f57f94ce458a38dfcf83801c89333029704414", + "rawBytes": 5803, + "rawSHA256": "B10BA599D21313AC0E5FC7D837D1FE1B999D270280959CA1AE30B8690AB4F6FB" + }, + { + "path": "RMQ/Core/WordRAM/Packed/ReadInterface.lean", + "mode": "100644", + "gitBlob": "0a68f62355dfd798bab3f2579e43135b8fcdb588", + "rawBytes": 5106, + "rawSHA256": "75509F98331EB79E87809851B1BFB340BC3157E4482405F9F47D1D49A7C1EA87" + }, + { + "path": "RMQ/Core/WordRAM/Packed/ReaderSafety.lean", + "mode": "100644", + "gitBlob": "37b534eac23885a9e17856adafb111c766eb5db9", + "rawBytes": 50353, + "rawSHA256": "AE8AA18EAE3C6639AE66843EFCA0A4A4E4CA9F52ED974756F092214408BAEA44" + }, + { + "path": "RMQ/Core/WordRAM/Packed/RegularLocate.lean", + "mode": "100644", + "gitBlob": "26e636e0cd038f1783541ab60545d6c0bf025bb5", + "rawBytes": 5670, + "rawSHA256": "047ECF38990BD410085689FDE702417C035785C59C738BA6E1D66B248709D360" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Safety.lean", + "mode": "100644", + "gitBlob": "a2aa663ac41075c94a9f973c7c6c83dd53a35328", + "rawBytes": 43628, + "rawSHA256": "EF0273D4B16F5876A949CAD219EC421864D7533FDDD5BB492BFF360C0134CC1C" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Scalar.lean", + "mode": "100644", + "gitBlob": "ba905d2a82b6e5947fa62baf346ba3ae2c380e4c", + "rawBytes": 3522, + "rawSHA256": "5D25C758D77F5523DF8AE1C1136AE85FAE12BD9B11BCB6E472DBFABF97506493" + }, + { + "path": "RMQ/Core/WordRAM/Packed/ScalarSafety.lean", + "mode": "100644", + "gitBlob": "9490454d58fb0c531469f12934f5cc04370954f4", + "rawBytes": 11712, + "rawSHA256": "E7AFB1FB9E238AD9F051DFC5236E3E095EF259B4D0CFD875E4A757C10AF858BC" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Scratch.lean", + "mode": "100644", + "gitBlob": "ad08e91a31b1323abdcb3c7b8d4c50be3971bc92", + "rawBytes": 4433, + "rawSHA256": "320DDD6C1F6549902951B99CCF99C66B231D2A0106487A710D8638372EF32E64" + }, + { + "path": "RMQ/Core/WordRAM/Packed/SelectProof.lean", + "mode": "100644", + "gitBlob": "1a1d2bfe44a2bb29ed46b6cc2266617d1db3ae9c", + "rawBytes": 162352, + "rawSHA256": "292AD12DC2879B2F523B29300DB2E5251AEA57BBACC5AD2154B2660DAF8946FB" + }, + { + "path": "RMQ/Core/WordRAM/Packed/SelectSafety.lean", + "mode": "100644", + "gitBlob": "42e973fa4096490518fabbd098ff960ce49a1624", + "rawBytes": 121690, + "rawSHA256": "43C6C183A6B08B38B58521C42320F56A7AC87C27D23DC7AAF0DD5F73EEFC13E3" + }, + { + "path": "RMQ/Core/WordRAM/Packed/SelectSource.lean", + "mode": "100644", + "gitBlob": "893b7deee585ac83ed3121312d476b695574233f", + "rawBytes": 9735, + "rawSHA256": "9C41270FE301B417CA622E523F6546E1EB4CB707FDF68D38F64F2975A97C9A5D" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Setup.lean", + "mode": "100644", + "gitBlob": "9fc02c520da4b841a3a519d833e251c6d90e5d62", + "rawBytes": 20542, + "rawSHA256": "B1BEF6D6859A63C33E8ABD31387697012C002209503D3E13F79B2C8145E6A918" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Span.lean", + "mode": "100644", + "gitBlob": "2631671b135a4400597b4b266a1430f23b8be00c", + "rawBytes": 15105, + "rawSHA256": "54E1A81BDDE51E0C460C9BA5ADFD57A04254FE5D14CA6A77259F4108A64584B7" + }, + { + "path": "RMQ/Core/WordRAM/Packed/SpanAssembly.lean", + "mode": "100644", + "gitBlob": "0e8cd2d15968d0425355049571dbe484fa4d118f", + "rawBytes": 26016, + "rawSHA256": "EA0B7CA706C9750A6E0CDF6220F5F8B411A54CEC33CFADDDED4F010020239106" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Structured.lean", + "mode": "100644", + "gitBlob": "680f1585b4d833318b86b67b5f511c258a66d563", + "rawBytes": 4052, + "rawSHA256": "F7F580A6A5E7BE2BED61F3C126AC83720046FE3A3D18C07286CF6B5AEF81A887" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Width.lean", + "mode": "100644", + "gitBlob": "a776d3e2ba49ab867683dff49deb7956b6a0cc02", + "rawBytes": 25342, + "rawSHA256": "6FB1D7DFE053E4A415B861819E46E448750EE056F8A0A6CAB8ED904277F9F9E5" + }, + { + "path": "RMQ/Core/WordRAM/Packed/WindowProof.lean", + "mode": "100644", + "gitBlob": "0b65303bb54e5e30b5ca1f09b58540979407854e", + "rawBytes": 20240, + "rawSHA256": "B0923835A5B9039D6041C15DE61D2FD02AE3BEA82AD79B83B7726FCDCC9D8408" + }, + { + "path": "RMQ/Core/WordRAM/Packed/WindowSafety.lean", + "mode": "100644", + "gitBlob": "42cea2741f64970b5819e52974db7335d53d20a8", + "rawBytes": 19064, + "rawSHA256": "21C514E1A3CD6E90B8FA31FCAC2BB71D147D5BAF66E0EC3B47CBDC7FCF394FA4" + }, + { + "path": "RMQ/Core/WordRAM/ReadStoreEval.lean", + "mode": "100644", + "gitBlob": "35435e9d3b9e224b458f8fbf898d7736757a3d8d", + "rawBytes": 29601, + "rawSHA256": "862496D886BE52077FD0B6F9A8AD6D4E49EE0C39234DCD3213C3DF33300397D2" + }, + { + "path": "RMQ/Core/WordRAM/Register.lean", + "mode": "100644", + "gitBlob": "eca2029a512cdbae6596467ccb0898139b45af13", + "rawBytes": 39440, + "rawSHA256": "93284E2A6DCACF9C3B425C3267EB8A0568E38CB2CDB083D21EC93FCDB32B783D" + }, + { + "path": "RMQ/Headlines.lean", + "mode": "100644", + "gitBlob": "b6072633607106b0d20372f551f5f5c92f10865b", + "rawBytes": 7201, + "rawSHA256": "FB71FD41FD5A395A725A9500023FD3F46363CC599EAACBA7AC0624BD9474CFD1" + }, + { + "path": "RMQ/Headlines/Lifecycle.lean", + "mode": "100644", + "gitBlob": "0ad61bd2b279519a254e2b4b412366eca6e5b7d1", + "rawBytes": 687, + "rawSHA256": "989B80022D6286E66033A99462C28AC346312D4454A41FD1360F11A6ED269AE4" + }, + { + "path": "RMQ/Headlines/RMQ.lean", + "mode": "100644", + "gitBlob": "4411ba0c8c555efa181a19ead7ff28751dcd0e3e", + "rawBytes": 44746, + "rawSHA256": "1B0703827DA6802B22649DF8CEA6C49BFD66E5F3F3E6F24EECBEA4658761E3FC" + }, + { + "path": "RMQ/Headlines/RMQCompatibility.lean", + "mode": "100644", + "gitBlob": "2ab3a1a46b8f7f7d2325564bcd402648ab794913", + "rawBytes": 9464, + "rawSHA256": "22E197BE5CC074B088460CDD19148E4283304C755DDD4E0C692467A156582546" + }, + { + "path": "RMQ/Impl/Equivalence.lean", + "mode": "100644", + "gitBlob": "fdeab7d65d2f6310cdf9a0f4f766e28731e8ede2", + "rawBytes": 8235, + "rawSHA256": "CCED314E3758108D9023D6927A58B6CF49DCC5C727E2B78AA2A05C5AFAD0AC36" + }, + { + "path": "RMQ/Impl/FischerHeun.lean", + "mode": "100644", + "gitBlob": "6ae0c496a2c200a6fd74c6b285ed0c9a422f5343", + "rawBytes": 82108, + "rawSHA256": "52B3DDAED6FEB9982AFFEC6FDCA9CEE0D73C57FBE388AB670D98F00DB45DF4A3" + }, + { + "path": "RMQ/Impl/FischerHeunCost.lean", + "mode": "100644", + "gitBlob": "b0875b2474683f5a96a1a03aeb2892040b37e311", + "rawBytes": 20541, + "rawSHA256": "1C4108A5B4D2E12D5F70DD00AEEEDBB1701FAE2C5063FF24C7556B639F5FA7F4" + }, + { + "path": "RMQ/Impl/HybridBlock.lean", + "mode": "100644", + "gitBlob": "8f627f319efb9253d42f2d5289a47c542f94ff9b", + "rawBytes": 21313, + "rawSHA256": "6E2B60C9912E30DBCA95DCBF6D91687A155B55C0417AC5B002BA54E1F32A4072" + }, + { + "path": "RMQ/Impl/LCACost.lean", + "mode": "100644", + "gitBlob": "f1667aa132ecc4a3e0d2eb4be51b3c1bcbe2f156", + "rawBytes": 58796, + "rawSHA256": "E9550C8CD1ACB63F1A11BFF7D5B440EBFDF2D5736C32DBF706E3AE2F50C63618" + }, + { + "path": "RMQ/Impl/LCAFischerHeun.lean", + "mode": "100644", + "gitBlob": "72098e48cafc01af47c07ea1ea815e0c5ec0a88b", + "rawBytes": 34730, + "rawSHA256": "BCAC2C38F5473504C5F42CC991E57CAAE682740BF43B904CECBB077DBA47B3A3" + }, + { + "path": "RMQ/Impl/LinearScan.lean", + "mode": "100644", + "gitBlob": "2b4132443e230e922c3e563d7cdd9034da262bba", + "rawBytes": 2878, + "rawSHA256": "45C4A2B92FF08DC802571AA726381DFE3930D861A769FD3529E0A45A50BCB208" + }, + { + "path": "RMQ/Impl/PlusMinusOne.lean", + "mode": "100644", + "gitBlob": "9d5d1336208da32e6a8ed5f8cc8b164426ee4bad", + "rawBytes": 3658, + "rawSHA256": "0F410278B15EAF10D160B9D8504D247579FC674A47F424FF2E1C8FCF7357309C" + }, + { + "path": "RMQ/Impl/RecursiveHybrid.lean", + "mode": "100644", + "gitBlob": "f8620ecf0e7e89bb3864901bb0e4e8eb25141baf", + "rawBytes": 9144, + "rawSHA256": "3B389A2E68278A919DBB2D470A259B67D375F607E004DDC8F804DA442D6DA931" + }, + { + "path": "RMQ/Impl/RecursiveHybridCost.lean", + "mode": "100644", + "gitBlob": "2e0a0697173eaace00fc9f5780f3d25e9a14644a", + "rawBytes": 10711, + "rawSHA256": "E03F0ED4A547FF9D3A6F8E45D6447394D179B23ECBA61096C79EA1F997DDD229" + }, + { + "path": "RMQ/Impl/SparseTable.lean", + "mode": "100644", + "gitBlob": "ca40d0a916ac41b7e6d9ef324ecf112f2bcdf459", + "rawBytes": 11287, + "rawSHA256": "9384FBAC678F74FD7E8B1B0C646AE55C42EE0CA78557C770B5C93099817FE69C" + }, + { + "path": "RMQ/Impl/SparseTableInstrumented.lean", + "mode": "100644", + "gitBlob": "f5838d5e2ee6d1e8bbdb59ecfdf235e09e3ec923", + "rawBytes": 33186, + "rawSHA256": "BEE384F2F29E57BCD71E1B9DC77C85F6B9DE36FFC40552513AE1CF835367BE76" + }, + { + "path": "RMQ/Impl/SparseTableMemoCost.lean", + "mode": "100644", + "gitBlob": "7ab7db7d6b690b1bba46def1ba026762bcfeba71", + "rawBytes": 16091, + "rawSHA256": "EF2E212C2391E7312DF93925EB3618F9F22357B4EEEF6EAE3274B31B00E46FF6" + }, + { + "path": "RMQ/Validation/.gitattributes", + "mode": "100644", + "gitBlob": "26dabad73bbdf2a327967dad24c74389970ba652", + "rawBytes": 107, + "rawSHA256": "AC74EC4BE7080E08E819BA40FF241A4A351CEA1EFE44997C5F722345A2FF51E7" + }, + { + "path": "RMQ/Validation/EGCPFinalFalsification.lean", + "mode": "100644", + "gitBlob": "e761c7f4b7abdd38e84448e09991ea336c2ef212", + "rawBytes": 152858, + "rawSHA256": "8ED9529DB28EE3A5E964B4305A32BB3E776AA9EC9766673ADF6E4A6BFFDF7AFC" + }, + { + "path": "RMQ/Validation/EGCPStageA.lean", + "mode": "100644", + "gitBlob": "bb94d1b7c5accfb982027e5175fcd3bf1a064067", + "rawBytes": 37004, + "rawSHA256": "96E5F6A0EFC5C87738B1570DECE59D2CA0C81331A2E7B57F79B1CBEFACC70773" + }, + { + "path": "RMQ/Validation/LifecycleContract.lean", + "mode": "100644", + "gitBlob": "cb87275bec76845642e33406c1c6496fc0379192", + "rawBytes": 12403, + "rawSHA256": "F7022AC916813779745B9847B43D9091A90F4F2356615BDBF3B560F2861AD9EC" + }, + { + "path": "RMQ/Validation/LifecycleNativeContract.lean", + "mode": "100644", + "gitBlob": "d6c52fb86b7b7ee89b3f9ea81f5901a796efc0b5", + "rawBytes": 47095, + "rawSHA256": "BA96FB82CF0DF9C44981CF5DFD1559E058783C62A30D872A3E1327555B354555" + }, + { + "path": "RMQ/Validation/PackedBitvector.lean", + "mode": "100644", + "gitBlob": "702061d81a8595ad940019bb5ec572e768eb78e7", + "rawBytes": 9387, + "rawSHA256": "333B0A6BD8FB3082051845D2F1BD333668B9D33758A9030A68B25695CFEE068E" + }, + { + "path": "RMQ/Validation/PackedLifecycle.lean", + "mode": "100644", + "gitBlob": "69d6ade9d2ec84521c208b559af1912561b80316", + "rawBytes": 14971, + "rawSHA256": "624236001FC72817441CC3DC536DA9C299CCB1DC9C050687B09896B7F1679C14" + }, + { + "path": "RMQ/Validation/PackedNative.lean", + "mode": "100644", + "gitBlob": "a759468a851ab432eebfa22d315f70d6e74945e0", + "rawBytes": 13565, + "rawSHA256": "437808A44FA6AAA92422B544B2036AD2F6CDFAD79297DF8BF94BFB402E081EF7" + }, + { + "path": "RMQ/Validation/PackedOptimized.lean", + "mode": "100644", + "gitBlob": "dfc6b3639a7224ec900c05736f512d28cfd21088", + "rawBytes": 12485, + "rawSHA256": "894A4048230E1ED095EAB24BF78E8EE594251579C5BDA1163185722AC821EEED" + }, + { + "path": "RMQ/Validation/PackedQueryContract.lean", + "mode": "100644", + "gitBlob": "1862749764fbacf3460faae49a7392b9aa98f73f", + "rawBytes": 21736, + "rawSHA256": "01F6A3F2B77F86D2C647D963EED8B6E79188F7C2D381EADCF96B128E2B52B1BD" + }, + { + "path": "RMQ/Validation/PackedQueryRuntime.lean", + "mode": "100644", + "gitBlob": "46399d6ed85585e4d2b2e061b0a89a0b15553c96", + "rawBytes": 12838, + "rawSHA256": "2F84A5E5B5C4470A07E9455B1292D8967239BC170D9D75FC0555BE9F8FF14FE4" + }, + { + "path": "RMQ/Validation/Preprocessing.lean", + "mode": "100644", + "gitBlob": "357d646ec8d701a93609657bf187f4db72a0e085", + "rawBytes": 11578, + "rawSHA256": "12FDF7FBEB1E40CA038CACB97F100E2ED5319471522D0BFA6E115F4DE04A98E8" + }, + { + "path": "RMQ/Validation/PreprocessingContract.lean", + "mode": "100644", + "gitBlob": "edcfca8e096f62db1eee312826f43c112932b22e", + "rawBytes": 88557, + "rawSHA256": "5893C423560DDCCF5FC63F8E7BA58C6334F90F70E1D6AF3C9E1735C1FBFEEB2E" + }, + { + "path": "RMQ/Validation/SuccinctClassic.lean", + "mode": "100644", + "gitBlob": "42658ef96a3f28283d3812b95596d7cd4db3a8a1", + "rawBytes": 18280, + "rawSHA256": "48883DC1C7FFEE53C69425F81560F72467F39F2D5B70E075B66C8C2B75D3DDC6" + }, + { + "path": "RMQ/Validation/SuccinctClassicCostHarness.lean", + "mode": "100644", + "gitBlob": "3f362837f206559783edd4b7ec616ad87af247ad", + "rawBytes": 27425, + "rawSHA256": "95ABCB4D3302CEFF84F14BBFA88D65D425867BF408C4C8BCB7E026080B6D33D8" + }, + { + "path": "RMQ/Validation/VariablePayloadLowerBound.lean", + "mode": "100644", + "gitBlob": "9dbf530287981149d5c8ae099b7cac34d9ea5c86", + "rawBytes": 29145, + "rawSHA256": "DFCEBF64749A43348FF7786C7305D01152093F469C6CF817405CFE8C90814598" + }, + { + "path": "RMQArchive.lean", + "mode": "100644", + "gitBlob": "2a75e345b97a0471346159db82425bfca499c32f", + "rawBytes": 217, + "rawSHA256": "E2E8CBDF62B8AF143AB21D2E31F5EAD8E2299C904311FEF8DC979BFF9DF9E704" + }, + { + "path": "RMQBPNavigation.lean", + "mode": "100644", + "gitBlob": "13d99a09bff63c97392a2e6de62b1d75b4688193", + "rawBytes": 2022, + "rawSHA256": "74D883C55E5492A73C5AFB9123D62DC24067E23521EAB0695C684766D8E1F167" + }, + { + "path": "RMQExamples.lean", + "mode": "100644", + "gitBlob": "ead80ae7ed6bf6be72066e7bcb5aa269f22bfc6d", + "rawBytes": 353, + "rawSHA256": "8156EBD4D3F50075F710F912307312676FA8E9593F8206114569A945852C3B28" + }, + { + "path": "RMQExamples/BPNavigationImport.lean", + "mode": "100644", + "gitBlob": "1fa4c62a9dab4c8e1eb6f471841fde5db05672a4", + "rawBytes": 1956, + "rawSHA256": "C3BAEDC76EE811FCB28080061E93494DD7A87876BFADE213BC5D57D6E37A8509" + }, + { + "path": "RMQExamples/Concrete.lean", + "mode": "100644", + "gitBlob": "82c72907f49bed98eb069c2865dad5a8c540377b", + "rawBytes": 11051, + "rawSHA256": "999523D23318CA959F8C9EB5C3BB4005995F15D59C8513638233183CAE5F6D52" + }, + { + "path": "RMQExamples/LowerBoundImport.lean", + "mode": "100644", + "gitBlob": "7a91da9876659eb2196c434b6d203d967e40aef4", + "rawBytes": 440, + "rawSHA256": "12052183C19045768FA576BA54E744CD0CCFA208C5FDBFE3342509DA59CACBEB" + }, + { + "path": "RMQExamples/RMQHeadlines.lean", + "mode": "100644", + "gitBlob": "5a17994899922772a2ad4d120d514ef91a253729", + "rawBytes": 1426, + "rawSHA256": "8CE6B0A60EB512FA98A322CCB109EC5F3B57544FF00E4F8779F154D3C7244936" + }, + { + "path": "RMQExamples/RankSelectImport.lean", + "mode": "100644", + "gitBlob": "8a7071f6bc781a65454f8ea63ea85758357b01ec", + "rawBytes": 1613, + "rawSHA256": "81325EA75D985130B35313185E6AE0A7CC2B6896AD5F6AF240DAE5DA4B4BBF42" + }, + { + "path": "RMQExamples/UnionFindImport.lean", + "mode": "100644", + "gitBlob": "47aa1bb122f510fabb0924934a36d8ff52ffa44b", + "rawBytes": 812, + "rawSHA256": "2DD1AFDEF4A2040C332EE244020E5B33EF9304631FD1657C48BDB79562274504" + }, + { + "path": "RMQHub.lean", + "mode": "100644", + "gitBlob": "519416922e5c33415a687e53f45bd867fd231b4b", + "rawBytes": 297, + "rawSHA256": "D56A4DB9EDE4FF8E34B20A3D3F4A4D4B7693482392F68C3FAE570FF317200544" + }, + { + "path": "RMQPaper.lean", + "mode": "100644", + "gitBlob": "14f3f66c82c0a340e67af42f0411c1bc67ecbdc6", + "rawBytes": 787, + "rawSHA256": "7583544715DF9F29F6747A327CA38A48F448AB329173916F430BC6C3AB93FAF0" + }, + { + "path": "RMQRankSelect.lean", + "mode": "100644", + "gitBlob": "91ddd891416da473b234c2f3c10dc6e24ab40a5a", + "rawBytes": 2854, + "rawSHA256": "F1CEF44E3E309373F5E125B40897C315F72F2A8B07BCAD05F2F13988D21D2BE0" + }, + { + "path": "RMQUnionFind.lean", + "mode": "100644", + "gitBlob": "2a5a9bd133c39b02118dedefcdec7c5241601a30", + "rawBytes": 13745, + "rawSHA256": "C15BA8E45198C46C8C5E31B4A571D6351995E1B4784CE61383BC6F93D613709A" + }, + { + "path": "VerifiedDS.lean", + "mode": "100644", + "gitBlob": "04e59c51cc5da1502b9fdf66e8926d1c23ae234c", + "rawBytes": 799, + "rawSHA256": "B5A0F4EBCDBD59135CFEBC03ECFAAB57286448FA067BFB20D20B116CEE60F63C" + }, + { + "path": "VerifiedDS/BPNavigation.lean", + "mode": "100644", + "gitBlob": "433cf90a05fdddc0fe57963861f87d50f2ffe78c", + "rawBytes": 279, + "rawSHA256": "3851302587CFEAABA9AEC1C0A652967B6D6FF94E08A0AA2E740580C7965738A3" + }, + { + "path": "VerifiedDS/Hub.lean", + "mode": "100644", + "gitBlob": "f0a84d6c204590a8b64fba456e8fa1af96ddd403", + "rawBytes": 394, + "rawSHA256": "137DF45FE00021F19F9ABA0D1C170AEA7BBF0F06DDFA1A978D5D56E7CDAA67E5" + }, + { + "path": "VerifiedDS/RMQ.lean", + "mode": "100644", + "gitBlob": "3411da19f09add718ce43641cc5fc04f5304fcec", + "rawBytes": 326, + "rawSHA256": "26E398A29C91E875FCB48AAAB46FA603E491EA5F250E5812DAC425F74A36639C" + }, + { + "path": "VerifiedDS/RankSelect.lean", + "mode": "100644", + "gitBlob": "5b55b874edb8f62686fca54705602a9a57e2a834", + "rawBytes": 328, + "rawSHA256": "26702BCF437F2DCC02599D0FF8753805EE5C45C7BEE0996E99636B6D7DBAFAAE" + }, + { + "path": "VerifiedDS/UnionFind.lean", + "mode": "100644", + "gitBlob": "f169bad9c58158536d63a726c1c3513fa3449ec8", + "rawBytes": 21800, + "rawSHA256": "6E79CC628AEBD259C25EBCC799A220FA65D55AE557C111551213F369CC609BD8" + }, + { + "path": "VerifiedDS/UnionFind/Forest.lean", + "mode": "100644", + "gitBlob": "3713c97ba25bca8a33c5eec8356facf873e6ea48", + "rawBytes": 796, + "rawSHA256": "FFAF07ED86FCDBB4F1887C440082010EFB7F3012B0C5BFD5E906459CCB1C5D13" + }, + { + "path": "VerifiedDS/UnionFind/Forest/Amortized.lean", + "mode": "100644", + "gitBlob": "39fc20f1610f7618f411992321064bc17059fa51", + "rawBytes": 30429, + "rawSHA256": "01FBBB2309E1A85857B2A8DA30BFB282A9198430387C25E17EC3F7172C937228" + }, + { + "path": "VerifiedDS/UnionFind/Forest/BackendOps.lean", + "mode": "100644", + "gitBlob": "f6b89fc8a0e36475478e677ce438119d154a5780", + "rawBytes": 52287, + "rawSHA256": "457622B148B1C5016F1E834B985AC63723AD503ADB4072F718D9DC784F5A53F9" + }, + { + "path": "VerifiedDS/UnionFind/Forest/Base.lean", + "mode": "100644", + "gitBlob": "3f2183c884b9af563ac10a28bb9a8f99d6dc28e5", + "rawBytes": 122271, + "rawSHA256": "20D06974E67C14E6330F79DEA290EA8B780326F16144021FB3691DDBD5423CDC" + }, + { + "path": "VerifiedDS/UnionFind/Forest/NoCompression.lean", + "mode": "100644", + "gitBlob": "f0e446f4e9d300ea252b94ca44e6b5aee402dbdc", + "rawBytes": 25086, + "rawSHA256": "DC247F6594551F78149F93777E719A006BF631FD97EC3DE83EA9CA1EAEFF1E57" + }, + { + "path": "VerifiedDS/UnionFind/Forest/PotentialProofs.lean", + "mode": "100644", + "gitBlob": "0520c04917567f4194be50ed6079d06d7d1323f8", + "rawBytes": 75885, + "rawSHA256": "9B5CD389AC103ABD0898B369D7FE64FEEAA2288450969E51824A72BF47199A89" + }, + { + "path": "VerifiedDS/UnionFind/Forest/Potentials.lean", + "mode": "100644", + "gitBlob": "b38697b9c2e098d3ce194a2462910ac609054d9a", + "rawBytes": 25740, + "rawSHA256": "72080D765E29016DA66D9AE84D4BDB3AA3C9E79A036F0A40F97B699A6A134B92" + }, + { + "path": "VerifiedDS/UnionFind/Forest/Reference.lean", + "mode": "100644", + "gitBlob": "bfb6f36c8052cb406a7f64a6f7ec00461491404f", + "rawBytes": 9008, + "rawSHA256": "03906C94D5EA14C0C783C00603E5BF687E99879628B0FE6EB97090A84E83273C" + }, + { + "path": "VerifiedDS/UnionFind/Sequence.lean", + "mode": "100644", + "gitBlob": "f3118eb08d02d6cf70fc37e6cc17002cb358e7f2", + "rawBytes": 25608, + "rawSHA256": "05A15CCC89F74C88EC8718FAEDF91C0A5C58D583221864F7996C2872E1AD386D" + }, + { + "path": "VerifiedDS/UnionFind/TarjanEvents.lean", + "mode": "100644", + "gitBlob": "822d8fe65571515e1daafd53bce50b752818b1f5", + "rawBytes": 106912, + "rawSHA256": "5F8C7E692D500C8D00BDF135E9E329729C2058BFD05D6198F43AD213FB5265B1" + }, + { + "path": "artifact/CLAIMS.md", + "mode": "100644", + "gitBlob": "3bfc6fc7fe905b123608539752bd97d1a4593103", + "rawBytes": 22134, + "rawSHA256": "7C0220C36E0C57CE60C3772D79254EA3A709583965D00CEB9EF07872AD02B697" + }, + { + "path": "artifact/README.md", + "mode": "100644", + "gitBlob": "235975868c8a484c5cc1a7c9b6a1a37f60b1ae37", + "rawBytes": 9868, + "rawSHA256": "0786161A511128DFB4BE3730CC657D19BB2590B3D6150C81153EED215FAA99FC" + }, + { + "path": "docs/ADD_PROVENANCE.md", + "mode": "100644", + "gitBlob": "a09581e68eebfed57e370be40bb7ca0d28064708", + "rawBytes": 14398, + "rawSHA256": "7F044DDA48DD6020B0757F79D7FD1B98BBB74AA349E2CA10D670C5CBEC09AA76" + }, + { + "path": "docs/AI_ASSISTED_DEVELOPMENT_NOTE.md", + "mode": "100644", + "gitBlob": "02b9280a175a8a687122ae5ffcf3a657aa452fab", + "rawBytes": 1786, + "rawSHA256": "96FAFE668251BCB9A9D5F47CA4695C360E675AA9A966E107C0EC4A356DE0A4DE" + }, + { + "path": "docs/ARTIFACT_REPRODUCIBILITY.md", + "mode": "100644", + "gitBlob": "cede178ff2a119fcdcad436481b73e25a3e0a238", + "rawBytes": 4351, + "rawSHA256": "F586E566F540B619F563A064A9BE4FC8B24A618FD6820B5B942DED619F4FF1D1" + }, + { + "path": "docs/BP_NAVIGATION_FRONTIER.md", + "mode": "100644", + "gitBlob": "588080a108a7887822a09adf2d910a008a780f0f", + "rawBytes": 15495, + "rawSHA256": "755D40BD8E1DC0051F04A808FB6B91468775B1BE07F8044574878B0863A53043" + }, + { + "path": "docs/CLEANUP_AND_ROADMAP.md", + "mode": "100644", + "gitBlob": "eaf4da5f1d2281ba9e369727de1ded452b77ea11", + "rawBytes": 25004, + "rawSHA256": "F9C55919F49EDF095C41529BCD638535C0B67936F18BC22F1799184D0DF1F9DE" + }, + { + "path": "docs/CODE_MAP.md", + "mode": "100644", + "gitBlob": "46d96a75efad3b38f4a097dbb9cdfc7bb82b9d5e", + "rawBytes": 10970, + "rawSHA256": "D4E3CEB5C6EF18F077F6C0EA19847A9C0D12345E5ADB621CDA9FD359760BAE07" + }, + { + "path": "docs/DESIGN_FRONTIER_OBSTRUCTIONS.md", + "mode": "100644", + "gitBlob": "76949015c11f53e0c178aa9b85ca5390318b08e7", + "rawBytes": 12517, + "rawSHA256": "237558DA1DF3CDC7510DA60305B339CD505626D321A5A447446E51BED818DDE9" + }, + { + "path": "docs/DIGESTION_LOG.md", + "mode": "100644", + "gitBlob": "840b11567ec10cb1126a086587e42ea760a07d12", + "rawBytes": 137841, + "rawSHA256": "80F095F5E36FC9762971B31026C433F6BED5768C9A4D51C71010590563FB5813" + }, + { + "path": "docs/FAMILY_SUMMARY.md", + "mode": "100644", + "gitBlob": "8e23fc0b539f73502140b08361990f5e65a04776", + "rawBytes": 263192, + "rawSHA256": "BCDF2E3607F276EDADBF9D96E75A66F645C90F13522967D872C9BD78B3DEE114" + }, + { + "path": "docs/GENERIC_SELECT_REFACTOR_SCOPE.md", + "mode": "100644", + "gitBlob": "b5d866fd91d2a89b84dea8e2232b9b17cd14a41e", + "rawBytes": 7392, + "rawSHA256": "F5514B395D486956B8E331526A01B1E5AC5EC6DD72C250F79339B7CCE910A637" + }, + { + "path": "docs/HUB.md", + "mode": "100644", + "gitBlob": "2d76742cd8343b838a0e79c0dfe494747a5cada4", + "rawBytes": 3333, + "rawSHA256": "4DD923FC85D9AFAA33CBAC9C40F89AD2E907FC8240998248937A408590898006" + }, + { + "path": "docs/INDEPENDENT_CHECK.md", + "mode": "100644", + "gitBlob": "a7a088158e7d24733a5f72cb128cef01591051ad", + "rawBytes": 3800, + "rawSHA256": "3EC0C4D14EB3F71010CD3CF18A90683E0A5BB9173514FF17AC8BC148BEC228F0" + }, + { + "path": "docs/PAPER_CLAIM_CORRESPONDENCE.md", + "mode": "100644", + "gitBlob": "1d7fdffc49820a5452133eec6f0431df938cf651", + "rawBytes": 28735, + "rawSHA256": "0C20CB3092758E8363BFA8190E767F74486AC452C5A85C48C4B732FE5F2E89A6" + }, + { + "path": "docs/PAPER_MAIN_THEOREM.md", + "mode": "100644", + "gitBlob": "ace4407ddaa578db16a2d64f19cd70effcf64dc5", + "rawBytes": 9786, + "rawSHA256": "1733F0E1C8C97EB4C077FD279A3E94B30764880DD6B684F837FDBEE820A20B4C" + }, + { + "path": "docs/PAPER_MODEL_ADEQUACY.md", + "mode": "100644", + "gitBlob": "dfda528a280b220d02c5f56f1dac1ae84e64b999", + "rawBytes": 27210, + "rawSHA256": "3E7C1E71C91E1E0CEE656B2AEE05423B2FB16CC1831F19C671B204CB67BBA2BB" + }, + { + "path": "docs/PAPER_RELATED_WORK.md", + "mode": "100644", + "gitBlob": "89bc05f09002541702f23e943e9966f2765b4a73", + "rawBytes": 8688, + "rawSHA256": "63DEC791CDA51C6BE5EA157E3210CBCE3C064B48DB0BC4A2C0E6AE996A770A20" + }, + { + "path": "docs/PAPER_THEOREM_MAP.md", + "mode": "100644", + "gitBlob": "55dad2e14ac9157899d48820c02744df73e8d4cc", + "rawBytes": 15517, + "rawSHA256": "6A65EC3C44C6B82B9F7BE5AACC248F5A2BDB71FAD4A69E2836C646EEC275341F" + }, + { + "path": "docs/PUBLICATION_STRATEGY.md", + "mode": "100644", + "gitBlob": "788593c1a2620ae62ea5d1a0dc436d6a39c76b63", + "rawBytes": 15320, + "rawSHA256": "7C030D2A663F32B78A19803FCE6D231ACC3E96B71D24A98A331FA66BFDDC7462" + }, + { + "path": "docs/RANK_SELECT_FRONTIER.md", + "mode": "100644", + "gitBlob": "19ea58cfdc2163a4f67636aeb295e839b2702dc8", + "rawBytes": 56713, + "rawSHA256": "F90E27A9F0247EC2E4EC9EC43A3747947337062B51C21A02EA69F59DBA30196B" + }, + { + "path": "docs/README.md", + "mode": "100644", + "gitBlob": "6a6479c2bcf8d664039d467a9dc61288329645ac", + "rawBytes": 5354, + "rawSHA256": "3C89AD41D454B5BA47857455B1451476757277D4627961EADD3A474024495F86" + }, + { + "path": "docs/RELATED_WORK_AND_LIMITATIONS.md", + "mode": "100644", + "gitBlob": "7c2e614c596174e4bb27ab79c448b36ea8f4566f", + "rawBytes": 4470, + "rawSHA256": "DEB52F76C995E2BC519F564E91B5E0712E01D3ADB02B1F5A1616B87709567C5F" + }, + { + "path": "docs/REPOSITORY_STRATEGY.md", + "mode": "100644", + "gitBlob": "24ec5930892f8d2e79545121214c48024c86625f", + "rawBytes": 4740, + "rawSHA256": "6827392394C750523A1E96CD6EA6EE82371E73F98AF489E21EDE126A9E098776" + }, + { + "path": "docs/RMQ_EXTRACTION_FRONTIER.md", + "mode": "100644", + "gitBlob": "7697a757bc3d0de5a8bb9e475b98ba7566483506", + "rawBytes": 4113, + "rawSHA256": "96760B9360B7D5CA0B679453672EF7864EB00745A7F1ACBFE6ECD0CA230E36DB" + }, + { + "path": "docs/RMQ_IMPORT_CLOSURE.md", + "mode": "100644", + "gitBlob": "0db19bd5c87e5fa92b9d57955dd08071182a816d", + "rawBytes": 6260, + "rawSHA256": "ADED17637F124A674A7C11C2263B7F1F4AFA56DA45DA42CEEFA7CE3CB2CA3584" + }, + { + "path": "docs/ROADMAP.md", + "mode": "100644", + "gitBlob": "d3d421f88644ece0f2d834e1c0189e457b66d582", + "rawBytes": 44671, + "rawSHA256": "F1E9D5B0475188F3F67A2DDED5C7AA87730AD5DF04A84B24EE064C5FBC44A59F" + }, + { + "path": "docs/TRUST_AUDIT_PACKET.md", + "mode": "100644", + "gitBlob": "a6b0f8b9c84fdd120f9af3a33ca46ef9b65a2b5f", + "rawBytes": 9958, + "rawSHA256": "2FAFA5D1E4CF5D51B5947280F26644B90E155A8EF1D1155BCDAF976E93BE7432" + }, + { + "path": "docs/TRUST_BASE.md", + "mode": "100644", + "gitBlob": "ae2574658093410c16b143c91ab3ce565b0f1ada", + "rawBytes": 3755, + "rawSHA256": "7ECF5B8AB4055505EFB2FBC04E3EDBA5F99C4095D49563DA3EAEB5425947C84F" + }, + { + "path": "docs/UNION_FIND_FRONTIER.md", + "mode": "100644", + "gitBlob": "2f51367d588989ec81050fcfb1ba2a26c10d4d5d", + "rawBytes": 59337, + "rawSHA256": "9EE00A4E7B0D903B6AB86182F11430DC61822619349D8D38C6DE83181876B1FA" + }, + { + "path": "docs/WHAT_IS_PROVED.md", + "mode": "100644", + "gitBlob": "fcb8d780d8f8a41d88b8c67d4157b80098ef8760", + "rawBytes": 56552, + "rawSHA256": "81DAD0BD1D323B37622EF28A139684C8048925FA2285A3BE02B3460D67C0E3BA" + }, + { + "path": "docs/WORD_RAM_REVIEW_PACKET.md", + "mode": "100644", + "gitBlob": "49461932ce3dbb908c99c6a8fc0441027957c98c", + "rawBytes": 13498, + "rawSHA256": "3DB4397DE2B733029E38609008A69818A8BF7093E22431350CFE858BE43CF288" + }, + { + "path": "docs/digests/COORDINATOR_COMPLETION_LOG.md", + "mode": "100644", + "gitBlob": "c181568cd483f6c792d71ea94f9fa491b497e7f6", + "rawBytes": 6721, + "rawSHA256": "0C2FF3B85806131013F4DCDC557B4E6C859EDD1B792352629AAC26595B497FEB" + }, + { + "path": "docs/digests/DEEP_PROJECT_DIGESTION_2026_06_28.md", + "mode": "100644", + "gitBlob": "0987ec0e5470ce977f640849e8f564eb7d3d2543", + "rawBytes": 40254, + "rawSHA256": "BAB09EED7B25890F595DA25C48979ACFB0C5D8BFD7E0F47D6BC225316269A801" + }, + { + "path": "docs/digests/LIFECYCLE_PROOF_GUIDE.md", + "mode": "100644", + "gitBlob": "e343d1c9b575ed2edc0e873bc348c888ff2fd864", + "rawBytes": 9262, + "rawSHA256": "9C43098ACF0D96BA74EA6A9D6E2CA5382277568E3E326DE46307B2F4CDE44C2F" + }, + { + "path": "docs/digests/PROJECT_DIGESTION_CURRENT.md", + "mode": "100644", + "gitBlob": "c7623b0d37e8406b71481dbdfec1eb2e370f2e07", + "rawBytes": 13370, + "rawSHA256": "26D32D8761D94E25D408DC210656D30AF250EF180EE6DF35C65879C36E7ED424" + }, + { + "path": "docs/digests/PROJECT_STATE_2026_06_28.md", + "mode": "100644", + "gitBlob": "109c282d8bdabfcd5418c5220e126e0f840f2941", + "rawBytes": 15749, + "rawSHA256": "7E7749709D9E1D5A729CB2B0A83592678B121ACB330383E5BD83FAE27A0E4EA9" + }, + { + "path": "docs/digests/RANK_SELECT_COMPRESSED_FID_2026_06_29.md", + "mode": "100644", + "gitBlob": "6bde4e2cacc1cc1452cb42a8c198e284cb87b611", + "rawBytes": 11378, + "rawSHA256": "D9D31C8BFEFFC2C89BB0B259F04C090F3A05E4D09324258A9D3B0E89C4B4B3A7" + }, + { + "path": "docs/digests/RANK_SELECT_FID_FRONTIER.md", + "mode": "100644", + "gitBlob": "47a0e4c6b3675efd73d634e29a1cb6521083b86c", + "rawBytes": 9546, + "rawSHA256": "C70F9937E59F71B4A18647D9B231FF4FF0F9772AF23A162F9E1393776300BE0E" + }, + { + "path": "docs/digests/RMQ_CAPSTONE.md", + "mode": "100644", + "gitBlob": "28a69dbad66bedc65e2fb7caac3672b42d8f9fe7", + "rawBytes": 4860, + "rawSHA256": "9CB8669A7A728B1668956A40B7F671DDDF1FA579A89683FF483C5D5F2B6ACAC9" + }, + { + "path": "docs/digests/RMQ_PROOF_MAP.md", + "mode": "100644", + "gitBlob": "5dd011ee673e8605085eb1259785f3582e008bb5", + "rawBytes": 3338, + "rawSHA256": "63BAC42CCACC6FF0B64F2C1C646487D87944783AB9E1767D26898178F2ABCAA9" + }, + { + "path": "docs/digests/SUCCINCT_RMQ_COST_COMPATIBILITY_HISTORY.md", + "mode": "100644", + "gitBlob": "a2435ade2189ae5c20db0f1b561a294fcd3d6f63", + "rawBytes": 4000, + "rawSHA256": "5D8063A67A3D26038205392C32809D4A22670E47B39CA721FCC85AA67E98AC26" + }, + { + "path": "docs/digests/UNION_FIND_AMORTIZATION_FRONTIER.md", + "mode": "100644", + "gitBlob": "2344588e1bada681ac20630f6c84213f54cd9329", + "rawBytes": 18119, + "rawSHA256": "6751CB73D96AA3ECD1ACEA14D31DC066A63BA1CABA143C24BD2C2A35BD5FB127" + }, + { + "path": "docs/digests/UNION_FIND_TARJAN_ARCHITECTURE.md", + "mode": "100644", + "gitBlob": "e76d0aed69d29dac397ccda288f8765c3de67a9d", + "rawBytes": 10566, + "rawSHA256": "7BD1635E4927DFE2E820276D48AC277770BCC14A23632B912E52AAFFBD37276A" + }, + { + "path": "docs/internal/ADD_WORKFLOW_TOOLING_PLAN.md", + "mode": "100644", + "gitBlob": "9d2ddd852d0629ce88bc568cf01d0ae8ad1d91b5", + "rawBytes": 5220, + "rawSHA256": "153797B759671E5A3E229335B8134654482840960B9D8E823B51A9C8777DBFC9" + }, + { + "path": "docs/internal/AUDIT_2026-06-18_FH_MIGRATION.md", + "mode": "100644", + "gitBlob": "d5941c311e5c84507d13c5362c41e5cec017de8a", + "rawBytes": 5017, + "rawSHA256": "29455612C7F8E4972BF467F97F0E65EA72EBD9B912576E0E8690BBA0EF0510B2" + }, + { + "path": "docs/internal/AUDIT_AND_A_DESIGN.md", + "mode": "100644", + "gitBlob": "83ca4fc67e1d871f3a2eff3881e97b70b1bb1eeb", + "rawBytes": 63623, + "rawSHA256": "55CDF774DD05380B7A679BF01309575B8C7C2037F681CD6A6E8FED0AD0C36824" + }, + { + "path": "docs/internal/AUDIT_PROTOCOL.md", + "mode": "100644", + "gitBlob": "63b32de746ba9c893ac8e3327b0d355904a846f6", + "rawBytes": 8758, + "rawSHA256": "1A651F51812D9B67EFF15E6E5A3B94B026512D13AFC0DA128F762ADA0E1C5719" + }, + { + "path": "docs/internal/B2_CHARGED_FRINGE_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "3ff455634ed07fcd22dc623b022fa469e93503d9", + "rawBytes": 137221, + "rawSHA256": "D27A19EBD471D12F564C9E3DEF634D5437708B41F17367CF866517AD75597CA3" + }, + { + "path": "docs/internal/B2_WORKLOG.md", + "mode": "100644", + "gitBlob": "5a80aea77f6ac5611adbeb2d08fae563d2508e86", + "rawBytes": 18783, + "rawSHA256": "07A74A0A074B0D58EF2B88333F6C43E3EFAB88E383AA867EFCC66D1029D7A08B" + }, + { + "path": "docs/internal/B3_WORKLOG.md", + "mode": "100644", + "gitBlob": "2d152ca701ae3132670f43d3b3f13b9b3b22929e", + "rawBytes": 40020, + "rawSHA256": "66530EDBDDF3A8F8C9D46FE10DCB464AD7DAB07C65923D1F359C35ABCA79D51A" + }, + { + "path": "docs/internal/B4_WORKLOG.md", + "mode": "100644", + "gitBlob": "c828ae8f60388acdd5c324c831db0b6411a12881", + "rawBytes": 14427, + "rawSHA256": "930C90CC55ADB3DCA2F8ABA572F311962759D3B92FBAAF77F8FC2B79C0FB70A4" + }, + { + "path": "docs/internal/B6_SAMEBLOCK_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "8779db9d2f4914353a42aabde281207533be49ae", + "rawBytes": 34904, + "rawSHA256": "1985363E41D62044BEB29CD24446DF1620147835ACC81096A194C274E2A4E5E4" + }, + { + "path": "docs/internal/B6_WORKLOG.md", + "mode": "100644", + "gitBlob": "03a6008d7a1d930217f630cd2a747e9da9769452", + "rawBytes": 28274, + "rawSHA256": "054566E0441DEC87FF258AB97C32A4A8DF2FDC85A8325F0D21EC84F503AF0824" + }, + { + "path": "docs/internal/B7_SPARSE_LEVEL_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "b33aa1482393b379b532b5ede2f77171c27f5afd", + "rawBytes": 129119, + "rawSHA256": "BE80B57364E51BBFF1FE68406504D0CA57E493529751D97E06B138FD4BC99533" + }, + { + "path": "docs/internal/B7_STEP2_WIP.patch", + "mode": "100644", + "gitBlob": "765199018b6ca6cd896bb8d018a80f3b1c4441dd", + "rawBytes": 101242, + "rawSHA256": "D5910658DF43F1ECB435BEDE1846F43ED351AB0CA30A51872E6BA9C1CAECA791" + }, + { + "path": "docs/internal/B7_WORKLOG.md", + "mode": "100644", + "gitBlob": "088e2f3aa1973c5b9aee2f8e705001adbc2ef1ce", + "rawBytes": 163862, + "rawSHA256": "23D8774EBE2083D610297FDC1D3CF6B9C4D05121B3E9BE58F3E56333659C4519" + }, + { + "path": "docs/internal/CLAIM_DRIFT_POLICY.json", + "mode": "100644", + "gitBlob": "491791898dca137d2a7d94126b87402545ccaa9d", + "rawBytes": 21046, + "rawSHA256": "4096C7A708DF686F0AC7B62D935B22C13C1F1212494A3B39FD2ADD127AD43CD9" + }, + { + "path": "docs/internal/CLAIM_DRIFT_POLICY.md", + "mode": "100644", + "gitBlob": "2cbf8cb57c7ab1c73c8018a2274d4e6106412f39", + "rawBytes": 18325, + "rawSHA256": "F12148DB46880580D2879EA4F8ADCD75CEBF2C8BDD0D31312524FAE1DE48384F" + }, + { + "path": "docs/internal/CODEX_AUTONOMY.md", + "mode": "100644", + "gitBlob": "b2c785e62e0f36141be8af69ac92bf85df63c016", + "rawBytes": 2305, + "rawSHA256": "2AB7188ABB78F1F0A7AE415EECF9392E17DA3AB9AF4E6781CF79E70DDE42F0C2" + }, + { + "path": "docs/internal/CODEX_ORCHESTRATION.md", + "mode": "100644", + "gitBlob": "ab26a72e9ce269c0eb7198b7a6866e5b3e947fcf", + "rawBytes": 2233, + "rawSHA256": "72AEA81DCDB221BA822CDB89A51358EF616B19FFB8CDAFF5B23ADA2EEED17EB0" + }, + { + "path": "docs/internal/COMPACT_EXCEPTION_LOCATOR_AUDIT.md", + "mode": "100644", + "gitBlob": "9192e995984b6d78d697c985e8ee54e20a84f08e", + "rawBytes": 14788, + "rawSHA256": "7E328A3A96072238ADE0421BE83293E67ED7C170ADB2508ED22BAA03630E6A6A" + }, + { + "path": "docs/internal/COORDINATOR_RECORD_STAGEA_TO_V1RC.md", + "mode": "100644", + "gitBlob": "a3483dc722cebb401b0cf298dca34238fe05d3a2", + "rawBytes": 18944, + "rawSHA256": "2A496D10FFA3143626775FEC5510A98D034C07F9CC5F943E12788A430C82943F" + }, + { + "path": "docs/internal/DESIGN_DECISIONS.md", + "mode": "100644", + "gitBlob": "8086e978bf50c04bb57ddafa50ef3c6a2b3f26bf", + "rawBytes": 845666, + "rawSHA256": "DC4463F96FE22FD770FB606115835C8F86A6D519DE1A95EACC992A8CCE5AB3C0" + }, + { + "path": "docs/internal/E1_AMENDED_MACHINE_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "05b4b693c18ed12fc39ad722614d601e605cc039", + "rawBytes": 26223, + "rawSHA256": "52900E7CE1DF7A9899D0E6C750B2A1645A906D864577A980FA0E6E8DBC00EF51" + }, + { + "path": "docs/internal/E1_ARCH2_B3ROUTE_R1_WORKER_TERMINAL_REPORT.md", + "mode": "100644", + "gitBlob": "f31b68c0880398515b58217f5dc707bfff74c577", + "rawBytes": 5782, + "rawSHA256": "2F3E4EDA6953393275DA48AD12229A83DAC2E8B25F3398E3425F10513EB02B7F" + }, + { + "path": "docs/internal/E1_ARCH2_CONTRACT_REPAIR_PREP.md", + "mode": "100644", + "gitBlob": "69a92ddaea704f63294d821d59b90fce6b2ad8d1", + "rawBytes": 23913, + "rawSHA256": "B871B94EC8F3449451248467D8FCF8E0ED9EA2D590F41C6EC40CEBAE4DF2485B" + }, + { + "path": "docs/internal/E1_ARCHITECTURE_COORDINATOR_HANDOFF.md", + "mode": "100644", + "gitBlob": "d8ff6358929fb6b5fbc40ca92de434a7b1939297", + "rawBytes": 28486, + "rawSHA256": "B7F35B50957C3E73BFE6D871F9364FF8F3ECDAC1B8427F1345515EAB8F93CA63" + }, + { + "path": "docs/internal/E1_ARCH_ADDENDUM_C05_2026_07_23.md", + "mode": "100644", + "gitBlob": "cf4c612e6c993f02c04e18cecd82e4fdb51ea22d", + "rawBytes": 16230, + "rawSHA256": "1F7E0C29DB1B0971ED7541C30D98397517BF22A369ADAD3BA8F142849D7DA0B6" + }, + { + "path": "docs/internal/E1_ARCH_HANDOFF_INDEX.md", + "mode": "100644", + "gitBlob": "220d60692865fed77f7e6cbb4f865d4ebfe83949", + "rawBytes": 4412, + "rawSHA256": "5AE23FEB08250669473EFB32D1A25D13D69AFD86D4D629BC1A68A7F562276AE7" + }, + { + "path": "docs/internal/E1_ENDGAME_F03_CLOSURE_RESULT.md", + "mode": "100644", + "gitBlob": "ccbec11854a93a5aca7b14f679555d95752d1a88", + "rawBytes": 11277, + "rawSHA256": "7A93B99CC1A28ACA330D7CCB44C6E4AB0E6CB10FA53D188072E95CE9C26FC259" + }, + { + "path": "docs/internal/E1_ENDGAME_F03_GEOMETRY_CLOSURE_CAMPAIGN.md", + "mode": "100644", + "gitBlob": "db91f904ae93bd50fe1e6703a8b46cd0b52d7f24", + "rawBytes": 19995, + "rawSHA256": "970739B783E4CE2C53E7ED09EDB2E0EB2BC8F4466818F145EB22C6BCB4E9E55E" + }, + { + "path": "docs/internal/E1_ENDGAME_T1_SELECT_LEAF_RESULT.md", + "mode": "100644", + "gitBlob": "2ade44b1ab2970d1168a222f4394f6122ba7b1fe", + "rawBytes": 7854, + "rawSHA256": "DCEEADB6250270EC472A33D96C8977242E37736F982982B05EF21AE56CF403D4" + }, + { + "path": "docs/internal/E1_WORKLOG.md", + "mode": "100644", + "gitBlob": "5d4c16907ab2acd838910f290f477bb866174a50", + "rawBytes": 157184, + "rawSHA256": "BEDA07A9C3FAE6D4E2C1B31D3B1036A4F0980209FE62B590BADA8DA8F8273C7C" + }, + { + "path": "docs/internal/EG_CP_FINAL_FALSIFICATION_MATRIX.md", + "mode": "100644", + "gitBlob": "46be6c10c5cc05cbab7e8838ec059b78bff9fa54", + "rawBytes": 152998, + "rawSHA256": "94CA97260F83248445736EFDC87F6D05D34BBC36F65AB5E12E943A78A6E6AF6E" + }, + { + "path": "docs/internal/EG_CP_FINAL_FALSIFICATION_RESULT.md", + "mode": "100644", + "gitBlob": "0bd5c6d7fe7ba2e4efa811a84bd38c8e11867caf", + "rawBytes": 57615, + "rawSHA256": "EE8D63DACED9661E8F3BF13CC18FB2E23247A6611AB7701142B1236FD1AED58A" + }, + { + "path": "docs/internal/EG_CP_STAGEA_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "69e32a5da5d5e26b25f87638d8914ffea49b1370", + "rawBytes": 72266, + "rawSHA256": "353754BA798D26A7B483CFD985F98652BCCA3D6694B11FA3CA73C9F1542E8BF9" + }, + { + "path": "docs/internal/EG_CP_STAGEA_RESULT.md", + "mode": "100644", + "gitBlob": "088a57b8d0d54a9279b04fb9d1545d511a0e321b", + "rawBytes": 48199, + "rawSHA256": "A0EDAA9F6CFC08DF0F0F9197A193E3E288C2FF2B6B655069E4307C90474E57B7" + }, + { + "path": "docs/internal/EG_CP_STAGEA_WORKLOG.md", + "mode": "100644", + "gitBlob": "107e22baf6a5e4138fca06a7b50f1d7caf893e62", + "rawBytes": 8338, + "rawSHA256": "4B6397862117F4D90B69C8F81E2AA1E411250FE9EF0DF5366D6021DA365E2719" + }, + { + "path": "docs/internal/INTERIOR_NAVIGATOR_DESIGN.md", + "mode": "100644", + "gitBlob": "44350df412d5989b20991e22ee97bcf602341f2d", + "rawBytes": 7968, + "rawSHA256": "796B3E353A15F8D89D6C0260344BA5B3CD0E74347A8578AAB8737951864304CA" + }, + { + "path": "docs/internal/LOCAL_BP_DECODER_PATH.md", + "mode": "100644", + "gitBlob": "e13aa53b847ab48bb6b431b14a1bb4789e179325", + "rawBytes": 11243, + "rawSHA256": "C5062983AA244162CAE7988793C4AFC280D7A8AC87092381E9A05FD22A8BF1CE" + }, + { + "path": "docs/internal/M1_REVIEWER_NATIVE_ADEQUACY_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "21b42ee8babefe6d96234a92c3f3e12b34cb1451", + "rawBytes": 213412, + "rawSHA256": "194F2E9562D2394DC5724D85414228CB8DF2DB36E5233B642CDC85132688F7FC" + }, + { + "path": "docs/internal/OPTION_B_CHARGED_FRINGE_DESIGN.md", + "mode": "100644", + "gitBlob": "a9c47741422d4e2066daa8e71cdc63b8e2dfda98", + "rawBytes": 7311, + "rawSHA256": "EFD64A2C1D21E9AE72AC1866F34C0FBD1B61BB20D53785BCBA6BD6F316EBF670" + }, + { + "path": "docs/internal/P1_POLICY_HARDENING_WORKLOG.md", + "mode": "100644", + "gitBlob": "d63e93d0fe563f66b14bdb21d36e6d4cd0c94f5e", + "rawBytes": 55440, + "rawSHA256": "32BD7EF286CD43867C39E51A3C00DD430A014C719C16AD9112BAC5F776F0ECD1" + }, + { + "path": "docs/internal/PLAN_AUDIT_DISPOSITION.md", + "mode": "100644", + "gitBlob": "af4b6f015a5690bbd9980e6a9422b31cbdfe8ff6", + "rawBytes": 19313, + "rawSHA256": "D25D29AD74A5274FB25E3405C406442269A0EE702814B541D9CC10C3EB5CD949" + }, + { + "path": "docs/internal/PLAN_AUDIT_DISPOSITION_v14.md", + "mode": "100644", + "gitBlob": "fba5c499de4f098bfc340aa9de4e8b2c49381b3c", + "rawBytes": 2740, + "rawSHA256": "633A9D49D0CC9050AA0A3B198E2783726686AB46621A82D4361F3A5A02F77B39" + }, + { + "path": "docs/internal/PLAN_AUDIT_PROMPT.md", + "mode": "100644", + "gitBlob": "5f44abc94c224b996430dbbd01d240a9e8e113fc", + "rawBytes": 5308, + "rawSHA256": "1DB8E3239315498AE5DCB8DEF2FA543BBDDDAB937D3B787AED6BA52C7C5AAB52" + }, + { + "path": "docs/internal/PLAN_LINEAGE.md", + "mode": "100644", + "gitBlob": "6946a670f3dbadd1a3f39219ccc30ca4803dfb10", + "rawBytes": 5914, + "rawSHA256": "6DA92669C550C57DB3B8339AC1799B695C397A5A7DC4282A7E1B0DECCAA2C12E" + }, + { + "path": "docs/internal/R1_WORKLOG.md", + "mode": "100644", + "gitBlob": "7f1fcd286dfdd23bb17b12735b8a31ee922ea2ae", + "rawBytes": 154831, + "rawSHA256": "04CC6278D24B5667AD0146E84F9D4DB089EF305AB1CD56749A62D98F9C375842" + }, + { + "path": "docs/internal/R2_ALLSIZE_WORKLOG.md", + "mode": "100644", + "gitBlob": "e7a186aa514e628c89f00f1e14c49806d5a5726c", + "rawBytes": 7922, + "rawSHA256": "680AE226FAB901E12F6160F6DCF9B593A8C07BB00413FBEC660796B7F3760541" + }, + { + "path": "docs/internal/RC1_CORRECTION_HANDOFF.md", + "mode": "100644", + "gitBlob": "a10679e4644342042aab6b0f6e604133ad5ab1f5", + "rawBytes": 12088, + "rawSHA256": "4C641ADA92B59D5D112AA6EF8C73AB5D203E487CB64D7F3917E64080B40BC187" + }, + { + "path": "docs/internal/RC2_CORRECTION_HANDOFF.md", + "mode": "100644", + "gitBlob": "b58efba8c2e711fc1d26385f5004039d02f4355f", + "rawBytes": 4073, + "rawSHA256": "6FFF3D4BB100477766ECF2180EC422E823C69C1B7999BDB2C29D0CD36D115373" + }, + { + "path": "docs/internal/RC3_DISPOSITION.md", + "mode": "100644", + "gitBlob": "3865ca3628cc2993e14c5aca752c102646db0179", + "rawBytes": 14779, + "rawSHA256": "143510DA80F7EDE92503F57E8953C49B3E25C0974993428EDB0CA6918169BA34" + }, + { + "path": "docs/internal/README.md", + "mode": "100644", + "gitBlob": "b64fa2654f86ccb99997291839f05379b0750b50", + "rawBytes": 2621, + "rawSHA256": "88DB538D661D063F3F39DC77A3B7E71D0E4A35F3B9006A443E771A4817521654" + }, + { + "path": "docs/internal/RELATIVE_RMM_LAYOUT_DESIGN.md", + "mode": "100644", + "gitBlob": "8dee2aa4be55c63b261fd967f96524f46c84f0ae", + "rawBytes": 11442, + "rawSHA256": "526089E3FA0CF23DDEED2A6C880F580C3B444979031DAFF8A91B4B37E0396369" + }, + { + "path": "docs/internal/RETROSPECTIVE_CERTIFICATIONS.md", + "mode": "100644", + "gitBlob": "5a8d1a9ca909e92a597c98913f6fa8b48fced8d6", + "rawBytes": 6942, + "rawSHA256": "C8A21045EA24DA6DDE9F24C352BCB14B20412B18582B02B76B47F2C6FA3052FB" + }, + { + "path": "docs/internal/RMQ_DECLARATION_CLOSURE_2026_07_10.md", + "mode": "100644", + "gitBlob": "56457fecc6acc34f3ff226355c036ddd5cce5ddd", + "rawBytes": 5760, + "rawSHA256": "03F0E045829DF97963F532C8872E79DFE50EB87EDFC4564119E57271118C7E4B" + }, + { + "path": "docs/internal/RMQ_ENDGAME_ROADMAP.md", + "mode": "100644", + "gitBlob": "12f84ba455d4bb8f19385575a7d5a74e95753953", + "rawBytes": 52798, + "rawSHA256": "D3C05249E0BF43ECAF527A3168B14D28F8398ABC530CC3260101AC6D05AB1C47" + }, + { + "path": "docs/internal/RMQ_FINAL_ROADMAP.md", + "mode": "100644", + "gitBlob": "73f67afb0e98c7358640a2a791d319b7b0679875", + "rawBytes": 32220, + "rawSHA256": "E8A69418D01424EB4C3772A6E4C673145D2443FFB4B88D2C94D6805C42054EFA" + }, + { + "path": "docs/internal/RMQ_PROGRAM_PLAN.md", + "mode": "100644", + "gitBlob": "37eaaae37a884cd15369393df5bf6f1cd44b2793", + "rawBytes": 44761, + "rawSHA256": "E66111A9545DA6C8E9F472BBAFCF81C3752AD734961853C9612EF8F07B113B86" + }, + { + "path": "docs/internal/RMQ_PROGRAM_PLAN_2026-08-13.md", + "mode": "100644", + "gitBlob": "b14cd7ccc5232bfbd3f53e8d46be5e417f4f53bf", + "rawBytes": 25557, + "rawSHA256": "98C1FF8029CAC4065C174588423F87D5778490C60395ED39AEA0D0E29CF54E6A" + }, + { + "path": "docs/internal/SUCCINCT_FINAL_PATH.md", + "mode": "100644", + "gitBlob": "bfd1aded8b9c1328b94f8c5d9388fb9006a2cc21", + "rawBytes": 46398, + "rawSHA256": "D0E06A2A3BF75ADFF0755BC6559B9051A8DA12BDCF12EE5F1DF94A9267443F0E" + }, + { + "path": "docs/internal/SUCCINCT_RESEARCH_AND_PLAN.md", + "mode": "100644", + "gitBlob": "2547359289338442007831917d13b57ab6f25464", + "rawBytes": 10217, + "rawSHA256": "4BE951CC893BCBB7C71EE38C55B5E1C9DB0803A575A3F8EEF359E93889BDF9F2" + }, + { + "path": "docs/internal/SUCCINCT_SELECT_LOCATOR_ARCHITECTURE.md", + "mode": "100644", + "gitBlob": "7cc2c626a6142ef7e0d6f7d01b2c29c878011218", + "rawBytes": 14339, + "rawSHA256": "92E0EA286726AC054B17FFB8FA1322D2B3A6EE0BC19B3A3F1ACFCBCEFC03F77B" + }, + { + "path": "docs/internal/V1_RELEASE_CANDIDATE_AUDIT_PROMPT.md", + "mode": "100644", + "gitBlob": "48335dec906409193ab4f4d02c2c53b1f45a0fda", + "rawBytes": 19322, + "rawSHA256": "B176E0F704E03C201114166BF9494D5A3AE7656BF1DB73BB965F184C4EB3A524" + }, + { + "path": "docs/internal/W15_U2_CANONICAL_PAYLOAD_WHOLE_MACHINE_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "054c97db8f3d6877df3af3149575149834eec13c", + "rawBytes": 114378, + "rawSHA256": "8453FCE1283460FF01DF74A7817DC8383C4812A4FCAC0CD845AF1A5484E44AA6" + }, + { + "path": "docs/internal/W21_U3_PRINCIPLED_ALLSIZE_COST_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "e2adac84f4d7267e01ed5ce90509d8c0b4d411b2", + "rawBytes": 27110, + "rawSHA256": "BC47D95743947A88AAEAE202E94A2254C785374C8DA003E3526E8AFF1652D283" + }, + { + "path": "docs/internal/WORD_RAM_INTERPRETER_REFINEMENT_PLAN.md", + "mode": "100644", + "gitBlob": "b59c6fa60709c2b9b2bffe70780f835a8cd941c9", + "rawBytes": 27836, + "rawSHA256": "FCEACE7A313C65CB64FF7E37E40CE109A06281C70F4274A35678E9F5C0EF1A0E" + }, + { + "path": "docs/internal/WORD_RAM_REGISTER_CONTROL_PLAN.md", + "mode": "100644", + "gitBlob": "cc8a0fe7be50bea0740c47d6f50e5cbe81244e04", + "rawBytes": 14505, + "rawSHA256": "93201A03D35CDB422E76438F6BDCE9AA33337782B6DAA2BEEFEE99337FBB40C9" + }, + { + "path": "docs/internal/WORKER_INTEGRATION_CHECKLIST.md", + "mode": "100644", + "gitBlob": "89ce88aedd0947308ef8c2cdbd619a9f2b85ea3a", + "rawBytes": 5552, + "rawSHA256": "4B9DFF882C4936E8E65F8F01D97940941468F3FC5F39456752780AE5D51FDB4E" + }, + { + "path": "docs/internal/WORKER_LIFECYCLE.md", + "mode": "100644", + "gitBlob": "fc58b9d056aae55007fde2ecdac6a31cd7fbbbad", + "rawBytes": 6149, + "rawSHA256": "1A2CCE5D2B9ED935295D34BE45E4B7A3D7F88E6A48C2E67030DD56019FA00BC5" + }, + { + "path": "docs/internal/WORKFLOW_DESIGN_DECISIONS.md", + "mode": "100644", + "gitBlob": "2c7f7e897bb230a978033fd5d8961e1b3c9cef9c", + "rawBytes": 958697, + "rawSHA256": "4682CD699CE600BA4B70DBC5C1A06C2DE5E94D3B5C7EB2A244C9C513D4BE9AA0" + }, + { + "path": "docs/internal/audit_packets/EG_CP_STAGEA_AUD1_PACKET.md", + "mode": "100644", + "gitBlob": "f992d829411e729398996986ac7681d194e78b8c", + "rawBytes": 10784, + "rawSHA256": "0F10A17E4DFAA9C8BB71D633C70A23476066D944903CD58C5E3B12B16979C034" + }, + { + "path": "docs/internal/audit_reports/2026-07-09_A01_rmq_frontier_audit.md", + "mode": "100644", + "gitBlob": "43b21e3fe52aa4f0be36be81814c96437f6108b4", + "rawBytes": 4389, + "rawSHA256": "1EB28B6A2C14756210645E99DE970418728D148C3DD93A5E37A197C3503DB27D" + }, + { + "path": "docs/internal/audit_reports/2026-07-09_A02_rmq_pre_w10_frontier_audit.md", + "mode": "100644", + "gitBlob": "83bf5c84d81f3d8ffb5a7f9cff6580ed99750f85", + "rawBytes": 20026, + "rawSHA256": "4FD892636AD6096E143A7FE802835A97565C089D156A1E7DD1CED1D51530AE39" + }, + { + "path": "docs/internal/audit_reports/2026-07-10_A03_u1_total_layout_audit.md", + "mode": "100644", + "gitBlob": "0f46e151df3cb03183ae6844c81c1556d18d3f98", + "rawBytes": 20349, + "rawSHA256": "23C3BBC662C0B0B1AABA6D8B7DE5DDD5513E61AE27320993BC6D3FE538236562" + }, + { + "path": "docs/internal/audit_reports/2026-07-14_A04_u2_blind_acceptance_audit.md", + "mode": "100644", + "gitBlob": "176fb015c8613505ee76ddfbe3235e617ee5a123", + "rawBytes": 29411, + "rawSHA256": "13706DF623B47AC1B8060C4AD1A49A66BE4DEB9CF408CAB0B78CBB2E19E79E8B" + }, + { + "path": "docs/internal/audit_reports/2026-07-19_A08_b7_charged_sparse_level_audit.md", + "mode": "100644", + "gitBlob": "642f057c9b947c9c041bc5aff1a648efcae461a3", + "rawBytes": 29641, + "rawSHA256": "119D0065712D8C9DE3225F000ECD89C2A1F126824A72B9DCA4F8DB76EE31D961" + }, + { + "path": "docs/internal/audit_reports/2026-07-22_M1_R5_R9_fresh_blind.md", + "mode": "100644", + "gitBlob": "bc5144abff8d4974799ae285782b67b0669bbb90", + "rawBytes": 42457, + "rawSHA256": "BB4849E925543CC3027C0B62B29731BE9D156C97958826AF4C0609CAA613D34D" + }, + { + "path": "docs/internal/audit_reports/2026-07-24_C06_e1_arch_handoff_package.md", + "mode": "100644", + "gitBlob": "98d7d07a93b1e778d5760df8814f1deaa034a7d0", + "rawBytes": 10975, + "rawSHA256": "00454BF5240E58A5B37F8E83AE379563E8260D0AADBDAE5EFE995045421B0CDB" + }, + { + "path": "docs/internal/audit_reports/2026-07-25_A09_endgame_plan_audit.md", + "mode": "100644", + "gitBlob": "836c11307aa2ad3ccf87db5594b609d47b168314", + "rawBytes": 38964, + "rawSHA256": "7270B33B0C9D73D6B03EF78A94B112506CD8590BDFDE5E4EFB5E2BC680621502" + }, + { + "path": "docs/internal/audit_reports/2026-07-25_C06_e1_arch2_b3route_r2.md", + "mode": "100644", + "gitBlob": "9132abe7256bb4f5789d620649717fbda5c39c26", + "rawBytes": 11171, + "rawSHA256": "CDDE31471D572737670E8AAF9ACB7DBAB429408EC8C060F5212ADE37B449DB74" + }, + { + "path": "docs/internal/audit_reports/2026-07-25_C06_e1_arch2_b3route_r3.md", + "mode": "100644", + "gitBlob": "dc394bf9f1476b7aa042dcef77606364b976e2fa", + "rawBytes": 10976, + "rawSHA256": "1E3BC6B60EAD54CAE11CFF5D938D2CDA05A71BCD31A700D75028F265BB5FB0D0" + }, + { + "path": "docs/internal/audit_reports/2026-07-25_C06_endgame_adjudication.md", + "mode": "100644", + "gitBlob": "69108651015651c9e9672bbde68a7acd5c2ffa32", + "rawBytes": 7483, + "rawSHA256": "A0A59FD93018DA7D585003AE38551DF32DC307BFA224FF367BB8488BFC5D79AD" + }, + { + "path": "docs/internal/audit_reports/2026-07-26_A10_f03_geometry_closure.md", + "mode": "100644", + "gitBlob": "a1e168cba058e6dd0aac4e8207c49a266775196a", + "rawBytes": 19446, + "rawSHA256": "004B070A1A27F9112CB9C59720C9B898E483B8AD5DF6D4DCFFDD1133D3E779DA" + }, + { + "path": "docs/internal/audit_reports/2026-08-05_EG_CP_ALLSIZE_R2_fresh_blind.md", + "mode": "100644", + "gitBlob": "d42272ee1d0c3adebabcbaabd280cd97c5db8f14", + "rawBytes": 18981, + "rawSHA256": "D4B511134AC09190EAC0DB6513F891D15208BBE941B259D92123C3CAEDC4B783" + }, + { + "path": "docs/internal/audit_reports/2026-08-06_EG_CP_STAGEA_CLOSE_R1_fresh_blind.md", + "mode": "100644", + "gitBlob": "fbcf778a1c22ce6a56a8de1b94d69a8f2f8f7ce1", + "rawBytes": 59918, + "rawSHA256": "D6D0FF08F971EFB3A94F2FCAE244E586B56242C61069356B4333B569C2CC9CC2" + }, + { + "path": "docs/internal/audit_reports/2026-08-06_EG_CP_STAGEF_CLOSE_R2_fresh_blind.md", + "mode": "100644", + "gitBlob": "2c24bdb5a70248591bc32d563683c06cdd59c113", + "rawBytes": 39645, + "rawSHA256": "11A671E3BF9006E49F38B52EC97F521041F28760ECCA137B34BCDD723E0C2326" + }, + { + "path": "docs/internal/audit_reports/PQ1_FRESH_BLIND_4c89378.md", + "mode": "100644", + "gitBlob": "55c1b95b4fc1440687dca94337449c7c600006f7", + "rawBytes": 45505, + "rawSHA256": "D14773AC45B93D75E03EA19B7D2B5B3263AA46980E65D87A0955759529B97E02" + }, + { + "path": "docs/internal/audit_reports/PQ1_MERGE_READINESS_20260912.md", + "mode": "100644", + "gitBlob": "c594f8e49ed5ce7a85813c23a48ec179ecb51514", + "rawBytes": 5403, + "rawSHA256": "002AD25F67054DA39A92DE63C88F5F6B359107EADA801935801B39DD8D4430F3" + }, + { + "path": "docs/internal/audit_reports/README.md", + "mode": "100644", + "gitBlob": "c7dc3b458fc6c1210f1136959cd8390bd60f34fb", + "rawBytes": 986, + "rawSHA256": "3E9CC023AFC4BFA4BEC3C4CDD999CAEA8E872F8B9B5BA86F2C13C55F848F1B30" + }, + { + "path": "docs/internal/e1_arch_prompts/A10_F03_GEOMETRY_CLOSURE_AUDIT_PROMPT.md", + "mode": "100644", + "gitBlob": "0a07cd8f284d4fcee7090213078e515b84fe3c25", + "rawBytes": 11877, + "rawSHA256": "037E044CA5C912F65AD45742A0F8691BC640A22DBD0DD79F1CBF9751039411FC" + }, + { + "path": "docs/internal/e1_arch_prompts/A11_F03_AMENDED_ROW_AUDIT_PROMPT.md", + "mode": "100644", + "gitBlob": "39304aadfbd4794e9cc55cfc656be0621400f1fd", + "rawBytes": 10078, + "rawSHA256": "848A175DCE1923EC974286F5281C61B50AEBFCACB0F978DEDC4E9E05A00B9C1B" + }, + { + "path": "docs/internal/e1_arch_prompts/E1_ARCH2_B2DESC_R4_PROMPT.md", + "mode": "100644", + "gitBlob": "0479b7c62bf911cb741625a0b8113f6a67cf5b2c", + "rawBytes": 18623, + "rawSHA256": "A3EC3C3077FEE9A34D34FBD745D393ED2DF9BAB92DA081CFDB79F5F6091A47CF" + }, + { + "path": "docs/internal/e1_arch_prompts/E1_ARCH2_B3ROUTE_R1_PROMPT.md", + "mode": "100644", + "gitBlob": "0941ab7a97dc319513c023833983366bff59a76e", + "rawBytes": 22058, + "rawSHA256": "EF0112772907E0005BF5B6A978EF7903957CFA0DEF948CF1FABB3F064165D320" + }, + { + "path": "docs/internal/e1_arch_prompts/E1_ARCH2_B3ROUTE_R2_PROMPT.md", + "mode": "100644", + "gitBlob": "e74a01f7150366776bfbe3e5eba728d2977684c7", + "rawBytes": 32547, + "rawSHA256": "24C9466DFA3F58CD76A9578E71A2131AB21DB9D012F2373FA4BD8882BF0BF4B1" + }, + { + "path": "docs/internal/e1_arch_prompts/E1_ARCH2_B3ROUTE_R3_PROMPT.md", + "mode": "100644", + "gitBlob": "6b065ae8f143d00c64e454a05564ed86ba879cad", + "rawBytes": 28154, + "rawSHA256": "E23313D7AA7C62CECFDF08D059BD0730213B987D3B9C5485A73B69257A0CAA7B" + }, + { + "path": "docs/internal/extensions/bv1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "d91d42d39bad8f1ed37e3ec5d31af119d9e8ee5f", + "rawBytes": 29096, + "rawSHA256": "80BD59A314FD33D37076802954444DA24F65C87A2A91DE23BC668B6AF9CCEB24" + }, + { + "path": "docs/internal/extensions/bv1/ACCESS_PROOF.md", + "mode": "100644", + "gitBlob": "68e4e7e569063951f0e91652b3eef0396b9672b3", + "rawBytes": 12485, + "rawSHA256": "5406A336BC4E4C2B82355FA32C6FA91D4A74F6D5548619974ECCC4C605445A09" + }, + { + "path": "docs/internal/extensions/bv1/ALLOCATION_FACTS.md", + "mode": "100644", + "gitBlob": "1f0821f98776b638be4c8b61f5a3fbe9df36b2b5", + "rawBytes": 14852, + "rawSHA256": "772E12F6D8B484500C9F8DDB3A2156C750CD7A5D824D2297D04522C351164935" + }, + { + "path": "docs/internal/extensions/bv1/ALLOCATION_READER_PROOFS.md", + "mode": "100644", + "gitBlob": "aadfa6d496896c348265dca699e0d0f5932c1c39", + "rawBytes": 15449, + "rawSHA256": "418A6C7840C1D3A7607803596B05F67727EA1B51325A8F570D2DDB5FA9B300C2" + }, + { + "path": "docs/internal/extensions/bv1/CANONICAL_MEMORY_BOUNDS.md", + "mode": "100644", + "gitBlob": "707444d9f5c4f1873d2bb3b8c35fb93d4561d0af", + "rawBytes": 14017, + "rawSHA256": "CCFB35D6C2AD82E0D0182C1C963F5635670863CC8D3C384B34526A7046A94324" + }, + { + "path": "docs/internal/extensions/bv1/CANONICAL_RANK_ACCESS_SAFETY.md", + "mode": "100644", + "gitBlob": "10ae75797d11de63753b0e26de722510402bfe93", + "rawBytes": 13931, + "rawSHA256": "625FC059C257F6B427A76B3168F391E7BE3DB8E978897EF98F0F819E5175328C" + }, + { + "path": "docs/internal/extensions/bv1/CANONICAL_SELECT_SAFETY.md", + "mode": "100644", + "gitBlob": "3611d7ea4131c96126a2d13982024e8e3ea5de98", + "rawBytes": 11616, + "rawSHA256": "25BE7079BCFB495E451458D54C54D9736D53344D8D6EBBA9D3260FAD03410067" + }, + { + "path": "docs/internal/extensions/bv1/CAPSTONE_COMPOSITION.md", + "mode": "100644", + "gitBlob": "2d38d6e273a47c2dcc7c411c24b7d518d9ecb33d", + "rawBytes": 18510, + "rawSHA256": "54E865CAB745C9E04988F3097024704678CDDEC3776B39C573984851799D0646" + }, + { + "path": "docs/internal/extensions/bv1/CAPSTONE_SCHEMA.md", + "mode": "100644", + "gitBlob": "f21a76e3014ef96b5542fd95401b361ae632ab1b", + "rawBytes": 5697, + "rawSHA256": "89B40DF3C68CF7FB50903984CC37D519D0A6EC567E4B6FF29E155C302CF927C4" + }, + { + "path": "docs/internal/extensions/bv1/CHARGED_SETUP.md", + "mode": "100644", + "gitBlob": "586b27fcbb4ca359e0afd6fee1a751e91749f303", + "rawBytes": 13047, + "rawSHA256": "02B99ABB531178C17602ACF8A5329DEAB47A621F9DC9C0F16FABEA0735524614" + }, + { + "path": "docs/internal/extensions/bv1/CHECKOUT_BYTES.md", + "mode": "100644", + "gitBlob": "b8a442c0ce14a3eb517d5ad59669a13f0c301103", + "rawBytes": 7745, + "rawSHA256": "11AD1F389569CBFB7C9A8FD05811278B828F45B066CB21C92164307D013B22FB" + }, + { + "path": "docs/internal/extensions/bv1/CHECKOUT_BYTES_DISPOSITION.md", + "mode": "100644", + "gitBlob": "503190799f369fd809cfd73321eb87794e42a6e0", + "rawBytes": 1725, + "rawSHA256": "7F8810E67213EE3071044DFE1E72F354B52D3C6C2D90D1D1A56462B9E2926396" + }, + { + "path": "docs/internal/extensions/bv1/CHECKOUT_BYTES_LAKEFILE_DISPOSITION.md", + "mode": "100644", + "gitBlob": "21bcc4371b2777f04af0c58c30d7ad39bd0b76a9", + "rawBytes": 3028, + "rawSHA256": "F43488628BCDBDED05BC7139719F6E9CCFF3B5272BB138B14B14EB316101F512" + }, + { + "path": "docs/internal/extensions/bv1/CHECKOUT_BYTES_LAKEFILE_PATCH.diff", + "mode": "100644", + "gitBlob": "59bf1a16cb8caa7035c5519ac26c6a889980d287", + "rawBytes": 363, + "rawSHA256": "A6D7771DAEEEB3618E55A9FCA3302E88A8D402455425B66616EEDFA6511E1CC6" + }, + { + "path": "docs/internal/extensions/bv1/CHECKOUT_BYTES_PATCH.diff", + "mode": "100644", + "gitBlob": "f8b4240fc07d93dbc03c2e6021fa23371ca7d28f", + "rawBytes": 679, + "rawSHA256": "22681770C2D5B2A42389E00BC00080A79B75ACDF968C27320FB0A90F2224E40B" + }, + { + "path": "docs/internal/extensions/bv1/CHECKOUT_WHITESPACE_DISPOSITION.md.gz", + "mode": "100644", + "gitBlob": "99cf52e863c580fa5aca2eef4c1e0ce5fa375947", + "rawBytes": 1854, + "rawSHA256": "1E5B6C40E1D751154DE9BE02201FB0B26054A2DF69CFF54CF426C178ECF7D011" + }, + { + "path": "docs/internal/extensions/bv1/CHECKOUT_WHITESPACE_PATCH.diff", + "mode": "100644", + "gitBlob": "ee97a7188cc5e75808f140f4604bf19c97ff4b39", + "rawBytes": 1927, + "rawSHA256": "8ADDBDB7B260ACEB3712CE30D59E066A2144C01013164F4E52352F1D464B057E" + }, + { + "path": "docs/internal/extensions/bv1/COMMANDS.md", + "mode": "100644", + "gitBlob": "48f4278afd76ad2de82e8926238ff0905af95e95", + "rawBytes": 15024, + "rawSHA256": "9F3C35C92863ECAD365DEA7EF89006164DB87EC6741ADABD60EF5609C6633122" + }, + { + "path": "docs/internal/extensions/bv1/CONTINUATION.md", + "mode": "100644", + "gitBlob": "6f5eb3acb81bc8ac86ac0fa41cb77d46c5395a3f", + "rawBytes": 4689, + "rawSHA256": "265264BE0EE49D12B258089EFB1C74EBA213B6DB8115E2311CC88750694EB18D" + }, + { + "path": "docs/internal/extensions/bv1/CONTRACT.md", + "mode": "100644", + "gitBlob": "cf852503874fffe3ffd7a3f7aa1c2ab183d01789", + "rawBytes": 10151, + "rawSHA256": "1F8FD493DB9896E66288DB850A9EA456A0CDAA05D55B6FE9686CCFC766FD4A00" + }, + { + "path": "docs/internal/extensions/bv1/CONTROLLER_PROOFS.md", + "mode": "100644", + "gitBlob": "95ecfc9cb0578a7debd235899f9c6e67813948da", + "rawBytes": 27322, + "rawSHA256": "A065C80BFE3C29B898D31587EB643D148ED7F662E18BD5DF19F7DDD0D7E7622A" + }, + { + "path": "docs/internal/extensions/bv1/COORDINATOR_ROUTE_DISPOSITION.md", + "mode": "100644", + "gitBlob": "d1dd25457982a7a90bcf5d63656be04afb7c7f00", + "rawBytes": 6169, + "rawSHA256": "BA1F222D4904290527417B951489B54F9833999DE3D0F1060A0E6E060002CAB3" + }, + { + "path": "docs/internal/extensions/bv1/EVIDENCE_MATRIX.md", + "mode": "100644", + "gitBlob": "1dc49c8954db1192a6a2200635bcd40eb157eebf", + "rawBytes": 22376, + "rawSHA256": "E6F34B2DE09FB86C0ADFCD5527C3F7944FB4F24A9D940EA153E60E83D7803FA4" + }, + { + "path": "docs/internal/extensions/bv1/EXCEPTION_CONTROLS.md", + "mode": "100644", + "gitBlob": "565928e6f5288c6655700a70042f88f2d966c6d2", + "rawBytes": 13721, + "rawSHA256": "F676ED4A5F4CBDC25B2B868EB081288D73A65C05762A1C7022A77A55692981A6" + }, + { + "path": "docs/internal/extensions/bv1/GENERIC_SELECT_SAFETY.md", + "mode": "100644", + "gitBlob": "e01643735009b999eb9414eb215eaa80c820cd3a", + "rawBytes": 16708, + "rawSHA256": "258B27BBB14229787F19B2391110F4044312DF2D3FAE42112FC106F7E9FA6C38" + }, + { + "path": "docs/internal/extensions/bv1/LEAF_CONSUMER_REPLAY.md", + "mode": "100644", + "gitBlob": "12bfa7976c58ae75277d809bcea611538c0477f6", + "rawBytes": 10324, + "rawSHA256": "AF80E6176EFD1715EE1A30CFC009258135FD1F0D94AFF79A1B07B1AAF0206DE7" + }, + { + "path": "docs/internal/extensions/bv1/MACHINE_CONTROLS.md", + "mode": "100644", + "gitBlob": "999d63f08f3fd0ea560d7576fdb1078be41c94ca", + "rawBytes": 20162, + "rawSHA256": "EF319FA374972399CAF190E3C1C3F0AFC9E1B6FC6CA98DDC57C2CAEB398C8190" + }, + { + "path": "docs/internal/extensions/bv1/NORMALIZATION.md", + "mode": "100644", + "gitBlob": "78f9f12db749b9783924758c92bc73b1510aca32", + "rawBytes": 14640, + "rawSHA256": "519753D23F9BC91BFE97F3120FCA21815328FA361E1E6494A9C60A4F7CFEDDC8" + }, + { + "path": "docs/internal/extensions/bv1/NUMERIC_READER.md", + "mode": "100644", + "gitBlob": "c898fdb857250e9cbf32a95b5909eb72a67ff8a5", + "rawBytes": 10280, + "rawSHA256": "D2BC1E797619A434F7B3B24140D776AF2203AC4B774EB7A55659FCB977C0446A" + }, + { + "path": "docs/internal/extensions/bv1/NUMERIC_SAFETY.md", + "mode": "100644", + "gitBlob": "9ffc6562256cf30dc027902e9808515e3cd63c05", + "rawBytes": 15029, + "rawSHA256": "48D2C5A4B30C3D501FED52F54C036D8B05E86E9564B8D7D3B9C4B4EEB5547690" + }, + { + "path": "docs/internal/extensions/bv1/PREFINAL_COMPOSITION_REVIEW.md", + "mode": "100644", + "gitBlob": "6621f00e3c9c6a059b75e8216cbf9eaaf18018fd", + "rawBytes": 15579, + "rawSHA256": "6795A463A9F640DF504B140652C633EAB0A6D15EE13A93CA7FDEED8235403B93" + }, + { + "path": "docs/internal/extensions/bv1/PUBLIC_MUTATION_CONTROLS.md", + "mode": "100644", + "gitBlob": "069b7e6715fa5164a28f5d4ab38c4449c8710f9e", + "rawBytes": 29772, + "rawSHA256": "00B9C435B65B5F5C5516D255B67DCFE558E243AA4537D358DB734C511D1D8C59" + }, + { + "path": "docs/internal/extensions/bv1/RANK_LAYOUT.md", + "mode": "100644", + "gitBlob": "16b536a7773e8428d93deeb2d3d87899301b3d42", + "rawBytes": 11351, + "rawSHA256": "01EDD5E631D3CD73E4D508B6C47A45083380BC52E432FFE20FE522F0B18D2304" + }, + { + "path": "docs/internal/extensions/bv1/RANK_SEMANTICS.md", + "mode": "100644", + "gitBlob": "2f090c860adfb708d908b9f2946cfbcfe8dbb4f2", + "rawBytes": 16494, + "rawSHA256": "BE503531C70F68A9AFAC08DC1A301729A9CA645CD1F6EFD9FA6A457AD8E1C8E7" + }, + { + "path": "docs/internal/extensions/bv1/REGULAR_LAYOUT.md", + "mode": "100644", + "gitBlob": "7c1792c56640296b01c4813a9593bbf82a5bb962", + "rawBytes": 17776, + "rawSHA256": "5E620E761B9D41FEDB6849354322A7F5882316E1FE1C13DE1CC4BF8023BA43FA" + }, + { + "path": "docs/internal/extensions/bv1/REPLAY.md", + "mode": "100644", + "gitBlob": "74c438e509841f719a3855dba945e7f475a241af", + "rawBytes": 5316, + "rawSHA256": "1387EE95A1C281A7AFF6C7BA959BAFD28F59C573D0868480FF6C9ECEDECF87DD" + }, + { + "path": "docs/internal/extensions/bv1/REPORT.md", + "mode": "100644", + "gitBlob": "d1eef7b4031bb23bb08e0c99024b9e37b869d9e3", + "rawBytes": 11579, + "rawSHA256": "5B3D640ED84691A596EE3DFF087D8AC589B41649D83AC9D6B5FCF0D8CFE30381" + }, + { + "path": "docs/internal/extensions/bv1/ROUTE_REVIEW.md", + "mode": "100644", + "gitBlob": "edac5b71a31dc37e3551be094c02256b460f08cb", + "rawBytes": 3091, + "rawSHA256": "24DAF17F573C3C45B17FE73AB21F5F04D2037F61EF8D9565367E990C37F12E29" + }, + { + "path": "docs/internal/extensions/bv1/SCRATCH_FRAME.md", + "mode": "100644", + "gitBlob": "022a95d51ad9a8273bd5a60e04232d519c17118f", + "rawBytes": 8079, + "rawSHA256": "8726F87B832549C0DD5132A163D4059B64E22D68579952517BCA1E122D9B031E" + }, + { + "path": "docs/internal/extensions/bv1/SELECT_SEMANTICS.md", + "mode": "100644", + "gitBlob": "df24efaebfe9bc9bb1a610513e662b82da794c58", + "rawBytes": 14847, + "rawSHA256": "07759680FC451FC55DD89DD99F8CA35B5AC2CF6A65D9DC18BD489CBAAA2AA46A" + }, + { + "path": "docs/internal/extensions/bv1/SOURCE_FACTS.md", + "mode": "100644", + "gitBlob": "715ea00f2c322dd95fb3dffcd0bb745bd5ab367c", + "rawBytes": 5764, + "rawSHA256": "1EE1F6908B5EFE8A139B0FBD197B9A0933B39DCBCD6B1FDA5E0DF6C98D098DBD" + }, + { + "path": "docs/internal/extensions/bv1/VALIDATION_CONTROLS.md", + "mode": "100644", + "gitBlob": "d5736de37d7416b6278ca72ade8dbdd74a8c8e5a", + "rawBytes": 18381, + "rawSHA256": "DF1268C6147D15D9C2A72AEF90A2C2C169544E3E9CB24FE609B609E6AF9F9FFC" + }, + { + "path": "docs/internal/extensions/bv1/access_expected_type.lean", + "mode": "100644", + "gitBlob": "0b9d6153194b473b2fdf895b2d9b01a6fa973974", + "rawBytes": 1344, + "rawSHA256": "AF77F97FEF74247BFC45061D2078EF8D4709D22EF5A77C00F7F11A9BB018FB54" + }, + { + "path": "docs/internal/extensions/bv1/canonical_rank_access_safety_expected_type.lean", + "mode": "100644", + "gitBlob": "de9465d826161dd834ca8254522f690f29fb4d2f", + "rawBytes": 3471, + "rawSHA256": "09503EDC196B297B331C3ADDCC938D863D2568AA85C161D34A2EE7BB84221E71" + }, + { + "path": "docs/internal/extensions/bv1/charged_setup_expected_type.lean", + "mode": "100644", + "gitBlob": "e0bb8975f68a2ba334bfda8d620120dcf4972119", + "rawBytes": 2428, + "rawSHA256": "5CCC0D63D945734387F6E8DDB4A9AD6D10F39A2EEDBD285DA48C46D5ACD2FB86" + }, + { + "path": "docs/internal/extensions/bv1/check_build_manifest.py", + "mode": "100644", + "gitBlob": "e2c92216c88873a169458d5230ba741f71e17a1f", + "rawBytes": 2232, + "rawSHA256": "B4424A7CF836C3E44B929D8AB77FFF7F04562E586A9E334C112D1424E229093E" + }, + { + "path": "docs/internal/extensions/bv1/check_checkout_bytes.ps1", + "mode": "100644", + "gitBlob": "0c7f548313c55209d3572b01a390c47755271f1b", + "rawBytes": 10854, + "rawSHA256": "C2689D8B37F7BBF6EDE527295E1DAD543132E00FF847D9D654FBE2C5290A0807" + }, + { + "path": "docs/internal/extensions/bv1/check_frozen_rows.ps1", + "mode": "100644", + "gitBlob": "2d4fdff09ff1673af8ebc479b626be43747e8fce", + "rawBytes": 4714, + "rawSHA256": "8487D2F0F9B5906802F44B305A866F0DF652ACAC31E0329803FE562D4B292AF9" + }, + { + "path": "docs/internal/extensions/bv1/claude/canonical_scalar_payload.json", + "mode": "100644", + "gitBlob": "1744925ad30252125b009a9b7deac0a2c7b8e37d", + "rawBytes": 2273, + "rawSHA256": "1013E7050CEFE6236962EF40CC87A427D2F4ADA890648BEFE3D8F9B3C1DA486F" + }, + { + "path": "docs/internal/extensions/bv1/claude/canonical_scalar_scoped_start.json", + "mode": "100644", + "gitBlob": "61bb3f8feb441460f15b78bc7213922fcb5a50ed", + "rawBytes": 8432, + "rawSHA256": "E862D492D924221EC3240B8949AFC4BC908DBCE4459038B5789352B30FAF3E06" + }, + { + "path": "docs/internal/extensions/bv1/claude/canonical_select_bounds_start.json", + "mode": "100644", + "gitBlob": "d478b7ae0e564e2860f124c1cbc52a48b928f54b", + "rawBytes": 4131, + "rawSHA256": "2E60B940238C0B9426006D65FCA25757E30368F6849215B537F311421FEF51D2" + }, + { + "path": "docs/internal/extensions/bv1/commands/access-proof-build-final.json", + "mode": "100644", + "gitBlob": "1c7801f4a3af0bdb4f4d7ed88a32a0a2b0685728", + "rawBytes": 227889, + "rawSHA256": "2E1100897CFDF434DDAF542BF075C59CC7EF9151E5DDE07922DD16C2A5C5F5A0" + }, + { + "path": "docs/internal/extensions/bv1/commands/access-proof-build-v1.json", + "mode": "100644", + "gitBlob": "b5c2c8fe70abdbafaf9e69c06c27de75cd0aaa67", + "rawBytes": 250137, + "rawSHA256": "D9CF58B18F8AC9375CF7558F6D64DEC123DC51E1A5468A9A586333DD553E1C0A" + }, + { + "path": "docs/internal/extensions/bv1/commands/access-proof-build-v2.json", + "mode": "100644", + "gitBlob": "e90afdb4a9890b92f020a8d50725cd8c535f1e8a", + "rawBytes": 246898, + "rawSHA256": "6CE84A2406CAE1769AFFCFB90ECB38FEC0D1EE0134BCB2D0021CAAD10AE7FF3B" + }, + { + "path": "docs/internal/extensions/bv1/commands/access-proof-build-v3.json", + "mode": "100644", + "gitBlob": "bf2ffdb82261a03e0a513397e8ced9febcba1406", + "rawBytes": 251357, + "rawSHA256": "D07C26CDE8B9D891807F7BD8FBA0C2855AF6EA8610E61711DF1C00CE2E6333E3" + }, + { + "path": "docs/internal/extensions/bv1/commands/access-proof-build-v4.json", + "mode": "100644", + "gitBlob": "60e3015cb5cb4c6d7e876db4f32a0c0df5d9df22", + "rawBytes": 250333, + "rawSHA256": "0D4C132ACC0A77CDACA5CA56DF571038217B6152CBFFE6FE8D817B3293A35BB7" + }, + { + "path": "docs/internal/extensions/bv1/commands/access-proof-build-v5.json", + "mode": "100644", + "gitBlob": "3e466e10618733363fa12fd031ce83c1b3d88e33", + "rawBytes": 242163, + "rawSHA256": "9F3AC7BEADA117BEC09F9F7B3554EC2F47062A01EF115B7E33A86FDFEC8D459C" + }, + { + "path": "docs/internal/extensions/bv1/commands/access-proof-consumer-final.json", + "mode": "100644", + "gitBlob": "60a2d61e1ed6c7cb3595a4420fccbdb500a42a3c", + "rawBytes": 20819, + "rawSHA256": "C49930F05884D6C8468995D7FE152D83EB2F79149DA6E6852D88B5D77D5E350B" + }, + { + "path": "docs/internal/extensions/bv1/commands/allocation-facts-axioms.json", + "mode": "100644", + "gitBlob": "c6a57ff53b6524ce4f8eb8e71d222747cd451032", + "rawBytes": 3977, + "rawSHA256": "41A36C0A915F3781786BC69961E0D95DC32E3B1E5D1C4B7974446ECD35565BED" + }, + { + "path": "docs/internal/extensions/bv1/commands/allocation-facts-repair-1.json", + "mode": "100644", + "gitBlob": "0e1a8a40839dc12df84ba1db0c055709bcde5019", + "rawBytes": 2450, + "rawSHA256": "FF46DD9E2FF614E2FC4E589FD9A2715E9FB7D39F165339342D6C0883BED43717" + }, + { + "path": "docs/internal/extensions/bv1/commands/allocation-facts.json", + "mode": "100644", + "gitBlob": "c4cf81f868cc3366001597132f8426d457c0e175", + "rawBytes": 5442, + "rawSHA256": "6C357989DBD4EB1868295F728BB20B392C3A24F409FC1EB4845219812C2FCAD4" + }, + { + "path": "docs/internal/extensions/bv1/commands/baseline-span-assembly.json", + "mode": "100644", + "gitBlob": "72609b03a5cc929c20603c68ca00e9bd1e9c542e", + "rawBytes": 17480, + "rawSHA256": "AD4C9B82BAD324C9A35DD2340C9E70D08F7F881001503FE53C271358950CDE44" + }, + { + "path": "docs/internal/extensions/bv1/commands/candidate-checkout-bytes-v1.json", + "mode": "100644", + "gitBlob": "59b13536c3ef6e516db00467681fecfd75484b66", + "rawBytes": 1220877, + "rawSHA256": "1E7944DDE24967717E629E632025B45E6DF7A7D6A6DA9A08A2FFF8425D30EE0B" + }, + { + "path": "docs/internal/extensions/bv1/commands/candidate-postcommit-policy-v1-output.json.gz", + "mode": "100644", + "gitBlob": "91c19ea59fef4ece6a4cbc7d770bfe7119ce18da", + "rawBytes": 576, + "rawSHA256": "24EC2A88C88DE6AC4F14D4264DCEF25EF6F7D7DE818FEA7A882879B34D50F7F3" + }, + { + "path": "docs/internal/extensions/bv1/commands/candidate-postcommit-policy-v1.json", + "mode": "100644", + "gitBlob": "483cae7e7ea35f34b62bfbfe5440228194d98beb", + "rawBytes": 1047, + "rawSHA256": "FCC5CFD8F90C85F3E78A74E7D6E54EAF37E8E2B4B66E43E1D36613BA4DAA6155" + }, + { + "path": "docs/internal/extensions/bv1/commands/canonical-rank-access-safety-build-final.json", + "mode": "100644", + "gitBlob": "893a8b3011dd25b6434d604913fd2205379c54d4", + "rawBytes": 235734, + "rawSHA256": "5347984506CDFF0C3CABFCA354DAA01ACC37C3A1847B15536BE72DB8EDB35AF7" + }, + { + "path": "docs/internal/extensions/bv1/commands/canonical-rank-access-safety-build-v1.json", + "mode": "100644", + "gitBlob": "77507292a152fa82dccb16c3718b5adf0c59dcfd", + "rawBytes": 243569, + "rawSHA256": "847BB8FEA147863856CE31B8022AE092300A110BD5C6F85B28D36E3D8D185DE4" + }, + { + "path": "docs/internal/extensions/bv1/commands/canonical-rank-access-safety-build-v2.json", + "mode": "100644", + "gitBlob": "ade853ca238651b361065a041b1c0fac380ef260", + "rawBytes": 239165, + "rawSHA256": "332AD83D70ECD64A3DDF02BA089616949011C3A62C397BE0824838F5552565ED" + }, + { + "path": "docs/internal/extensions/bv1/commands/canonical-rank-access-safety-consumer-final.json", + "mode": "100644", + "gitBlob": "b36908468e339f0f0ea565b18e409321eaf8f6e3", + "rawBytes": 24627, + "rawSHA256": "B720AB8236895EA7FA00541F973DE25A29AECA78F4D4091242BD4F5F46F5871D" + }, + { + "path": "docs/internal/extensions/bv1/commands/canonical-rank-access-safety-static-final.json", + "mode": "100644", + "gitBlob": "0c2f9dcf5e2f028f59801aea3e57cb90b246f3d3", + "rawBytes": 800, + "rawSHA256": "180840C62D7E92E228702F347085B558DFB2919AE042DE211C7666E10DE1C91C" + }, + { + "path": "docs/internal/extensions/bv1/commands/canonical-select-safety-1.json", + "mode": "100644", + "gitBlob": "9ab590d57278b087834a7bc59c00951c2bbd7e81", + "rawBytes": 244296, + "rawSHA256": "1E95BD3EA3D8D331362DCE7E9CCD6C591D4BF7417BB3F2887C13BEACE48F35FF" + }, + { + "path": "docs/internal/extensions/bv1/commands/canonical-select-safety-2.json", + "mode": "100644", + "gitBlob": "a0f54876c81a993995d035752285f031baefd2a8", + "rawBytes": 232084, + "rawSHA256": "22BB586A3AFD4626FFFF7180BED167AD7808AC2E9F0BC9F1CCF1103DAE3327C2" + }, + { + "path": "docs/internal/extensions/bv1/commands/canonical-select-safety-consumer-1.json", + "mode": "100644", + "gitBlob": "558eae3221c9670a92daf4ff309b358b35c9df7f", + "rawBytes": 24780, + "rawSHA256": "B059995C121C7002E704E99117E25F4C47BFB7E8728D2EAD6BEA7566ED620D92" + }, + { + "path": "docs/internal/extensions/bv1/commands/canonical-select-safety-consumer-2.json", + "mode": "100644", + "gitBlob": "ac2b06864ef92c079de174aaef511dde91e4c77c", + "rawBytes": 24237, + "rawSHA256": "61CFEC7DF405152D480E58D10CE1FD1384EB162A7FC26027E5290E121FE27785" + }, + { + "path": "docs/internal/extensions/bv1/commands/capstone-allocation-reader-consumer-v1.json", + "mode": "100644", + "gitBlob": "5a83a4d06d1cd1bcb3ebb9159c94caab6ccc5415", + "rawBytes": 29844, + "rawSHA256": "875E393DE82148EF9BA60EB0FB6DE83000A4E16C8211E1699EB9C4F66059038C" + }, + { + "path": "docs/internal/extensions/bv1/commands/capstone-build-v1.json", + "mode": "100644", + "gitBlob": "097fed3967f82e7e348fa63fbdb2e99993e8159e", + "rawBytes": 239614, + "rawSHA256": "C4498F08ADD230F1540B50E8DE665BCE41E6B78547AA061EED9D3407B810BDE8" + }, + { + "path": "docs/internal/extensions/bv1/commands/capstone-public-consumer-v1.json", + "mode": "100644", + "gitBlob": "5718ef8df097da7b2946057f09f0d1546115aa07", + "rawBytes": 37322, + "rawSHA256": "D90182DF1D0A7137BA6A095FB6EA7E2500DE82410AB41A6E1AC2031659F9FE0C" + }, + { + "path": "docs/internal/extensions/bv1/commands/capstone-public-consumer-v2.json", + "mode": "100644", + "gitBlob": "ef61a0e10eab4308f1bb53b6938a1168a3b6f2bb", + "rawBytes": 34377, + "rawSHA256": "136F18B21A308CAF06B28A5D6449A9763A74B9786B01FD1470FFE39BE889204C" + }, + { + "path": "docs/internal/extensions/bv1/commands/capstone-static-final.json", + "mode": "100644", + "gitBlob": "9cc5b93d473e93a3a99f0d6a7dff95adfd3a23a9", + "rawBytes": 548, + "rawSHA256": "07A61E7E16F87B2DF7D276702BC53D34C59098BE5D94E458422D46E3AB44F556" + }, + { + "path": "docs/internal/extensions/bv1/commands/charged-setup-build-final.json", + "mode": "100644", + "gitBlob": "5443c2669c03c6924bf729eb6d1a582cb9ff88fc", + "rawBytes": 221825, + "rawSHA256": "5AAE919523725A57D2AA18A2221E3620668E755C11E4806810A357F7D17668CA" + }, + { + "path": "docs/internal/extensions/bv1/commands/charged-setup-build-v1.json", + "mode": "100644", + "gitBlob": "9cd5d58378023e67ee1dff263ea8fdf27ac42d6d", + "rawBytes": 20570, + "rawSHA256": "A2F95DB09E1C3A3A500E75EA2AD58A102A1A37174053FD741E085FCE89701730" + }, + { + "path": "docs/internal/extensions/bv1/commands/charged-setup-build-v2.json", + "mode": "100644", + "gitBlob": "47651df9d2b919996d188a677213a41563d3d27a", + "rawBytes": 1022951, + "rawSHA256": "3B6A902FC15C2E620295A0B688E0A55AC5D8015072D2BD23B2DC257F0D4D5001" + }, + { + "path": "docs/internal/extensions/bv1/commands/charged-setup-build-v3.json", + "mode": "100644", + "gitBlob": "6799a479ce801bb9a188a416275d4d1d2c62b6b7", + "rawBytes": 229697, + "rawSHA256": "9450EEA3E4784071CE7A9A8E6856D7E13F9AB26EF66C71F7E63436D07C0A680E" + }, + { + "path": "docs/internal/extensions/bv1/commands/charged-setup-build-v4.json", + "mode": "100644", + "gitBlob": "e24a71a455738c6a2f2f5f5d7dfdd2e5a5f0290a", + "rawBytes": 222342, + "rawSHA256": "AA1509516C658000069225F5E2CC53F95468CA8368C2D156350CFB67AD3DD3CE" + }, + { + "path": "docs/internal/extensions/bv1/commands/charged-setup-consumer-final.json", + "mode": "100644", + "gitBlob": "58db6ce468e7327bfc9701c6322097cb43d6dead", + "rawBytes": 16555, + "rawSHA256": "83A4D989A92326221B66E676E6612647BC8AC2FAB4F29A9ED8B3F43C9C1D0F8D" + }, + { + "path": "docs/internal/extensions/bv1/commands/checkout-lakefile-observation.json", + "mode": "100644", + "gitBlob": "e123b3d734c4b64ed66c83a09e43dd03b24aee07", + "rawBytes": 855, + "rawSHA256": "ED856DE5AA0475D6B95677A71E927839543FF4D60C9D54F6831E3A09A2D7AA2D" + }, + { + "path": "docs/internal/extensions/bv1/commands/complete-layout-11.json", + "mode": "100644", + "gitBlob": "d3599091f73218d28970105eb1d2bbafe93db32e", + "rawBytes": 223463, + "rawSHA256": "0855ABEE6C4811A99B862D8D26BF79E445030AABD4687F07482D7F9BF5D68BD0" + }, + { + "path": "docs/internal/extensions/bv1/commands/complete-reader-12.json", + "mode": "100644", + "gitBlob": "bbb354a37a47c500e5f08694471b13cbc4827e70", + "rawBytes": 233313, + "rawSHA256": "3C95147E3F37848C125BCE040B7E228316974FC73CFF67EAD53BD53EE3DC970C" + }, + { + "path": "docs/internal/extensions/bv1/commands/complete-reader-limits-13.json", + "mode": "100644", + "gitBlob": "239a13a0c4f3391c6f788fbee9e1b3c8ed82f8cd", + "rawBytes": 229651, + "rawSHA256": "65D9B24CAFEB1F9C98E4B3A1AABA26DED0459F549992A3907E8FB915952D4644" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-generic-rank-r3.json", + "mode": "100644", + "gitBlob": "241d9695933fc19c9de1e0d1cd9a75dc43fa801d", + "rawBytes": 217176, + "rawSHA256": "B8F2878F1D3919156E60B21002013627DE2FFEF2E8B5FD3AD3D9641DEE4B77C2" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-generic-rank-r4.json", + "mode": "100644", + "gitBlob": "b0f26f876ed9463409ded81143d52ea763000be1", + "rawBytes": 218791, + "rawSHA256": "EB3C01DF188E217F979FB8518E902903C5BE3D3E4904729E62D41E6990C9660A" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-generic-rank-r5.json", + "mode": "100644", + "gitBlob": "b180ea95fbaae0b74b6f138b8d92292601345cf1", + "rawBytes": 214203, + "rawSHA256": "2CBB14B1C57DE4CBD0D2FDAFF4010BCB80436305094989D0D785A2CE588BF726" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-generic-select-r6.json", + "mode": "100644", + "gitBlob": "2c4cdf202355ec45b8c4cf9fbe012a1e2ab565cf", + "rawBytes": 221006, + "rawSHA256": "00136C2BD049BA567C02E0E42F509A32EB22AA7F44B8058A1C5F989CF2796303" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-machine-known-r17.json", + "mode": "100644", + "gitBlob": "f247765216bf3d31fa287f11118d74419bdbea63", + "rawBytes": 27014, + "rawSHA256": "1B2D79A1B8D52ABA452E154F0DC65B45FF108EFD9F5C437AA4B636AE871FBE93" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-machine-selectors-r18.json", + "mode": "100644", + "gitBlob": "cde8e50a269f8ad04aa65ca0d18671e068344271", + "rawBytes": 26247, + "rawSHA256": "6D22D44AF537072771A3392544C3934EAABF117C6565E0F7918056A90E5E54A3" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-machine-startup-r16.json", + "mode": "100644", + "gitBlob": "d3a54675bf2e394e203957cb72ab5f38b4495a11", + "rawBytes": 24348, + "rawSHA256": "2C2D0D42022800E613DA9B74939371AD907414BC1C1A97B7D1F932283B8E3CD8" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-machine-static-r20.json", + "mode": "100644", + "gitBlob": "eb661e2ccfc6259527bb777a8a5fb7188cae7c9a", + "rawBytes": 42482, + "rawSHA256": "17E1DC942B1FB86EDA0CC7DA407A1BECF876C32216C0219B2A39D19BF76057FA" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-memory-consumer-r15.json", + "mode": "100644", + "gitBlob": "41d8d90a7e48ab5f0c046b67b1cc24db3d3a3221", + "rawBytes": 27010, + "rawSHA256": "B4DFC1911A842B9AF973B0B1CF36D0DE6AFFDD116394326D196694D027DAC454" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-memory-r11.json", + "mode": "100644", + "gitBlob": "810b862525f734d2d42a95bf5d9bccdf00bd791f", + "rawBytes": 229780, + "rawSHA256": "F47A0C1B86A54231E27E8650CB827908CE2BB4E283B9E01FB84F3EDFE8931A5E" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-memory-r12.json", + "mode": "100644", + "gitBlob": "dc35b4682d58bbc41e4bd3428d334dadcdf36aeb", + "rawBytes": 226332, + "rawSHA256": "1342F5964633C4F77FB9BBD68DB85E8EF98267AEE67C80B361FDADF23E736C03" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-memory-r13.json", + "mode": "100644", + "gitBlob": "804543422acf385e0c5d01f23ac206da14f99d9c", + "rawBytes": 232507, + "rawSHA256": "88391794ED5640F5382B6F5C614708751FF27C914A605621D23948863DCD319E" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-memory-r14.json", + "mode": "100644", + "gitBlob": "f65b10013a1ea5a430ff8e6cf6f97e13df21ef01", + "rawBytes": 229048, + "rawSHA256": "DE1D61FF8ED4049B1BA21179BDA03877CC3969443BEC6893D55D267A3542D682" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-rank-prerequisite-r2.json", + "mode": "100644", + "gitBlob": "c72f7d95c08f8ba1cbeaafd49b8b015cb458043e", + "rawBytes": 213772, + "rawSHA256": "4AC098274B138DD83A2F1C2F3A017623CD72AE6403A111E73EC147F6ED91B20C" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-rank-r1.json", + "mode": "100644", + "gitBlob": "3b5cbb41be0931cd8c942f13f4ca396404d82d56", + "rawBytes": 177860, + "rawSHA256": "81AD5CC2B6A88853E024186CBC219DF39EE4542E56DEAED558792F6DB899E4E9" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-rank-safety-r9.json", + "mode": "100644", + "gitBlob": "3c11b83294edd56fd0be547fa120119cd7f9af7a", + "rawBytes": 218295, + "rawSHA256": "0562EBAF4F7ED430CEF43E8FFC1C7DD5E404707E4CEEC6F3CF8322E5DCC4B1EA" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-safety-consumer-r10.json", + "mode": "100644", + "gitBlob": "3733a0b28fb6545669d55edb495b6bb1de9ed6cd", + "rawBytes": 18863, + "rawSHA256": "E5F7147B0D66B3EA1A4891BCBE6C1F10E62C81395A66556E4A2A519BEE0D3152" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-select-interface-r7.json", + "mode": "100644", + "gitBlob": "4e4b0f26a2550eae0b5ac58994d4a3ca533e82e9", + "rawBytes": 216983, + "rawSHA256": "8AD42A4F414B9F3F2E822D88214040C6C9BE0C3089CB4670C2AFDA7F0AC23688" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-source-consumer-r8.json", + "mode": "100644", + "gitBlob": "b0b7e385882b6e1a35049d795b49d04a89587277", + "rawBytes": 15652, + "rawSHA256": "0461B4472FA13F4F5239F02F7282EC132533EF667A2EA493BCEA11C1AED1B39D" + }, + { + "path": "docs/internal/extensions/bv1/commands/crossing-known-case.json", + "mode": "100644", + "gitBlob": "f3d8497fb24ba1ec972dd649336bd0f32427a7f2", + "rawBytes": 3346, + "rawSHA256": "107B024045569970D416F968D0B68B9E5C467AEED4C3560F2C95A382E3A3B7B2" + }, + { + "path": "docs/internal/extensions/bv1/commands/crossing-startup.json", + "mode": "100644", + "gitBlob": "4fd441d66e48f23adf973c6d7c647861f86463d6", + "rawBytes": 2554, + "rawSHA256": "7DD909F870DE9B660097E37B5C4EB3E7E39211B0EB0975E33F6528D846EB3FF6" + }, + { + "path": "docs/internal/extensions/bv1/commands/crossing-v2-known-case.json", + "mode": "100644", + "gitBlob": "f7dce17e3b381e8c851f3fdde8b7187151b4e0b4", + "rawBytes": 3667, + "rawSHA256": "FC96B072493C6B7C9B746156203F77E582FE28D28BECAA9320D69B97A0303204" + }, + { + "path": "docs/internal/extensions/bv1/commands/crossing-v2-startup.json", + "mode": "100644", + "gitBlob": "3e98f1fb820dab2305ce3ac2f233f84210a04933", + "rawBytes": 3419, + "rawSHA256": "B1EBFABD762C9FFCB6193F1A4C27A589AC0E274547D973EE28C6186DF3E09799" + }, + { + "path": "docs/internal/extensions/bv1/commands/evidence-design-correction-v1.json", + "mode": "100644", + "gitBlob": "9b5735c02316af730a3815f0e4949ad3df454085", + "rawBytes": 713, + "rawSHA256": "43BFBC62162D0A650F1E6658D9EB9A391F4933A8D7DF33A8048A03E3ACBE1F51" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-known-v1.json", + "mode": "100644", + "gitBlob": "2239cef887031ff52282c59354c8ce07baed950c", + "rawBytes": 61727, + "rawSHA256": "CF68372361F73C40D5A281B80003A482A42C30B3E520AE8D9E0F085FBA93FAC4" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-replay-v1-omitted.json", + "mode": "100644", + "gitBlob": "faf7ff06b11c4f93b8c67d6f51dfc2172845a721", + "rawBytes": 64111, + "rawSHA256": "F53E60AEE1ED2DE4D4DDEF95AC5EB9801107FC39A3BB623836CAC1872AEB99BB" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-replay-v1-route-accept-after.json", + "mode": "100644", + "gitBlob": "7dc4edb1729429dd43d1a3177316e90a56ebcab9", + "rawBytes": 62934, + "rawSHA256": "D6A6A614F1D2E5A262739A0F0FD371D0E947439304029454EABE1FC9C69BDAAE" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-replay-v1-route-accept-before.json", + "mode": "100644", + "gitBlob": "a3165fa5698d0176401856db698c46cdc13c4dc0", + "rawBytes": 62742, + "rawSHA256": "8FED62F8546109CE6C9194327F555A7DFFAE44818234E9C37F000AF2E9C92FD8" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-replay-v1-route-reject.json", + "mode": "100644", + "gitBlob": "f843de2da00247226860dbd881001adc4ab6531c", + "rawBytes": 62798, + "rawSHA256": "8C346BB716311C1A313A0E185CD7E7FCC56F0A1A5141A601FB4C8C5394E5CBD2" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-replay-v1-valid.json", + "mode": "100644", + "gitBlob": "809271bbf0af5286e161dc73ff65d3ada620f434", + "rawBytes": 62555, + "rawSHA256": "77605BB5447FB564C2422AD59DC3B32E46E5E0B477BB10F688CDC780F54A0018" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-replay-v1.json", + "mode": "100644", + "gitBlob": "25696570b45a29fc74b54c1dea07a46dc606aed9", + "rawBytes": 84679, + "rawSHA256": "4BD36879A9C95006D943A2DC7D0A6ABB285954759B8ED0147697F5D97E51B64B" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-startup-v1.json", + "mode": "100644", + "gitBlob": "cd0e482f990dd30aca6fe67f0f547fc266ee94aa", + "rawBytes": 109465, + "rawSHA256": "086C4C43EAB8C703A88FD4E2AE0B893811E8383F379A7F10A7B46155CEBF0584" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-startup-v2.json", + "mode": "100644", + "gitBlob": "30b87560a78c5b855dcc2aecc660010e802152be", + "rawBytes": 62975, + "rawSHA256": "7EF191F1DC401A7BA573AE5A7FB5B51145FE7D50C4EE7288CF6421255B3AB791" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-startup-v3.json", + "mode": "100644", + "gitBlob": "6c6459f2e99f832c028c3ffe2527a79b4756501b", + "rawBytes": 60950, + "rawSHA256": "C122E720B82056894069AD050ACD39A35031D1A6E25C3A8380A719602E0C2367" + }, + { + "path": "docs/internal/extensions/bv1/commands/final-report-claims-v1-output.json.gz", + "mode": "100644", + "gitBlob": "3cd9f82831b5399997204fa895ceb27ca134ca62", + "rawBytes": 31557, + "rawSHA256": "E3215C620F71942E895536119117F17831C1F7061272D4B5AB31121D41B34839" + }, + { + "path": "docs/internal/extensions/bv1/commands/final-report-claims-v1.json", + "mode": "100644", + "gitBlob": "9ad61183cd77e1baa4cfca4c9badf242352626f3", + "rawBytes": 799, + "rawSHA256": "BD863F1BA5984E24B4D445AC67C0BE4609824CDB7BB8144917A60FC3F87282E7" + }, + { + "path": "docs/internal/extensions/bv1/commands/frozen-rows-final-policy-v1.json", + "mode": "100644", + "gitBlob": "0c9f60b7e5cbc67cd70bc0ec24706176b5d661db", + "rawBytes": 10146, + "rawSHA256": "CD4357F022324752A0EB66D97A59B1E846139061483C38A81E075B365806F824" + }, + { + "path": "docs/internal/extensions/bv1/commands/frozen-rows-implementation.json", + "mode": "100644", + "gitBlob": "cc0e2effa5d7d9d29288f9d1a9dab57a88cec790", + "rawBytes": 10145, + "rawSHA256": "C5F23AE4FB9D86F72AC83727B05415D1553ABABC929C7F2B898D454B7575A186" + }, + { + "path": "docs/internal/extensions/bv1/commands/frozen-rows-pre-replay-repair.json", + "mode": "100644", + "gitBlob": "eff0d7703f4a7e1842f809c80d88826900acad4d", + "rawBytes": 10148, + "rawSHA256": "943BA6D806B9AC8C4A49C707A0D1935C532D87555F4E235E4A3DCE6D6BFB94C8" + }, + { + "path": "docs/internal/extensions/bv1/commands/generic-select-safety-1.json", + "mode": "100644", + "gitBlob": "58993f3a4094b1fee533cd4ea334dca109e6c887", + "rawBytes": 227111, + "rawSHA256": "69DE0DC7B6F832BB3BE3630C14C2E3FF64789E70C089E898506388ECA2D1BBB3" + }, + { + "path": "docs/internal/extensions/bv1/commands/generic-select-safety-2.json", + "mode": "100644", + "gitBlob": "1f134e5e5bd16ec7e616cd678a4a0ef733285e2e", + "rawBytes": 223496, + "rawSHA256": "D4F0FC074429485BF62638D52A5344A6C2E35F61B115A3C2587C7CD5D20FF9F5" + }, + { + "path": "docs/internal/extensions/bv1/commands/generic-select-safety-consumer-1.json", + "mode": "100644", + "gitBlob": "5d5e4a3955deab9247afe1a2b4ce9fb6900544a0", + "rawBytes": 19411, + "rawSHA256": "072F87ECCAC657BBDF46083797677B22E57D6BC10A7BB32996E8FE772069962D" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-final-policy-v1-claims.json.gz", + "mode": "100644", + "gitBlob": "3458e3f047c34a19e59ff17b8490465ddd0aa00f", + "rawBytes": 1198634, + "rawSHA256": "C80D9E825FD18A7F974138295ADD19245E286C4FFCBAAFF7B668118F6B2336F6" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-final-policy-v1-design.json.gz", + "mode": "100644", + "gitBlob": "f23d5dc6caeac20dced49f2e9fe17230834db162", + "rawBytes": 279, + "rawSHA256": "23F0243C259ED54A450630688D909E61444D0F01E09DD538D425547C4588CFDD" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-final-policy-v1-native-trust.json.gz", + "mode": "100644", + "gitBlob": "1559476b22a5c124bb3615e19e842e0a8cbfcfbd", + "rawBytes": 216, + "rawSHA256": "CF8320C46A07D78091BD847A1B5D0D681E3E8CB99E3E762D105000B6BBEDC576" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-final-policy-v1-range-diff.json.gz", + "mode": "100644", + "gitBlob": "3324b2c6c23067a936638a93d3945b7fc7a546b8", + "rawBytes": 216, + "rawSHA256": "9DED06C4403978C0C54091287FDA10B4E6C617AFA34623E9AA0815EEF3B08446" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-final-policy-v1-staged-diff.json.gz", + "mode": "100644", + "gitBlob": "6040be92a1f479e13083119efab6758a5a2f520b", + "rawBytes": 281, + "rawSHA256": "202C1ED84A83095AD7B52145F088CE42C70221ACD0C5C440ED1CAB03BE70326E" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-final-policy-v1-trust.json.gz", + "mode": "100644", + "gitBlob": "acf324fe2cefb446f8bb83208a65b902c6b323cf", + "rawBytes": 209, + "rawSHA256": "5565C3124076B9D6413B814CB9ED803CED1BFD7628B5F13859E67AD1323D2924" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-final-policy-v1-working-diff.json.gz", + "mode": "100644", + "gitBlob": "1e6c3cb4456fe828c920c54397b88c73718dcf6d", + "rawBytes": 216, + "rawSHA256": "7DD79014E0D19958E001CFC1EE1DE101DFDDADB88DE3C8533FA52249FE35227D" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-final-policy-v1.json", + "mode": "100644", + "gitBlob": "91f71ab740946de70475454bdd471c40e8accd50", + "rawBytes": 5851, + "rawSHA256": "2ED077B782C67ADBB7ECDF84E85287F38075123C287D39D5FC4A3A0D1970F352" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-precertification-claims.json.gz", + "mode": "100644", + "gitBlob": "b7d20ec4bcc0a86baae618cfeeb4e2aa6eed7b0b", + "rawBytes": 1188985, + "rawSHA256": "24698F2B225CD0574316514CDD4B1910C70B1674E43943C72D98E32676D05AC6" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-precertification-design.json.gz", + "mode": "100644", + "gitBlob": "9400e0b0fdeb9a145d6db0ef05de26b1d1cb74c1", + "rawBytes": 274, + "rawSHA256": "E457741CF1809D9576208ED01FF5EF13FC993DEA98E81335F6DB40AD91739305" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-precertification-native-trust.json.gz", + "mode": "100644", + "gitBlob": "6d04ad56dd8b69d7bfde6344066d1e22af2c15c0", + "rawBytes": 212, + "rawSHA256": "05A3BCF86170144ACCCF79626736792D3D8A195A5F45897782A05AF1356AB33A" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-precertification-range-diff.json.gz", + "mode": "100644", + "gitBlob": "e0fe46c801dd6f95e37462d2bce8cd38dd637ae7", + "rawBytes": 211, + "rawSHA256": "9323A76D487EC99FC1769DB47F432676A00D2D37ED45E44AC1F6668F6AD7E489" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-precertification-trust.json.gz", + "mode": "100644", + "gitBlob": "7593c2628e1ef421d67ae1d789ef46d3f85cdb7d", + "rawBytes": 207, + "rawSHA256": "3E7CD96BFDDB6A2C1B13D01979D4C96766C07DA38B32B79D4548DE4BE11A88E0" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-precertification-working-diff.json.gz", + "mode": "100644", + "gitBlob": "aacdbce67c4e75b2aa80bcc6ef17f094f58921a8", + "rawBytes": 485, + "rawSHA256": "EE28ADFDA9282557955164CD9DA62FA69B44F2EA9F0E8B3639EAD012851757A3" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-precertification.json", + "mode": "100644", + "gitBlob": "e2df599d80c36ddf420aea835de4f278c2876d21", + "rawBytes": 5420, + "rawSHA256": "319D1E77EC69984EF8447459689532A7EA9C3D535B0EDD292D7C038F25FDC265" + }, + { + "path": "docs/internal/extensions/bv1/commands/index-byte-final-v1.json", + "mode": "100644", + "gitBlob": "37b360668df697f544cdc21ae136203cb7b38709", + "rawBytes": 287230, + "rawSHA256": "692121A53FC12712DFC64E0A1AE611BC88A449AE6624C45F6C527598B9CBF6F6" + }, + { + "path": "docs/internal/extensions/bv1/commands/index-byte-preflight-v1.json", + "mode": "100644", + "gitBlob": "3bd41399a3e7cd06118d0b71d489dd2a1a689aff", + "rawBytes": 10557, + "rawSHA256": "EEFA2A706BA1616C8898536318B4F472E3338B111C4415AC4B42C7E30C25CE25" + }, + { + "path": "docs/internal/extensions/bv1/commands/index-historical-eol-v1.json", + "mode": "100644", + "gitBlob": "f22fb2438356b038cf4e2202134891f5d3505b56", + "rawBytes": 8868, + "rawSHA256": "AB7CD75359F43BAB5A3FB302A2DD0B6C46E40915BD047C164685CA9BE2BE6861" + }, + { + "path": "docs/internal/extensions/bv1/commands/leaf-replay-20260912130101742-canonical-select-safety.json", + "mode": "100644", + "gitBlob": "49bfc225cb86e3b9429b4cce912d497fd455272f", + "rawBytes": 33671, + "rawSHA256": "CDEB96061245BA59F592DC827288A0EC041FED5DD40057053BC40315A134BD5A" + }, + { + "path": "docs/internal/extensions/bv1/commands/leaf-replay-20260912130101742-generic-select-safety.json", + "mode": "100644", + "gitBlob": "3161c2bba3d0a5a8dd5324c37b4da1e3ba26e1e1", + "rawBytes": 33627, + "rawSHA256": "71412F83A9780B15AFADC835B7CC955E938F415015C62DDB0EEEA0FC6903C024" + }, + { + "path": "docs/internal/extensions/bv1/commands/leaf-replay-20260912130101742-rank-layout.json", + "mode": "100644", + "gitBlob": "d5933e58ddd4dd43429b72a368b1aa3b9568f6bb", + "rawBytes": 34025, + "rawSHA256": "8E1B2F9E875CAD259CEA07C8A065D9C04CF8E16D41D349551F0CA9451F7B6A20" + }, + { + "path": "docs/internal/extensions/bv1/commands/leaf-replay-20260912130101742-rank-semantics.json", + "mode": "100644", + "gitBlob": "3f994a65b48211159cb61871014e444a53c63308", + "rawBytes": 32293, + "rawSHA256": "608D67251A2E366CD44D26B2FB6100FBE13121DFD87B83724ABFFB0FD910FBD5" + }, + { + "path": "docs/internal/extensions/bv1/commands/leaf-replay-20260912130101742-regular-layout-axioms.json", + "mode": "100644", + "gitBlob": "13611dd697d0768912cfacf89b89367f230e60c5", + "rawBytes": 32062, + "rawSHA256": "05C7019250A1087E44981111DFB9CB8D4E1017C0CF40C1D622F833689DA79FD5" + }, + { + "path": "docs/internal/extensions/bv1/commands/leaf-replay-20260912130101742-regular-layout-types.json", + "mode": "100644", + "gitBlob": "e61066772bc9b3836916de8013ace1c55643ff24", + "rawBytes": 33849, + "rawSHA256": "B56A4907AA7B8BAEC6106ED24696134F055A2DBA8A574F8409E1F934A8905598" + }, + { + "path": "docs/internal/extensions/bv1/commands/leaf-replay-20260912130101742-scratch-frame.json", + "mode": "100644", + "gitBlob": "43c65303a72a18f2ae6f33a4552cc8d82ff73829", + "rawBytes": 32945, + "rawSHA256": "06FA7F9769EDD48C758933F457D88B40144DA0CB882F261810104176B8B8063A" + }, + { + "path": "docs/internal/extensions/bv1/commands/leaf-replay-20260912130101742-select-semantics.json", + "mode": "100644", + "gitBlob": "a3779286f93976686658b0b498f877d2108a26f1", + "rawBytes": 32926, + "rawSHA256": "9EE21F88A484CB7E5D203998436B3F026B1E0813A5A578C058169794D09ED71E" + }, + { + "path": "docs/internal/extensions/bv1/commands/leaf-replay-20260912130101742-summary.json", + "mode": "100644", + "gitBlob": "262e1e8df6ef68b88276b750272578e8292a2b8e", + "rawBytes": 13668, + "rawSHA256": "E1A6FCF86B0F856DC1ABB486836A13E42CA31240FE458248230F6D81402C2C30" + }, + { + "path": "docs/internal/extensions/bv1/commands/machine-controls-v1-20260912111911796-bcf37cc6.json", + "mode": "100644", + "gitBlob": "88bb6e70fbc73a273a76f51c758a58d068a1c5c1", + "rawBytes": 60033, + "rawSHA256": "CACE30F722697D762E31EC2814D28AF89FFB2B45DA789FFD841991A4B266407D" + }, + { + "path": "docs/internal/extensions/bv1/commands/machine-controls-v1-20260912111955043-999b380b-omitted.json", + "mode": "100644", + "gitBlob": "a1816068efe33d11f90fbe0b72290158f4464bf2", + "rawBytes": 67995, + "rawSHA256": "95F84FD158C4E46A9A0490272DD99A2E3D283F173EE9045939B93693B6350E2D" + }, + { + "path": "docs/internal/extensions/bv1/commands/machine-controls-v1-20260912111955043-999b380b-valid.json", + "mode": "100644", + "gitBlob": "4c70a9387caf4ecf8ec2172a0889d2af53e753b2", + "rawBytes": 61089, + "rawSHA256": "B2C64DA938E9C3C120D78C49CF6A44AE6B0776F2AC1BE1D063E88792CF8A373B" + }, + { + "path": "docs/internal/extensions/bv1/commands/machine-controls-v1-20260912111955043-999b380b.json", + "mode": "100644", + "gitBlob": "3079c79d4fcd0f4680c7d6de19c5c689c93f0fd7", + "rawBytes": 77385, + "rawSHA256": "109AAB4B6E6FFD90B6DA496B6C1A46F104A68138C7D8031C1C5C5F67D403B086" + }, + { + "path": "docs/internal/extensions/bv1/commands/manifest-raw-staging-v1.json", + "mode": "100644", + "gitBlob": "7b84b3fb690bbcc17ccaf6b8c6fd6e497f39efc0", + "rawBytes": 510, + "rawSHA256": "4BE7C5B09AF0824ECC8F28AA0454C7D69EDE5085A06B8D40EDB81A76B555B890" + }, + { + "path": "docs/internal/extensions/bv1/commands/manifest-semantics-v1.json", + "mode": "100644", + "gitBlob": "2db43595677687c846b6b480ad96b39604bdc6cb", + "rawBytes": 770, + "rawSHA256": "B78A8150F50CC0D80541FEABA2EC32A04B6C834F88D7D03C04EE6EC17875C44C" + }, + { + "path": "docs/internal/extensions/bv1/commands/memory-layout-1.json", + "mode": "100644", + "gitBlob": "54bcbfaaea209c6758b2bafc29f890327239d004", + "rawBytes": 8119, + "rawSHA256": "0B3CED500236DCBEB8BC43B89089A70053CFE733D0B89F0FA90F2E299FE625AB" + }, + { + "path": "docs/internal/extensions/bv1/commands/memory-layout-2.json", + "mode": "100644", + "gitBlob": "3916fa31fe824189baf2f8494174db1b00124627", + "rawBytes": 4037, + "rawSHA256": "8F4BC4C1B1DCCC13D565057E6BC505EBCF7A9C6101D58C94820452744E12DFEF" + }, + { + "path": "docs/internal/extensions/bv1/commands/memory-layout-3.json", + "mode": "100644", + "gitBlob": "daff23e0e115e621a38e8e16b7f071869f2f4e6e", + "rawBytes": 18941, + "rawSHA256": "DC0FF4C4546996A45814C697BF9C3B6FEF94A57DA455F4DE8F5C967ACF7390CA" + }, + { + "path": "docs/internal/extensions/bv1/commands/memory-layout-4.json", + "mode": "100644", + "gitBlob": "f2a26643409cbdc8f822afaf1dc2f90aa1db0408", + "rawBytes": 33124, + "rawSHA256": "251B09244B5C3C2433B608071A3D33E9DADF5826E587FAC23905DCA188B7ADE4" + }, + { + "path": "docs/internal/extensions/bv1/commands/memory-layout-5.json", + "mode": "100644", + "gitBlob": "f1bd1b8bb44380eff44db77dd7f808c7b0332112", + "rawBytes": 15728, + "rawSHA256": "485ECBF4803E634AD95E3A7B734ED7B8247DB13D709540D6CEDD25C7C258D005" + }, + { + "path": "docs/internal/extensions/bv1/commands/memory-layout-6.json", + "mode": "100644", + "gitBlob": "3ea7e8b6a9c90eb54332e232ee4f17049535a5cc", + "rawBytes": 13176, + "rawSHA256": "04A7ADA5D6573D7C6B1F310B0310D5E548973A0BCFEF0F83AEFB2EF96C022012" + }, + { + "path": "docs/internal/extensions/bv1/commands/memory-layout-7.json", + "mode": "100644", + "gitBlob": "a09894ca8ef39b4a18925d145e781ef8bcea3757", + "rawBytes": 111350, + "rawSHA256": "0B72CB3B2B115A5C8FEBA3BBDC6C5A77B0F3BD2B4871E3028C1FE68183EE8695" + }, + { + "path": "docs/internal/extensions/bv1/commands/normalization-axioms.json", + "mode": "100644", + "gitBlob": "65e7898d575f389c123a1dc6c18ff35fe22a20a4", + "rawBytes": 2674, + "rawSHA256": "5A396EA974D67BDAB45F3B26BF37BFEF7124712925D9F1C4E8AB67758CC5C7FB" + }, + { + "path": "docs/internal/extensions/bv1/commands/normalization-final.json", + "mode": "100644", + "gitBlob": "a2cd0b172c58c4a2f29dff73820e13700b3d0071", + "rawBytes": 1077, + "rawSHA256": "FFAB97E0C967554B6D5202C71A928911FAA14DECC913502485382EC987757D62" + }, + { + "path": "docs/internal/extensions/bv1/commands/normalization.json", + "mode": "100644", + "gitBlob": "1faee7b38c0da895e822989bb514bced7156d145", + "rawBytes": 2327, + "rawSHA256": "AB3DE5F3277A7F22BB8892CCBCEB606208062F5F441540829C25CE4B5D46B2CD" + }, + { + "path": "docs/internal/extensions/bv1/commands/numeric-reader-build-final.json", + "mode": "100644", + "gitBlob": "956d3e7e3b3aa6ba3bcc947d8ec81caee6d349e6", + "rawBytes": 11276, + "rawSHA256": "4D1E351B22CF9F1719DB7499BDB5FD56FEE5D878F95C48F876BB69CE56B4FA93" + }, + { + "path": "docs/internal/extensions/bv1/commands/numeric-reader-build-v3.json", + "mode": "100644", + "gitBlob": "5158d4b38791caaa6fb5c0db2cabd6a6b69ae79d", + "rawBytes": 19376, + "rawSHA256": "700AE87D2C708C737044C52829D17D71171CBBF8B4327FD71E29EDD36B3F3FE3" + }, + { + "path": "docs/internal/extensions/bv1/commands/numeric-reader-compile-v1.json", + "mode": "100644", + "gitBlob": "2e77d83bbff18e080f23713df4f83554af00f653", + "rawBytes": 179644, + "rawSHA256": "3C233DA69003757FE9033D8F079D0A324BA10B5A11C0582074880097F8FA8BFA" + }, + { + "path": "docs/internal/extensions/bv1/commands/numeric-reader-compile-v2.json", + "mode": "100644", + "gitBlob": "a238778aabe2b5dac12f36b1fc2eae53a570c0c3", + "rawBytes": 110529, + "rawSHA256": "C65EC384AAE9B489859C218F3FD8F57F35179DC76D428623E179AEED79CD7F55" + }, + { + "path": "docs/internal/extensions/bv1/commands/numeric-safety-build-v1.json", + "mode": "100644", + "gitBlob": "7271f25b043026c0ad21939e35a3dbc8b7a5a1ca", + "rawBytes": 284233, + "rawSHA256": "C256ED07C731F93739AD917E3D182DCD2D1790A1E90A147D9050660A5A3E2F03" + }, + { + "path": "docs/internal/extensions/bv1/commands/numeric-safety-build-v2.json", + "mode": "100644", + "gitBlob": "ed7e447e26e6a1d4fedb2b2c2a659301ea9bdcfd", + "rawBytes": 280144, + "rawSHA256": "72CCD651EE1259A9CF27477C2210EF22637C75AB0ADEE8CF9FAE860D71F3AE53" + }, + { + "path": "docs/internal/extensions/bv1/commands/numeric-safety-build-v3.json", + "mode": "100644", + "gitBlob": "6987e6ce78a7946b585ae69cb0bd540117815f40", + "rawBytes": 220931, + "rawSHA256": "5A7BA4F2CAF4D9ACEFCC9F42525BB00C08B7E12ADBF89B4B928122DD4F007A3E" + }, + { + "path": "docs/internal/extensions/bv1/commands/numeric-safety-prerequisite-v1.json", + "mode": "100644", + "gitBlob": "f77ec5cc85892bbd9266259b809bada10a600307", + "rawBytes": 216014, + "rawSHA256": "CC17C6EA8763FCD36C1A26C212FB029A427D93441DD96421D062DB292D3B1857" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-14.json", + "mode": "100644", + "gitBlob": "8e9f0bd6198fea645d72f01fc50433d863de565e", + "rawBytes": 241595, + "rawSHA256": "3C34CE19B0AB0350BBA52DBD952BDAB74CD9758488D66E4B204D42D52A325BC0" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-15.json", + "mode": "100644", + "gitBlob": "3d56532248940fb80da3eca90b705049cdaf193e", + "rawBytes": 228977, + "rawSHA256": "1EE190588BF5AE4AF023F53B27609AEF80ED1FDC339CA0B1FF18C0BEF50E698E" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-16.json", + "mode": "100644", + "gitBlob": "524b49c8e356660b003990157dee89be3dfc4330", + "rawBytes": 237399, + "rawSHA256": "92C924674719C11DF4EDDD153B76AE76DB79C6E7677F2EA2ECB6161D8AE5AD38" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-17.json", + "mode": "100644", + "gitBlob": "37fd623828aa03c3561e79e91aec985b90685b4d", + "rawBytes": 23725, + "rawSHA256": "C6799EDD33BE6994DA943AD4F1F0D640DE64B03CEFDFA015B1E3CCD3D328DF86" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-18.json", + "mode": "100644", + "gitBlob": "ef4cb6d0ecd4db75cceec3a89f3162aa1139c790", + "rawBytes": 235181, + "rawSHA256": "3CBAE330E9D31141AE546950E9CB773A32165BD545908FE6AC729D15BFF5E353" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-19.json", + "mode": "100644", + "gitBlob": "fc02b6c30d34f8e404ed195f155545972c5ccc8e", + "rawBytes": 236878, + "rawSHA256": "8BEBEE33C93B34D4DCD967B45B3CB98B9A01A0BA8B58204BE275B4B3FBB2D8D3" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-20.json", + "mode": "100644", + "gitBlob": "2bd071817760a4e4615ac8c3787ceddf852ed24f", + "rawBytes": 240813, + "rawSHA256": "117F6B72E0AD9BFF652A29775D362BB409552BC8F6D18B1701F06D5C45D979CD" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-21.json", + "mode": "100644", + "gitBlob": "e7099c0ffaa0ef6dd70b42a5fec05171f9bc8786", + "rawBytes": 241344, + "rawSHA256": "1B22A8AC734B7C9AE0ECD56784FCC0C8E0F67C4A0B4D04112A481B217F804A44" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-22.json", + "mode": "100644", + "gitBlob": "1e1edc8d31f14dd8d8ec5e231c220a92cefecc79", + "rawBytes": 243818, + "rawSHA256": "CE7DF6C3641842B57CF287199CB2DF8591939A2262C1C3B357DA89CD7B755469" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-23.json", + "mode": "100644", + "gitBlob": "9937545cb1f67bc6b1bcd0e0c13f0b08ad2c7c75", + "rawBytes": 238075, + "rawSHA256": "D6DE55FAF1E3FA977251A7E3CFEFEEC3F4ABD9008647ECE1D9D8BEDC0502C2DD" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-24.json", + "mode": "100644", + "gitBlob": "a528935d34b6f81d03b4e2f97666dd5257e5f88a", + "rawBytes": 251683, + "rawSHA256": "AF9B7575B97DF5C5F6FD1836A54EA35C5EFF107AF6D4D47974053EA035E80F70" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-25.json", + "mode": "100644", + "gitBlob": "a231fb5685fe7c90003b56324515fb67b1b6e771", + "rawBytes": 269368, + "rawSHA256": "15B294ED5B2AC1EE5C4D2104A4C75CDEE51EEDEE886C1914527A8FCDA0E2A9C1" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-26.json", + "mode": "100644", + "gitBlob": "5a0730dd4ea5b3f9d0a6151cb700ea516a4fc57e", + "rawBytes": 285902, + "rawSHA256": "8A92C0876CA1E64FE8AF6E6EBAB63232279D199D2F8C4062868CD9BB8D2E65A4" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-27.json", + "mode": "100644", + "gitBlob": "0c6e87eecf6588a7c0342a32d03d3645da2732fa", + "rawBytes": 498706, + "rawSHA256": "BAB8667CE6D220683F33FBCB708E73808C3BF9FCF65D6F09BC06ABF337BB7B81" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-28.json", + "mode": "100644", + "gitBlob": "4d626b3047a3246897fa58277fe4da0152da1cbb", + "rawBytes": 269113, + "rawSHA256": "0823F9B639A6CABDFFCB47601D28C00ADC098BE0D76B8D15CCC449B1CD73F01E" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-29.json", + "mode": "100644", + "gitBlob": "d47c09392b9564ed7ac9b932d5a103cd3f40651c", + "rawBytes": 242550, + "rawSHA256": "DCCF072C0BEE703486C53774581610E86087D645D4B116D7785EAC6F2EE434E4" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-30.json", + "mode": "100644", + "gitBlob": "3e449dd5de06f0373163a4802acc92254294c37e", + "rawBytes": 236329, + "rawSHA256": "53B5A876C863E8755AF4FBEF997A7D12A25B82C966FCFB4D5034C1F448D15D59" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-postcommit-claims.json.gz", + "mode": "100644", + "gitBlob": "e54977658cc9d98b96604c175136fec49b10ff49", + "rawBytes": 1169364, + "rawSHA256": "2B00B67D50BC0DABD6A090B6CAC08B3FC3F5D34036A76363B9BC7A3DD84A210A" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-postcommit-design.json.gz", + "mode": "100644", + "gitBlob": "352cc6be08c69be6527daca763114ba8c0718f79", + "rawBytes": 267, + "rawSHA256": "E418D4B3534D507734FC121531C8C98E925872A78A0B918029B095BF1C1F0F9F" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-postcommit-native-trust.json.gz", + "mode": "100644", + "gitBlob": "b4b3d0ec8a31e079820f0b6a25cd9024838ad4ee", + "rawBytes": 200, + "rawSHA256": "E064A06AA3BF0E51DA32F9D274C96827979495491F3368FC4EC3DD0721B12311" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-postcommit-range-diff.json.gz", + "mode": "100644", + "gitBlob": "2f68097dc24fe33d8815eee20b968bcb7ab4778b", + "rawBytes": 203, + "rawSHA256": "A56C74DF68E9FACF093E30BC7E9A3749249C7429F688E95FE0635360F4B153DC" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-postcommit-trust.json.gz", + "mode": "100644", + "gitBlob": "843b3578ec4c3c53cd38fdc72d9c920491187e5b", + "rawBytes": 197, + "rawSHA256": "1B2754223EE3C894871AE071BD549EECE417285BF24E0F03E21D51EC6D06C629" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-postcommit-working-diff.json.gz", + "mode": "100644", + "gitBlob": "a3ff3bc7a56fb757eb08a6647a0f66c06d4fd177", + "rawBytes": 341, + "rawSHA256": "76FF7E8C1FEB573509A09E9A03CDDFC2B03515EE83214A6C143E84860D0CC2D9" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-postcommit.json", + "mode": "100644", + "gitBlob": "aa1e570784914100d6a8b04cafb12bde350f6a53", + "rawBytes": 5306, + "rawSHA256": "1E3AD9EE5C0850BDF2FC38D5F93D9043A05EEEB16DB11381B3F2C3D7062AD4C9" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-claims.json.gz", + "mode": "100644", + "gitBlob": "f442ebd3be0bde366c6ccafae68783d6548d4b2a", + "rawBytes": 6330702, + "rawSHA256": "1C81DF3849FF0498E1316AA317616CB7FDE17C92B04B41ED47056EA1C7545C5F" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-design.json.gz", + "mode": "100644", + "gitBlob": "1e0c61fcbc12b6154cd3982e9f5b5d67a2f37f30", + "rawBytes": 266, + "rawSHA256": "872999DE12B7F7D0A5A8AA37F88B78088BCF70C0F59713EBC14926A88E7CB472" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-native-trust.json.gz", + "mode": "100644", + "gitBlob": "9eec55a615f0aec1e19f8c3869142f4e95ed4486", + "rawBytes": 199, + "rawSHA256": "42905804016161CEB5B0B4252A2EC0C9D8FEA31B907400FA7A10A624CC70E63C" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-r2-claims.json.gz", + "mode": "100644", + "gitBlob": "042aa05aea2b25c960be59d40e21ac754270e195", + "rawBytes": 1166740, + "rawSHA256": "6690DD4F178C64CB249FD1A84B6987CEACDE4A56414133B79168ED5ED8D0EADC" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-r2-design.json.gz", + "mode": "100644", + "gitBlob": "cb7b7a98b593bceb4b70eed1c79636b71e63aed4", + "rawBytes": 269, + "rawSHA256": "571136FF0B2A2B23036182E65437A6CEFDE9770491C5AA93E072B6C6722DF632" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-r2-native-trust.json.gz", + "mode": "100644", + "gitBlob": "9fae177fb666127d55428cfea55a7e7ed4b7db41", + "rawBytes": 205, + "rawSHA256": "993ABF75D1371778197A7D16D13A6EF860D21386C2DB42A5F95988419A295A82" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-r2-range-diff.json.gz", + "mode": "100644", + "gitBlob": "c4f0de2d2a654626829dc35cbdded15a1ac7d695", + "rawBytes": 205, + "rawSHA256": "807CC5071BCABD70147C2622D4F812D9AAE3853466811A1121E32B071C5FCB86" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-r2-trust.json.gz", + "mode": "100644", + "gitBlob": "78b999c3300ea3324bac89a5b32716b8554d424d", + "rawBytes": 198, + "rawSHA256": "E7985C7CD3BF688DDD343B6436D66A23F4648C99F65604A7FDC7940D24C514E8" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-r2-working-diff.json.gz", + "mode": "100644", + "gitBlob": "7cc4424b29afb44dac54adf3a6852b2da4f79839", + "rawBytes": 340, + "rawSHA256": "D89861C04B553DFC878E51963933634646B993E3C36E709B56FDB8907DA0EB39" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-r2.json", + "mode": "100644", + "gitBlob": "4fa8c8c1bf79fb8c232f44314a2a547529e6a6ee", + "rawBytes": 5294, + "rawSHA256": "23FDDDB8FF6E71877C1252FB1B1A2EDCF1BA8142E7550BA394A2D905256D1B9B" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-range-diff.json.gz", + "mode": "100644", + "gitBlob": "bbc7179392ae9c441151f27fceceaf853c545cd2", + "rawBytes": 203, + "rawSHA256": "7CFAD20856E23B7B578DACC15A1C4D5CB26DE74F26503C1307189DF94916FF9E" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-trust.json.gz", + "mode": "100644", + "gitBlob": "8b00e7b8c2a107fce34c31e117e75492e48316b3", + "rawBytes": 198, + "rawSHA256": "EB7EEEE7DCA17FD5FC09DC43DEDFC0767D94E635639AC6E553010072A10FF585" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-working-diff.json.gz", + "mode": "100644", + "gitBlob": "9741b0b5200877c755af4df26734489d8961ead3", + "rawBytes": 335, + "rawSHA256": "85730978D93FCC33C8EAC2FF93B9D7AA3F6D50DF1A0EAF86FA6B958DDC3486B6" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit.json", + "mode": "100644", + "gitBlob": "b3d72ba9464faaea4a7b092faf2fdd1655afd49e", + "rawBytes": 5278, + "rawSHA256": "FBB6F49B8A0B6D7F819DB4F6AF97FE7C68C142893B9F6674DC918E1FA8F2968E" + }, + { + "path": "docs/internal/extensions/bv1/commands/provisional-evidence-design-failure-v1.json", + "mode": "100644", + "gitBlob": "43ca2e497649464c552f2b9a79c085f30ce10322", + "rawBytes": 1068, + "rawSHA256": "AC6784565E14D08144E063FE9FFB019FAE0A44177A8BE58B23C67E6FF08FECF7" + }, + { + "path": "docs/internal/extensions/bv1/commands/rank-layout-1.json", + "mode": "100644", + "gitBlob": "a454a331514f0a5ebfa2da49e663ecc17daf39af", + "rawBytes": 13865, + "rawSHA256": "980F203778BE1E513B1AD9536231AD8BCB0EC93F81CA3267C7ADC3CF871BE44A" + }, + { + "path": "docs/internal/extensions/bv1/commands/rank-layout-2.json", + "mode": "100644", + "gitBlob": "0bb0222b0ea260b9355d0a2e6b993c38b344d0f6", + "rawBytes": 13644, + "rawSHA256": "22ACCD5AB23DDE3D05BC7AFA07F9D2BC4AD07031E6DB25E7F06A7A5D48D13116" + }, + { + "path": "docs/internal/extensions/bv1/commands/rank-layout-consumer.json", + "mode": "100644", + "gitBlob": "a53c64c246bb626259ad1f38b6fb0256e10ba9b6", + "rawBytes": 16312, + "rawSHA256": "60056965796ACF009363DAB4F86CF5B08FFEBEF98960673FE8C2941AFE155256" + }, + { + "path": "docs/internal/extensions/bv1/commands/rank-semantics-1.json", + "mode": "100644", + "gitBlob": "e32249b49c5968551edc0bae05c7eff0a4172093", + "rawBytes": 29218, + "rawSHA256": "1B2A87914D3550FA7C2B8B76BCE143A0369E2FBB0C779C2B841AEE7283199E8A" + }, + { + "path": "docs/internal/extensions/bv1/commands/rank-semantics-2.json", + "mode": "100644", + "gitBlob": "82e96d5ec6b2dc1917e5da6c4a814d659488ecc7", + "rawBytes": 21528, + "rawSHA256": "9650366E79E29F7EDF98A0140CCDE3F879D69A9BEA6ECFCFEC7EF942ABA29234" + }, + { + "path": "docs/internal/extensions/bv1/commands/rank-semantics-consumer-2.json", + "mode": "100644", + "gitBlob": "905e1ccf8815baa06849b9fc758fc6e94db7f89b", + "rawBytes": 12308, + "rawSHA256": "2F6566E97767D9BD2EC7D3748592EFA0C668DF2A1BF75291A2BACBABC4C5D301" + }, + { + "path": "docs/internal/extensions/bv1/commands/rank-semantics-consumer.json", + "mode": "100644", + "gitBlob": "ba2e521a614491f51dac2497988c5c2bbc937f3e", + "rawBytes": 13804, + "rawSHA256": "40BE56DE7D32A3FF5434F58228AFD49A083803579A3E5A2BF27FFC8FCDE3FC02" + }, + { + "path": "docs/internal/extensions/bv1/commands/reader-geometry-9.json", + "mode": "100644", + "gitBlob": "4b4b146c7cac460bf125fd08eb4fc6402fabd0f8", + "rawBytes": 223997, + "rawSHA256": "E731C733040F2B68754B51E15C5D19363349A4CDCC0E613C86A6F9B3202C890E" + }, + { + "path": "docs/internal/extensions/bv1/commands/reader-space-10.json", + "mode": "100644", + "gitBlob": "8880fb4d686abce2119f891463dcc6a58cc64404", + "rawBytes": 232365, + "rawSHA256": "30FD3E8FC6BAF88AC38949D5F64719B689BBAF7F3F4617259424122F79F9ECE0" + }, + { + "path": "docs/internal/extensions/bv1/commands/reader-support-8.json", + "mode": "100644", + "gitBlob": "185bccae6fd776a5176e4c341297c4765a9354fd", + "rawBytes": 14000, + "rawSHA256": "05C98DF23E912CEB165AD4BA7A888EA23C73E5A8DC117C6CFC8215C183D51053" + }, + { + "path": "docs/internal/extensions/bv1/commands/reader-typed-axioms.json", + "mode": "100644", + "gitBlob": "2cc623dfdc2c8d713dc6110b92c2fc70d2b66cef", + "rawBytes": 3642, + "rawSHA256": "030CE603AEB22900875BD950D695B69DD4B78B5B9F5E023EBA1EF38850DEF1D1" + }, + { + "path": "docs/internal/extensions/bv1/commands/receipt-report-claims-v1-output.json.gz", + "mode": "100644", + "gitBlob": "ac929cac455b65808ed5fb9167a2a3ac448d51c6", + "rawBytes": 5742, + "rawSHA256": "B476D2B78B3A6A0A1D2DB89CE4A2FA94A0E354820F0F2C085A4D917374D16C93" + }, + { + "path": "docs/internal/extensions/bv1/commands/receipt-report-claims-v1.json", + "mode": "100644", + "gitBlob": "f73f0a5be1b62385f42ee5f8ff1f18e45228ac1b", + "rawBytes": 1017, + "rawSHA256": "0B7B3F309BCFFA3E82CC634E6010CC6C2F91689E05A71227A446AB23793C2DC8" + }, + { + "path": "docs/internal/extensions/bv1/commands/regular-layout-1.json", + "mode": "100644", + "gitBlob": "523fbfa0cf48dcb72e2cb0e207b8d94bb43660f0", + "rawBytes": 17427, + "rawSHA256": "576BB8609C564D2B248415EFF83C42F602A598A32D01379F3272AFAB9C63C8ED" + }, + { + "path": "docs/internal/extensions/bv1/commands/regular-layout-2.json", + "mode": "100644", + "gitBlob": "f9c859595da0030396b58cb7de015f117481acfa", + "rawBytes": 8858, + "rawSHA256": "8B6F9776B7463DA434077995EFBED54DA8AF5E1D0F90BECEB717C9DC97038ADC" + }, + { + "path": "docs/internal/extensions/bv1/commands/regular-layout-3.json", + "mode": "100644", + "gitBlob": "323ba6c5649532bd4f6c51303d9de6254e74e489", + "rawBytes": 5972, + "rawSHA256": "438A8BE409A500A6FB503C568C73CD95C3EDC503D19387C0E08962081D134F6F" + }, + { + "path": "docs/internal/extensions/bv1/commands/regular-layout-axiom-source.json", + "mode": "100644", + "gitBlob": "a64ee11026ac2b1687cf3a4a83e5c6f1969401e3", + "rawBytes": 7040, + "rawSHA256": "DE8754EDCA0C6E67DF9E74BECF74160100FCA5E9DED29E7288800CB05B95C209" + }, + { + "path": "docs/internal/extensions/bv1/commands/regular-layout-axioms.json", + "mode": "100644", + "gitBlob": "ccf91b61c0a73de55ebfbd8db5531fb0782875c1", + "rawBytes": 8846, + "rawSHA256": "B59C60E80DCBCE5A41CDA7CFF5D87633E883E48A59AAFDD41F26E9D9DE97E079" + }, + { + "path": "docs/internal/extensions/bv1/commands/scratch-frame-consumer-1.json", + "mode": "100644", + "gitBlob": "2254024d06e215768e88cfe006dff29d688e32f7", + "rawBytes": 23491, + "rawSHA256": "8E5DB3407733F593D9B5D027908BE4F49A9E18482FC822B13486BE0C7787D8FC" + }, + { + "path": "docs/internal/extensions/bv1/commands/select-experiment-compile.json", + "mode": "100644", + "gitBlob": "17fe04b8891d2c19072413e44e1810d30d739e41", + "rawBytes": 4192, + "rawSHA256": "8497256A6218E97D3642041669BFBD15C12AF56DE826E07873985536F1F74962" + }, + { + "path": "docs/internal/extensions/bv1/commands/select-known-case.json", + "mode": "100644", + "gitBlob": "e6faef7593a7dc2debc4f7090f0416f9c6e5ddf7", + "rawBytes": 2397, + "rawSHA256": "EFF5E47AAA2B941A7F9274622968D8C8DDF749E7AFBE0B7EA60E9C10C367E18E" + }, + { + "path": "docs/internal/extensions/bv1/commands/select-reader-compile-r2.json", + "mode": "100644", + "gitBlob": "5a4d5fef7f573198d732ab83d1d925a1b618f409", + "rawBytes": 1258, + "rawSHA256": "105BD8BB6BB420D28F1CC2124533220F7C9D0B0568881F632A500D445B0EC24D" + }, + { + "path": "docs/internal/extensions/bv1/commands/select-registry-v1.json", + "mode": "100644", + "gitBlob": "429613884ea30d28d314176c6b5c18e871820ead", + "rawBytes": 6761, + "rawSHA256": "C7827D26A18C302F09CE6902E03B9D90429D6FBE358F9D370E915427C29DD142" + }, + { + "path": "docs/internal/extensions/bv1/commands/select-semantics-1.json", + "mode": "100644", + "gitBlob": "d06f3db059afae7610c941882d02b5cdc77c576c", + "rawBytes": 36028, + "rawSHA256": "FDCF3F46B691D093B9827EB47C62481623D6EA02AFFC13A5C46488B2AE585FD9" + }, + { + "path": "docs/internal/extensions/bv1/commands/select-semantics-2.json", + "mode": "100644", + "gitBlob": "d19a70aaf4b9cf6d5cf4ced877b11b56967118c4", + "rawBytes": 80670, + "rawSHA256": "ADAB4D5D52D975D2D3F3C21F5881F6320BD743F55C690BF4D37BDBA7E2019196" + }, + { + "path": "docs/internal/extensions/bv1/commands/select-semantics-3.json", + "mode": "100644", + "gitBlob": "e94d5e77698eb2fb419f11afe53d92eeb7bac038", + "rawBytes": 19631, + "rawSHA256": "1D39B0F0E2581E036DCE49968818D3F65F7EE9988BA429D4C57D4E3D9074AA2A" + }, + { + "path": "docs/internal/extensions/bv1/commands/select-semantics-consumer.json", + "mode": "100644", + "gitBlob": "87d144c1ea65ed1458f3eb7df5747fce36ab2503", + "rawBytes": 10802, + "rawSHA256": "65D2D19B62700511D7953A7250759B85B4F0D9D63486DB7BF4486C920F20471F" + }, + { + "path": "docs/internal/extensions/bv1/commands/select-startup.json", + "mode": "100644", + "gitBlob": "f755bec316d90ac15f3aa198fdae3562bc514057", + "rawBytes": 2074, + "rawSHA256": "F4D75585761602DD84631EB71BE4C50EB7AEF43EFC12DD7EA5BDDD52DDF0ECDF" + }, + { + "path": "docs/internal/extensions/bv1/commands/selector-controls-main-v2-final.json", + "mode": "100644", + "gitBlob": "972d9bd6a56cc65e00705e346fb9cdba8ac7d3ae", + "rawBytes": 51445, + "rawSHA256": "9DEDD1345B46D867ED735419CF795B59CC3505BA5D3AF98D6E17D241C2543C9A" + }, + { + "path": "docs/internal/extensions/bv1/commands/selector-controls-v1.json", + "mode": "100644", + "gitBlob": "c8bb3e170085a28b2fa4dcf427f98b9ab82863e8", + "rawBytes": 21521, + "rawSHA256": "5D2A9F16E0C9FF1F85958943774D32207D0D69C8E637CEBDB5F2F382F9A2C3E4" + }, + { + "path": "docs/internal/extensions/bv1/commands/selector-controls-validation-v1-final.json", + "mode": "100644", + "gitBlob": "01737b36f214d59c191da9ee4198aecab3512159", + "rawBytes": 10909, + "rawSHA256": "E5E424E5121C5A3B809F29F45AE17636C381450E8EC685AD8CB6EA5C2B4C5018" + }, + { + "path": "docs/internal/extensions/bv1/commands/selector-omitted-main-v2-final.json", + "mode": "100644", + "gitBlob": "23b9288a4950ca41fce4afc58b815efac2917578", + "rawBytes": 48945, + "rawSHA256": "8BCDBE202527191FD84501C27E02C894D987CACF1F272DC4EE0A68C1E6E6D293" + }, + { + "path": "docs/internal/extensions/bv1/commands/selector-omitted-v1.json", + "mode": "100644", + "gitBlob": "31003b3d1a0dad3cfd0cf13480af319dd586b51f", + "rawBytes": 7081, + "rawSHA256": "8B98D984C817016B4F683FD4C047E3B431906F2FA92FD13104BB84C5B5DF39AE" + }, + { + "path": "docs/internal/extensions/bv1/commands/selector-valid-main-v2-final.json", + "mode": "100644", + "gitBlob": "10bbe1c0e967e238581a392d4c2b43eebd0191c7", + "rawBytes": 31182, + "rawSHA256": "1EB13D7156E15B5915B152ADCE2EF888417EEB774EB3B7D04A08785C7B0B64FE" + }, + { + "path": "docs/internal/extensions/bv1/commands/selector-valid-v1.json", + "mode": "100644", + "gitBlob": "a0e2ecb1faaea365ce77ead6520f7cba09feb529", + "rawBytes": 2814, + "rawSHA256": "203E389B086C46EAA2B11FF495CC9D6E15D3EE9F672525684B8623B9FF64EF46" + }, + { + "path": "docs/internal/extensions/bv1/commands/staged-whitespace-diagnostic-v1.json", + "mode": "100644", + "gitBlob": "2a41f2fa768f6941eb6b177fa066e3e4fd8833bc", + "rawBytes": 11126, + "rawSHA256": "1BB86B5D38173E8A4187E0EAC85FB876498414AA404D1E4197C85EEDCCBAE11B" + }, + { + "path": "docs/internal/extensions/bv1/commands/validation-controls-selector-omitted-validation-v1-final.json", + "mode": "100644", + "gitBlob": "dc60529314be2af96681ce3f2a2624415d08d7fa", + "rawBytes": 16207, + "rawSHA256": "83E9DEB9562CF9A9384DA68C55C8BE3175D84D34BEC02449F3CD2C2BD8317E7A" + }, + { + "path": "docs/internal/extensions/bv1/commands/validation-controls-selector-valid-validation-v1-final.json", + "mode": "100644", + "gitBlob": "191b9f009294d014317f3be09a9d8fb8f1d699a6", + "rawBytes": 8957, + "rawSHA256": "4C406A2572DFB0F857D454CEED5EB19E40D822C78542CE8A9965B057D5551188" + }, + { + "path": "docs/internal/extensions/bv1/commands/validation-crossing-v3-first.json", + "mode": "100644", + "gitBlob": "707b648b8c8077261689c0507344bede967cced8", + "rawBytes": 29084, + "rawSHA256": "361D4712D4C15BB91CE9A42E92781A7C506DE820BE8A2562C46096B3B36266EC" + }, + { + "path": "docs/internal/extensions/bv1/commands/validation-final-static.json", + "mode": "100644", + "gitBlob": "b411cd3c443a64e67375760a30bf80f4e0c0041b", + "rawBytes": 4534, + "rawSHA256": "C965BCB4060BE0E6E5787D61313568D5675E9BA6CE245FD89D4AE9C4F2EDCD36" + }, + { + "path": "docs/internal/extensions/bv1/commands/validation-v2-known.json", + "mode": "100644", + "gitBlob": "83929e134685b52726fd365b61a2e4297858e583", + "rawBytes": 28475, + "rawSHA256": "1B636540B73EB9CEFAC6AAE64E76241D2C4DC703366DA95E80989876AFF925BC" + }, + { + "path": "docs/internal/extensions/bv1/commands/validation-v2-startup.json", + "mode": "100644", + "gitBlob": "614d2743eb1db61dd267d190c65595f93ebee65c", + "rawBytes": 27935, + "rawSHA256": "7EB7FF55AC5337368EB207F67E9B5969769711997E2E7F2A6108CAC66231D0E6" + }, + { + "path": "docs/internal/extensions/bv1/commands/whitespace-attributes-v1.json", + "mode": "100644", + "gitBlob": "6faa7c2cf6713d0d1aec48addd5b695de813fedd", + "rawBytes": 44028, + "rawSHA256": "C7AA69ECDC79D64DE7698C0B142650954CA6FBA15C17C6B4003577705E9ED67F" + }, + { + "path": "docs/internal/extensions/bv1/controls/allocation_reader_expected_type.lean", + "mode": "100644", + "gitBlob": "b8d5b2048b4097587cc54be27e7060c66ce3c36d", + "rawBytes": 4290, + "rawSHA256": "DD09511ED00D8753C97164EEE06CC0E58C066CB0BFE33C0A37CA04D2C6D8F7ED" + }, + { + "path": "docs/internal/extensions/bv1/controls/controller_axioms.lean", + "mode": "100644", + "gitBlob": "d30198a229102f569172a4699f7a0f7d7fbd5a73", + "rawBytes": 10008, + "rawSHA256": "10705AE00918BFD709027B1DD3936867C8C0EF0502D5C84E630C7B9FC755B957" + }, + { + "path": "docs/internal/extensions/bv1/controls/crossing_v1_expected_fail.lean", + "mode": "100644", + "gitBlob": "ca27842b6cc81eefcbc73f123bb6689ee4e8019c", + "rawBytes": 1405, + "rawSHA256": "F9201FE1970244D968AF47EB884D42E6BC2055984ED4A853985AFB64351ED758" + }, + { + "path": "docs/internal/extensions/bv1/controls/leaf_consumers/bv1-canonical-select-safety-consumer.lean", + "mode": "100644", + "gitBlob": "1a1e8cfdc6d4e9d31ad637a068222acd69138bc8", + "rawBytes": 3741, + "rawSHA256": "6EB1741EC157B37904DCE556CDBC16BA9730DFD28269217C16FEEA0EE9B44C50" + }, + { + "path": "docs/internal/extensions/bv1/controls/leaf_consumers/bv1-generic-select-safety-consumer.lean", + "mode": "100644", + "gitBlob": "01c0de4061a9943662290e6b6aa1094ff3f01e58", + "rawBytes": 4382, + "rawSHA256": "297C96DB48830938A8236C5D02CDA3DE35E87AFD4CCD75E17785814B5F53D8B7" + }, + { + "path": "docs/internal/extensions/bv1/controls/leaf_consumers/bv1-rank-layout-consumer.lean", + "mode": "100644", + "gitBlob": "c796a04648b75c4a8dd76a331de1f2a72ebcaf41", + "rawBytes": 2044, + "rawSHA256": "283CE0B7E52E49F63108BBDBCBB66E916C6086C0E821F49C1F6B8B5D6A071E7F" + }, + { + "path": "docs/internal/extensions/bv1/controls/leaf_consumers/bv1-rank-semantics-consumer.lean", + "mode": "100644", + "gitBlob": "2367efceefca82d879bb3c6a1850a0f8e412cef6", + "rawBytes": 3117, + "rawSHA256": "2F4D7A5B4FF532C80CCD162519C8A989F5B78B44B249CD9A159F122E7EEEA2C0" + }, + { + "path": "docs/internal/extensions/bv1/controls/leaf_consumers/bv1-regular-layout-axiom-source.lean", + "mode": "100644", + "gitBlob": "e5b1344fd89fd497141c2a11b12eecfa7279d6dc", + "rawBytes": 363, + "rawSHA256": "67012CCC16E31764979ADED20BA08C462E1CC207DA389839737219CD98E7627D" + }, + { + "path": "docs/internal/extensions/bv1/controls/leaf_consumers/bv1-regular-layout-exact-types.lean", + "mode": "100644", + "gitBlob": "f4f08493067048bbc3ceee869b8561a079115ad9", + "rawBytes": 3415, + "rawSHA256": "F59CCBB23FD0074B8E769D98DC16ED263C16A7DBC3939E6F76FF20CC1586E337" + }, + { + "path": "docs/internal/extensions/bv1/controls/leaf_consumers/bv1-scratch-frame-consumer.lean", + "mode": "100644", + "gitBlob": "f190e7b03cb27d76edd7108c76bf1e3122c4334e", + "rawBytes": 1684, + "rawSHA256": "C40D8F1B3D776C84E2594FFC6605E51AD347F9ABBA1B5A83E1788CB214AC6712" + }, + { + "path": "docs/internal/extensions/bv1/controls/leaf_consumers/bv1-select-semantics-consumer.lean", + "mode": "100644", + "gitBlob": "b572118f9f808ee63248feb00705ae8755596516", + "rawBytes": 2874, + "rawSHA256": "35A9FEB285AA5CD883F9AB0FBECC693EE7DE9271242EB63E8F45EA07B27026A0" + }, + { + "path": "docs/internal/extensions/bv1/controls/leaf_consumers/replay-list-v1.json", + "mode": "100644", + "gitBlob": "e928d2382b1a1081c3494e5b77febffea332f248", + "rawBytes": 10079, + "rawSHA256": "FCA3D67AD0B3B13AE65416431F73A209FBE8CECDE1C08E790FA7DADB2DFBEDEC" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_expected_type.lean", + "mode": "100644", + "gitBlob": "77799af6f8a981de81e5e91e85929247d66013c8", + "rawBytes": 13417, + "rawSHA256": "FEA8D045EF0A9CB9679949ED8825F2E04A4542C01E8F056A778BB0B474BF7A9E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/capacity-without-code.constructor.lean", + "mode": "100644", + "gitBlob": "dcff956498a94d9e36ac789b581d5e334de287cd", + "rawBytes": 11829, + "rawSHA256": "648A6A344CFD1D95B1384AFF1D805A7F66D8A6ABF72C13A36C49B70F00B5B55F" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/capacity-without-code.consumer.lean", + "mode": "100644", + "gitBlob": "9f8c2d3f12b04a6c74443c4141155fb120dce4fc", + "rawBytes": 25204, + "rawSHA256": "0551357AB6FDECA16921CBC2E38131462338188C72BCF697886139A68B356ABD" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/capacity-without-scratch.constructor.lean", + "mode": "100644", + "gitBlob": "ce5f16c77e0e43beca7cb141e1e5bdcd0e8ffc82", + "rawBytes": 12171, + "rawSHA256": "7BF69AADCDD603D3DAE0FD3A4194C2151BB94F7B51E90D1ABC5CA0C81D446EA5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/capacity-without-scratch.consumer.lean", + "mode": "100644", + "gitBlob": "482507db97b824eb46600deeefd326d8c2f508e2", + "rawBytes": 25546, + "rawSHA256": "4854D99D124B5B7AB5E0C07AB4448499C8FF6E1A5D3CBA3B3CCD02797B1F0872" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/delete-accessCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "4e700258a22c22b183c3c94899b83b06f35ab634", + "rawBytes": 11313, + "rawSHA256": "E107CDBA1FD835C7CD236AA6EE5CB28B632B4BC79821A5607B4AE0070D24D0A9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/delete-accessCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "8e79188fde15e57d13709c5294cf6acb87b65d98", + "rawBytes": 24688, + "rawSHA256": "623C809616B6935F1AB462AFE46940F9DEF46BCFB105D4EFC002B4B05530A930" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/harmless-comment.constructor.lean", + "mode": "100644", + "gitBlob": "2d9c01574473366581c1683657f4c2e3e002d0c4", + "rawBytes": 11638, + "rawSHA256": "B98A0874F9314EEC8601EA885726D66F17847062A29F444F2F92309152B1E937" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/harmless-comment.consumer.lean", + "mode": "100644", + "gitBlob": "ffe24e322ebf7452d2b8b403ad483a38e185ea84", + "rawBytes": 25013, + "rawSHA256": "6B4D647B5CC0FB377CB4F2ACA1DE30AB1BB0D84E1C810AC5E1F8F3DE42A1ABA8" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/public-proposition-True.constructor.lean", + "mode": "100644", + "gitBlob": "6b97ac13a445ceeade28acd38230c89f8d8cf13f", + "rawBytes": 8464, + "rawSHA256": "C0795054B92747D206166B629DCB8AD43A25C0BAB8A289F8BD6FBA2EBB959F4E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/public-proposition-True.consumer.lean", + "mode": "100644", + "gitBlob": "131a1e6f871572821ae2bdbfe571ec171b0eabae", + "rawBytes": 21839, + "rawSHA256": "5FE7E7C2CD8F5EF82956B103C12CF1B1A28F88E43974BEA4AFE13E88F3CA0D61" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/sibling-completeCapacity.constructor.lean", + "mode": "100644", + "gitBlob": "dc30237ad3df8354203d66859211dc92e3879dc3", + "rawBytes": 12334, + "rawSHA256": "D7A40FD7F8CCA01DDAB064D1258459145CDB263207CCAB7E003A62463ED07438" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/sibling-completeCapacity.consumer.lean", + "mode": "100644", + "gitBlob": "36d0c84fc9d182e1b40f26dbaef522110b47a66d", + "rawBytes": 25709, + "rawSHA256": "B515C27BBC7C7445E64563C2E91C476813186742FBCBEF4B0C40F6DE9D7CC29F" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/sibling-readerCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "72172a15eda02c88eda38acda10de449f7163560", + "rawBytes": 11090, + "rawSHA256": "D5A0136709D05AE4DD09BF7033B1691370225221997DFA87F144F0BFB7C29236" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/sibling-readerCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "007a00bdd8503f1b9271a62399cea60532a4599f", + "rawBytes": 24465, + "rawSHA256": "5C359574D244E725DEE232E852C94516EA06AE455FB8C2659AA053789BF9B565" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/sibling-selectSafety.constructor.lean", + "mode": "100644", + "gitBlob": "673be9ec6c646a824895efc99fc03a5ae01fca6d", + "rawBytes": 11615, + "rawSHA256": "C25B0530845C1B02F0A01BAE596D5B7A8DFED8AF5337F9F8AC33664D8F1EA66A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/sibling-selectSafety.consumer.lean", + "mode": "100644", + "gitBlob": "11ee0e684491a3ea02ed557cf5b89be41117daa7", + "rawBytes": 24990, + "rawSHA256": "35924FBC0C83E6A97B0825490D9C97BBD650318CA84DE27C928C55D18D539E3A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/unchanged.constructor.lean", + "mode": "100644", + "gitBlob": "c52bf5ddd24b34224533f8090b12de44bab236fc", + "rawBytes": 11567, + "rawSHA256": "051E5472BB3AA2F8F22B6A1C392E68EF2CCE2F0744F2F1657B58CC45F18EAFAE" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/unchanged.consumer.lean", + "mode": "100644", + "gitBlob": "8d0d2b8d1b0f69a6f6b0868a2075736a8ae49dbd", + "rawBytes": 24942, + "rawSHA256": "07320BBA0DBFCE2862CF737CA2549371E50C85ED31062C2C73740EF03BEC8B32" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-accessCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "78098a5fe2d36fa36702a5423d4dbcbd4169ec38", + "rawBytes": 11502, + "rawSHA256": "BA8855F6A16EF8F8AE7216DA53AAE1C2F5F4A68571C98F9E8B0B31C816C1BF64" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-accessCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "6260bc3868c380f7cea8d5f87ab0e2fe6ed73f84", + "rawBytes": 24877, + "rawSHA256": "10E69147FB2A58BA4A63A6A949EBD72050866172D53F2227DBA829723670C7C4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-accessExecution.constructor.lean", + "mode": "100644", + "gitBlob": "c052a7f899a4aeb9753df979bb0f1510cdcd92a5", + "rawBytes": 11122, + "rawSHA256": "6582D802F511E7636F238DB3F91F51834625F31875D68D97480EB41B724DA79D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-accessExecution.consumer.lean", + "mode": "100644", + "gitBlob": "e2d88a57d841a00ea4979d84ba021b048b18b598", + "rawBytes": 24497, + "rawSHA256": "6C3A572FEE66F47158C9564BFFC4734FB1D6CFEE8EBD4FFBD071AD73EC2A58D9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-accessSafety.constructor.lean", + "mode": "100644", + "gitBlob": "b002788a5f9881c404fe347d129bb3c0b260b6f9", + "rawBytes": 11293, + "rawSHA256": "E91610F2212F81F1A3D09FE4727CA187CC24239EF1BB56565A39357A2B4DE554" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-accessSafety.consumer.lean", + "mode": "100644", + "gitBlob": "9078c5ddd5fb92b54955869232c3c7e80ff1f340", + "rawBytes": 24668, + "rawSHA256": "34C2327113E1356622DE8AB2DFF3CF42326EF2528A3BD40CD38FB74F93AD1C37" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-categoryBounds.constructor.lean", + "mode": "100644", + "gitBlob": "ba144a6d9753d0979c18d17c0d8b7ce3781f5724", + "rawBytes": 11352, + "rawSHA256": "6949E46511D90A5F2F4BECF310E5016B1E98A3B6B1BD7D67E349B86EB127F66A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-categoryBounds.consumer.lean", + "mode": "100644", + "gitBlob": "681a3f1ed6166242e01fb1dfcd7d64462d841cdf", + "rawBytes": 24727, + "rawSHA256": "0609F1C9021FAF43B3BC5A9A02E45D3CCF950B42C03A8476E249420FC0790AA4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-categoryPartition.constructor.lean", + "mode": "100644", + "gitBlob": "f5efbf2b0597a46fb9bbafd0255847f6e45fae34", + "rawBytes": 11186, + "rawSHA256": "7C19221F37F3FD07387C8999B5FD1D1EE683955F983C248951F489E5F3A9EA9B" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-categoryPartition.consumer.lean", + "mode": "100644", + "gitBlob": "72ab8829e9529368a519d793a0518fefdea10ebb", + "rawBytes": 24561, + "rawSHA256": "AA1E55E48F0A618C1B96DAB1937A0DD24F3005E51F163AB3D3227ED2AFEF0EB5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-completeCapacity.constructor.lean", + "mode": "100644", + "gitBlob": "25bb9b1c3dbae9bc3ffea1f8e9faf5c0fbf544de", + "rawBytes": 11203, + "rawSHA256": "F17A26D72B7C0A9A9CA79A0E9D99879C56FF0739CD5F5780349D77C7ACAEB4D9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-completeCapacity.consumer.lean", + "mode": "100644", + "gitBlob": "9c5eeae1da9a3b5a2fcd71e2fcb4833e56e32d3b", + "rawBytes": 24578, + "rawSHA256": "0D5C916242818400E43F59A1F7A59E415E84E9FCFBB57B36B83B9C9D9B2042C5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-finiteScratch.constructor.lean", + "mode": "100644", + "gitBlob": "4f3f765f217b3089983f6f411b53c65daa088855", + "rawBytes": 11359, + "rawSHA256": "1132BE4D82415B8E0EDED57F266A11BF296A081FECDF96B06F2CD587D5E69193" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-finiteScratch.consumer.lean", + "mode": "100644", + "gitBlob": "564ab30914cc3d7e7c2fbd6216c4966325366c6f", + "rawBytes": 24734, + "rawSHA256": "6430D5EE21F8F5B04DD6C427CF2C23CE2765C9F2474198D1A044344999E80875" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-memoryWordsFit.constructor.lean", + "mode": "100644", + "gitBlob": "fe027f44908da00299a0851bdb6afd0c1af4fe80", + "rawBytes": 11438, + "rawSHA256": "4309D769AA3B95540AB4BEE346CA264A51FB0E5B8E1B2E650A6048C3305D6728" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-memoryWordsFit.consumer.lean", + "mode": "100644", + "gitBlob": "635611625f4ed77ae6c3dbcb36246da1a16ad365", + "rawBytes": 24813, + "rawSHA256": "86F30A1E37EA8E53AAE7CAC29B5D2C1A5142E30D62F79EBCAEC9047807870D27" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-overheadLittleO.constructor.lean", + "mode": "100644", + "gitBlob": "fc06d1549b41e7801096c034b7b03ce0791b0266", + "rawBytes": 11537, + "rawSHA256": "35ED2361481CE3409F0F0200EB6B41D894B409DB8C1191325BA8BB1805EEF4A4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-overheadLittleO.consumer.lean", + "mode": "100644", + "gitBlob": "b30b8465e7cbb1caf91ce4469b1f549a1165b19d", + "rawBytes": 24912, + "rawSHA256": "F28B855D9AE3A3792462F4199EEDC6F164286479DD168CC6D790A952A1403937" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-programLengths.constructor.lean", + "mode": "100644", + "gitBlob": "2104f1c20ad96331c8b02f2897a228d4e032a8d2", + "rawBytes": 11394, + "rawSHA256": "73EDD80D3493862ACFAAC033C720F70DE216E2984C6E274B0FAC5E12444268C1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-programLengths.consumer.lean", + "mode": "100644", + "gitBlob": "f058f1a487c1e897b8eab2a1141ff31d1bb2448f", + "rawBytes": 24769, + "rawSHA256": "2D2EFB3ED01BA27749498A2A29208A7792A699F5988E3D2E009465DA6DC8EB6E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-rankCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "19a50698edc8b37de94f43771b41f3e34fc6449d", + "rawBytes": 11397, + "rawSHA256": "0B5EC9D0FDB6B003FA4A5E5129CB38ABF77E8FEF64717B0768F0D24C6B2E69AB" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-rankCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "6c05d2c293cdebd77eb0a8ec8cf8cded9e08448d", + "rawBytes": 24772, + "rawSHA256": "C918E25B84C82860F2F9A69AD33E27BA11981CE7E9AB7302E0C4300DA9EE0A46" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-rankExecution.constructor.lean", + "mode": "100644", + "gitBlob": "b8d6416c2e9835e4df68f8ef82df4eacec4d6c86", + "rawBytes": 11096, + "rawSHA256": "929124CB2D24A019614A6951E0F651F4AC8D88E1477E4F76D66A39835EF2602E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-rankExecution.consumer.lean", + "mode": "100644", + "gitBlob": "24d05da2a5ff95a47a4b96cb178d8c3a020b8692", + "rawBytes": 24471, + "rawSHA256": "A18E055613BE6B35AEF2D73124A3939A5E763A18F15685354751B7256E28B43E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-rankSafety.constructor.lean", + "mode": "100644", + "gitBlob": "99ec78f302d6ecde363464abcaf78d33ff00be5e", + "rawBytes": 11284, + "rawSHA256": "B4CF3EA1E6C9E9665495E8EFC3725C0D4828879242A0B4B0AE0DCC7B92CA1623" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-rankSafety.consumer.lean", + "mode": "100644", + "gitBlob": "9a1772c02264836346f77c58ae9959d6e6bbfca3", + "rawBytes": 24659, + "rawSHA256": "04E66EB52C517F09CB1B68152553C8D907EDF348CC110931E1E78BC9B1CB7C21" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-readerCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "1773ba48f0938a26591f3d7147c7e131264b6e95", + "rawBytes": 10894, + "rawSHA256": "EF9FD42A99BC7FC9E30EC36860547697FD1066DCEB5B2C8F037DF9C84C8E6442" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-readerCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "397f570cee1e92a37e8d04aeb7daeb2c92b77cc0", + "rawBytes": 24269, + "rawSHA256": "8FB7AB2DD365B1A2CF50EC646E9B8B20F254D16607FF8A82EB12AB46AF2CDC5C" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-readerGeometry.constructor.lean", + "mode": "100644", + "gitBlob": "aa377eb52f10c53a2f0eb8298e387c97ad5edd1d", + "rawBytes": 11268, + "rawSHA256": "A17C94536127915C823B65826C136ACEE50C7F09A8D67698604105B894496F22" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-readerGeometry.consumer.lean", + "mode": "100644", + "gitBlob": "33158e890193ce150c1ed68bc04f9fc554f251a4", + "rawBytes": 24643, + "rawSHA256": "FFE06E2491A7D86FCD28E5951C5697231F90A7DA7B4D8518DA94BED1AC72E13A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-selectCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "4ebb063d892d661bf6b09251c6f114f4d6d3ad33", + "rawBytes": 11439, + "rawSHA256": "C1AA1B79B631EA5943CDC4736C179B4E6041CCC574BE7F88E0917BF942511BC2" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-selectCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "e1c435b99150b16a82309ca14254682ebc8ddd75", + "rawBytes": 24814, + "rawSHA256": "10846343307642CEC627ED4C9FEA917F1112F358086579DED3353708A23EEF84" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-selectExecution.constructor.lean", + "mode": "100644", + "gitBlob": "6fb95585bd9b74b8fc4f2145c990410a36794d8b", + "rawBytes": 11066, + "rawSHA256": "2CB005B1D063B78C95AEE13E431F352156EE44F3F7AC08A49190253C04EEAB88" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-selectExecution.consumer.lean", + "mode": "100644", + "gitBlob": "60b71251d4195a13c0398eec4879bd6af7ebdbc2", + "rawBytes": 24441, + "rawSHA256": "5F0EF38FCC7FBF843612B39E0948429DEA7D76B34C01E5B26D426D75B4F9800E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-selectSafety.constructor.lean", + "mode": "100644", + "gitBlob": "05af4d81ac49a623222512a79db8024e135481df", + "rawBytes": 11276, + "rawSHA256": "9AC67AF9F57D88E5BE80A609F61A630CE67522CA0E3AEEA9453D7F51BF36A3AF" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-selectSafety.consumer.lean", + "mode": "100644", + "gitBlob": "5f6ac7d185f402c0e4c940c5869b5015e30d9fa8", + "rawBytes": 24651, + "rawSHA256": "886CE818099F531C25B1D7D59DA8E82E04027D0731048948D6FDB2C4D5CEB2E8" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-sourceBudgets.constructor.lean", + "mode": "100644", + "gitBlob": "1c09abeea72531de4a339f2809c62ec6d7598423", + "rawBytes": 11394, + "rawSHA256": "826D9211D0AE37384D09E5C931341577B3DC2E23A091CA10E049505DF9EA7A74" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-sourceBudgets.consumer.lean", + "mode": "100644", + "gitBlob": "1a212c7045ae7378a85cfcbad1470ed6ebeccc01", + "rawBytes": 24769, + "rawSHA256": "3B1B57A79FA8AE065AAB959B78864BF2617D8ED74079BC96A53BC2EE7425319E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-stepsBound.constructor.lean", + "mode": "100644", + "gitBlob": "afcb0b556d8fe5126db2bc1a3d56e5c870f429a4", + "rawBytes": 11400, + "rawSHA256": "D9F4B4C9791037A3C5760B743CE3C4606E126B59FC63C5EE47E37513F55E5F73" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-stepsBound.consumer.lean", + "mode": "100644", + "gitBlob": "8fa556cdee818cfbaa122c151d5e5f79edfb3d33", + "rawBytes": 24775, + "rawSHA256": "16421CDA6CB337FDBA04DE4727CF19744DCBD5350246EBFE32761517CAFBA63E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-suppliedMemoryAgreement.constructor.lean", + "mode": "100644", + "gitBlob": "e7043541fa1e13a9a757c268e68311d4cabf16a8", + "rawBytes": 11152, + "rawSHA256": "61BFA2E0E489D2BAB4A64D155B1F0B224388E1578EC7DEC01A59509B636858DA" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-suppliedMemoryAgreement.consumer.lean", + "mode": "100644", + "gitBlob": "8d2d4db56cf811f71d517122d76dafb9c4e99178", + "rawBytes": 24527, + "rawSHA256": "813CFDF046C30C83FA2506747BE016DE1E9699760BFA3B76A3F2FE40A7E85767" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-validArgumentFits.constructor.lean", + "mode": "100644", + "gitBlob": "3478c531356f46808333b9a545e7e2b14aada19e", + "rawBytes": 11486, + "rawSHA256": "4E70B1E0541ECD469F9FD28E4D4A0FF9BBC1712D9960000701745EA7DAA89E65" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-validArgumentFits.consumer.lean", + "mode": "100644", + "gitBlob": "b02eea3df85b222cf7dbbb7bb7f5b21f48672a0f", + "rawBytes": 24861, + "rawSHA256": "7816DB0F5B2BE3B00746DE43AF9DE3A2894DC0118176C9D5479834172B5B91A8" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-widthBounds.constructor.lean", + "mode": "100644", + "gitBlob": "9d1e010b095eb94779ad664881baad06a0d557a7", + "rawBytes": 11448, + "rawSHA256": "8C77D786737FAD5EFD287AD46B889BC72CFE6A2D74B6A4BE2BDD0098AADC9FB3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-widthBounds.consumer.lean", + "mode": "100644", + "gitBlob": "e4cbb00d512f907823054f15d3c75a2aa9665fcb", + "rawBytes": 24823, + "rawSHA256": "879657296DC3615A02661B33A7913920F6EF7E2BEFA199093D465F12BB377D41" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/capacity-without-code.constructor.lean", + "mode": "100644", + "gitBlob": "650fdb6c82509ea5f282ab3e79ebbcf4b0acfb81", + "rawBytes": 11904, + "rawSHA256": "7C09B74D503BF7F673A834D9B1CB2F092BBA8A17B41F5160BEE3C10679C1AC04" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/capacity-without-code.consumer.lean", + "mode": "100644", + "gitBlob": "62cf44bfb72b6240679b5af65035d4350574d056", + "rawBytes": 25279, + "rawSHA256": "7849671DA72D77E6ECF49F4ADEC7CC0608CD4DC6F9054B9823FBFBD09715735F" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/capacity-without-scratch.constructor.lean", + "mode": "100644", + "gitBlob": "6ad1c635ee7e84334333ac773db46aa43f479cfa", + "rawBytes": 12246, + "rawSHA256": "904825C2C5A5F96040BFFB84135D504A417174EF5D7A2D46B9691DC9F73B75EB" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/capacity-without-scratch.consumer.lean", + "mode": "100644", + "gitBlob": "ad28d7ff656ef44fef14c56fa7e1af99bc0fe399", + "rawBytes": 25621, + "rawSHA256": "B679C671E706C9F9F3FB042E9913C900A3388752186D28DD016962F343E411D1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/delete-accessCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "e49773659d34d7ad4e74a3a1c1428007e4d123fd", + "rawBytes": 11388, + "rawSHA256": "0F0406739EF1C369E2CFC38541A4FB51B22A4E3C6D0259E538061AC58A6AC3AF" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/delete-accessCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "78fb908f580e744119e62135cbecb718aafcdada", + "rawBytes": 24763, + "rawSHA256": "0F0D99598825D9946B77913AA886E69C4648AF272F46B90EBCFB0071E9F80A5A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/harmless-comment.constructor.lean", + "mode": "100644", + "gitBlob": "c8f5f25dc5bec852f867009b448a28d435b7ffc5", + "rawBytes": 11713, + "rawSHA256": "A4AB5E4587BCD8F59FB11CEB44EFB47BE70C216BC864AAD1794F8FC24FA96A87" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/harmless-comment.consumer.lean", + "mode": "100644", + "gitBlob": "857410a8f3cdec32c8ce203e2bf2bbbc347cd108", + "rawBytes": 25088, + "rawSHA256": "B4E84042625F412B9A5EC0EE94172EA685F43390FA7D1686CF171E198A31A874" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/public-proposition-True.constructor.lean", + "mode": "100644", + "gitBlob": "d8519f2571453cbc71d22b62508640e07d9cc8c3", + "rawBytes": 8539, + "rawSHA256": "32E8C382C78FADE4CA06BF78228FE1B8A7E59D5F8D929C5F61B1F0DC81FCD3EF" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/public-proposition-True.consumer.lean", + "mode": "100644", + "gitBlob": "0356a311fbeb986e295b4ded1c2774c4d5b8f013", + "rawBytes": 21914, + "rawSHA256": "CC86C2519BC28F797AFA57832A4A480DE69D814AD747F4FA62DF3BD72C34CF58" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/sibling-completeCapacity.constructor.lean", + "mode": "100644", + "gitBlob": "c3b2862d4ebd3844724a7c28054879154d84a895", + "rawBytes": 12409, + "rawSHA256": "E97FC11F28A067D0FC4CA0B2BFAB0B68FE6889ACD89FB08E589C25E523D45B3A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/sibling-completeCapacity.consumer.lean", + "mode": "100644", + "gitBlob": "34ae8110584f219d4a4a0023f30c2659870d0e0f", + "rawBytes": 25784, + "rawSHA256": "277C6FFDC862520B9BD3C16D95622A727338363154530122E1464727B1F65606" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/sibling-readerCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "5b2c7a1ed3d2076ab2e767ef65cd35a4959c1ca3", + "rawBytes": 11165, + "rawSHA256": "2AD7E7C62D2346D57A9ECB9D415C67ED6D4C5BDDC4236A840F193F2FB7D59BD1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/sibling-readerCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "3ee17763ed0a649ebf5a34d96423f2789f207c04", + "rawBytes": 24540, + "rawSHA256": "731B15131915CF739754C250405F1F897FBDCE48CFD3D5C9853295AB9FD7290A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/sibling-selectSafety.constructor.lean", + "mode": "100644", + "gitBlob": "20bc459a1e4fe32babb434e271c29b8b1eb260a3", + "rawBytes": 11690, + "rawSHA256": "1CC63491001F357B5C76799177A79C1AED57B3D7FD79CB18DFAB80EDF028B74D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/sibling-selectSafety.consumer.lean", + "mode": "100644", + "gitBlob": "ea9b95634a17d299afd967f839cc264e347a8917", + "rawBytes": 25065, + "rawSHA256": "040BCE96780FB16A9FE681CE8A5B9AEC1CC099B467E1203E42B894A0F29A6B58" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/unchanged.constructor.lean", + "mode": "100644", + "gitBlob": "dcab715171e9e3414a8ecffe3a50e73ca1e16764", + "rawBytes": 11642, + "rawSHA256": "7F7B7EC00BFA68887243AD12B3D0D87147D37EC457E2025AE99359B8A47E2C12" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/unchanged.consumer.lean", + "mode": "100644", + "gitBlob": "98dbb8532c03342401e1f721014cdfda273ed5ed", + "rawBytes": 25017, + "rawSHA256": "BB8983EA0A13E5B50163522EFFD007F2AF98E563C3D0681F2E0C3DB941E9B6A3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-accessCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "beaf3608671da3dfc23f9d380bddde81536e1d8b", + "rawBytes": 11577, + "rawSHA256": "03446601C88A0F8D4EE1E69EC635FF62995F9A1EFBC5923165783510B80FABAE" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-accessCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "ef6779b38f15dac71abab7ee0475fec118fbccce", + "rawBytes": 24952, + "rawSHA256": "A9122CCF5714FD08D5DFCF813995DAE0C2E37FFFDCFDAC078B8C6AAAEF2D613D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-accessExecution.constructor.lean", + "mode": "100644", + "gitBlob": "8235da8f7b07d293edb687f7fa030ef71a92ce67", + "rawBytes": 11197, + "rawSHA256": "4EBDB3F8FE1DD35D563FB0315380292BDC9BFF48DEE55DCC45E4FDEB0166ECCE" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-accessExecution.consumer.lean", + "mode": "100644", + "gitBlob": "346dd1ee2b3a2c99f5ca720d538d7234ae8419bf", + "rawBytes": 24572, + "rawSHA256": "A6EC15E8BF0B17E4DA01E968CE8F3DF496F191FAE3D207E89C9850EC9E3EADE9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-accessSafety.constructor.lean", + "mode": "100644", + "gitBlob": "998cfd32c4124c6ed7c8168407ade71d1991577a", + "rawBytes": 11368, + "rawSHA256": "D4236DB17F212D0BAD7778440138FB61954163905FA0E2797E03D779C0BA1B1C" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-accessSafety.consumer.lean", + "mode": "100644", + "gitBlob": "492ac5bbf07883c7dd02b9aa48287387a278dda2", + "rawBytes": 24743, + "rawSHA256": "47FC99AD80104B2A3AAE5DA7BC471E85F81EB884D7A91A7830F5CAAEDA0497C6" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-categoryBounds.constructor.lean", + "mode": "100644", + "gitBlob": "7e6882c326deec45a4af0db4d2722dc06f0da0dc", + "rawBytes": 11427, + "rawSHA256": "F09305959C7BE02EB358D1DF577F7F0DF2B59E776AD41FBE1283B98643759781" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-categoryBounds.consumer.lean", + "mode": "100644", + "gitBlob": "50479bc32abab4ab0835b12dd138dd73e807ce73", + "rawBytes": 24802, + "rawSHA256": "A996C5DA62ACB6F95BEF10B5E950AB6FC2A9123FDC6EFFA15A4C63851130BB48" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-categoryPartition.constructor.lean", + "mode": "100644", + "gitBlob": "b6096adffc84868b405f490f194a6db792e67445", + "rawBytes": 11261, + "rawSHA256": "01E8DCD4F40FB210DC78BD3B2CCCEB8BA08252F82E27B02BA22407DA8438F41B" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-categoryPartition.consumer.lean", + "mode": "100644", + "gitBlob": "04f593d2be17f2a5c21edc3c632ae198ee8c717f", + "rawBytes": 24636, + "rawSHA256": "38676DBAF807CFE09EF8B6474DC67EA5FC560521E8944F6D828096E964EA4EB0" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-completeCapacity.constructor.lean", + "mode": "100644", + "gitBlob": "27e9711bc8ca5714d0660c53ff975aab177b6822", + "rawBytes": 11278, + "rawSHA256": "C2CC22B5A53391CF69C3D68BDE36B8B9A096CF9E88B57CD91B81FC5E80FDD661" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-completeCapacity.consumer.lean", + "mode": "100644", + "gitBlob": "b2ddea77b83e66663e6ef573bb4a515543040361", + "rawBytes": 24653, + "rawSHA256": "FF5F485929E3AEF036422E1CE658C7FEBDFEB59D2DFD24D91BF43D917FD994E4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-finiteScratch.constructor.lean", + "mode": "100644", + "gitBlob": "a6cb7603dd41057f96f5013083ab7c61f0d40d0c", + "rawBytes": 11434, + "rawSHA256": "D21A76992F4EE54F58AEA7B9E6332B44268F1E4349F682918EEFD57191F5A080" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-finiteScratch.consumer.lean", + "mode": "100644", + "gitBlob": "29a038946035f29e94c39afc9a6032dcbe569bc4", + "rawBytes": 24809, + "rawSHA256": "F6532543B8B0444DCB13F6ACB46ED30E05D83ECFA0BFA56953079E9D848E88C1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-memoryWordsFit.constructor.lean", + "mode": "100644", + "gitBlob": "9afb789d8902e7d054dcfc212ccb0771e92ad479", + "rawBytes": 11513, + "rawSHA256": "328063870767754D95EE7B2192D4263AE37335289C5A90C81F413E3E0F8FA99C" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-memoryWordsFit.consumer.lean", + "mode": "100644", + "gitBlob": "ee77b1673b18cc6b41bf1f2a892d0d3c2d03572e", + "rawBytes": 24888, + "rawSHA256": "E4C525AA498BF0F609182BA82D0D4AAF661B4EF2A79CBF929D286A96B45C101D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-overheadLittleO.constructor.lean", + "mode": "100644", + "gitBlob": "26546cd85a407f868198cabf6a3ae1b7fdec200b", + "rawBytes": 11612, + "rawSHA256": "DFB67100F9E512F9EAA7270D650949491193CCE5D504AEBA5E54DC46AA9C5D95" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-overheadLittleO.consumer.lean", + "mode": "100644", + "gitBlob": "1a1ca7c7ace49beed6c79b5046486e4cbf73ee19", + "rawBytes": 24987, + "rawSHA256": "8517D6B5F604E384AC9CE2FF68908C028A06DF5BA0174F40A0879F663965F405" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-programLengths.constructor.lean", + "mode": "100644", + "gitBlob": "b9446ad827a93f33a9c14387e01227019ea2c657", + "rawBytes": 11469, + "rawSHA256": "284691291D50277EB8AB79F917CDF6691939CD5E2940D1BC61756DB3ACFF8F61" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-programLengths.consumer.lean", + "mode": "100644", + "gitBlob": "3f70eb7c86a344a8707d6d407696d8a53ba36aba", + "rawBytes": 24844, + "rawSHA256": "F02584E3B4FDE6E7F8D0BE7C11240E2DACC8436EA627F4FCC2F45B8DA57E4A27" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-rankCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "fe16fad50765acdd31e3cdb83cf7a2040a99cafe", + "rawBytes": 11472, + "rawSHA256": "04C3F219060F67B66423AB9CC9A73DC0F114521655187419F1C865D4FA559446" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-rankCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "0f3e16210a2c6254b768ba4a79059a21df72dac7", + "rawBytes": 24847, + "rawSHA256": "7BD0479E0FE44FC476753FD1578C27C25C7B4286DD5BB2E87D0BD3BA2137D537" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-rankExecution.constructor.lean", + "mode": "100644", + "gitBlob": "9c70a510ee7ec140d37d62c1b6359a8ca4fcba30", + "rawBytes": 11171, + "rawSHA256": "483F2074D1ABE6A72364AFB6654300A0D2AE7038363BC46A440865ADC004F9D9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-rankExecution.consumer.lean", + "mode": "100644", + "gitBlob": "8901dcaa2cb240f140c04c8dba1f454d696a39a7", + "rawBytes": 24546, + "rawSHA256": "FDAC29ABBF3A0DEE84EB673BFC9CCE83049C0147D619D92B10D288ABD94E65BF" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-rankSafety.constructor.lean", + "mode": "100644", + "gitBlob": "e23ac973c2e54860595b2a1fdbe730c64ef2d2f8", + "rawBytes": 11359, + "rawSHA256": "FA0E57B48FFC2B3EE1AA02EBBAFAD39A81FDC6ADD2D8899B831AE05D41291654" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-rankSafety.consumer.lean", + "mode": "100644", + "gitBlob": "ebbd07e33170a896440bf6e3dd9e941b4405e3ae", + "rawBytes": 24734, + "rawSHA256": "EDF9308C83EB831EC444C5E8393F263E845396D583715692F6F43030AA13FD95" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-readerCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "b9d2dfe94a0bcda7c117c2faa943168f6135b09a", + "rawBytes": 10969, + "rawSHA256": "70F29691A7A81238D8287AD1204CB42580B3BDE1DEF21C11B43BBCEC91769D21" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-readerCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "4640a5dcf616d71cb3451bf7d1d74fdfdf88e722", + "rawBytes": 24344, + "rawSHA256": "A686E61143D39E595C3544B523FA06086ACC6E5B5D0623096B90B9989853C522" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-readerGeometry.constructor.lean", + "mode": "100644", + "gitBlob": "4010f6f99838441aa26d04f245f1ceeedec2a5f3", + "rawBytes": 11343, + "rawSHA256": "7EC5D47EB0C8D6260FD30ECF2F2791333CAADE175E7283C52008DA24A5986663" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-readerGeometry.consumer.lean", + "mode": "100644", + "gitBlob": "fb8df43159baba23b466d17cef00d5720ba6e093", + "rawBytes": 24718, + "rawSHA256": "9EF134D70A370C8F5E6C63CF239A3621AF529D6E4EC2D0488DB8518B0F73ED55" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-selectCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "58cbdb875cae56c3fe638e7d25f5b7ee6e0fc908", + "rawBytes": 11514, + "rawSHA256": "129467D512207044D15388AE05FC3CC0EDAFA81B50EC98C071924AEBDF1C0ADB" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-selectCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "bfdf5c998a503ceff1cd9b877e7457fcfb0ea9a9", + "rawBytes": 24889, + "rawSHA256": "0131FD5B04E6194DF51FA1E04C447254AC43698761B7C4A563635DE8C0AFBE04" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-selectExecution.constructor.lean", + "mode": "100644", + "gitBlob": "6aadeb5a8414a87b5a0da931ed31b625f64a4d44", + "rawBytes": 11141, + "rawSHA256": "256145ADDFCB7A2B746C28D61F2001AA200CB7F1BFF24EB21C8A22762D5D001D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-selectExecution.consumer.lean", + "mode": "100644", + "gitBlob": "0f3498f5646f136b78f52bcf79462e014b8a3053", + "rawBytes": 24516, + "rawSHA256": "6C6DFAC4D59C02176F2883C103261EDB0A549EA3B2BD460918CCACD2BDAC6626" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-selectSafety.constructor.lean", + "mode": "100644", + "gitBlob": "cba231e230c468700f5016166a1e9a7f5b09c040", + "rawBytes": 11351, + "rawSHA256": "1A2E66C5AF4AD393CCCAD4E9C087C51410C9785DDFCB25F2B36D382157BA3F91" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-selectSafety.consumer.lean", + "mode": "100644", + "gitBlob": "e65cd6d0aa3dbbf3be13c0c3c827e5260a3e229a", + "rawBytes": 24726, + "rawSHA256": "31D27BD8C8B62F39B4BBF24445E0869A71A9EEA01A07E8DD032106F4DCACC1BD" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-sourceBudgets.constructor.lean", + "mode": "100644", + "gitBlob": "0ac22a00b23fe5f123bf1908ac24872c64df17a5", + "rawBytes": 11469, + "rawSHA256": "C0ABBB5591BA2198028DFC2C3306B78EBA3BB50B0C35957DF850A87EED198A9D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-sourceBudgets.consumer.lean", + "mode": "100644", + "gitBlob": "8ebcf380ba46fdfa2383d950a44113a2e47c05be", + "rawBytes": 24844, + "rawSHA256": "637AABF5E10408764016D9D972CBDD3F74D2A56A9A96C932B0D80D717495DC32" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-stepsBound.constructor.lean", + "mode": "100644", + "gitBlob": "7a19a9b09769e13388889e85b7f8b9e4d8987d71", + "rawBytes": 11475, + "rawSHA256": "9CAE3C200B773EA6A3A9E6DF07B1E1678C3536C365FC90AC504F5441E65D1E70" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-stepsBound.consumer.lean", + "mode": "100644", + "gitBlob": "e9d39d29a3aefc9dcc09e6fdaf917c05863dd3d2", + "rawBytes": 24850, + "rawSHA256": "A8041A49032744E7AAD19A522BDB826264BCE7129E7002B912CDAEB99E9578E1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-suppliedMemoryAgreement.constructor.lean", + "mode": "100644", + "gitBlob": "caba8e0eecda659baf87bae8ebd28f7c4d758488", + "rawBytes": 11227, + "rawSHA256": "3B57BE9502209F2E102938C3914B8E6E2071C78D7803EEAEC6A9F1D181AA665B" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-suppliedMemoryAgreement.consumer.lean", + "mode": "100644", + "gitBlob": "eea90d0e57135df9c25ecfa3029804155f9f9fa5", + "rawBytes": 24602, + "rawSHA256": "3EC6F253E26664AB9BD7542514ECD75AE2C63250F483B940D6E36D2091BF4824" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-validArgumentFits.constructor.lean", + "mode": "100644", + "gitBlob": "98bacbd30fcd7a17be2d69a55eefac4ff1ef90b3", + "rawBytes": 11561, + "rawSHA256": "6312C19E40DAEECB8166E82F6D609F0D0F94A04F5CFDF7FB5AAAE129500B2C44" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-validArgumentFits.consumer.lean", + "mode": "100644", + "gitBlob": "e06e4a8830a652e59876dda41f17c79df29b332a", + "rawBytes": 24936, + "rawSHA256": "472F158CE31D7C0F1AA63E1F00506005E19EBD11E2651B1F2CB311BB61A5FD91" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-widthBounds.constructor.lean", + "mode": "100644", + "gitBlob": "15dfa1443eef6538c14e53f3f66b2dfc3c618d17", + "rawBytes": 11523, + "rawSHA256": "7A76E88C776843C55677298B903B0CB051580D56EEF772981987A4F47FFC778C" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-widthBounds.consumer.lean", + "mode": "100644", + "gitBlob": "97414c714081d0c1d549dc34881a8290a14c427e", + "rawBytes": 24898, + "rawSHA256": "3B2DFFF51A9959F39C12F25C50B6AAB67F6FF74B721A70A28070468066808EC5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/capacity-without-code.constructor.lean", + "mode": "100644", + "gitBlob": "515b663f92b6833ae30a68ad22e6cef3f4d94015", + "rawBytes": 11823, + "rawSHA256": "B1498ED33EC8656803133CCC32F6560A3EF2D9A345E6F8C2FB70DDDAC670FEC9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/capacity-without-code.consumer.lean", + "mode": "100644", + "gitBlob": "4f75bc2e2bcc97a81ca986573a5185219cb43a18", + "rawBytes": 25198, + "rawSHA256": "3C92A1A989EEE049BB61A36CD138B6D834E622EA4706C96EA428CF955D3ACA51" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/capacity-without-scratch.constructor.lean", + "mode": "100644", + "gitBlob": "b8645a5b221a47202280b0fdd4a1eef917426c2c", + "rawBytes": 12165, + "rawSHA256": "9BD68C775DD930400A88A320855BE4D66C3A91DABA162F8B556745F53061CB16" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/capacity-without-scratch.consumer.lean", + "mode": "100644", + "gitBlob": "79afbbe4e723e6f8835eff5fbbc2bbe23363be39", + "rawBytes": 25540, + "rawSHA256": "A3AB73E68543F636B03EFCD85E345B43C0537AC0754ED0609F92D0A64F5EE9E1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/delete-accessCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "d501900856a222f63ebcef52caa1b431e77f7c79", + "rawBytes": 11307, + "rawSHA256": "D5A999CFDB2FEA2598EFC0999D10D15002D67B6D2090CF8EA1117CDF8BEEB343" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/delete-accessCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "e3bd6e4aa10e552ba48943ebe7dbc952bffd1d5c", + "rawBytes": 24682, + "rawSHA256": "50CE522DB5671B9DA3FA9BCEEF71D38A05D4F2A8BE41C9B5F7C182CE4329B25C" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/harmless-comment.constructor.lean", + "mode": "100644", + "gitBlob": "58dff7038e0ab087dca4a2bd0850ed8b4952f839", + "rawBytes": 11632, + "rawSHA256": "FEC9E7C7BA1299C60E8D3EB6E3DCF06BB51029D9CF66509F2049CB4C55D900C9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/harmless-comment.consumer.lean", + "mode": "100644", + "gitBlob": "e51ed9b2437b8aad0e2fd1a5198ab6fffe32551e", + "rawBytes": 25007, + "rawSHA256": "2D37F54478DDBAD26E5EA0132323739A6B5D33CA4EBACB4CD45BA920E468CDD3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/public-proposition-True.constructor.lean", + "mode": "100644", + "gitBlob": "5f70b6920e9c57f1c32e5b1f54e4183291133cd7", + "rawBytes": 8458, + "rawSHA256": "67676F9278028407C5D50E0B0DB3858FD63526659468285912F27C09A29FD155" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/public-proposition-True.consumer.lean", + "mode": "100644", + "gitBlob": "b7da322ba2a93b49714f5fad9774268302e23c09", + "rawBytes": 21833, + "rawSHA256": "18C8D76BDF639FEF1B55C052A30CA6BEB80980A7B5AA9EDEE421C6C4CA47A62D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/sibling-completeCapacity.constructor.lean", + "mode": "100644", + "gitBlob": "9a06c60f325da387900ad316512610689efaab74", + "rawBytes": 12328, + "rawSHA256": "12E410D3F19C1BA5288D506549F8BA4A1FD5142D4FE776DB7FB11D1ED4FD3E40" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/sibling-completeCapacity.consumer.lean", + "mode": "100644", + "gitBlob": "2e14e749704d99bd1fef73396b2674b4d49e337a", + "rawBytes": 25703, + "rawSHA256": "E3619A833E72A70B5030D0043B4E4963DAFBAF78D40BC3690195D56BB8DE7BFC" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/sibling-readerCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "da2b175bfb46284ad94bf79785737b4ac171189b", + "rawBytes": 11084, + "rawSHA256": "61D16C948DDBB3825BA19C7F780AF94C108AEA700CF4330548EC2BB5953EBAAB" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/sibling-readerCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "eb574d4c9080473160a7d868b2c2885df6c804b4", + "rawBytes": 24459, + "rawSHA256": "9AC0FE972CFE6825F48781B502086434F421DA86255AAA04FC978BBCF2EFECED" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/sibling-selectSafety.constructor.lean", + "mode": "100644", + "gitBlob": "d4e0416fbd11df6deac3aefeb7e0599c1f2c2e3b", + "rawBytes": 11609, + "rawSHA256": "FEB06585E104DA3C4B665B4AF9B1BAEBE0642F39CD15AE472FDDD0AAD0F49809" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/sibling-selectSafety.consumer.lean", + "mode": "100644", + "gitBlob": "20cc96dea023dc04ec142900afac47eb277d401d", + "rawBytes": 24984, + "rawSHA256": "2AC4C251760BF877E382109D55996EAA1387881C3E4D6E90D0C7BCC8D5B65EC2" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/unchanged.constructor.lean", + "mode": "100644", + "gitBlob": "52e9cc5c2e2352a99b7d6a6345131f4734294d27", + "rawBytes": 11561, + "rawSHA256": "3E6163098F25F0A698A33A9E3CC9F5BF230A56451DD1570CC571D5DF4510ED77" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/unchanged.consumer.lean", + "mode": "100644", + "gitBlob": "91924d7091871bf4773b0dc1d647090bfd291941", + "rawBytes": 24936, + "rawSHA256": "0214F8540456AD97CDD60A19431CB9EA14DD162370C2CD63902A4F916C6C868D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-accessCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "09d9abd90fe91d005611ff27a1e2b65514466e5d", + "rawBytes": 11496, + "rawSHA256": "A91B8EC7BF919DE89E97D36030AA10A45A1C260ECE541520F20B0A6901B4A61F" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-accessCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "a96606fed7422fbc3e4d50bdea26ee9b15e48b08", + "rawBytes": 24871, + "rawSHA256": "3EDADE56CADB4067C7467710B3FD61BA5D2C6537E0FE414611F04057DC9850A4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-accessExecution.constructor.lean", + "mode": "100644", + "gitBlob": "72c4e00479ecd92130a70c869e55789f2505f824", + "rawBytes": 11116, + "rawSHA256": "8CA893FA74512AAC3E84E6825524A1140A90198C09D8CD02242DD1BDDA78A2BF" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-accessExecution.consumer.lean", + "mode": "100644", + "gitBlob": "3922ba3699912d7a69def89eed1673f3b8754b26", + "rawBytes": 24491, + "rawSHA256": "D5C5545945AB8540BB5F05B72634C3BE1B30B8C05E339D2FA8AC55327B127C53" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-accessSafety.constructor.lean", + "mode": "100644", + "gitBlob": "5910a7d5bccef71fc0072355a0de5d7679f12256", + "rawBytes": 11287, + "rawSHA256": "AC2F6B6FF76FFD51B8B37F2B738ACA1049B78F07C4E1C10B38DD2A6380C7E33E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-accessSafety.consumer.lean", + "mode": "100644", + "gitBlob": "dc63eec5ea441834743bd378b6b29de423f09332", + "rawBytes": 24662, + "rawSHA256": "A1556436823BB967CE0CF5A30CB1AC530C542F323DD9C3CD7287D25A111DC3D1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-categoryBounds.constructor.lean", + "mode": "100644", + "gitBlob": "69cf1c5ae32e10a36068750f9b28bf33e5510b46", + "rawBytes": 11346, + "rawSHA256": "C869FA9C5559F6365BF73B2D6B2AD3C0395BE79E8D6CAD015FA3913829E63DC3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-categoryBounds.consumer.lean", + "mode": "100644", + "gitBlob": "c26e9bb04c357988cae6d711599c7a50eb0629d3", + "rawBytes": 24721, + "rawSHA256": "DD1C80FB12A567C40177BB26AC88AAA7159864D45C565E5A5792F79816D1B37C" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-categoryPartition.constructor.lean", + "mode": "100644", + "gitBlob": "17b66c31de1454102ca74d7748d1f811b1000024", + "rawBytes": 11180, + "rawSHA256": "4BC1E2E56BD83331C1F0073E805FB1ED9F4F68E9E52EB590A72EBCB6AFEBC691" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-categoryPartition.consumer.lean", + "mode": "100644", + "gitBlob": "f4e3b77596a7e1cdfc688c386331c1f39c59bb41", + "rawBytes": 24555, + "rawSHA256": "05B77E9A4682110852E02330EAE35008F33689FFAB0C95E1C57F379B91CE9AAB" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-completeCapacity.constructor.lean", + "mode": "100644", + "gitBlob": "b8aadd31b47e8d6076b0364d4c3eda127ff9d0b6", + "rawBytes": 11197, + "rawSHA256": "A2A79B31028DCBAA990C354CCB6EAC4F15E69C015776FA99F5133F09FC120108" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-completeCapacity.consumer.lean", + "mode": "100644", + "gitBlob": "a958edb1b1c58a406fc707c89b413b3ef14438a2", + "rawBytes": 24572, + "rawSHA256": "7974FEABD9C67765DC3D10AC6C4AA507645268B47647F42E757BBE167151C25C" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-finiteScratch.constructor.lean", + "mode": "100644", + "gitBlob": "f8754e09c77cbd961e6647b68883b874cc477bb3", + "rawBytes": 11353, + "rawSHA256": "9A14F8D9BA315A63E2794CD9ACC62066B09A8CD6EC24F3B4E538F6B352029F66" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-finiteScratch.consumer.lean", + "mode": "100644", + "gitBlob": "3a80ce4867e71c9fabfb518d1c35fe14279e627c", + "rawBytes": 24728, + "rawSHA256": "342682DAF21A7C0B94A4E59041084960E09B16110B094C295F3BE1D7891777B4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-memoryWordsFit.constructor.lean", + "mode": "100644", + "gitBlob": "97ad82add7d98c3c519596eef8974cf37457e800", + "rawBytes": 11432, + "rawSHA256": "C1D3730D6AAC0A1128C823821F17A4A7BCE6B20BD88B4785789F9EB232933C1F" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-memoryWordsFit.consumer.lean", + "mode": "100644", + "gitBlob": "20a252518297f672231818d4a3b2e2091857bbc6", + "rawBytes": 24807, + "rawSHA256": "0E1FA937E9D1BF2739AB2BE64F15EE0477E0D1F6C578D7CC0E2DF5A6B08D42B2" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-overheadLittleO.constructor.lean", + "mode": "100644", + "gitBlob": "691fa976294e420a64b79067318cbdb0c41c5bc5", + "rawBytes": 11531, + "rawSHA256": "C9CA06D84EA8AD65B10C87EC9C2285C70EFDAB2EA33DAD354195E972BC237142" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-overheadLittleO.consumer.lean", + "mode": "100644", + "gitBlob": "507011bfe03ecc82a30739cff384055de9a7782f", + "rawBytes": 24906, + "rawSHA256": "FB1F0EF5ACC97B9DB6E08B3B39759B2EE0ADBD358748AB803BC1E2535CF6FD12" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-programLengths.constructor.lean", + "mode": "100644", + "gitBlob": "55f896818bd82e2d345322f952559ea8b7d33ff9", + "rawBytes": 11388, + "rawSHA256": "0C61E1D4CB45C8147D736B11C33FBD4703FD266AF833429D31A3E1F5B5C210A3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-programLengths.consumer.lean", + "mode": "100644", + "gitBlob": "e37318ec4320bd485584a6ba58ef1d35aa663455", + "rawBytes": 24763, + "rawSHA256": "301A49EC9AD804E7DC9E2D3AA2D782F93ECDC30901147DA5DB42CFE2DCD274D2" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-rankCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "2dc827fe66b158f8ba609fa0b55aceca720dec37", + "rawBytes": 11391, + "rawSHA256": "5E5852B5B5216E9762BF204C9BE8BC0F43CED3E9610247665D4F9ECBB081952B" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-rankCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "f557ce56dcaff8f3a35a4ab40fa70fc555a18810", + "rawBytes": 24766, + "rawSHA256": "5060AE513318AC89BBA83BAC95E4D3D3B62B38388DBE04DF4BE0A95C7F96BAE5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-rankExecution.constructor.lean", + "mode": "100644", + "gitBlob": "f295d8dda841f4f11f8bf1c09c382dc1b58b2d70", + "rawBytes": 11090, + "rawSHA256": "DB3C462314D91A669D9EE1D9FFB80F3D4A4ED36C781E9A139E35081A897E9BD9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-rankExecution.consumer.lean", + "mode": "100644", + "gitBlob": "f562ce9d3efecbd4b671a99785475b57daed1f34", + "rawBytes": 24465, + "rawSHA256": "4357F0DFA0DFA23EFA153D502B4E960FAA7C531329BAB18915912E7DC48F754A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-rankSafety.constructor.lean", + "mode": "100644", + "gitBlob": "2cee78c55ce6c2a745ffe9603c3599b80a0e7395", + "rawBytes": 11278, + "rawSHA256": "A8697E1E9553C7A0CAB78B0EFE5BE5FCF6217C401BA11E781DEE489BB214A03A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-rankSafety.consumer.lean", + "mode": "100644", + "gitBlob": "280b2879f924d6dc2aa67e2bfb7a9cb399f95606", + "rawBytes": 24653, + "rawSHA256": "22F88A61AF30638089BCF15B71900C137056C1F8A434CD4ECA61746C4DBF30DD" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-readerCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "ae6f258afa82c6f2335da4f71b230e1692054324", + "rawBytes": 10888, + "rawSHA256": "BA1FDBF0ABA815C0CFAECCCA117AC46C36C0D4BC2EFACE02AAC969FB53385381" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-readerCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "7fd7e0075c31d601fcb2d6ed4159c2ce4a55d5d1", + "rawBytes": 24263, + "rawSHA256": "BEF27C49C398627DEAAD4490F5DAC22E4C9DBB55A8E4D0C1F772FD54B83275B6" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-readerGeometry.constructor.lean", + "mode": "100644", + "gitBlob": "b1bfccca365a17ae30ea7742057b4a738478dcdb", + "rawBytes": 11262, + "rawSHA256": "CEFE12EB9AD045B3109C60D4E4A839B22588F07ED71C34002766FB0516005962" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-readerGeometry.consumer.lean", + "mode": "100644", + "gitBlob": "bce078189acb11566ce6a73040e370a51b1ef393", + "rawBytes": 24637, + "rawSHA256": "B459C912FA63A869F0353B8E6D1BDECA91D2D61B4A0DF4FF6EB1B2DC965AA046" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-selectCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "b4c9d373b78ef027b7cc26e7051cea241f52508e", + "rawBytes": 11433, + "rawSHA256": "5A8B507444F96A5FCD981AC792EC98B1828D68BC9178257846A1C04D6414D24E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-selectCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "ebdcd922a10abe403ae70b9a1754b5a90bf69301", + "rawBytes": 24808, + "rawSHA256": "7BA9F6E3635B6CF6EACE442F5629C8157B562006E6B50118B66D4CBF0F520573" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-selectExecution.constructor.lean", + "mode": "100644", + "gitBlob": "75a116f29d984dd6e0b764db7a15ec882e99c23b", + "rawBytes": 11060, + "rawSHA256": "E2257A7AD3B756E144E142F2B0097CA03A63423307E2D4A0FC24CF92B830968C" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-selectExecution.consumer.lean", + "mode": "100644", + "gitBlob": "f7702035b48c282ad09578d9e6c0b3c3e6079c21", + "rawBytes": 24435, + "rawSHA256": "D6164A4C8B8765EB193BB335E9F4F3CC2A41DA4EA924D9C1087BC2A49B526EA4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-selectSafety.constructor.lean", + "mode": "100644", + "gitBlob": "4f4c7b5d9c3ebdb7930012294b64c96b72c32793", + "rawBytes": 11270, + "rawSHA256": "087312E4EABDBCE8868FA93B0489BEB3129CA756B8F27855BACF4EAF62182E0D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-selectSafety.consumer.lean", + "mode": "100644", + "gitBlob": "ccc615f20e91256dd2d3de883f7e470d5a8574b5", + "rawBytes": 24645, + "rawSHA256": "C3F5DF9AF70E24D549D6BAFEAAE7FC8293BC44C3CEF55351210F5BDBB06C7738" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-sourceBudgets.constructor.lean", + "mode": "100644", + "gitBlob": "17a044876c0784059e0540e680dbeb61038bdc18", + "rawBytes": 11388, + "rawSHA256": "5630B8D3EEB6EFEDBEB00609A9B29E4A5FFCBDB190B133CB88F7E1F7C8D411A4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-sourceBudgets.consumer.lean", + "mode": "100644", + "gitBlob": "086eeaf32be4b9216b2aaff0c86a1df0dc4ff69d", + "rawBytes": 24763, + "rawSHA256": "9DFA351D725D4D6BFBFF387FF3CC7E556D433EC0AECBFF3F88BBE601520FD7A5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-stepsBound.constructor.lean", + "mode": "100644", + "gitBlob": "3f4af7cf06e35e0847a86f4f537e8161446f748f", + "rawBytes": 11394, + "rawSHA256": "287279111614FA86ACE3BFA7B6B0D34EF1D23CC8D4DDDD5CB0FA728C6B1C3075" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-stepsBound.consumer.lean", + "mode": "100644", + "gitBlob": "3468e33ad53bfe2bc18c066f0d4d17ed9a0ffdfc", + "rawBytes": 24769, + "rawSHA256": "57E53CA68683C31D4D71F34A8504C4F14C92F09F4FF097B9F7BE9973E34E1488" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-suppliedMemoryAgreement.constructor.lean", + "mode": "100644", + "gitBlob": "4ad093d673a1b096cfc2b97039a6e01c0bafea27", + "rawBytes": 11146, + "rawSHA256": "D37D398A33627168DBFA19CD30487F4E6E4F3B7A8FA48F5A1649FD971A99A7E6" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-suppliedMemoryAgreement.consumer.lean", + "mode": "100644", + "gitBlob": "5848525126b6a62946ece6c3b47403ca2ba2025b", + "rawBytes": 24521, + "rawSHA256": "979C4975E4484D66DAE9864380269BB37FEE0926695DCB61D37FE1A3865593FE" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-validArgumentFits.constructor.lean", + "mode": "100644", + "gitBlob": "bf29c02c26476cecac082dd2a043963f0145e070", + "rawBytes": 11480, + "rawSHA256": "3ED0A28AA01AF37DC29A2170ACBB0EB14CFEC27686EFBF156CC9E2E53E1A5F21" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-validArgumentFits.consumer.lean", + "mode": "100644", + "gitBlob": "1fd0b65abe837a19d45fd812584409240a1e677e", + "rawBytes": 24855, + "rawSHA256": "5B2AF2EC240642F0CD03C38FE51EC6E51C810E519C9DE28BFA6D93EF4FF71B54" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-widthBounds.constructor.lean", + "mode": "100644", + "gitBlob": "1c76722e5df313e661da7ff4d36ce697fcbdcf6a", + "rawBytes": 11442, + "rawSHA256": "E5B7627E6BEBE4733ADBCEF700C3976B6081924FC230D98797B68D085B39BC05" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-widthBounds.consumer.lean", + "mode": "100644", + "gitBlob": "04fe4f7190bdfcc9d1c96d4bb31f1d907b4e5fbf", + "rawBytes": 24817, + "rawSHA256": "D9287C6F1E8402A30A66F79D76FD65A05902D67ABCEEDF66CE1F90DA6840B10A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/capacity-without-code.constructor.lean", + "mode": "100644", + "gitBlob": "a09ac4fef7ce4b45f2f3ff9b3c74cd718a55c8d9", + "rawBytes": 11674, + "rawSHA256": "3B8F2B138D8688E6135B810B4DFE542D2E6A541CD0228EE11F3EDF7A7A7BC4FB" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/capacity-without-code.consumer.lean", + "mode": "100644", + "gitBlob": "77211266476610042602cf0018555ab8841da42e", + "rawBytes": 25049, + "rawSHA256": "51441D1D50D5306585FB86A5B6E7878A40227EF4496E567482675373B6F55A80" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/capacity-without-scratch.constructor.lean", + "mode": "100644", + "gitBlob": "d96fdb2f0732fbd87f561640c451c26617ff9fee", + "rawBytes": 12016, + "rawSHA256": "A753103B1A5ACF77E6C1E99AE347C5737CE5F430BE46AC37FF0A6F5FCC33A6C9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/capacity-without-scratch.consumer.lean", + "mode": "100644", + "gitBlob": "cfdb4c8b554b3ab363ae805637de53eea9a57298", + "rawBytes": 25391, + "rawSHA256": "C4F7C8FD7424E1E114FA44146C8264A73DB4979B726735DC43C6D7A5F2CA338C" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/delete-accessCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "2476fca2abe7dbaa66da65680a665301d3a5d5c3", + "rawBytes": 11158, + "rawSHA256": "651791C2BACE987748195F70EAE64B2B7456DAD1B64F76D39959113EDEFFC6E7" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/delete-accessCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "a2e585992498bc3b6be2a163851887449e0fee3b", + "rawBytes": 24533, + "rawSHA256": "1D448F39649BE5CA08713BA75E8B198063819BC1DE619488DE32A3D06145DCEA" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/harmless-comment.constructor.lean", + "mode": "100644", + "gitBlob": "ae0a57829e7dcc813a86aa375c821691b2ea3f46", + "rawBytes": 11483, + "rawSHA256": "72FB34AEFDD6DD4C5D58160F954FF6F6A251B957438528E4BFE9FE86CCDA4DAA" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/harmless-comment.consumer.lean", + "mode": "100644", + "gitBlob": "570516f92f378ae3df0ab4d691fb122f3c8b9081", + "rawBytes": 24858, + "rawSHA256": "FD5635974A1AB26F392D5AD314220BC219019ACBC066C38D8B4BB1275A3917A8" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/public-proposition-True.constructor.lean", + "mode": "100644", + "gitBlob": "5fd81410e22ed0c9adbc8e8b304fd971e33e1edc", + "rawBytes": 8309, + "rawSHA256": "25F7DFA212CA726BFA0B94D53514F418F636334834E611683C107DDB500198F5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/public-proposition-True.consumer.lean", + "mode": "100644", + "gitBlob": "2b40da833cc40572f755deed688ff3b5ce0752c5", + "rawBytes": 21684, + "rawSHA256": "CD318D4A01D7EB7D85734777D2DE9793DF29C799AF2DBBC66E6E39521CFB8E2A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/sibling-completeCapacity.constructor.lean", + "mode": "100644", + "gitBlob": "830663d296b3c0671ec8b200e37367e1562b61a9", + "rawBytes": 12178, + "rawSHA256": "383AC71E84D35B513E61FB2D6922511EC707A66D73906EDBE059F110BB4CA583" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/sibling-completeCapacity.consumer.lean", + "mode": "100644", + "gitBlob": "7f3fb3d33027495d529f4719e60c1b99c00acb4d", + "rawBytes": 25553, + "rawSHA256": "3D897DBE47103BB5DBAB786B2EFC7DBB6320EDCFEDAA5E5F050AF8C9B6A321A5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/sibling-readerCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "b9e942b8ac95e8582bd01c2c19e7de3391931f23", + "rawBytes": 10935, + "rawSHA256": "09DD0A40D2E4AA6100F2FCD52327F3F1A899DFD7C18CFA8AA6025D02A56D8A93" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/sibling-readerCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "f8e64748eace4d1a60bcdcdf3df979f9a05ded95", + "rawBytes": 24310, + "rawSHA256": "8BF63B05D98C8F0785AC0684B7F1D960757C792A0A81CEF5B98445B5845DA11F" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/sibling-selectSafety.constructor.lean", + "mode": "100644", + "gitBlob": "0fe2b2a154a94bc3c6e9c73b75140d1d694b83b1", + "rawBytes": 11460, + "rawSHA256": "E7EC2C585E24141BF454AC9B116F824ACBA24EDE85D58D5CFD33B9670BF7E2A0" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/sibling-selectSafety.consumer.lean", + "mode": "100644", + "gitBlob": "8783cc147547d65d482021fa38f1ef5c4c31848d", + "rawBytes": 24835, + "rawSHA256": "E6C6E5F62FEB8B9A903A40606A2FCE0C84E467480595BC097B9DB2F2949DBF0E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/unchanged.constructor.lean", + "mode": "100644", + "gitBlob": "8184759bbac7eb8b54cfe5acea62c9b86cb8211b", + "rawBytes": 11412, + "rawSHA256": "1C6CD0A85B77FBA7706C77DA87DE358808A24FA661D5635A3C4B3BBF96005D69" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/unchanged.consumer.lean", + "mode": "100644", + "gitBlob": "333c7f7b9185d5f19e703855126e300f0630b0da", + "rawBytes": 24787, + "rawSHA256": "34030EC06C9424F6692A02E49352D7B58CB67A6F1A874BCF07D980DEA0FCB3FB" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-accessCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "1d1566db6c748a2005e9e61c18d92df996201130", + "rawBytes": 11347, + "rawSHA256": "BE09F4706F3D5A0B82A0B7A2B3C2F7EC974F39181B7FF6EB82A3C2F0D0905839" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-accessCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "4d2d4efffff52f03062ed28e0d0ce3d1f703fbf2", + "rawBytes": 24722, + "rawSHA256": "3E46A4250093F07453FDDD3077B0CD86D24E4F0C7DA68E0B7A36614937D1EB8F" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-accessExecution.constructor.lean", + "mode": "100644", + "gitBlob": "3daad8f272f9a29156236becf0a9fe9b8b94c106", + "rawBytes": 10967, + "rawSHA256": "D08CBAFF37A5A3CF762A697B7C0B041D91612DB39CED86481A29F11D80A9A4F5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-accessExecution.consumer.lean", + "mode": "100644", + "gitBlob": "811a8bbb0b624dc28ccf54f044b142bcd23e3fd4", + "rawBytes": 24342, + "rawSHA256": "233BC572F5947A66BFB47857CA8629E696B691E3399AE6DDB7BEF3814129EF9E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-accessSafety.constructor.lean", + "mode": "100644", + "gitBlob": "8b63d87d332133a7d6cab2b046a4bf1070f7b60e", + "rawBytes": 11138, + "rawSHA256": "89BD8C1D125D764AB8538610A7986B71B4639107B89DE60C3B00B012F89127E2" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-accessSafety.consumer.lean", + "mode": "100644", + "gitBlob": "aec90e1e7fe49ab2530abe5e301daf058331420e", + "rawBytes": 24513, + "rawSHA256": "5433D05760D65D9F969D3433834EEDABAB1A6274F65F951EFA5FD0AF339E901F" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-categoryBounds.constructor.lean", + "mode": "100644", + "gitBlob": "2b7a998ee82242c228d9e5e4e41a7202f673780e", + "rawBytes": 11197, + "rawSHA256": "7716C9062519F437B242E46328219893B7C9DA9FDB4F56C7F7CAB92E96A899F5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-categoryBounds.consumer.lean", + "mode": "100644", + "gitBlob": "f73dc29a882e258ffaafe9981bec1f894f9b4da5", + "rawBytes": 24572, + "rawSHA256": "E4311923FFF5ADB3787056D750814B35477E68419265D522BF46FCA8D7FF79A8" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-categoryPartition.constructor.lean", + "mode": "100644", + "gitBlob": "51a91f75c783f1a07a9057b7eefe75d4f02d7255", + "rawBytes": 11031, + "rawSHA256": "04863CC2F81C1F9DE7E69F8A8E551AF2DC69AE39DD7327ACE348FDC7314C0719" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-categoryPartition.consumer.lean", + "mode": "100644", + "gitBlob": "0ad1aff421088743802d92beaaf57937487d1446", + "rawBytes": 24406, + "rawSHA256": "A87CC95187DDEB2E09FB08D0834036C10F434318E32B1631581E80CBDB05106A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-completeCapacity.constructor.lean", + "mode": "100644", + "gitBlob": "6b9a4ebb43ffb4f9c18513ae7d179d2984737fd0", + "rawBytes": 11048, + "rawSHA256": "4B0706831969C019A3D2783BA58FB40FCF6314ABA0324A8FA664F5F8E1486FA7" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-completeCapacity.consumer.lean", + "mode": "100644", + "gitBlob": "9f37df32e743f745c3f3f9eeec94350a16aec239", + "rawBytes": 24423, + "rawSHA256": "6EEAC100AD379A0CCF6D0AE1DF62AED680DB286B4A3ACA11A204C23ECFFA28E4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-finiteScratch.constructor.lean", + "mode": "100644", + "gitBlob": "6039b399f77492b63f72fe0bcc983203ffa7a6fd", + "rawBytes": 11204, + "rawSHA256": "B152A554E610CD1B71AF4FEBE48EF7DE76A07AD1E552BBBB369329F73E753D95" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-finiteScratch.consumer.lean", + "mode": "100644", + "gitBlob": "73d618a553f1bdcf6da6eec731b92e47101e5806", + "rawBytes": 24579, + "rawSHA256": "45A0F90170383AEBCC6A26B1F805930C9EDD1C7AC7712A4572CB05413B124C07" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-memoryWordsFit.constructor.lean", + "mode": "100644", + "gitBlob": "a281320d581f1d5d54df90d3713b0d8f3245680a", + "rawBytes": 11283, + "rawSHA256": "357895F2A939A21AD32072C92496E332A6A7C0D19B11ACD6460BB4777F1365BE" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-memoryWordsFit.consumer.lean", + "mode": "100644", + "gitBlob": "5734d69446f18daf6c7e8d5bd85a7acfeb01041a", + "rawBytes": 24658, + "rawSHA256": "7C694AF7B9DCB60A38645BEF898AF307E331504B9234F03C727782CE119FB382" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-overheadLittleO.constructor.lean", + "mode": "100644", + "gitBlob": "8ed06564d248876239944cb3abbb19084b1394bb", + "rawBytes": 11382, + "rawSHA256": "81B4ED9073C48C982CD353D2FC5AEA6DB93312EAF20E1A5F3B1E59B0F57AF1EC" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-overheadLittleO.consumer.lean", + "mode": "100644", + "gitBlob": "b85064500f53df05e1704ed05308611255c7dda5", + "rawBytes": 24757, + "rawSHA256": "4B929237A0A552FB5C0452ADC7C67645CC48145DF3136145429E914DE25A39E3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-programLengths.constructor.lean", + "mode": "100644", + "gitBlob": "550bb409b7ff387703fac09747804da606320944", + "rawBytes": 11239, + "rawSHA256": "218B2E0E75ADA30FF7CC020751D13604192493D43BF9DEA4A8A38720A1BEC884" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-programLengths.consumer.lean", + "mode": "100644", + "gitBlob": "1f345bd3b0750d52ad62a951e9daa2dc34367738", + "rawBytes": 24614, + "rawSHA256": "6504D0887EBEABC94D26FF26EC79CFBB9BE8E44E192D1179A9B9A872799E425D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-rankCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "68d19f16af2b8fd83a3f89e78e4e22c1108511f7", + "rawBytes": 11242, + "rawSHA256": "CB537E5BDF53729456D4CC64D8ED0C587EB0DCB02FC71B0890E0FEACFFF08AED" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-rankCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "7a8ff28d0acb1cae1b605f33babefa41913aacdd", + "rawBytes": 24617, + "rawSHA256": "70DC8889FB84878BE1F28130F289EFEE45D4A993A1B41AF79F989B1B637468E9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-rankExecution.constructor.lean", + "mode": "100644", + "gitBlob": "9454db01084751433eb6831e392789a8801f70bd", + "rawBytes": 10941, + "rawSHA256": "94001D672071D489778FA49426B372FBFBC332370182A6281D7548F5702CA367" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-rankExecution.consumer.lean", + "mode": "100644", + "gitBlob": "1f4be86560bee62a285e994f11d1075e4c3e4ef8", + "rawBytes": 24316, + "rawSHA256": "8560837AA178EAF503503DD786C74EA68E3AD4CA57822877611C460FC5762AFF" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-rankSafety.constructor.lean", + "mode": "100644", + "gitBlob": "6697061bf711bb009d330e0f4d95b9107204ea47", + "rawBytes": 11129, + "rawSHA256": "507059533A947EBAF1CEDF8BF78F68A90E76904793922602F4EFB1BCCDBD8641" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-rankSafety.consumer.lean", + "mode": "100644", + "gitBlob": "f96d5476f508ad71411580b2be4c20cec8966025", + "rawBytes": 24504, + "rawSHA256": "5CA82990A028513E0955CFD0D3BB20E97D6B7109A30BF36A3FC8305CA6ADC937" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-readerCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "28b673e42454f8a92bac1035abeccbdb9cc8e238", + "rawBytes": 10739, + "rawSHA256": "93E5ED046477366087D233485968F19B015170505D15C2E7745C1EBC54F5C1DC" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-readerCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "1da9913307f9082269bdda156622f96c35e90f8c", + "rawBytes": 24114, + "rawSHA256": "ED39EA38FA85B96952E8C5442E95D3F60BB16147A4995C5CD2256C0F8B6EE0B7" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-readerGeometry.constructor.lean", + "mode": "100644", + "gitBlob": "152181f03342c990eb0b2d862bb00ce5bddd2397", + "rawBytes": 11113, + "rawSHA256": "B83749B6812A69E42E75C286F433BDEC4F07B8297B50EC220313C8EDACAB1029" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-readerGeometry.consumer.lean", + "mode": "100644", + "gitBlob": "13b5db7ea87fe732e5ff633ffaef111f0f18fb01", + "rawBytes": 24488, + "rawSHA256": "94B58CD1D753928B54BE64BF9341E3F01AD2ED48EF6FFC1ED915D28D7B18F7EA" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-selectCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "dda8a9e04b53ebabb62afd2318cf1f7824e105da", + "rawBytes": 11284, + "rawSHA256": "CF4D7AF5EFA1270F66619985DA7A42453826FEC680C932BF3CD562DEDA1D4820" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-selectCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "59b4310658fd9852090d5ae1997a7c6a8762a561", + "rawBytes": 24659, + "rawSHA256": "EC2BC5463D39D9511A08403449B9818356DB57309E3D0BA6CADC6875B831BB81" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-selectExecution.constructor.lean", + "mode": "100644", + "gitBlob": "895abd72751b7c334c3d5d24e418cd0b1a88b763", + "rawBytes": 10911, + "rawSHA256": "6F840AFC5BA6467310E7DB225FC8A8D1396F3B01339A8463CCC3AB60716BF122" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-selectExecution.consumer.lean", + "mode": "100644", + "gitBlob": "c19e3fcd6b0eca01d803d05515c82f3dd77450d7", + "rawBytes": 24286, + "rawSHA256": "0507FAB74975C9FFA4094FC2644580900A2AE77FD74013F6131E0666D7A326F6" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-selectSafety.constructor.lean", + "mode": "100644", + "gitBlob": "94edf5c2043e7eae01f2ecc634430e2f9f7b7cd6", + "rawBytes": 11121, + "rawSHA256": "2B7D753EC6DFBF5848B7F3E14BD0C6C4AE0E98D0D04876EFFBE316ED497C5BE1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-selectSafety.consumer.lean", + "mode": "100644", + "gitBlob": "eb0a28141277ce7dff35c304f5a5d4d25f872ce4", + "rawBytes": 24496, + "rawSHA256": "A61094FE7ECF898D423E14830D6845942F59E93C24DFA49F10B3559D8CD1B588" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-sourceBudgets.constructor.lean", + "mode": "100644", + "gitBlob": "5649fcbc908b923e244fae25768a16468aada7fe", + "rawBytes": 11239, + "rawSHA256": "005BB35670B2C32FBE85E30EF1718DC644B1234AED677F8754C5659BA5AC2331" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-sourceBudgets.consumer.lean", + "mode": "100644", + "gitBlob": "290f1355401845c41fd468cac840736f6fc758bb", + "rawBytes": 24614, + "rawSHA256": "6C7C268A1034C947B8F8E922E17B4DCA6E675F1B40F2FC6962B8227D3DB1631E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-stepsBound.constructor.lean", + "mode": "100644", + "gitBlob": "95d47280ef6088fe846f34b6021d835e9ff9d053", + "rawBytes": 11245, + "rawSHA256": "01046965F0DB6E44EB0701DC4D8E77BE3A61037132270B41D24B76324384E193" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-stepsBound.consumer.lean", + "mode": "100644", + "gitBlob": "218635533e9b447f5067cfa7ee0866176c6e1da0", + "rawBytes": 24620, + "rawSHA256": "BBDFC89E87897BEC6F8CDFE092134FF9D8AA413F0BBED409D832DD7077DE9765" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-suppliedMemoryAgreement.constructor.lean", + "mode": "100644", + "gitBlob": "59b8303f4a08710869d4d5ec53edbbe6d8e10cf1", + "rawBytes": 10997, + "rawSHA256": "46B67E7A43110C142844548F3C12F71C6A261E216105A7E98EE0511E909F96FE" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-suppliedMemoryAgreement.consumer.lean", + "mode": "100644", + "gitBlob": "a7f23e23244d36e27c5b68da21a210c5069c5863", + "rawBytes": 24372, + "rawSHA256": "BC23BD30C1C415D25127455ED9C75E7158BAB19325CB69F93797032FD9F3E195" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-validArgumentFits.constructor.lean", + "mode": "100644", + "gitBlob": "ca3d46df660efdf67521f9145f327e4db0dfd1cc", + "rawBytes": 11331, + "rawSHA256": "6B9A8F0B135126F6A20839D0AC2E1EDA63FAE2ADDB068C2E40CA3FAC14C89C35" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-validArgumentFits.consumer.lean", + "mode": "100644", + "gitBlob": "e16b0775c56df82ff5fb46abf8b8a7b9f4547054", + "rawBytes": 24706, + "rawSHA256": "FE300CD5BE7A660467EA4C06DD91B6CDDE02C5BAD63490A5A6C9EEE56226AF69" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-widthBounds.constructor.lean", + "mode": "100644", + "gitBlob": "acb6e5fc9dc8ea55830cf10d1f648424313aab01", + "rawBytes": 11293, + "rawSHA256": "DCAC8F2FE924655589D8A5436CB92A1288A0BDD797F3A20A8E15C2B0BD0F4689" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-widthBounds.consumer.lean", + "mode": "100644", + "gitBlob": "eacfe7b1c1aff9543d2d38d9fe2561ab48c9b2c8", + "rawBytes": 24668, + "rawSHA256": "2ECB9D416095DC8ADFF4067438A5D2FD17D57D5EC63EF29B747C6FE0108380CF" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/diagnostics/capacity-without-code-r10.consumer.lean", + "mode": "100644", + "gitBlob": "f714f0ebcafd2f667c93281db823014577b054ab", + "rawBytes": 25232, + "rawSHA256": "46FA2E22E169F04DA3348E33986EC96BDDDA9441F385079F019CE390B91E25EF" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/manifests/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A.json", + "mode": "100644", + "gitBlob": "40df2724ffdc8ee04f59de7f69cf3b1af11251bf", + "rawBytes": 76712, + "rawSHA256": "177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/manifests/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821.json", + "mode": "100644", + "gitBlob": "138a358f42fbdab9cfdc7a06a3e50b27c9086976", + "rawBytes": 76787, + "rawSHA256": "55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/manifests/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2.json", + "mode": "100644", + "gitBlob": "8ca13d336f77a2c1eba785344f0b3a3f1afbc971", + "rawBytes": 76706, + "rawSHA256": "6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/manifests/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618.json", + "mode": "100644", + "gitBlob": "8ebe97ae0ad7f70c92e219cf9b3352bc7665d2e6", + "rawBytes": 73041, + "rawSHA256": "B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/capacity-without-code.json", + "mode": "100644", + "gitBlob": "94f90d2c75b7a26ef5e4652f71b46b4b44671a78", + "rawBytes": 11745, + "rawSHA256": "218B564248CFC043ED72DAD7712900703B7FCB3E50526F3F80C2447AB34FF030" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/capacity-without-scratch.json", + "mode": "100644", + "gitBlob": "ace528ae29ec17b4181e7a4ab5be6d6563f3302b", + "rawBytes": 12297, + "rawSHA256": "D9D63CA9D840280C0421FBCAAB91C2D22C2D6A3BB9782FC69DC5E782ED7BA54D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/delete-accessCorrect.json", + "mode": "100644", + "gitBlob": "de3bcf320a1762cc35cb4be51032ee694e89085b", + "rawBytes": 10782, + "rawSHA256": "C63667ECBCBF93AD2B97340459C09C525686CA5F6D771AE0321F3F24670EF9F9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/harmless-comment.json", + "mode": "100644", + "gitBlob": "510fd62159933b170d1cc1d838cc8cd0307911d2", + "rawBytes": 9318, + "rawSHA256": "542EBCD8671A0D75E1A584EE17E7F38DC859862CF5F52BC544C9DB758803451A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/public-proposition-True.json", + "mode": "100644", + "gitBlob": "557cc01b96c9f0fd3635eb4c11577bd437591254", + "rawBytes": 10575, + "rawSHA256": "2D01C5558EE5D5AEB9F469200D079472CC33405090C4ABB81A40843D8256722B" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/sibling-completeCapacity.json", + "mode": "100644", + "gitBlob": "eeb031df10e4f2782360c8c00f5969f5b07dc4db", + "rawBytes": 12433, + "rawSHA256": "807CACE1B1BA4530E66DD6AF6F91F1F42133796BE6AFD4F460F09EFB15128C1D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/sibling-readerCorrect.json", + "mode": "100644", + "gitBlob": "658fa676ad804416961be0701dac6d6c397dd501", + "rawBytes": 12071, + "rawSHA256": "21C344C900687FCC7685CFD9F0307DAF90C5D6C1623B61C439B5E5E24E032498" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/sibling-selectSafety.json", + "mode": "100644", + "gitBlob": "b1a0db5efdedeb10e9cd1ed69bc74558e5433878", + "rawBytes": 15310, + "rawSHA256": "4DD630756B4A4024415BF8A91350A12B7E72E26C408F7738875A26C198E970C9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/summary.json", + "mode": "100644", + "gitBlob": "f20f507aa95f9f8ae4306e00b3d811fb6f63685d", + "rawBytes": 500628, + "rawSHA256": "DC190DE58D493133D28D800E73A1CE58FD474D674BF5A9D8F61017987A5016C1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/unchanged.json", + "mode": "100644", + "gitBlob": "69469b1573a2732ff6368a65cbf9106abbc6cf24", + "rawBytes": 9298, + "rawSHA256": "38F7F634E83E047C78DB2AB86305B9775C4AD7A41E4435532F399F2AFAA3A799" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-accessCorrect.json", + "mode": "100644", + "gitBlob": "f41a320212fd30d11f3adad8d1fd115634f8ae3f", + "rawBytes": 10733, + "rawSHA256": "65AFA75BA0FCC50063446D66E15647A713363C86D05BC3AC5B4BC50C68F2CAA3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-accessExecution.json", + "mode": "100644", + "gitBlob": "798524091ae9b64ec7ec6521fb36e73fb0dda475", + "rawBytes": 10749, + "rawSHA256": "1E51557748066F4355BC771B9C657A1147527B406E75B1D34ED533954134734F" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-accessSafety.json", + "mode": "100644", + "gitBlob": "04f3c63bbe496b4920747f466bbc183f7b38839d", + "rawBytes": 10722, + "rawSHA256": "68160FDDB776B184889AF48B76AA4B33EEAB4CBA8AF1DEED47599D39DE28D597" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-categoryBounds.json", + "mode": "100644", + "gitBlob": "0999ff7643e2ce1642d4e6d337bea4336b290e71", + "rawBytes": 10738, + "rawSHA256": "48C7EAC3C35F1A141F800D5CDAA83E022211D1F7A4CBCE909141C2869D6A7498" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-categoryPartition.json", + "mode": "100644", + "gitBlob": "2eec79f6e5ea7fe73cfbf15cb47f657e3c13d91b", + "rawBytes": 10762, + "rawSHA256": "4CF07693F65CAD28FA3E0F365B592B7679ABD414CB2ADAAF3D19DDB67E151216" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-completeCapacity.json", + "mode": "100644", + "gitBlob": "723f22b8d1549d688c7f097d25b7c2953faf3019", + "rawBytes": 10753, + "rawSHA256": "794E04DFBADB5742E01D979F9BCF81CC331FB3F8B31B2DE061F62311331E710E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-finiteScratch.json", + "mode": "100644", + "gitBlob": "2f40a4e11f7d1472056e80902025544f4c2852d5", + "rawBytes": 10734, + "rawSHA256": "9A415A1A199E2B557FB73D89313F0ED183D86F3D26DBEA6DADA25CF374716396" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-memoryWordsFit.json", + "mode": "100644", + "gitBlob": "d0306ef35d9e35d279444295f5eccf93caaae4f7", + "rawBytes": 10738, + "rawSHA256": "73C5B67F305F6832828D5D56AE5AA7AFF7222E6CD682D737650FE7F1C9A98916" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-overheadLittleO.json", + "mode": "100644", + "gitBlob": "f85589dea0b5997be9cc2cfadbe716f3761f842e", + "rawBytes": 10669, + "rawSHA256": "CD012E14F23863D28D98CBA4D37B0280151415D2F95C6BEFDAD9DC81F9DBBDDD" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-programLengths.json", + "mode": "100644", + "gitBlob": "eae71c5737b2a18e670b4a481529e165951dd32c", + "rawBytes": 10923, + "rawSHA256": "77746BC59DD7B5C83C44F4F644146CD339C2F380DB080919A7E2302757536E82" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-rankCorrect.json", + "mode": "100644", + "gitBlob": "32ee40a91a50be367557794f029db3edef33ce1c", + "rawBytes": 10714, + "rawSHA256": "88679530B7E56C31E45F03B4F41C07B46A087A9464AEE8236DB8FF8E600AB015" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-rankExecution.json", + "mode": "100644", + "gitBlob": "e99f3ee1317a9c9ce26665823b58e5ab1b7a3909", + "rawBytes": 10733, + "rawSHA256": "08E32AC6411DCE2831C1D8FD1239FBBCB9682101DAE866F79409D5464F0C7E87" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-rankSafety.json", + "mode": "100644", + "gitBlob": "4bed602459efb3c22a68e22424e7ea5045d1a250", + "rawBytes": 10706, + "rawSHA256": "7E7C4D7DB8CD26F3144A7D1D2D8AE5A649EDECC4BD78725F597AAD77B2989A8D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-readerCorrect.json", + "mode": "100644", + "gitBlob": "1137453ade2929421fbb726bc9550b1b3dae2e65", + "rawBytes": 10730, + "rawSHA256": "8AE24729CBB9893B28DAA455C5C251DB4F0A7FDE48C722C302360B1D2243504B" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-readerGeometry.json", + "mode": "100644", + "gitBlob": "6f56ee397d0b78c876c2068280c350df4792e819", + "rawBytes": 10738, + "rawSHA256": "90B282F678A9CE46CCAC42807BDF1D6C987C0AC9941C1E3C28C49B503507B75A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-selectCorrect.json", + "mode": "100644", + "gitBlob": "cbe820781ca4bd64fd0da3d88f299e0a7708f760", + "rawBytes": 10733, + "rawSHA256": "463D8217DD8B67AC7745F09AB30F07DB365372C692EF4F714D87FEB29D40F510" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-selectExecution.json", + "mode": "100644", + "gitBlob": "c7a6e70ece3761f755886a16ef9e45530e04cd80", + "rawBytes": 12034, + "rawSHA256": "FF92B9B1CC91937758A49E7439F2F3FEC5C81438BA8329D084786C0FB6BD0A1F" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-selectSafety.json", + "mode": "100644", + "gitBlob": "597b5956306c25618ea9fdb1e362b6d38ee79adb", + "rawBytes": 10721, + "rawSHA256": "F664D534DC90C38D2DB50BEAB2E245153C9712A8680C0EEB0957E8BF8BA98B2E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-sourceBudgets.json", + "mode": "100644", + "gitBlob": "a673d2fc87b35ebf18f5646bbfb11c4770f5d866", + "rawBytes": 10891, + "rawSHA256": "EC89931815B8C56F1664A23A1633D9A9E6D527858135A28C3E34384AD8D7AE5C" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-stepsBound.json", + "mode": "100644", + "gitBlob": "2ca9ce8af60e6087a42f33ed9cf00f012f263b94", + "rawBytes": 10706, + "rawSHA256": "CD04B1D72BCEED20F8091F9CCAEA3F84A845D05D9443913EF29B66C1291E28A5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-suppliedMemoryAgreement.json", + "mode": "100644", + "gitBlob": "97049f434b95813624a57df9b030501217aec459", + "rawBytes": 10810, + "rawSHA256": "E98F669BBBAD677C3D64DF121410A14AD3354E86D07C86B6473FD0F2FD0FD5BB" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-validArgumentFits.json", + "mode": "100644", + "gitBlob": "106a9729a721ae6041c38cff6e35995eb09b4a08", + "rawBytes": 10756, + "rawSHA256": "6EDA749FE36ECA43ECD022D178F23DAB20CC7BB8951C7CC3ADF7B7FBA4D055D3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-widthBounds.json", + "mode": "100644", + "gitBlob": "64e5936b29664ae5c8bbfc4c5b503b6aadbbecf7", + "rawBytes": 10711, + "rawSHA256": "A1170C4BD6DA3C75AC9CFEDBC866FCFE15C35BC5B5400E64B32C82590FC2C46B" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-valid/summary.json", + "mode": "100644", + "gitBlob": "b731e304e9b9b9e68e89c3df908bc3a44a4173a6", + "rawBytes": 129729, + "rawSHA256": "94D5C1E8678D63E7F3B1FAD31AA829E8DA55B1D70BE433B04A655B32F5470185" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-valid/weaken-accessCorrect.json", + "mode": "100644", + "gitBlob": "e44c1d9d7a9c787dd8424ea5102ac36bec42ebbb", + "rawBytes": 10729, + "rawSHA256": "9B2BAA4802CA6B2138DECEE73043265D5267E37EB83D2FD1CCF420C8CF460654" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507/summary.json", + "mode": "100644", + "gitBlob": "92fbd7ec61c689fa0389690f6b8e2448d35224c9", + "rawBytes": 133847, + "rawSHA256": "176C5D9D041B2791D10F4E635D51DD664367B8A3AC2FA59DAF0D6BD95777420D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/capacity-without-code.json", + "mode": "100644", + "gitBlob": "cbbde7260b2829b8795d5c24e239e4bf459942a8", + "rawBytes": 11174, + "rawSHA256": "789C5A54E7AAF6B957A4A4F76C8AE5637A5F28CAB4EDB49A7016E30459C2D4AA" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/capacity-without-scratch-consumer-campaign-v1-20260912120258157-2c2c1792-omitted-24a73644b0e14a389023d3d989968e6b.bootstrap.ps1", + "mode": "100644", + "gitBlob": "65cd30d465ee4dbd8dbfac2dc91f5273f49fece5", + "rawBytes": 542, + "rawSHA256": "E66C4BE027DE2BFDBE634A0AF46B0CC346B514788014246CA6482BD416F7DFBA" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/capacity-without-scratch-consumer-campaign-v1-20260912120258157-2c2c1792-omitted-24a73644b0e14a389023d3d989968e6b.launch.json", + "mode": "100644", + "gitBlob": "ea4323ee1df72b9ceb4000b057c6ecbe6441fb2e", + "rawBytes": 3478, + "rawSHA256": "6FEEF544985AE20C47FE3AF8B731BA567C0B6FBA825CD47502D287396E7828E8" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/capacity-without-scratch-consumer-campaign-v1-20260912120258157-2c2c1792-omitted-24a73644b0e14a389023d3d989968e6b.release", + "mode": "100644", + "gitBlob": "f73a879c57b3b06728c6e7abdf61ad40308199ee", + "rawBytes": 5, + "rawSHA256": "F5E6D024C05C9CC2746A3E127408B91A8B7A7F2A30DA0C259BC54265502DDEF4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/capacity-without-scratch-consumer-campaign-v1-20260912120258157-2c2c1792-omitted-24a73644b0e14a389023d3d989968e6b.stderr.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/capacity-without-scratch-consumer-campaign-v1-20260912120258157-2c2c1792-omitted-24a73644b0e14a389023d3d989968e6b.stdout.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/delete-accessCorrect.json", + "mode": "100644", + "gitBlob": "1a2ca4f52ba2ce6c472716cd791386a2882f666c", + "rawBytes": 10770, + "rawSHA256": "8AF49B1A6F73CCA7DD9FE7A25AA5016B0382F3C9C577EABE182F60CF2D0645FC" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/harmless-comment.json", + "mode": "100644", + "gitBlob": "81bc342e99dd56652b3bdd7eaeb447a608e3d119", + "rawBytes": 9306, + "rawSHA256": "7744F7B3D1706DDEDB49A5E0A4FEB775CC13F68138CA306F943F1FE80B30F6C5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/public-proposition-True.json", + "mode": "100644", + "gitBlob": "f3f2650747031c8f83f68835582f8237f6e260ae", + "rawBytes": 10564, + "rawSHA256": "3C36B10B05DB79B8AA7B356647D32B926701D57BBF3DE07AC16D06BAE8BCCA18" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/sibling-completeCapacity.json", + "mode": "100644", + "gitBlob": "227673fe279fb4b37ccdd862ba34b975120018e7", + "rawBytes": 2328, + "rawSHA256": "20F74544602ACC3C307D92328B6E4AEA04AABD19A2463660144D7E0397E83E98" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/sibling-readerCorrect.json", + "mode": "100644", + "gitBlob": "a3ee8c754f6468a2a30f9e8a47f61f6e4e285845", + "rawBytes": 12060, + "rawSHA256": "1CBA0C3D18735BC4782E8808A4D072FFAD26B1CDA269D6CC6D570299A6707F71" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/sibling-selectSafety.json", + "mode": "100644", + "gitBlob": "4b62c3701e785bb68a5e5590c368feba321042f5", + "rawBytes": 15300, + "rawSHA256": "680BBE2DEF3A5C5372030BC53DDF1B4C251374B45BB895552202199A323460FF" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/unchanged.json", + "mode": "100644", + "gitBlob": "388c21f7f456c0230c248ddf97e483f5dbab901f", + "rawBytes": 9286, + "rawSHA256": "79C71F7421481F6C61F68AFA5100E737DA6E65D55E92F655C70E21CE7A090802" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-accessCorrect.json", + "mode": "100644", + "gitBlob": "a00abc70f2d25f41850389c86b1b9c3ae9c8bbb9", + "rawBytes": 10721, + "rawSHA256": "13025C57DD6EE46504D49A0A2283367AD4F304C610FFD49016BA2E16B970317B" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-accessExecution.json", + "mode": "100644", + "gitBlob": "a058c6244868520a6916822692ae06187b496a9d", + "rawBytes": 10738, + "rawSHA256": "B25E70B2E168089CCABF71F04757A049A7019209F06A9126A8426D0BB7C9EA94" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-accessSafety.json", + "mode": "100644", + "gitBlob": "9c3540c2019b0c658d78fa2ae3f2ae9c9143a6e0", + "rawBytes": 10711, + "rawSHA256": "258010DCB6CE2F2D8D983B642B51A41D6DA2986AAEE12F5C535FF2C30C3957CF" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-categoryBounds.json", + "mode": "100644", + "gitBlob": "48cba7ccb6e57856bbf7449352868f0a8d650f39", + "rawBytes": 10727, + "rawSHA256": "FD90787AE8D0DE8E9B1C836AC210CFC2DD7EAB82EFE5188B3B88D4F836593C6F" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-categoryPartition.json", + "mode": "100644", + "gitBlob": "0d13effc909e2196b6394214ebec3a6b4445cdcd", + "rawBytes": 10751, + "rawSHA256": "129CFB8C2344698E73CD40935F5C931F183FA336301E4BD033149C83A0E67336" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-completeCapacity.json", + "mode": "100644", + "gitBlob": "787d8e82812e81d788fbe7d15bfeb3d2e275dc2b", + "rawBytes": 10742, + "rawSHA256": "02CACF411343EE091F420E0E931568418AD0DB2519725AA172B2223392181826" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-finiteScratch.json", + "mode": "100644", + "gitBlob": "fdbd4ac263667cd522462cd96ca7d04b0f283940", + "rawBytes": 10723, + "rawSHA256": "3332311A14A2EF97437D73CDAB65B5EAC3A1CD07A3DB30DDB624EFD248324D9D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-memoryWordsFit.json", + "mode": "100644", + "gitBlob": "d4e74782793f0fbf310a7576d1f9c677d1b82f73", + "rawBytes": 10725, + "rawSHA256": "B9AE7DD4117F19804AD90558AAE64698D7369EA78EFA13E10B4F9506965A6E09" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-overheadLittleO.json", + "mode": "100644", + "gitBlob": "2586967d1fbe6c78507d5f2b9862644fe85d96d0", + "rawBytes": 10659, + "rawSHA256": "3004A5A5CC8D091C9247C9DB9ED1B715DC5C8ABC029BBE0B51B2A11E4D7347BE" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-programLengths.json", + "mode": "100644", + "gitBlob": "5dbf80d439ab7eb312a9796fc6e37869df318722", + "rawBytes": 10910, + "rawSHA256": "C1BDC511045C38BCAE793AD44ABAB09A81B27AE8B9C4F63E6DA07F5BE735768B" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-rankCorrect.json", + "mode": "100644", + "gitBlob": "f3756c6e61fb994bc205c0a6f6cc22e4558f9905", + "rawBytes": 10703, + "rawSHA256": "24DE8525CBFC2D2117DA6CD3D0D26E71C66BA7A160655C8ABAFC43BAF62189D3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-rankExecution.json", + "mode": "100644", + "gitBlob": "639e20cd1778014d5a3469d3b1c24c8a494b4428", + "rawBytes": 10722, + "rawSHA256": "0BC449A586B4D0D522D67BFC732C5A7C71954709E6E9D82201DB2D1F86396542" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-rankSafety.json", + "mode": "100644", + "gitBlob": "8f04c2f9033b8a8fc419bbaf3ebca677f3908638", + "rawBytes": 10695, + "rawSHA256": "52A8B89B236A96AF2843501D72E9BE2D8B6733FFA2F68CECFA384B0229359DC2" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-readerCorrect.json", + "mode": "100644", + "gitBlob": "f1dd91808320a4cc1fe9d74f4d282ab2c0430ed3", + "rawBytes": 10718, + "rawSHA256": "21C099880974B57EAE5F2394B1C633FB2309284EB101E7E7B9B1222AE59DA390" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-readerGeometry.json", + "mode": "100644", + "gitBlob": "2ea64297448ef7ad08aff09ee6f6d94a35b8cf4d", + "rawBytes": 10727, + "rawSHA256": "16F295E4F066B2F7B94FB5227359E028FE008769550A0FC94D69CCB885D7B1F9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-selectCorrect.json", + "mode": "100644", + "gitBlob": "8ea8525625944015792eb859fca125ee583c079f", + "rawBytes": 10721, + "rawSHA256": "96B5B4C1BFF269CB3ABC64E5B2519393D3E63FDC82575CCFBB95D63F0551FAAE" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-selectExecution.json", + "mode": "100644", + "gitBlob": "98f5951fd20e7c8c93dbed8a8b74e7f83603a02e", + "rawBytes": 12022, + "rawSHA256": "275A26EF8ABC4F81EB2C8A50FFA9C0599E830AA3F0B3CC2D616E001E7AEED482" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-selectSafety.json", + "mode": "100644", + "gitBlob": "33cd18ee693ad0852769e062f945687d69b20083", + "rawBytes": 10710, + "rawSHA256": "13BD295EF3584CCE4128DDADB803DECE9773C1B900C7AB35C332FBDA12C1B50D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-sourceBudgets.json", + "mode": "100644", + "gitBlob": "18193e7e32db1879245df40d8aea036b23fba010", + "rawBytes": 10880, + "rawSHA256": "58FED9ED5E1A7BF453E0EBCB9B9CED144ADD0AAED0D04E28416FC6EB8E7D7B8E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-stepsBound.json", + "mode": "100644", + "gitBlob": "c31455461e1281ffca216d55a324a8d64bd05f00", + "rawBytes": 10695, + "rawSHA256": "0CCAA2071E9A6F35E5A9CEE0329CAF8A0B89151C3FE66B3EDEFCB6ABF0B89A55" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-suppliedMemoryAgreement.json", + "mode": "100644", + "gitBlob": "2f16341d6636e6302820e48452461c1419e69329", + "rawBytes": 10799, + "rawSHA256": "081D4D07D9D824E88A7397A41386E077DCCB4D7680D269701542E31686FCABC1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-validArgumentFits.json", + "mode": "100644", + "gitBlob": "eaea1f9510c3a73f271ed4cb7dbdb66f92294ef5", + "rawBytes": 10745, + "rawSHA256": "E5EA6A139E8E65CF1443ACF518620FC3261BD5BB5CADB6BF644BDAE29D452DC0" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-widthBounds.json", + "mode": "100644", + "gitBlob": "f45f4e678b1b9206e378cd4866b5db1b54f6701c", + "rawBytes": 10700, + "rawSHA256": "DF2C85E9847FB837581B75F8C21BA0A5D8833CC1F8DEF8EE310E9409454D0B95" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-valid/summary.json", + "mode": "100644", + "gitBlob": "2ffb0e12a2ca0341f36b47594355260fdd9cb973", + "rawBytes": 127528, + "rawSHA256": "1991B66202A780E3ABBC9D448CFEEBA73044EFAA90D380260C30249BECE3C4F5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-valid/weaken-accessCorrect.json", + "mode": "100644", + "gitBlob": "0538e72c7e07398a77c2eeebbf8a3a529cfba522", + "rawBytes": 10718, + "rawSHA256": "D4A15477F5272D8BC8EBCB448A5BC8F20A1B423BEE4ECFD8CCBDEF20EB856C27" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792/summary.json", + "mode": "100644", + "gitBlob": "379ffb578e61622ae49c527c0e1febdcfaed9898", + "rawBytes": 129539, + "rawSHA256": "65546AE004A15E5B09DB583E169803A5C22C5E83A5C927AC5217A9CA6F40C1EC" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-known-r2.json", + "mode": "100644", + "gitBlob": "d9ed7f55ec062eb95e127b8904c7a3d5b79dfdda", + "rawBytes": 2603, + "rawSHA256": "9ED285C82152C828016BF095A9DD4A70C1B2BF7DAC2AC64CA28F8EC4311514A0" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-selectors-r15.json", + "mode": "100644", + "gitBlob": "8511e12e527776d5e307b7801a3008664f1d5ca2", + "rawBytes": 3143, + "rawSHA256": "648BFEF62D26C2F97765785319F28DB321CB289FA5F31F4E9613BDEE81035695" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-selectors-r3.json", + "mode": "100644", + "gitBlob": "8e43515ee8d64797e97494a14c1d8bdfdd55be16", + "rawBytes": 3134, + "rawSHA256": "15E9CCEAA5BD9B7A6B7A69678C9012DA4B9E57CC5779108DCD376EDFBBE9C46F" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-sibling-capacity-r14.json", + "mode": "100644", + "gitBlob": "6f67aa1383cec65624ac2dec8e2fd72e0730b47b", + "rawBytes": 2640, + "rawSHA256": "88405A9141EDF748F43D970A1828E85B206799DE80DB95763D6DB20788A86D3D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-startup-r1.json", + "mode": "100644", + "gitBlob": "fe77d19cf780fec4b8996c69163a517f28ea88d3", + "rawBytes": 2665, + "rawSHA256": "68937007517CF24122EA01B03B750A4F324D05AF256C426432BB6167AE856FE9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-startup-r11.json", + "mode": "100644", + "gitBlob": "d1fca654e1690313398791263ad1db20d6e485d8", + "rawBytes": 2646, + "rawSHA256": "08CD3BA113D91285C3326B0A3406ECE175C590FAC6353EFA58064F044A8E2C60" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-startup-r7.json", + "mode": "100644", + "gitBlob": "9610db1cade9d6e7f5ec5eb7a34bf145f0eb7afb", + "rawBytes": 2627, + "rawSHA256": "E6630325A65107E4C596406E25E09691137BE3D5F7FC7EA49AD2E949A2BDB56E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-startup-r8.json", + "mode": "100644", + "gitBlob": "1ba1c152eeb132e52b0cacec19cb15ff4dbce833", + "rawBytes": 2723, + "rawSHA256": "45327F4CE0E73A92E505994CD11B5151A9915B8F407EBC4EB84F9D45480EB309" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-without-code-r12.json", + "mode": "100644", + "gitBlob": "a49d079340ee622610b48a5f5a3b4de3a40f4278", + "rawBytes": 2615, + "rawSHA256": "1AF88927E2370B4ABC688E7E90E95E6F2D7703289AFEB66B601F594796EAD6CD" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-without-code-r9.json", + "mode": "100644", + "gitBlob": "b4d9a71d670b98d1626cd51c374db51a5d78b930", + "rawBytes": 2601, + "rawSHA256": "871C0C21BEF28913B224439C83F4719AF7F0DF23892B7C2C4050806C0A40194F" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-without-scratch-r13.json", + "mode": "100644", + "gitBlob": "fa4c7a4375e5f5b893d8a5d3e0597c1363bc55de", + "rawBytes": 2636, + "rawSHA256": "78AC9D40B1ED9D1EF03303914EA60E7095DBE6D030E2DED4E0F4369598E56D98" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/final-static-r16.json", + "mode": "100644", + "gitBlob": "33e20f4d8d406825b27320e11161799f8b3135bf", + "rawBytes": 118993, + "rawSHA256": "3A6B5CADD17A7F4FE7BB7D0D263C33D34A4B8BA10C79290BFB54E2DC902B6180" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/first-campaign-multiline-axioms-r6.json", + "mode": "100644", + "gitBlob": "b0b6d550022c52c22f1ea6e5169266be9b4b65e9", + "rawBytes": 23080, + "rawSHA256": "027B1C9613213338E7F53E55A20B5DDCC6626E0D1A1BB3D2D1DACAED8C92D06F" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/known-v1-20260912120122614-27f1d4e3/summary.json", + "mode": "100644", + "gitBlob": "31c650ab7fc0e9684dd6649ef46b5ef9d26dae66", + "rawBytes": 126194, + "rawSHA256": "9DB603032EE96EE9C5D97C6B18DA8A36A9D364E7E896148466D3794D1CF64494" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/known-v1-20260912120122614-27f1d4e3/weaken-accessCorrect.json", + "mode": "100644", + "gitBlob": "76e1b0ee799eb8310b045ea3feca468312e32cff", + "rawBytes": 10699, + "rawSHA256": "9803BD6D4745FB61BA011FB59E20AD4DD83292EADF65F2BDBF7A7D5667B8397D" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/preparation-r11-allocation-boundary.json", + "mode": "100644", + "gitBlob": "3ab6d6bad926948de1f8dc971f88ffd1f519f9ce", + "rawBytes": 21268, + "rawSHA256": "B116B00C7E8D02CA6C7750D0B0388CE1EF81353CDD6AB9466AD316BBAC864300" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/preparation-r5-amendments.json", + "mode": "100644", + "gitBlob": "c2ef2cf5dab6035ca8d3d28536cf15b0357e3d69", + "rawBytes": 28070, + "rawSHA256": "9684D50BF35829AA05FFCA39B9DB919CAAAB7E6BCDB7B863C5B847F1829CC856" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/preparation-r8-local-scope.json", + "mode": "100644", + "gitBlob": "f8a7c4d54cf21c7e16356ee885fc7893df24e81c", + "rawBytes": 21010, + "rawSHA256": "EE178EA4B25ED69052CF5E02211EE90054F2E02BBE42347E71DB8D11B44C29A3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/reduction-diagnostic-r10.json", + "mode": "100644", + "gitBlob": "1fe752a4e85fc95da288bc5a1c5175c15969971b", + "rawBytes": 40618, + "rawSHA256": "3ABCCBF66562F75B0649B86519353ACC317CC4405051B269A6DFDF09CBD23FEB" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/sibling-capacity-bounded-v1-20260912131232993-0dae1d73/sibling-completeCapacity.json", + "mode": "100644", + "gitBlob": "3017fed25154289a0805b5d52415c0933bb9f987", + "rawBytes": 12437, + "rawSHA256": "7FA9ED78DAF87DBFA065AA82F089CFBF2563FE90F1EEF664D3301E3425F2C7DE" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/sibling-capacity-bounded-v1-20260912131232993-0dae1d73/summary.json", + "mode": "100644", + "gitBlob": "815a2d74e4a4e2fbea66fafa9c3f6cc23a5894b3", + "rawBytes": 131425, + "rawSHA256": "9AF7A77855DF07179D3A9899388EECACDA58DCEE1F78DDF193EF9B3ED6F97FD3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/startup-bounded-v1-20260912131112382-16de550c/summary.json", + "mode": "100644", + "gitBlob": "1ed4dfdb3311da946164df0d379c7e08952b540a", + "rawBytes": 128047, + "rawSHA256": "C34A27BB72B9FE87D646CC539FCC75140392CFD64EDFAB6852C7E778957437EC" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/startup-bounded-v1-20260912131112382-16de550c/unchanged.json", + "mode": "100644", + "gitBlob": "0057136fe38fe983785e13a7f29150f2fef32360", + "rawBytes": 9284, + "rawSHA256": "CFD77BACBCB8304D1F814C8E4D3C61749737619EDF706F539E48537CE933D94A" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/startup-fixed-v1-20260912130326593-5ae12815/summary.json", + "mode": "100644", + "gitBlob": "e484502dccb4ff6891d04488c9cb61f6d1b81ead", + "rawBytes": 120137, + "rawSHA256": "140A2DCEAC22BE786F125B87BDA9C5DDB5FC70E808735394568F1F1FC4DAC964" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/startup-fixed-v1-20260912130326593-5ae12815/unchanged.json", + "mode": "100644", + "gitBlob": "2e0071e1b17f0bfe76c0dfeb3149ad844274d30e", + "rawBytes": 1999, + "rawSHA256": "7A384C2680324D69C5F8BAFD967BF878B9812216710C5059FC21451E02E99B6E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/startup-local-v1-20260912130542938-da84d62a/summary.json", + "mode": "100644", + "gitBlob": "0e7dce1534075b00ece9923ffe495056f2205036", + "rawBytes": 128041, + "rawSHA256": "9CB2EC431BFE07917529597F2A951CB612D4ACEB1507E9EC245EFC1AFC895EC5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/startup-local-v1-20260912130542938-da84d62a/unchanged.json", + "mode": "100644", + "gitBlob": "d33d971baa69029797936ab5e49144f0593cfb9b", + "rawBytes": 9280, + "rawSHA256": "AFAB159AC4C59F2F9A31715C5762BB7EAE420E9B0F0941263FEAA71DF49090E1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/startup-v1-20260912115946824-c5633795/summary.json", + "mode": "100644", + "gitBlob": "2c860e6280e1151731e21bffb48620a24759900a", + "rawBytes": 124581, + "rawSHA256": "31F1115F7ED0F4AE460ACED3DC3E7D12D46D0D24060361B33B612BF1E5AED027" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/startup-v1-20260912115946824-c5633795/unchanged.json", + "mode": "100644", + "gitBlob": "a0236bcce9afedd6b6148c7aec5390de9e416c08", + "rawBytes": 9268, + "rawSHA256": "E8BBAFE43C54802F8564204AE1186A615BBBE00ACA39498FEBD2325461782BF6" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/without-code-bounded-v1-20260912131141013-c315be77/capacity-without-code.json", + "mode": "100644", + "gitBlob": "0b4f3a341de5b514131b4ed111ed2ecc00fa063f", + "rawBytes": 11741, + "rawSHA256": "CEA9E5FE376C2A5C79699FADA5A17BA54AB8DF89652B0A71A02638064AC30CA5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/without-code-bounded-v1-20260912131141013-c315be77/summary.json", + "mode": "100644", + "gitBlob": "3dda8fe68487ea6f32fa99665d772a9e8128e87d", + "rawBytes": 130679, + "rawSHA256": "4BBF4D3C1E7E863574691CEC3A8031034C01D4C642E1AFD09EF0B32746874E2E" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/without-code-v1-20260912130638654-f62ec813/capacity-without-code.json", + "mode": "100644", + "gitBlob": "3a7b97ddc2961100ccd73a47d6e027df86745e6f", + "rawBytes": 11164, + "rawSHA256": "776C35AFD301F51C3F46641E0ADB319EA220D4F9F42DF2625EF8DF219D2C9630" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/without-code-v1-20260912130638654-f62ec813/summary.json", + "mode": "100644", + "gitBlob": "fda7e3f0f49661dcce22566ff9739a350d6b33b5", + "rawBytes": 130011, + "rawSHA256": "4A5B4F30C3E2B83F71395407B5D962E87F3F181DD2F69E9D13F72AA80B794035" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/without-scratch-bounded-v1-20260912131205253-a3c06263/capacity-without-scratch.json", + "mode": "100644", + "gitBlob": "dcf1ea6c6512a0b3b76b49ad00f2ff1ffcdb1eb8", + "rawBytes": 12299, + "rawSHA256": "897C3B948E05A28EACDE75F7FD7EC9B4336321A51651752583B317586A5E0032" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/without-scratch-bounded-v1-20260912131205253-a3c06263/summary.json", + "mode": "100644", + "gitBlob": "04269d84a46491eb63dcd9a095fe7e6e27cb41e7", + "rawBytes": 131270, + "rawSHA256": "D4490C8903753A59FE1FBB54E2E0F25B7A932BA26C43623D34DB135B40F106B5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/write-scope-freeze-r17.json", + "mode": "100644", + "gitBlob": "ee478c7c27cf9996a4d67bda7eefb508b1c1cc86", + "rawBytes": 103609, + "rawSHA256": "D9100B6EE635781917FA551189F764FA66D999664E33A134FF19B0560E8F5D73" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/registry-v1.json", + "mode": "100644", + "gitBlob": "60b2170865b060b909e44fdad0c18975e71c3c71", + "rawBytes": 194, + "rawSHA256": "546ED02ED97227C269C4649C0B75C5A7337B9D40DE6ADA14CBBE2546AD79FEEB" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/snapshots/97405C70ED3B60CED72874D6DF622D2E9BBA0BD8F04808A3F98ED34EE1CEB770/Capstone.lean", + "mode": "100644", + "gitBlob": "8184759bbac7eb8b54cfe5acea62c9b86cb8211b", + "rawBytes": 11412, + "rawSHA256": "1C6CD0A85B77FBA7706C77DA87DE358808A24FA661D5635A3C4B3BBF96005D69" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/snapshots/97405C70ED3B60CED72874D6DF622D2E9BBA0BD8F04808A3F98ED34EE1CEB770/public_expected_type.lean", + "mode": "100644", + "gitBlob": "77799af6f8a981de81e5e91e85929247d66013c8", + "rawBytes": 13417, + "rawSHA256": "FEA8D045EF0A9CB9679949ED8825F2E04A4542C01E8F056A778BB0B474BF7A9E" + }, + { + "path": "docs/internal/extensions/bv1/controls/route_v1_probe.ps1", + "mode": "100644", + "gitBlob": "56b10b0c192073009fd4a98c265e4fb3cc340568", + "rawBytes": 1693, + "rawSHA256": "8C3D92D057026636386BCD075886C54E9D034C6E2322F8C7290244B1934F4D38" + }, + { + "path": "docs/internal/extensions/bv1/controls/route_v1_selector_controls.ps1", + "mode": "100644", + "gitBlob": "33778f78952730c95cc0148f81a8fc070652b431", + "rawBytes": 3190, + "rawSHA256": "D676AC5F587F3EECC0A15B75CCBB0E76B729DD531E7E6A72EAF1FFCB3F0E1228" + }, + { + "path": "docs/internal/extensions/bv1/controls/route_v1_validator.lean", + "mode": "100644", + "gitBlob": "727ff397c3c56a97e4235322fffa310ec3fbe177", + "rawBytes": 4441, + "rawSHA256": "A36ACF5EDF0750D2F5F01BCCE931B2104310E68AEFEB4F7A6BBE6CEBEA30ACA3" + }, + { + "path": "docs/internal/extensions/bv1/controls/validation_v2/baseline.lean", + "mode": "100644", + "gitBlob": "702061d81a8595ad940019bb5ec572e768eb78e7", + "rawBytes": 9387, + "rawSHA256": "333B0A6BD8FB3082051845D2F1BD333668B9D33758A9030A68B25695CFEE068E" + }, + { + "path": "docs/internal/extensions/bv1/controls/validation_v2/registry.json", + "mode": "100644", + "gitBlob": "eb7884ee4e29c206f40644ecea1c336e565ef92f", + "rawBytes": 3204, + "rawSHA256": "BA82633FC1D6647A294C150DC20A21159C64635A08FFD5CBA5B3C16464B64CDF" + }, + { + "path": "docs/internal/extensions/bv1/controls/validation_v2/removed_fixture.lean", + "mode": "100644", + "gitBlob": "36bc541d427a58eefc583cf2c029bb7caad7d16c", + "rawBytes": 9306, + "rawSHA256": "1F2241088DD172B38673AA376F291400C5B68DB319545A3C465B78E971875BB2" + }, + { + "path": "docs/internal/extensions/bv1/controls/validation_v2/restored.lean", + "mode": "100644", + "gitBlob": "702061d81a8595ad940019bb5ec572e768eb78e7", + "rawBytes": 9387, + "rawSHA256": "333B0A6BD8FB3082051845D2F1BD333668B9D33758A9030A68B25695CFEE068E" + }, + { + "path": "docs/internal/extensions/bv1/controls/validation_v2/wrong_crossing.lean", + "mode": "100644", + "gitBlob": "6eb488621eac8ac4e5306b30c8b08fae9af443c0", + "rawBytes": 9387, + "rawSHA256": "6B9484013683BFA4E6C0F46800582BFEDE057BA8661273DCACA5BB8453D06D14" + }, + { + "path": "docs/internal/extensions/bv1/controls/validation_v2/wrong_packet.lean", + "mode": "100644", + "gitBlob": "1d0478d02f82624fd652cb8664ba32a339980e1a", + "rawBytes": 9391, + "rawSHA256": "4895B39F548A5C434D173288346A59D812D996F5A2A1D31D1CC0E7FBACF478A1" + }, + { + "path": "docs/internal/extensions/bv1/freeze_contract.ps1", + "mode": "100644", + "gitBlob": "4c5f2997143f1746d914ba3f12c29f8b4ad2019f", + "rawBytes": 11973, + "rawSHA256": "930F16AF7C38DAC2198F9F894F6BA96AAD4B9153FDC02205F2196CC646EA9F45" + }, + { + "path": "docs/internal/extensions/bv1/run_command.ps1", + "mode": "100644", + "gitBlob": "f2b6b69b8339224d2b8787df23bbf404a2686248", + "rawBytes": 2193, + "rawSHA256": "BD1B93838AAFFDF67BF06BF5E613B208E0944F55027DEDD223B36CCE483099F7" + }, + { + "path": "docs/internal/extensions/bv1/run_final_gate.ps1", + "mode": "100644", + "gitBlob": "d87947b32f3b08432f06afc221fc9c22ea14ddfe", + "rawBytes": 6837, + "rawSHA256": "3C7B8F56F96406CC170FE80E135B0CBBD8C6109F0A6EB27D5A9D24F6BEF34EA3" + }, + { + "path": "docs/internal/extensions/bv1/verify_phase.ps1", + "mode": "100644", + "gitBlob": "c688d094e5f873da2cd73c7f8b389ea3c7d9ecc9", + "rawBytes": 3629, + "rawSHA256": "0727C072E20B50CDDCD983D7CAAB56ECA84B906A5EDEA2EB242835A88FAA4AFE" + }, + { + "path": "docs/internal/extensions/lb1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "0ef956c9d6922a94e55b5afed2d2b3e8e768aeb5", + "rawBytes": 18465, + "rawSHA256": "21D7970E80844C07B6E87AB0CA78B3A792B624B11E1F0EE1D975DDF8C5578C95" + }, + { + "path": "docs/internal/extensions/lb1/AUDIT_D6_INCONCLUSIVE.md", + "mode": "100644", + "gitBlob": "7d843c28c6796e6b288cdb3d3ae501330a264375", + "rawBytes": 997, + "rawSHA256": "45C5125FF020E050E05496B3BC061C2F8C0C92228BFF4A80BECDDC894470A773" + }, + { + "path": "docs/internal/extensions/lb1/AUDIT_PROMPT_DRAFT.md", + "mode": "100644", + "gitBlob": "1b5253bffe86d67bd3a0af2f1cdef3f76d1d9630", + "rawBytes": 30280, + "rawSHA256": "C747B0B3D423EBA89FA80416627F8DAC31F4B03DC690D9AFB29B7986E6943547" + }, + { + "path": "docs/internal/extensions/lb1/CONTRACT.md", + "mode": "100644", + "gitBlob": "49c4763d142d277a282aebd510f8ba55b9ecf912", + "rawBytes": 6963, + "rawSHA256": "C37A1604C4D9A73B4E8B9BA336ED7F8138BDA9DCC14C9CE4709EBCD51F253DC1" + }, + { + "path": "docs/internal/extensions/lb1/CONTRACT_REVIEW.md", + "mode": "100644", + "gitBlob": "cad3efd2edaf3cbe1c9b432913e9b2cf48148c18", + "rawBytes": 14550, + "rawSHA256": "4521F23D2295ABC87CF7DC4735C486C8AAFF125F064CD07A973F0BC9C02AFDA2" + }, + { + "path": "docs/internal/extensions/lb1/COUNT_PROOF_NOTES.md", + "mode": "100644", + "gitBlob": "4f5e5c140d9b76ed6f942dde039931a041b8ed26", + "rawBytes": 22524, + "rawSHA256": "1684DD3DAD857808BA959E74FDA1F607B55D287069B3D094BEB05E6EFF794452" + }, + { + "path": "docs/internal/extensions/lb1/EVIDENCE_PLAN.md", + "mode": "100644", + "gitBlob": "1d1553ef9d3ac463fca963d0a4e46555777577da", + "rawBytes": 13426, + "rawSHA256": "BB85EBC1AFFCE213A3AEC70695E64D6B27C3D62BFAC5B79AE29F7CA67167A8F9" + }, + { + "path": "docs/internal/extensions/lb1/FINAL_AUDIT.md", + "mode": "100644", + "gitBlob": "ecccf970b8ef207dafa9982f73251254cf1069fd", + "rawBytes": 60590, + "rawSHA256": "7F26751CB14DFB9C345BC13DC374C1F4D6AA8CC0E8677D3B7FECD236A6726778" + }, + { + "path": "docs/internal/extensions/lb1/FINAL_DISPOSITION.md", + "mode": "100644", + "gitBlob": "05f0547a0acf7f9bef43538dafc8cde77d07d0e8", + "rawBytes": 9723, + "rawSHA256": "307BEF03AA8179AE71CC2C79F7CC4EF211C902BE34FFA369DE16FBB49D52D967" + }, + { + "path": "docs/internal/extensions/lb1/FROZEN_INVARIANTS.md", + "mode": "100644", + "gitBlob": "bccbdf3e2b7663f219e67f7aae50ed7404c012fb", + "rawBytes": 5172, + "rawSHA256": "DBA3E9A832430B6B77AF233694591E3F3351B8D0F8F0E1089A742E069983AF8C" + }, + { + "path": "docs/internal/extensions/lb1/FROZEN_REQUIREMENTS.md", + "mode": "100644", + "gitBlob": "a13021ea8fca97b96179bad0f42536bb3952d91f", + "rawBytes": 2903, + "rawSHA256": "C6973439FB2F915F47CC0D641F33FA1F4F9844260B3D2A42DC4C5D41BAF9A7D1" + }, + { + "path": "docs/internal/extensions/lb1/FROZEN_ROW_EVIDENCE.md", + "mode": "100644", + "gitBlob": "28b9090a802856577550ffbc225837a78380e36c", + "rawBytes": 9483, + "rawSHA256": "AD164B668CBEB805019C4368F3564D5FF5E182B2B09ECE89DCD84200FD527F71" + }, + { + "path": "docs/internal/extensions/lb1/PACKED_PROOF_NOTES.md", + "mode": "100644", + "gitBlob": "c5e0c4ad01837b420881a75837b8f6d22e3a4e25", + "rawBytes": 9778, + "rawSHA256": "87699ACC658F305232E9ED45054A203BE4CAA80EB18B20736EC28AA8628358A3" + }, + { + "path": "docs/internal/extensions/lb1/REPLAY_REGISTRY.json", + "mode": "100644", + "gitBlob": "16adc302887bb2d13b8388af8463b6328a604acf", + "rawBytes": 10844, + "rawSHA256": "9015398F8F1AEE8AF69C21294B2437B68FC77DF70006B69EDD2A593878D07E8B" + }, + { + "path": "docs/internal/extensions/lb1/REPLAY_REVIEW.md", + "mode": "100644", + "gitBlob": "92c165edc90b806d0115204616408d514836e8eb", + "rawBytes": 7818, + "rawSHA256": "97C9E31D32B6BD801166EE4DD340BFDE62CEB7CDF622655D2D5C92BBB0D71212" + }, + { + "path": "docs/internal/extensions/lb1/REPORT.md", + "mode": "100644", + "gitBlob": "8b939ff059a658aef8742b97322ffdf21f954a1d", + "rawBytes": 15415, + "rawSHA256": "0669030286C33C1C2C272A6D3E02313F41BC0F0A0B18E39FD108FB10468460D9" + }, + { + "path": "docs/internal/extensions/lb1/SOURCE_RISK_REVIEW.md", + "mode": "100644", + "gitBlob": "fa24eaf9364f3770d5ff463aa43c042f396e5d5e", + "rawBytes": 25192, + "rawSHA256": "EBD0EF82D236FE465EB246B5835F8DF117B76EB43227D17F5CE5A0398B4460D5" + }, + { + "path": "docs/internal/extensions/lb1/VERIFICATION_LEDGER.md", + "mode": "100644", + "gitBlob": "9833d8aa5a5c5a732880a64b19ffda35944bac55", + "rawBytes": 12914, + "rawSHA256": "672F419DA9469F6A88528CE56B262F9DB2DC43C8EDDB057C397B1851F1E9B4B3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/REPLAY_REGISTRY_v1.json", + "mode": "100644", + "gitBlob": "6f97ed70ae35fd0cc49a9cead0425172e6055b30", + "rawBytes": 9654, + "rawSHA256": "C8228678C188C14BF579EE1DB2876A0D511010EDA539D1404CDFDCAF38BBF0B8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/REPLAY_REGISTRY_v2.json", + "mode": "100644", + "gitBlob": "4257558f7bd807148fb87a4a56aa94ba68e493f8", + "rawBytes": 10691, + "rawSHA256": "C31CF089904CF1B377C53F19109CB756DBBC969DCDD6A95B7D92ABB4899B86CE" + }, + { + "path": "docs/internal/extensions/lb1/evidence/S03SamePredicateDiagnostic.json", + "mode": "100644", + "gitBlob": "f3f65cfa14d97b561c89d90b84954bbc3bec2082", + "rawBytes": 1198, + "rawSHA256": "DBB395EDF0E0413EC63FEC7C91F8E0AEE3CD2BB7B8020712B15A88D408AED04A" + }, + { + "path": "docs/internal/extensions/lb1/evidence/S03SamePredicateDiagnostic.lean", + "mode": "100644", + "gitBlob": "47bc35beaed406ecdadfa427e531f3511ed88e1e", + "rawBytes": 885, + "rawSHA256": "3748714FC508B7DB57FB97F95DD871AC218E70B1EA7150CCAF29FE8C3D778C72" + }, + { + "path": "docs/internal/extensions/lb1/evidence/audit-launch-5033/AUDIT_PROMPT_READY.md", + "mode": "100644", + "gitBlob": "70514bf71f0262d096e3d6686bccf946234c731a", + "rawBytes": 32925, + "rawSHA256": "63B4119CBA8797D2CD8B8A319ABBE14FA9FEC9F157311C634A52682A9BF91767" + }, + { + "path": "docs/internal/extensions/lb1/evidence/audit-launch-5033/baseline-runtime-manifest.json", + "mode": "100644", + "gitBlob": "1ca9fac057d5fe8ef47a64e9cb9adf368139617e", + "rawBytes": 5761, + "rawSHA256": "4FF2AD65D48A36B95C6BF5B419FBE18C555E2E4FB055101F8A56CE62CAA77B10" + }, + { + "path": "docs/internal/extensions/lb1/evidence/audit-launch-5033/delivered-evidence-manifest.json", + "mode": "100644", + "gitBlob": "f58c2bae496148fc5a4cbb855079fd3a9fe87cd7", + "rawBytes": 6369, + "rawSHA256": "3C8459BED9B99A4DEF74CB8970F4C5038629F46B1A9B79922A6F902423BDEE7D" + }, + { + "path": "docs/internal/extensions/lb1/evidence/audit-launch-5033/full-replay-manifest.json", + "mode": "100644", + "gitBlob": "906031c67dcb62eb907a24c238cea76ea784db61", + "rawBytes": 59582, + "rawSHA256": "BC23837A1B04C1714FB8CEF1E09BE14F456306419687EBCED8CA49728048AE30" + }, + { + "path": "docs/internal/extensions/lb1/evidence/audit-launch-5033/immutable-source-manifest.json", + "mode": "100644", + "gitBlob": "0804feb17143180d33dace91ad70d3d8216081bc", + "rawBytes": 283557, + "rawSHA256": "046E16AA91D82722BAA39AF0F5BF3CF949811757430E85A5372289176E366549" + }, + { + "path": "docs/internal/extensions/lb1/evidence/audit-launch-5033/launch-receipt.json", + "mode": "100644", + "gitBlob": "cebd0f6b667ca07fe1346c041bc1db9d850e77ba", + "rawBytes": 2386, + "rawSHA256": "6AE98C59D886E70E825EDFF8019FDC54297443D5A5FF2FD463730460847732E0" + }, + { + "path": "docs/internal/extensions/lb1/evidence/audit-report-receipt.json", + "mode": "100644", + "gitBlob": "fdc5c0201a26b7907765d291a774ecab949a5e0f", + "rawBytes": 725, + "rawSHA256": "211FB39287488676C2564E48F8A0FBD7048AEC31BC42E5E81A2B3B6C105902FB" + }, + { + "path": "docs/internal/extensions/lb1/evidence/axiom-inventory-development.json", + "mode": "100644", + "gitBlob": "07c09497629f93241a82bc1aaabdc1946c048ed3", + "rawBytes": 6151, + "rawSHA256": "67A7BA044588C45401562D8FC31BA72DDCBB592A3C95D2373C5CE16B305F8149" + }, + { + "path": "docs/internal/extensions/lb1/evidence/axiom-summary.json", + "mode": "100644", + "gitBlob": "c3153265b5161b1b786be806ea0001261e73e61c", + "rawBytes": 1595, + "rawSHA256": "190DDF0CFA10A211D7B519DD621C153A5272E6880F86302CC5863F63D4781CE8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/build-20260912T071459461.jsonl", + "mode": "100644", + "gitBlob": "e6347117261eaf0885e5e8acd65b34b23766c3a4", + "rawBytes": 11228, + "rawSHA256": "AAAF13F1C08E1B64DB60BEC42C2D92A031DEEB2EFB411AA4891F64E43D5C67C0" + }, + { + "path": "docs/internal/extensions/lb1/evidence/build-20260912T071953550.jsonl", + "mode": "100644", + "gitBlob": "7ad5569c7acb0e26f5f6f0baa722cfdc4c2e3761", + "rawBytes": 872, + "rawSHA256": "B1FEA60DA6F066F541ABE008C17CAA7805BEABC6B77FCA3EA6DF15924EBD80FA" + }, + { + "path": "docs/internal/extensions/lb1/evidence/build-20260912T072455472.jsonl", + "mode": "100644", + "gitBlob": "b3d0ce7bbf257f4ea6ebace50036b5b5c9158147", + "rawBytes": 426422, + "rawSHA256": "3DEA96F33F468F166526179324A7D41CA91007C0C6536DD787A477DE1EAE1BBB" + }, + { + "path": "docs/internal/extensions/lb1/evidence/build-20260912T084142579.jsonl", + "mode": "100644", + "gitBlob": "3c5fb2e6f3f56bfe38284341230687bf5c66dafb", + "rawBytes": 912, + "rawSHA256": "C6BF421628F29BDD09DACC771B9E55D0C990E90AB7169DDAC5564CF3BD69878F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/build-20260912T084243070.jsonl", + "mode": "100644", + "gitBlob": "cdb4e39c572186441827e3bb219412d435c71a4c", + "rawBytes": 1427, + "rawSHA256": "C38D36ADA3480909082EAEA53A5912F23E14C410BB29B7E4DD270F15F3841270" + }, + { + "path": "docs/internal/extensions/lb1/evidence/build-20260912T084355841.jsonl", + "mode": "100644", + "gitBlob": "f9bfac05e3f1bb84441627a081af2d14236962d2", + "rawBytes": 892, + "rawSHA256": "488654F212715A4711625E1FB64F1FE232B8B8E156943F1F0F3C3E41DBCA71CB" + }, + { + "path": "docs/internal/extensions/lb1/evidence/build-20260912T100805553.jsonl", + "mode": "100644", + "gitBlob": "adbd6c7d28f2b8130f8e173ffd89e8b0938d2750", + "rawBytes": 892, + "rawSHA256": "BE805F42763FEFAF78EFFBB7503797EEE36B3851DA66EF257A5CDABD07239598" + }, + { + "path": "docs/internal/extensions/lb1/evidence/development-checks.json", + "mode": "100644", + "gitBlob": "bb22f02a1c4a05b270e5e92b8bd71e3adc11da92", + "rawBytes": 2653, + "rawSHA256": "B7AD3379491473351D00E8790C616DD8F2A95CA105F7AE89EC8FD827E132E433" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-evidence-manifest.json", + "mode": "100644", + "gitBlob": "ccff4a28c37009d6041369112e314b84e51e387b", + "rawBytes": 71281, + "rawSHA256": "9EAC10B7DB0D08A860887145B1E62F2853D7E369095712EF9C3F4006002248E7" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/audit-d6-inconclusive.md.gz", + "mode": "100644", + "gitBlob": "96fef014611389e30b9d0d034273211199e1e75e", + "rawBytes": 22013, + "rawSHA256": "2C3248E96D1804EE2BE82CCD46426111FA58B7E794B56AEC5EE15E064ADD782C" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/final-frozen-rows.json", + "mode": "100644", + "gitBlob": "0fc16f19ce945ba4efc7a1a6510eb1c3ba378fca", + "rawBytes": 12424, + "rawSHA256": "785AA40020B248D50F409F53D60DD9AA5EFF37B5A775267F86AF45705E91A46E" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/final-replay-verification.json", + "mode": "100644", + "gitBlob": "1f55611f91b8b14771e97588522cb06f4cb3f915", + "rawBytes": 338835, + "rawSHA256": "9E12B8D8C2148F38F253E0BCBC8955C89CE371E1A641FE96D12740C3ADD12494" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/full-terminal-receipt.json", + "mode": "100644", + "gitBlob": "02d7a97efc8d884d245b97fd3818caa28d066a73", + "rawBytes": 2215, + "rawSHA256": "00846AA0F1D3320DDC3EF207286E0110C42382609189008E946CDDC999FA86E2" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/historical-audit-claim.log.gz", + "mode": "100644", + "gitBlob": "0e22ab18c1e80077f1caab06255d4af096b629fb", + "rawBytes": 585, + "rawSHA256": "58516BE0BF581E826356E33E8B30DE65F5CE20FA5D79F75A334746A3BC096DDD" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/report-certified-claim.log.gz", + "mode": "100644", + "gitBlob": "e6066d900344957c8260c6f6f7d643fb86a38dec", + "rawBytes": 604618, + "rawSHA256": "A750C8419ABBC29B136282394546A46BB2F07EA22259D6ACAA6C5A6D0A980D27" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/report-certified-design.log", + "mode": "100644", + "gitBlob": "07d0a0374e8cb9b21b77987fefe49edd60956bad", + "rawBytes": 76, + "rawSHA256": "CB70C605B01AC3BB88B012B3BCB073900DBC7801060EC0ED0DCF218A86C82B0F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/report-claim-discovery.log.gz", + "mode": "100644", + "gitBlob": "93a7db9b2819b1a6aba27915f82a8210c2cee65e", + "rawBytes": 3214773, + "rawSHA256": "FE035CF19490C87AEB9A51FCED1B86719E4575B69F7FDCF821094D9463883E99" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/report-whitespace-discovery.log.gz", + "mode": "100644", + "gitBlob": "09efc1d151b596ec8738acc243df07260e3711a4", + "rawBytes": 304, + "rawSHA256": "C8754E96A4CC6A627D51C9E3021194BAC484130BDE04F046C467C9B6B45E64F6" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/run-conflicts.ps1", + "mode": "100644", + "gitBlob": "2272d16533e2b0b05f2eb9efcbf83d343e68a9dc", + "rawBytes": 4906, + "rawSHA256": "DD5DA56B8A1DBC34FC659E1E0B88400BC11CDAFA2BCAD121D967865D999AA466" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/run-final-trust.ps1", + "mode": "100644", + "gitBlob": "affb1c44cc5f02633fd59abfe4de6a093a06b37d", + "rawBytes": 5984, + "rawSHA256": "FE19DF3C0D5C562FD01AE7D5918EBBA0BCD092CABA30D02BDF56275770A55F97" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/run-focused.ps1", + "mode": "100644", + "gitBlob": "a1537b410159d37e2714ad48fa978527a9f12168", + "rawBytes": 4295, + "rawSHA256": "898238CD16BD54A0901B06F2B6A1DAAACAB761B7A52A3F6AA0E517FBA2023539" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/source-5033-claim.log.gz", + "mode": "100644", + "gitBlob": "2a5e9682835181469cd8949cd4226ba0da124950", + "rawBytes": 604156, + "rawSHA256": "83CC10ED0F4C1D64720C15607AF0374791F1BE40263695BC95FBCD69EC6153A8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/source-5033-design.log", + "mode": "100644", + "gitBlob": "1663957322b0dfe1eb2359c26c93de4446c02e56", + "rawBytes": 75, + "rawSHA256": "B8C6F527AFCEB3E87AAE310E208AA97CAAAA1EF4EA72D91D5F4235B55FA828CC" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/source-5033-policy.json", + "mode": "100644", + "gitBlob": "66b602a0fe90abf7ed5ace7ee0783fc1f4087a90", + "rawBytes": 1066, + "rawSHA256": "AC5752D0902FCA77F56F5C64DA022E9343453DAAF7A4A0E4AD4FB2F3466606A2" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/stopped-audit-2.json", + "mode": "100644", + "gitBlob": "96041d9fd10af35b1e31a47022ec19465e8d9a28", + "rawBytes": 721, + "rawSHA256": "64D83970DCC0344B6A7C560756E4001475B5A6AB521017719494D8D1941FD4E6" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/verifier-discovery-001-bytes-property.json", + "mode": "100644", + "gitBlob": "b9fd380af33b911a323661e1e010102f7772eaf9", + "rawBytes": 2334, + "rawSHA256": "000738B4DAAA67BB2D262677BA5A093BE33CF8A12AFCA8849487274846F94177" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/verifier-discovery-001-pipeline.json", + "mode": "100644", + "gitBlob": "9a62a8f36455c7bbe29ea04c8d0017fe413a4299", + "rawBytes": 315, + "rawSHA256": "56C0C9E656DBD26DACD0C50FFBF348CC0820D9979348E80A67E3063876AEB36C" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/verifier-discovery-002-nul-excludes.json", + "mode": "100644", + "gitBlob": "170f5cab2d1fa62c7b0724615670834263558cd9", + "rawBytes": 2310, + "rawSHA256": "384D4E5C751D24316F3AED4556008CC9D3DD35C6C7D93DAA1799C864F58187D2" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/verifier-discovery-003-local-ignore-pass.json", + "mode": "100644", + "gitBlob": "36390f47e954eea1fa515f855f9dd48c7a776af7", + "rawBytes": 338835, + "rawSHA256": "3A2D74AE62305053853CFB166AA8BE7039153429405B4FF6931A9CF022DF3722" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/verify-final-replay.ps1", + "mode": "100644", + "gitBlob": "6265a990614b87686c5b031326c42e44300c84d7", + "rawBytes": 34122, + "rawSHA256": "B0F56D591E67B67DF2C5E24F43E8564EEA993D579EBA15DAABC4CF1CE15D7BBB" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/DeadlineOnly.json", + "mode": "100644", + "gitBlob": "11fdbe69941afd303cf18b0b34e55316996fd8c7", + "rawBytes": 3459, + "rawSHA256": "4353B059D6FFCA82E65130C6B4CF296BBECE4CE42CB95641FD649ABD839D48FB" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/DiagnosticOnly.json", + "mode": "100644", + "gitBlob": "e57cd0424a5d837e371c91d12ec45afa1314f6eb", + "rawBytes": 2742, + "rawSHA256": "1D8D9EBAB95BE41760797F19A189DA2559CA0C17404237B1E87B70B6E630248A" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/RegistryOnly.json", + "mode": "100644", + "gitBlob": "b6ea83b2b355941b6a5a110a516511f02f819c1d", + "rawBytes": 2718, + "rawSHA256": "2FAD915984F617B7EC55815C63884D68A7357E6709FC59FFD03CC2BE5F08C969" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/RuntimeOnly.json", + "mode": "100644", + "gitBlob": "d655b426cacb397b62a629223053c8b4315c0b17", + "rawBytes": 3493, + "rawSHA256": "7EA5DF824E0A62032D3D28F914110FC53681E27BE8CB9E43061AF43645334F1F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/SelectorBoundaryOnly.json", + "mode": "100644", + "gitBlob": "cfb1c03d05342475dcbcbdd13822b7d9876317ae", + "rawBytes": 3388, + "rawSHA256": "9F89761636147579B8D22FCD45DC8574187875CC6FC58D1C36EED64D2F3EC808" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/DeadlineOnly-0/deadline-fixture.ps1", + "mode": "100644", + "gitBlob": "f26738b0309cb5949e09ed4bcb6b5bf6087ed4c2", + "rawBytes": 431, + "rawSHA256": "4E890249F8D3222EE32D0174E1ED8F886E98EF11642B222F85F67A1317A919E8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/DeadlineOnly-0/deadline-result.json", + "mode": "100644", + "gitBlob": "ab090c44876af83015bcc3e53b44dcc42d97511b", + "rawBytes": 343, + "rawSHA256": "FB778481933E195FCC8630D0A49FCAB74F2F2BA697D3EB2A427CFDBB42038744" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/DeadlineOnly-0/descendant.pid", + "mode": "100644", + "gitBlob": "c05bef18ed18cf0cf210446be47381acf4b4eafb", + "rawBytes": 4, + "rawSHA256": "BB4895391BDDAADEAD1C9015D8C4DF4806458CD7901F221B5C6B92B8CFA9297A" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/DiagnosticOnly-0/diagnostic-boundary.lean", + "mode": "100644", + "gitBlob": "8dfb0224f2a771d50e00d47e79f440cb1b8bfded", + "rawBytes": 82, + "rawSHA256": "095AA29925219A82EE935057C12CE34296AD318BA3415B2EDE6B51A1E3101343" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/RuntimeOnly-0/runtime-full.json", + "mode": "100644", + "gitBlob": "96a2eee91d007ef320d1fb5d9c2f31cda4ae6baa", + "rawBytes": 1135, + "rawSHA256": "526FB4A54D572F9CBB1F38A8573E35B7FBCBA651E0963201B4C695F6D0C554AC" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/RuntimeOnly-0/runtime-known-selector.json", + "mode": "100644", + "gitBlob": "81c79328e5fd7c4b3706c397eb78489fd86fe2b4", + "rawBytes": 576, + "rawSHA256": "E95A55307426F3950C42511F860019105428C4047989649EF0E518296F6516A8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/RuntimeOnly-0/runtime-selector-empty.json", + "mode": "100644", + "gitBlob": "b2cb87a292f5fb3ffbc76fa1c37012f7516ad2bc", + "rawBytes": 413, + "rawSHA256": "5943B041FC62558A9894F3E26C267A5315602D1F7FF32DFC69D2622E8C50E7AD" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/RuntimeOnly-0/runtime-selector-malformed.json", + "mode": "100644", + "gitBlob": "077c2cd1e4c74e7b34eedc1d2b3e928086bf8bf0", + "rawBytes": 440, + "rawSHA256": "30C7BE856E171A4E692B901D18E35553DFF3A993BB34B565218920BBB559D340" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/RuntimeOnly-0/runtime-selector-unknown.json", + "mode": "100644", + "gitBlob": "e358cc0e862d00c4c39681c65a8c9d9d742d43bc", + "rawBytes": 446, + "rawSHA256": "C425152E89C44CCEF3A6478B917EAD72F71D1E92B10E8EB556BC3AF64591AE8D" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/RuntimeOnly-0/runtime-selector-whitespace.json", + "mode": "100644", + "gitBlob": "2d94ed68f3b1aa7b4496a1f33806bf3df682c3df", + "rawBytes": 429, + "rawSHA256": "A957511191D26677E07BA2F86C89443B4276D5B6CF975D944DD7EBA677416A34" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/RuntimeOnly-0/runtime-startup.json", + "mode": "100644", + "gitBlob": "1afc54e9702686e392f41f9f5cbd8aab2feeb534", + "rawBytes": 704, + "rawSHA256": "8CFF41191A00812CBEB4AD6CB6C2B0304048F25D5146C4BE4C4B9C510819EFC7" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/SelectorBoundaryOnly-0/selector-empty.json", + "mode": "100644", + "gitBlob": "1fe21ca75323fcb7270e6df47d577af3ef928b18", + "rawBytes": 1002, + "rawSHA256": "C0C4F89ED1C3CF19B7DE13D042BCA633C8FCC7E7925A29720FFD2B1628D7BB4B" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/SelectorBoundaryOnly-0/selector-malformed.json", + "mode": "100644", + "gitBlob": "34d1cda170d2353054d67ed6bab4e1810b5b7b2a", + "rawBytes": 988, + "rawSHA256": "BDFDC7518F60CCCDEDC6B5B17BFBF2D0FAC8B9B1B2598D66300987EB4E3DA2B1" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/SelectorBoundaryOnly-0/selector-omitted.json", + "mode": "100644", + "gitBlob": "0bdf06241e8769275116070af2ac72cf7c9ef2fc", + "rawBytes": 2882, + "rawSHA256": "21EDCD4956F58A7603B72EF957B7D68096BF596F9A35AB89695A3F49C4C022B0" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/SelectorBoundaryOnly-0/selector-unknown.json", + "mode": "100644", + "gitBlob": "90feab8f18741e2462aaa6739581fb7cae386d20", + "rawBytes": 979, + "rawSHA256": "4F805DEA975D7A07656A90AADBC5AF35A827EF5B9CA1B2726F598EE2FF41C664" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/SelectorBoundaryOnly-0/selector-valid.json", + "mode": "100644", + "gitBlob": "97d70c0602cc5e23a99a3d6a53cff30f4abf4896", + "rawBytes": 402, + "rawSHA256": "C9D8E36DA4B135B5F5B862D2E24F19A609CC691159754C5436D7D803A21CF231" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/SelectorBoundaryOnly-0/selector-whitespace.json", + "mode": "100644", + "gitBlob": "b81fb8b6b1463c19998c565e56e6c67d9f0a3108", + "rawBytes": 1007, + "rawSHA256": "D40CB998A07AC96491C569077BCFEE77A5F7D6FBCE9A4096310799159DDB2883" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/summary.json", + "mode": "100644", + "gitBlob": "4e8245ecf78250baa3edef49157b0eeacb1b1e4b", + "rawBytes": 18074, + "rawSHA256": "AE6C9ABCF27BCBD059AD40D011BEC743932B6B31C781039DD4ADC769F36FBDAF" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/S03-SIBLING-BUDGET-consumer.json", + "mode": "100644", + "gitBlob": "de749dca468fd290a08685c9e76cf2a5c352df0b", + "rawBytes": 1243, + "rawSHA256": "58E28F29A2494E82314E91B303CFFF45ED9CBC71970C8C77F7811D038406B439" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/S03-SIBLING-BUDGET-producer.json", + "mode": "100644", + "gitBlob": "f65794e4d96734e8ddf54124a3005d8cdf98fd95", + "rawBytes": 300, + "rawSHA256": "8105A064EF2C9A4C53E9519FFB999D6CDBD8F864BD829E77DC86FCD0B7C6206D" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/baseline-consumer.json", + "mode": "100644", + "gitBlob": "f96846af6d869aa965898f8ca869dcabfb3f3041", + "rawBytes": 293, + "rawSHA256": "95F31DF092195B0153A5DDA7E7C2AE3C14594DF3EC2F3816D6E7EB068CAD1616" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/baseline-generic-consumer.json", + "mode": "100644", + "gitBlob": "ca5712403a40f0d4d90f2c30aa25ad7c136d02e9", + "rawBytes": 300, + "rawSHA256": "96A7EA7DD24B07BEAD3AB14838C1475FC11EB9707E36CD15243BED27623F8786" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/baseline-generic-producer.json", + "mode": "100644", + "gitBlob": "913ffab5bf21197ff1fec5ad433b009322446d7a", + "rawBytes": 300, + "rawSHA256": "F7698694F62D758CAE495B429B00E647B42D956F672D4821E2681281286F2B45" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/baseline-inventory.json", + "mode": "100644", + "gitBlob": "6dcba452a5917a50d6318fb12f2c6bfbd8ec0357", + "rawBytes": 696, + "rawSHA256": "C72559E98DD6854A89F1CE567A2D7D12CA5F921EEE17C658848C5BDD0A4DC21E" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/baseline-packed-producer.json", + "mode": "100644", + "gitBlob": "bfe3403f4d7b0f19552b43cb38bbca6e1abe2c6e", + "rawBytes": 299, + "rawSHA256": "233BD9D05B14BCDCBB190913850673B454547EFE8308CDE36D098A0C06C6B7A9" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/candidate.txt", + "mode": "100644", + "gitBlob": "aea86e28aaca292bc0d7ddbc17018da7072b3f64", + "rawBytes": 40, + "rawSHA256": "38E9F2BE4EE79EDFA800B36A3E1C3945EA26D0A4B3F9298D014293A2116E3586" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/diagnostic-boundary.lean", + "mode": "100644", + "gitBlob": "8dfb0224f2a771d50e00d47e79f440cb1b8bfded", + "rawBytes": 82, + "rawSHA256": "095AA29925219A82EE935057C12CE34296AD318BA3415B2EDE6B51A1E3101343" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/summary.json", + "mode": "100644", + "gitBlob": "4f06615480cfa3dc20b36834efa82032dc8d65d6", + "rawBytes": 4162, + "rawSHA256": "76A94106857CF44762EFE51ED3C805EFA5FAE0215C7C9180A5673F45C099FC29" + }, + { + "path": "docs/internal/extensions/lb1/evidence/frozen-rows-5033/binary-git-result.json", + "mode": "100644", + "gitBlob": "37e82f1e2ab6c6f4769e87f172265d5cae406426", + "rawBytes": 398, + "rawSHA256": "12C017570AFBF1678E5747B82839B0271EE9CF011D83204F016935B4BED17D3B" + }, + { + "path": "docs/internal/extensions/lb1/evidence/frozen-rows-5033/binary-git.json", + "mode": "100644", + "gitBlob": "e2255a13c499fae39d17e5fa4804400d1763bb37", + "rawBytes": 352, + "rawSHA256": "A4EC1484EF04A42D5A28105480D131AD48F27F897BB09AA5DACA2C5F2A454BEE" + }, + { + "path": "docs/internal/extensions/lb1/evidence/frozen-rows-5033/evidence.json", + "mode": "100644", + "gitBlob": "06321cef6b1ea909f0a0475b3d290f9f151c1c33", + "rawBytes": 12423, + "rawSHA256": "ADD641EE29784166FD20F1FF972B1C6242A246E8F82770BB9D6577465FDF8D4D" + }, + { + "path": "docs/internal/extensions/lb1/evidence/inventory-repaired-20260912T084829575.json", + "mode": "100644", + "gitBlob": "d989b47897104ff104ba9224ae4bc7219a9c977f", + "rawBytes": 2973, + "rawSHA256": "7829D223AFEA1A1933B3009EF1E41585E2E581A2B8ED8BE9E732A263E01FD533" + }, + { + "path": "docs/internal/extensions/lb1/evidence/process-controls-development.json", + "mode": "100644", + "gitBlob": "073e0c8c7186927ba8149cfe4804c2c0417555fb", + "rawBytes": 11936, + "rawSHA256": "55980C87B8D7B190F76637809ECF2F2D2E18A4C3863C85E7219965232BCAD5B3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/A01-BASELINE.json", + "mode": "100644", + "gitBlob": "56ef52a53841c2d04ea8b94947db2a2504d5effc", + "rawBytes": 288, + "rawSHA256": "FDEC8BA62747A85A7D1B3738293AA4C0F28D4365437AC16CB95D18BB0ECCEEE7" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/A02-PROOF-ONLY-WRAPPER-consumer.json", + "mode": "100644", + "gitBlob": "75e213aba34c37e07d64edba3b5495499aaac128", + "rawBytes": 307, + "rawSHA256": "37B454D8592D08958F89A75A712CBAC5AF64E4D50579C3736E34C98444BF06EC" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/A02-PROOF-ONLY-WRAPPER-inventory.json", + "mode": "100644", + "gitBlob": "3a4fb21462271dfa897cd02da7a9be7ec86f6a03", + "rawBytes": 711, + "rawSHA256": "01D5F17320D325CF6F7E8CE259372865B5B592612C5BC62E7D1089DBDBCB8BBB" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/A02-PROOF-ONLY-WRAPPER-producer.json", + "mode": "100644", + "gitBlob": "9194d711a00991b0fcdac87ae90f274610f383d5", + "rawBytes": 306, + "rawSHA256": "AFEE235AC7D1AA045F6A4600ACE28B9AB4E466403540BA5CA83B327073D21085" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/D01-NULL-DECODER-producer.json", + "mode": "100644", + "gitBlob": "2e276415d0f4999569b8509b1cd08301b5bdd8d1", + "rawBytes": 3803, + "rawSHA256": "FA7C6D71E4E02BAA1DBC4AA987034DF930B74C7327EB17883C7BE98C095D2B35" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/D02-WRONG-DECODER-producer.json", + "mode": "100644", + "gitBlob": "a93ac9bf7d9069b65b991e0704e8a6720e895393", + "rawBytes": 3802, + "rawSHA256": "D1C575A32A7C9AA61545BCCC1F7ED0707C988E7E32ECB953762922D07780B8CE" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/D03-ZERO-SERIALIZER-producer.json", + "mode": "100644", + "gitBlob": "97adb4ef9f73e43210344d81570bce00a27c96d7", + "rawBytes": 2850, + "rawSHA256": "E8A1EF2169A8F95D61979694D6FEF263B8A062CEFED80B55DDA9A32145E399EE" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/F01-DELETE-MEMORY-RECOVERY-consumer.json", + "mode": "100644", + "gitBlob": "10e45c2a3d6ac814113a524d1772c76c0d83e695", + "rawBytes": 1735, + "rawSHA256": "ED099960C4E0BCEBCE883256F526641142FCF3792B997B2279011786582872AE" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/F01-DELETE-MEMORY-RECOVERY-producer.json", + "mode": "100644", + "gitBlob": "0e9aac910006b5b03d9a34d9256f6a7356718611", + "rawBytes": 310, + "rawSHA256": "BBF32A1FDB4AA435EE98B339A322C94C4AE61EB67630D4DC7E4624156165216F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/F02-DELETE-READ-BACKING-consumer.json", + "mode": "100644", + "gitBlob": "a9e60617a6c3d7bc3305fea2cbd8401a967eb3d7", + "rawBytes": 1092, + "rawSHA256": "8A83B47FB5C3F77A179FFB52065A0B7B38E5EC91181F00760710C3C027E022C0" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/F02-DELETE-READ-BACKING-producer.json", + "mode": "100644", + "gitBlob": "9757773f41d56af26d9720faa64b0cc5509a569f", + "rawBytes": 307, + "rawSHA256": "DBB7F035489CF8C430D263EBFA7C95840603B0C90476D476427DAFF1C9EE6FFC" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/G01-LOWER-PROPOSITION-consumer.json", + "mode": "100644", + "gitBlob": "b3f34e5f3f64327e72a00582856401258b57a254", + "rawBytes": 991, + "rawSHA256": "2A76C30F2F32DD5B92E7491F64313AC6A2BD4D393EB485B2D2034EF623C2AF38" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/G01-LOWER-PROPOSITION-producer.json", + "mode": "100644", + "gitBlob": "356eba7ebf9ba14c4b7d2125e4938657a1bc59a6", + "rawBytes": 759, + "rawSHA256": "E68D8C9B463E63D8C0ED3BBE51321F7FA76C3D5EE0BF6A4E4D4CCA8ECBEA1FC6" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/G02-DELETED-EXACTNESS-producer.json", + "mode": "100644", + "gitBlob": "62b7bdc89d904844607780281a3ec7b8a2ce6153", + "rawBytes": 6763, + "rawSHA256": "95002AA2FDBAEF374667DF66226AC619A2E09924B85AD16932AF4D9A4BE12EA5" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/H01-EMPTY-ONLY-DECODER-consumer.json", + "mode": "100644", + "gitBlob": "8cbb8d52d19636e61145fce4af9aa8f20a0503ae", + "rawBytes": 3589, + "rawSHA256": "64D45F3FA10261FCE5CC8400E50401C0F2214115E41569F492BF45F908FC019E" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/H01-EMPTY-ONLY-DECODER-producer.json", + "mode": "100644", + "gitBlob": "a0a215f0b62997127391f5ef278836a36953735f", + "rawBytes": 306, + "rawSHA256": "CBF16DB8FA922BD48B83D2F6AE5E4E36ADD2F9CE63F5880E5B08D69256795232" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M01-allocationResidualLittleO-consumer.json", + "mode": "100644", + "gitBlob": "6514661b6300e59d43e73510180a75ff5e777a82", + "rawBytes": 976, + "rawSHA256": "52A1CDF91D1D6A4DF1B0A61483D0E7FAB982401B76FD1DBDBB119B64377F6872" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M01-allocationResidualLittleO-producer.json", + "mode": "100644", + "gitBlob": "dd76685103bbe63543a1123221e71b5915501c13", + "rawBytes": 312, + "rawSHA256": "E2BC4CC288A601B55EEC2ED31D867CB7A13890591FF2054DE3DAD12DF8BD2C79" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M02-completeResidualLittleO-consumer.json", + "mode": "100644", + "gitBlob": "fec3dd4f3411d06e6113144a04912887cabf1a0f", + "rawBytes": 976, + "rawSHA256": "71FD5B8BAB1717EC19C26D63F63E7AF399FE32AC7E9542136BC92863C1AE6430" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M02-completeResidualLittleO-producer.json", + "mode": "100644", + "gitBlob": "26ff2e1f956bf0901d3a708d4b55126af89a9e8b", + "rawBytes": 311, + "rawSHA256": "8FC192D27E487BB714CDF98C19D3CD59BD50BED4C1F7756432E5983E7F3E9C0B" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M03-widthBounds-consumer.json", + "mode": "100644", + "gitBlob": "c058b1a64c91fb2e2c2f10a1e991c276e0b39a9a", + "rawBytes": 1064, + "rawSHA256": "F588F79302DAACAE86ACC4F67859123D34532B38B353E2D6E3E69181DF119C89" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M03-widthBounds-producer.json", + "mode": "100644", + "gitBlob": "74624a36195277ceb3fcf616d5214d39576ed01c", + "rawBytes": 299, + "rawSHA256": "36948CA1A254269254682D08FB33E579F0AA40BC8E440C628F25E0CCE73CE0EF" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M04-dataCapacity-consumer.json", + "mode": "100644", + "gitBlob": "265032d42a1ef9f5e1d62bb07d6dbf225ac7541d", + "rawBytes": 1155, + "rawSHA256": "76A605143A73753983FCB907D3B52AF595F55E7ACBBC5F416A05700513FF394F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M04-dataCapacity-producer.json", + "mode": "100644", + "gitBlob": "a6b9961d1ea3636e02980e2e2b61fca65e9a9196", + "rawBytes": 300, + "rawSHA256": "2FF22457B637E44A4FD57469DC959B6B470B05DF1EAD7497E998517E6FDA25CC" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M05-completeCapacity-consumer.json", + "mode": "100644", + "gitBlob": "ad7c9ee87b2bec6f945209d44d2a56a73c28c8d1", + "rawBytes": 1451, + "rawSHA256": "BF4DE5914472DC5399B8F44E381E222E20E11E7F67F10C003FD5E1E2CBCB08F8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M05-completeCapacity-producer.json", + "mode": "100644", + "gitBlob": "9c3f812f06247283cfe44675be20263997d0f734", + "rawBytes": 304, + "rawSHA256": "535722F321BBFBF3F658F63BB35335B2C0BFACB5B690D455047A69C183D64CA7" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M06-memoryWordsFit-consumer.json", + "mode": "100644", + "gitBlob": "a530841acd2c96fbbd9b3a83c4c0b76c36aa390d", + "rawBytes": 1090, + "rawSHA256": "AF9A390AA081AEFEA479238955F8F368616464463D471F8D21469753A9A80857" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M06-memoryWordsFit-producer.json", + "mode": "100644", + "gitBlob": "05aff58b43b4a9ec3749a02a530bcf0ce0f39adf", + "rawBytes": 302, + "rawSHA256": "131ED87169DC670BD4A9A77F5979E3237FEE5413F85BBE2C777397A058192398" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M07-allocationAddressesFit-consumer.json", + "mode": "100644", + "gitBlob": "7bbed25891809277ce0d5e270d998d513a1da568", + "rawBytes": 1185, + "rawSHA256": "49C33E5A2D6EEE7F94E70715802B4F6B71938F5D95EEA5856BB21CB505CD1BB9" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M07-allocationAddressesFit-producer.json", + "mode": "100644", + "gitBlob": "d580f0a44e7b350441e5434e9df9c4a2728f7161", + "rawBytes": 310, + "rawSHA256": "D776D706BB1DD2071E3AFF7CE36EB678120C2F23928EAD8DB6C08B7BA962385D" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M08-programFieldsFit-consumer.json", + "mode": "100644", + "gitBlob": "007e402faec986d225490f1b4ccdfa02b0eba0b1", + "rawBytes": 1157, + "rawSHA256": "DB166373A5ABA11B0CC688A4F21F552CFD643F25A1B51EFB2172EAB327F491A3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M08-programFieldsFit-producer.json", + "mode": "100644", + "gitBlob": "083aa484a03cee6deb3ff3b915b0d0237c021548", + "rawBytes": 304, + "rawSHA256": "8CD6DE85898AD52882B1CC4C7EFAA73B619F5865FE499D9C06AAB3E18A0E66CF" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M09-budgetExact-consumer.json", + "mode": "100644", + "gitBlob": "0de884d39664be61f60af50e9392ba4b03c96e4b", + "rawBytes": 922, + "rawSHA256": "3FCF31D0CE5228DE3583639784F8AA2C4A8C6CEC593924B43955F4A4E924108E" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M09-budgetExact-producer.json", + "mode": "100644", + "gitBlob": "007e22d18b9037c2c2a9cfb8dded7739e24937de", + "rawBytes": 299, + "rawSHA256": "3081B1CEBD0D71533F9E7A1BBE63BB7128C91D868372043E6ACBAFCA50BB8A84" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M10-programLength-consumer.json", + "mode": "100644", + "gitBlob": "c3814abb6a6f342aa5358590dcf7be9c8a18cf6b", + "rawBytes": 964, + "rawSHA256": "97601D4ADFC9A07A0121F4179541092ACB1407ED18284FC2BC9FB5135067F1BC" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M10-programLength-producer.json", + "mode": "100644", + "gitBlob": "8cd0202941aa38a7484c18ea79ae2a2db70a932f", + "rawBytes": 301, + "rawSHA256": "7111E52D9A19792D0870DECD6450ED36CB99C1F74BAC27DCF6BA5BA83E5A4EF5" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M11-encodedProgramBound-consumer.json", + "mode": "100644", + "gitBlob": "842b812a27427fde87ad2f09cc478d21815188bf", + "rawBytes": 1064, + "rawSHA256": "89918415A3049B7D3C68FF1543072E76B423A03DA4483F3172E5D4920C27EEDB" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M11-encodedProgramBound-producer.json", + "mode": "100644", + "gitBlob": "c6c99ba041b6bf199f7e53e1d8cca19a862d539d", + "rawBytes": 307, + "rawSHA256": "2F018FE65A7BA0942676C55EC01319D210E394C0519B5A397C90E5D6BF8D6E80" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M12-registerCount-consumer.json", + "mode": "100644", + "gitBlob": "c3d054f96c5349ee9255b89ad9ac78ca10868cfd", + "rawBytes": 938, + "rawSHA256": "9E65F0B76B24299C21E18275508C611D5DE70DFE6D101F2F0F7421679F4F2867" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M12-registerCount-producer.json", + "mode": "100644", + "gitBlob": "b0c75f6ff474f26affce28ccfaa426322f0f04fd", + "rawBytes": 300, + "rawSHA256": "393C4BD4BED0B333C6425718BA0527D0B60EB392BA3339888EDBBC53F498E0FF" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M13-scratchCount-consumer.json", + "mode": "100644", + "gitBlob": "7f18a117571be6b44f73931d5256f042b5650853", + "rawBytes": 933, + "rawSHA256": "E59C7CC5FA748D6F9C4900B179677C1ACA3A44717C0DC8AED1402460962FFB5E" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M13-scratchCount-producer.json", + "mode": "100644", + "gitBlob": "0c003e002d2ad03d9c78478400fa2a071946c61f", + "rawBytes": 299, + "rawSHA256": "536CC66928D9FFEC54124B060B0C7F9F530E50A8E816775967CB02C22F9A8E19" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M14-unusedRegisters-consumer.json", + "mode": "100644", + "gitBlob": "7e786181392193b9083728265c30fe3f0ca92fda", + "rawBytes": 1300, + "rawSHA256": "4E3DE7B9C684D3864A2933D4485FFE0AD5012F15A5DC84543D3A3571EDFE0E36" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M14-unusedRegisters-producer.json", + "mode": "100644", + "gitBlob": "0ec2bf329cee2667841a60b305948318af1d0a79", + "rawBytes": 303, + "rawSHA256": "D7306D7F46E6BCF9097DD7BA1C11F8DD71A52801045388706141BF8098420E55" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M15-validInputs-consumer.json", + "mode": "100644", + "gitBlob": "9041ae5b55daba9b77fd70c7c3ed0ecc03aa879c", + "rawBytes": 1398, + "rawSHA256": "49E61ED2F08FDDC5C311B4D93127E885D75E2D5C6BD649C2780DE8FACBDDD06C" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M15-validInputs-producer.json", + "mode": "100644", + "gitBlob": "855860217fecf8ab143bb345234ad637d7e9298a", + "rawBytes": 299, + "rawSHA256": "A3E716A012EAF003E39D62CD01A46593B18A22202E9219AE816D467CF22AF13F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M16-natContract-consumer.json", + "mode": "100644", + "gitBlob": "ca18b04a5d4c2bdb326fd27a6a7bb5e7f33ff8d5", + "rawBytes": 1293, + "rawSHA256": "B252B57EC53D35EE71E10EEF5B3A787B781BD95CE2B6A14ABDD337CED758B7EF" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M16-natContract-producer.json", + "mode": "100644", + "gitBlob": "0b8882039b329432ca7f7e03d3f7f86dfa125ada", + "rawBytes": 299, + "rawSHA256": "5F0FFBFE7A7DF333B5981691D4F0BA069ACF65464B39738F67F30FDE4C381B4D" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M17-leftmost-consumer.json", + "mode": "100644", + "gitBlob": "2588b61ee7f21f506648d3dd5d9d59f5a62c7e70", + "rawBytes": 1200, + "rawSHA256": "BD9B154A72DF1EDDA22F6A96595F0B3D348611153E99EBFA8D856926DC737A1E" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M17-leftmost-producer.json", + "mode": "100644", + "gitBlob": "fdf2413cef995d20445b24ae7e9e8ca183e10c6e", + "rawBytes": 296, + "rawSHA256": "1CFB0698AD63D6BB3825852C97FCE98D9826474AA871A5F6753EC91AB3844B86" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M18-result-consumer.json", + "mode": "100644", + "gitBlob": "1b066be755d18486732065264a46a3f371b70836", + "rawBytes": 1564, + "rawSHA256": "CE88185082C6AB4C80443907C5FFBD01FE8F05FA2E72D03CB96A8BAF15C31A8D" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M18-result-producer.json", + "mode": "100644", + "gitBlob": "ebeaa250baf277203c4b2432244883ccf0bd9783", + "rawBytes": 294, + "rawSHA256": "2A34D51D2949DC77A8143E800D91124A821F6E6110724005C46E262211D45D86" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M19-halt-consumer.json", + "mode": "100644", + "gitBlob": "65179872ad931a2da9027822397fd8f8c9378963", + "rawBytes": 1589, + "rawSHA256": "F760ABE8E8D28C9ACD5B428CA64DBDC6A4D09AD0DCAF86C15F70498E3BF18DD4" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M19-halt-producer.json", + "mode": "100644", + "gitBlob": "a96c7a72645e14c559b49d86f5332d172a6ab6ec", + "rawBytes": 292, + "rawSHA256": "BEC9CFB8C418EE47A86E4EFE478CA1CF43A7B4879F74CDA7CFB786727ECAD97F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M20-invalidGuard-consumer.json", + "mode": "100644", + "gitBlob": "854b62a4cc3dd53947ae284b7ffcbc472c48982f", + "rawBytes": 1801, + "rawSHA256": "9C7EC7724EDB8B8A172B379E0A01D8B00B3043D6B206A3B5376225E2D46FE8C3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M20-invalidGuard-producer.json", + "mode": "100644", + "gitBlob": "065f4803838288247c6c2def4046705cfe87f36b", + "rawBytes": 300, + "rawSHA256": "ACF764D1EFB6BE7ED31966B7BBFDD577A215043C1A604D92FCB1BF77E09A1F29" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M21-stepBound-consumer.json", + "mode": "100644", + "gitBlob": "1fc5a4dcd0739959e4988cee7f68d1e7545cd1a3", + "rawBytes": 1234, + "rawSHA256": "9E3930281094149CAA088B4CC37BA49CA06A9B21AC1A5787657BA1046AB57C86" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M21-stepBound-producer.json", + "mode": "100644", + "gitBlob": "8bd4fc3b12567027da6ba2e447ab8a535be94f4a", + "rawBytes": 297, + "rawSHA256": "99613F3A5FB34CCF1FD8B9B2EDEC6EAE23E60E2353E26C2AE83797EF8AD1FB19" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M22-categoryPartition-consumer.json", + "mode": "100644", + "gitBlob": "03191e0839e9981c547c58eff2d0ba8cd143269b", + "rawBytes": 1950, + "rawSHA256": "45D66191A6C91CDF1740997169D7BB310920F323DCB36520979CF5565A7D1784" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M22-categoryPartition-producer.json", + "mode": "100644", + "gitBlob": "19c15cdceee1cab89fc29402ef2271b9b6406e6b", + "rawBytes": 305, + "rawSHA256": "BDE10CB28BE505DF32D5AF3CEDB317424BC595022B88B1B6A454C30893506F16" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M23-finalStateFit-consumer.json", + "mode": "100644", + "gitBlob": "bd415f09e6613f5888968b132830b1cf5d8cb0e1", + "rawBytes": 1490, + "rawSHA256": "99DD41497861FDF086890C56EB1CA462FB2B0CC45D342AE380CED91C8FC783F6" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M23-finalStateFit-producer.json", + "mode": "100644", + "gitBlob": "b1d138155a94740501151b611366e31abdc5b256", + "rawBytes": 301, + "rawSHA256": "607A9AB6C008818ED506F47F4F13BBA5A91E97C16F07F366A54DE4C1448F05C8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M24-transitionSafety-consumer.json", + "mode": "100644", + "gitBlob": "12c79979d6f04f72b62d9cd8a28d289de167b739", + "rawBytes": 1957, + "rawSHA256": "EDBCAAF3CEE1AC9ED99FA7D999224C121C81C5780EDF5C1CFB386ACD2CE731EB" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M24-transitionSafety-producer.json", + "mode": "100644", + "gitBlob": "93cdcc08199c25ae488d4841b66401a4c21d58d1", + "rawBytes": 304, + "rawSHA256": "1C0F49CF32F11C6CEC8EE6B3CCDE5998E51863ADCA41504B817AEF126CE0181B" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M25-prefixSafety-consumer.json", + "mode": "100644", + "gitBlob": "ea4024437f0a64ca3a659a5c0b73ee02ca092efd", + "rawBytes": 1643, + "rawSHA256": "EF13C51C519F1E5632B47263E19B8263D83DB34848742B8F196070FF643E4FEB" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M25-prefixSafety-producer.json", + "mode": "100644", + "gitBlob": "a4e1e7afcc8b50fedab8a0adb83d41eb7a52aabf", + "rawBytes": 300, + "rawSHA256": "A30A8E9CEA206571C7C7FC51CDBCE64472DE710F5692C2BC1C14757928A26A05" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M26-readWidth-consumer.json", + "mode": "100644", + "gitBlob": "9e347e1488fc0a26ce7427cd36c0ab2a7bf79c4f", + "rawBytes": 2302, + "rawSHA256": "01722EB97709DF2E351DC8C149CC70AE5E4D3AC7E61B53DA1209C7BFAE2DCBF1" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M26-readWidth-producer.json", + "mode": "100644", + "gitBlob": "b5247842ee988473db28c07b3e0ff64eebf3394c", + "rawBytes": 297, + "rawSHA256": "405B0F1811CA1B3FCE0086411E06DB0E1E4343EA14B4EDA337A3381049B16965" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M27-positionalReadBacking-consumer.json", + "mode": "100644", + "gitBlob": "0f984c0cd4bb8bb1af3e53698dd5f935c28242ff", + "rawBytes": 2732, + "rawSHA256": "15016E3DBD054B4F506B3FA70D81F126A82DAC94E5BA8DD2BE27DDFF16713921" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M27-positionalReadBacking-producer.json", + "mode": "100644", + "gitBlob": "f16ebcbbd5432ec1e6453c1310be05433452131b", + "rawBytes": 309, + "rawSHA256": "8AF81870F5235AF53F18CE1A8C519305BCBDEB4AF1F3998EEFD3DEED7A55336D" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M28-orderedLogicalRefinement-consumer.json", + "mode": "100644", + "gitBlob": "ee4bc0abf775e8b41cf5d497a5445a514d4489d1", + "rawBytes": 2013, + "rawSHA256": "055A404E3A38D482BF3746846C8B04778B18AFB99AC15E779E118151FB71FFFA" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M28-orderedLogicalRefinement-producer.json", + "mode": "100644", + "gitBlob": "3b7fab1cee89305fd1c6ad38383a2b15b76aac29", + "rawBytes": 312, + "rawSHA256": "F765FCB1B9B61F86C584B9024264D49D53CC233A592AC6F530B44F3919877996" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M29-logicalReadOnly-consumer.json", + "mode": "100644", + "gitBlob": "acbbf4a6099003a3eb6e13fda6f3e4ef0e43242f", + "rawBytes": 1109, + "rawSHA256": "12E89D09EA556ED3FA6434A0F5A00F34028A5B0231E9E20FAA44BBBB2E746472" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M29-logicalReadOnly-producer.json", + "mode": "100644", + "gitBlob": "7f699065dad4dcd1554e4eb24cbda11681984bae", + "rawBytes": 303, + "rawSHA256": "06F93A1D4D01B1CD6F463FADFFE687208D76E04B3359A04EAB8A91450023C272" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M30-suppliedMemoryAgreement-consumer.json", + "mode": "100644", + "gitBlob": "40c4353c46b79cfbc110ef4bb0173132e3111279", + "rawBytes": 1942, + "rawSHA256": "DCBF711C0AC19CC7DF19BFA79ED2A310755B16AA85775A8D58E56D195C7C55CE" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M30-suppliedMemoryAgreement-producer.json", + "mode": "100644", + "gitBlob": "56992ae098ddf9b6903297d26ae5107c4cf4247d", + "rawBytes": 311, + "rawSHA256": "655CB1BD01A97F21A09F0F7A4DDB989679BD38EAB32E6E4F83E24E3D6EB78227" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M31-specResult-consumer.json", + "mode": "100644", + "gitBlob": "514f1328b97efa78136e92666e055f3907dae7c1", + "rawBytes": 1391, + "rawSHA256": "0A4CBF278F37A8BC62D81E383798419B754E97F1758469197C280AAC7D566ADA" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M31-specResult-producer.json", + "mode": "100644", + "gitBlob": "b614949cb8189e60463a353d56eb15178f065780", + "rawBytes": 298, + "rawSHA256": "BC0C669284A5C9619C3FFC27D6DA225F5E1179FC7A505A5BAC468BDCE306BD1F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M32-noFailedLoads-consumer.json", + "mode": "100644", + "gitBlob": "c9b992ffb04b7e579a98e72d3fa8c39d08159ca9", + "rawBytes": 1498, + "rawSHA256": "CF55C28E9549C75643414E61D9A175BD3D57BCDFFAE6026F5F42F6B55953D6FD" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M32-noFailedLoads-producer.json", + "mode": "100644", + "gitBlob": "7fbfa176a32d7a0cb5b96739d1225c22c143332c", + "rawBytes": 301, + "rawSHA256": "68C540BB4D1AB09FBCCBB7F81CCB929682B60048C9252F75175B3A57389341B4" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M33-invalidGuardSteps-consumer.json", + "mode": "100644", + "gitBlob": "e2b45d1b80c866c6c39dd42fcd2b0b11316da4a4", + "rawBytes": 1299, + "rawSHA256": "D30D71FB88972E36181B9FE2B137FE1E4F5B7067ADB0381715906018954F149B" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M33-invalidGuardSteps-producer.json", + "mode": "100644", + "gitBlob": "c1b1ad088a3748afcb48d053020af0a6b62580e2", + "rawBytes": 305, + "rawSHA256": "3521F57F8A8D1DB9217576D3C645C8402F6E8309BDBC2AF906C18332D3C78F5E" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O01-wordRoundTrip-consumer.json", + "mode": "100644", + "gitBlob": "1bab1dbca70495331c3006f0da184984e2b3f472", + "rawBytes": 1296, + "rawSHA256": "B88E4CAD4EB53110BC7CB35A6738E06976191627AC149DCCF3BB644CD089C679" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O01-wordRoundTrip-producer.json", + "mode": "100644", + "gitBlob": "f3e8649c72cb6aaec6590b6a9b9fd92c5ea56229", + "rawBytes": 301, + "rawSHA256": "3A25A97B9F9E68576A4521F2AB8BE51CD08A2CB4BB6E680BAD45F1745B25DE0B" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O02-wordSerializationInjective-consumer.json", + "mode": "100644", + "gitBlob": "a79eb6dfdfe7b4bd7715ca72cabab918aad2b798", + "rawBytes": 1538, + "rawSHA256": "E2AA4C5B24E5CA8C4077AE22D98816D8D9A5637EC656DB69F9AE9D87C7ED191C" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O02-wordSerializationInjective-producer.json", + "mode": "100644", + "gitBlob": "1ff54acda8bcca8f6d2d6fa29bc5ac8d352e23bc", + "rawBytes": 314, + "rawSHA256": "BD8279494C42C350FB0307F1416FEDE55CF7D2B56994A4F140BBE814FE41BD41" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O03-serializedLength-consumer.json", + "mode": "100644", + "gitBlob": "8b604537e056f81ccc83e4bbc60593bbb753527a", + "rawBytes": 2075, + "rawSHA256": "29462EC22B6BC7FD2691AA34F4D4A04BF903908926457A1FD678AB63B7DE37B7" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O03-serializedLength-producer.json", + "mode": "100644", + "gitBlob": "f310904b8838e322e77f6794df55696e2e33b0f2", + "rawBytes": 305, + "rawSHA256": "F0538068CC287A6B9CEB91A533AB3324CCB59D00AB156B0935579E47554150F8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O04-memoryRecovery-consumer.json", + "mode": "100644", + "gitBlob": "43d64d5bbb66f87412d1a649246f0b1a58f01df3", + "rawBytes": 1921, + "rawSHA256": "A24AF19845A9BC4E522ED1990941D7E36C64F2B57DBA41EA1884903CC60D8A11" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O04-memoryRecovery-producer.json", + "mode": "100644", + "gitBlob": "ad8ffce03fa81e69657c847a7cdcdbc43415179a", + "rawBytes": 302, + "rawSHA256": "1F9924AE7DF6209BAD84EF5063A6E5C34CBFAEC4AC4ADA5235E4C89B19CDE095" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O05-decoderExact-consumer.json", + "mode": "100644", + "gitBlob": "bfa7107d42c5acdfea4b1818a9a0751847b49867", + "rawBytes": 2531, + "rawSHA256": "AD3127612ABB183992512DAD9612B44AF9E53AF75AE70B107E725297A0325AA3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O05-decoderExact-producer.json", + "mode": "100644", + "gitBlob": "c49a7b4eb2bfb65604572c3189cc84c3577aa9a6", + "rawBytes": 300, + "rawSHA256": "64D1DA3997EC21E6D02D285B1735125DC813D6C166A2DC74C1C69A83821918C4" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O06-decoderLeftmost-consumer.json", + "mode": "100644", + "gitBlob": "5cb1ef899e7a56147832036d198efb6c8d7a3e8f", + "rawBytes": 1212, + "rawSHA256": "CAA1439E8F5D2EADC3719749BBACDAAC980D87B789AE7E40D6E9EBF622D266B9" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O06-decoderLeftmost-producer.json", + "mode": "100644", + "gitBlob": "33a8d1823042af5dc8b6c29a9e363a4cb53469fb", + "rawBytes": 303, + "rawSHA256": "6ABD864AFEE661E2498EFA46C13C71E2E336E82FEE39562ED3D1E8FD2210C54F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O07-sameShapeMemory-consumer.json", + "mode": "100644", + "gitBlob": "b66c7d394d357a54bfb807f57e493c1ce2619712", + "rawBytes": 1033, + "rawSHA256": "AD04875D8635910CCFA45E9859D78E0B4DDA0A23B8D028C6F28DB1E16E8CE317" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O07-sameShapeMemory-producer.json", + "mode": "100644", + "gitBlob": "7d2422837d2bc19e4ce9838525f426de6b235cc1", + "rawBytes": 303, + "rawSHA256": "5C94EFE53F608ECBD3D258DAAA3D250A6046A0CBD1EF58502892DD7E591E6015" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O08-shapeInjectivity-consumer.json", + "mode": "100644", + "gitBlob": "55db0fcca6d4805fa676d4ee5f4ac6d7063a544f", + "rawBytes": 1361, + "rawSHA256": "8BB9BFC0E09D59ACCECD0EF617407F558C5C7F8DE1DEB9C8AF981D44B8BAE661" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O08-shapeInjectivity-producer.json", + "mode": "100644", + "gitBlob": "37bbe00215b2b27675e6a755da30d010cf4a0e95", + "rawBytes": 305, + "rawSHA256": "75687DA036F7F044E9EB127C698E09ED53A931DB39FF0958E1B2752D364CD091" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O09-uniformBudgetCount-consumer.json", + "mode": "100644", + "gitBlob": "bbeff7859c152d15c72ba6db1b27cd2ee8cf3482", + "rawBytes": 1048, + "rawSHA256": "9F0F25849CC2BF121484A25C4E4A88A0E5F61CBD45869763FCA27FD0A37E78D2" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O09-uniformBudgetCount-producer.json", + "mode": "100644", + "gitBlob": "254de8fb3868443d46f1f4d9cf1bcfc08ee438eb", + "rawBytes": 307, + "rawSHA256": "FE000646C2D162664379354FB6C088935C293DBA9B5EFF63E01AA820883797BC" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O10-uniformBudgetLower-consumer.json", + "mode": "100644", + "gitBlob": "7f051c1f72ff7954e4eac87a9c273d515667fdd7", + "rawBytes": 2299, + "rawSHA256": "B5200300879E69B213E200FF1C3332102C976FCE314A8EADF97DCD329E759CC2" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O10-uniformBudgetLower-producer.json", + "mode": "100644", + "gitBlob": "5dd8453723c4002d34ce1142be665034f7d0ae1d", + "rawBytes": 306, + "rawSHA256": "3E4AA26FA2D51C1EB3220F2F0EF324B84FD9574B072E5EB02FD637CEB019E16B" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O11-canonicalCount-consumer.json", + "mode": "100644", + "gitBlob": "f845ec431e329719bd10d347553ff9149955f155", + "rawBytes": 1011, + "rawSHA256": "01366D1A1F4432B84D55AA21CC2F189D60C7EDFDCEDD1432DB4B20400A0A5297" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O11-canonicalCount-producer.json", + "mode": "100644", + "gitBlob": "c84867cd53a9519ba6c8cb2dc981dfd9bc3dd119", + "rawBytes": 303, + "rawSHA256": "34F34C9AB9C0F7DDD863655082F815921C1F67E71B10974447B9770C300CDE84" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O12-canonicalLower-consumer.json", + "mode": "100644", + "gitBlob": "52750275d72a822f86123d447c97e54f451909a0", + "rawBytes": 1061, + "rawSHA256": "053F00E967B181705ECEE68C49136ADCA110AD8DCC995FD6E4E3A5502CDBB72A" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O12-canonicalLower-producer.json", + "mode": "100644", + "gitBlob": "d79bfee9675230641ac695951ecbc0f6d204f8c4", + "rawBytes": 303, + "rawSHA256": "F0601F18441C8B93A79B465149FDBFFD0750CCCC0FBA3AB9AF2774F1EEEC06C6" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O13-upperCapacity-consumer.json", + "mode": "100644", + "gitBlob": "7c0ba3d100cb3e41c9b99eeb5d445cb0245639a6", + "rawBytes": 2128, + "rawSHA256": "B31525630541FE48BEB949F174D1701A8277B183FC28CF97BB1199AFC10ED419" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O13-upperCapacity-producer.json", + "mode": "100644", + "gitBlob": "4ce8209dc749af8a9b9042920c8e81a23b0325f8", + "rawBytes": 301, + "rawSHA256": "43F0E95E59C5CFC4461F7C8B95A1FEECC3D1B2C126FFDCCBB32B2B22467FEA56" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O14-allocationResidualLittleO-consumer.json", + "mode": "100644", + "gitBlob": "1a788667d16f5d00cc20987afd20b313f5a3df39", + "rawBytes": 960, + "rawSHA256": "62CCEDA85F1D17358E1A68BFD28630F20F9AC682E0D239942298EDDD8FE6A6B6" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O14-allocationResidualLittleO-producer.json", + "mode": "100644", + "gitBlob": "10fd4f212a99be14f6a459e71c8b4cb40b6c4f34", + "rawBytes": 314, + "rawSHA256": "3EEC155180DA431AD9FADFCA46F38A9384070D14DAB7677A810586E3C694F4EF" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O15-runIdentity-consumer.json", + "mode": "100644", + "gitBlob": "e25c6d2bc55ed7380644230520f6e10ffedddba8", + "rawBytes": 1323, + "rawSHA256": "754F2ADD08B6DE3D6BFDE035795C64DEB6A7FC48BA4243CFF8855D0D8AF47101" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O15-runIdentity-producer.json", + "mode": "100644", + "gitBlob": "a340cbff7c46fecdd39fac4d46237f478bb64180", + "rawBytes": 299, + "rawSHA256": "F86C15C3FB7D658C423C39576AEC4171D640F222EC58D51E7E804EEE635E9A1E" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O16-machine-consumer.json", + "mode": "100644", + "gitBlob": "803dadcbfc1f1f6e1d6226e931994ed5932e7d51", + "rawBytes": 19896, + "rawSHA256": "ED92801E3B7293F66F444845EF4D7C252A0EE539BC5C8A12BAD3E9525513E167" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O16-machine-producer.json", + "mode": "100644", + "gitBlob": "97d6250b106eb1505c29d920363fd738b3bfdb95", + "rawBytes": 296, + "rawSHA256": "B22AE9CD403B27FAE432FCA588CD28452C04C66ED950388318CF269ABE453DA4" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/P01-PUBLIC-PROPOSITION-consumer.json", + "mode": "100644", + "gitBlob": "0c34e72101a611d2a86053164a75bac871d1b099", + "rawBytes": 30175, + "rawSHA256": "32D024A563F60B2FF986BFA4662D7D034DC5204FA2C0C5966EAB18C9353E27DE" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/P01-PUBLIC-PROPOSITION-producer.json", + "mode": "100644", + "gitBlob": "3dd259d113ec9d6df0d4722aea52e0deb02f0696", + "rawBytes": 306, + "rawSHA256": "6A6D90D0B22EFD5D20371C5384BFFC8219672E5B7B146AA5B57555D8F677E9F9" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/S01-SIBLING-MEMORY-consumer.json", + "mode": "100644", + "gitBlob": "c4f4aa3db1783831d3ac0e2ed181697680084310", + "rawBytes": 2177, + "rawSHA256": "330F0D21F39A19A002DC9E11928CFB6453F811FB2FEBE3AF29B0A8D13C658624" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/S01-SIBLING-MEMORY-producer.json", + "mode": "100644", + "gitBlob": "50095f5ceb6ed9ce3f8be41123381a51a14afee0", + "rawBytes": 301, + "rawSHA256": "CDCC4AF58A601DBDEA128C7AE5DFC039003576427C154FDDFA27526AA119E936" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/S02-SIBLING-RUN-consumer.json", + "mode": "100644", + "gitBlob": "2d5c1097f25f74207a407c4a228b46ab68498709", + "rawBytes": 1792, + "rawSHA256": "4669E67F5F8963200D277714498C47C55CFA599C6B9474F9CB2A01168F9C607B" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/S02-SIBLING-RUN-producer.json", + "mode": "100644", + "gitBlob": "db82028865b978603b19276456a246574061e288", + "rawBytes": 299, + "rawSHA256": "1A26EB830A0D8CF283AC07DDE73474CE84E331E114279D887CC3E949B31281A0" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/S03-SIBLING-BUDGET-consumer.json", + "mode": "100644", + "gitBlob": "67eba3584b20d46070585b9c49535dae657bfa2c", + "rawBytes": 1243, + "rawSHA256": "1BDC90E51DA8A87C8D84C009F7721E13D3915B959A02E600B62F151D65E36341" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/S03-SIBLING-BUDGET-producer.json", + "mode": "100644", + "gitBlob": "6bc580d324162c033abfb9d113c9ed1af0fc3d9c", + "rawBytes": 302, + "rawSHA256": "DF2C6C01C04982DEE338C7D751EA6AC6F650D41FAF27CF09459BB4346C9CF7BD" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/baseline-consumer.json", + "mode": "100644", + "gitBlob": "c7f612106958cca8486f63b163476414bc282fc4", + "rawBytes": 293, + "rawSHA256": "4C8F7DFD1B77A0738AF57CAED1C5BCCA7A2E2EED4DEF70F5A77D07D78686B31A" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/baseline-generic-consumer.json", + "mode": "100644", + "gitBlob": "a34c8d6ec4090628d77663399f6d17ca9e690d4c", + "rawBytes": 300, + "rawSHA256": "764B25FB42F66405B8E8F04C6D09744D276C674ABA2E8D933F6B5E70201C437E" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/baseline-generic-producer.json", + "mode": "100644", + "gitBlob": "7fcd74c778ef62cb9832a9a06c2e7e1da13c9114", + "rawBytes": 301, + "rawSHA256": "83F1E0BBD236626DC287DF8A8F57B6248E1F184FF807C853AA7FF082E8C9213F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/baseline-inventory.json", + "mode": "100644", + "gitBlob": "b4c6b3d1e8e081922b67b7acf3f5749fb9a26328", + "rawBytes": 697, + "rawSHA256": "212879380044D9DA954945EED5C8C31B8395A76B41AE9C4E50C65EFB35B0A4B6" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/baseline-packed-producer.json", + "mode": "100644", + "gitBlob": "9cc86fd9c870c02cf33c08a6c62b480d7297c49d", + "rawBytes": 299, + "rawSHA256": "FFA658F03EA44E6974A36FB7CB7A8EF5CCCA7B42A6EE1EB34455092615F5F588" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/candidate.txt", + "mode": "100644", + "gitBlob": "aea86e28aaca292bc0d7ddbc17018da7072b3f64", + "rawBytes": 40, + "rawSHA256": "38E9F2BE4EE79EDFA800B36A3E1C3945EA26D0A4B3F9298D014293A2116E3586" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/diagnostic-boundary.lean", + "mode": "100644", + "gitBlob": "8dfb0224f2a771d50e00d47e79f440cb1b8bfded", + "rawBytes": 82, + "rawSHA256": "095AA29925219A82EE935057C12CE34296AD318BA3415B2EDE6B51A1E3101343" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/runtime-full.json", + "mode": "100644", + "gitBlob": "c124c26226a575438add25bf00cf79335dbbdc4d", + "rawBytes": 1135, + "rawSHA256": "274DA194CF15E0062FF89A8C775DF1EC8FD68C236AD074D9F345DF1E9D3AD7F4" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/runtime-known-selector.json", + "mode": "100644", + "gitBlob": "c26c7bcb5290b280e9dc9b1b7f26dc251a50de21", + "rawBytes": 576, + "rawSHA256": "017FBF50FB9F0409528FC1B5B41FDCA73AA365798CDB7A51AFF0E2E9FC216B16" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/runtime-selector-empty.json", + "mode": "100644", + "gitBlob": "b29e2a075a96d6639ed93a3dc41e3cafc4699f95", + "rawBytes": 414, + "rawSHA256": "A9EA3F0527D05F4EB2D28E45686E32EC1F77CD6018837A11AA78A5839D2CD846" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/runtime-selector-malformed.json", + "mode": "100644", + "gitBlob": "8c6714bb883df4e0e28d932d85c18ef0f6ed1e77", + "rawBytes": 442, + "rawSHA256": "1847FC1A4475A6E45F16C952F51AE441B81030F50B6A3430A13ABE0FCDC4D6FA" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/runtime-selector-unknown.json", + "mode": "100644", + "gitBlob": "bff55d182d299409b1e9cd84c1b9933883ebdac9", + "rawBytes": 446, + "rawSHA256": "CC840553F920161CBCA7B1F17E1F35EA0FDC19841776F6528DDAA38CCF6A51A0" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/runtime-selector-whitespace.json", + "mode": "100644", + "gitBlob": "c1300f6572c0b9f999abb6de473b173a2c3483d7", + "rawBytes": 429, + "rawSHA256": "4381CF8D5E38BD91674675EBE77F8A42DBE379AB4347D866B277FFB2D531F86F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/runtime-startup.json", + "mode": "100644", + "gitBlob": "f38e5bd3613fca560d8f27e12ea520ecaadf7a5a", + "rawBytes": 705, + "rawSHA256": "166FE6CD3838E2675E1FFBA69B0091F07AE5F161706B3B1375D09037D61D6B35" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/summary.json", + "mode": "100644", + "gitBlob": "4f1fd4b962b9ffc70031fb6282cefffa530e6a37", + "rawBytes": 194336, + "rawSHA256": "2747EF8ED6285B345B683D53B42A58D527B644D183DA85EBCCBCBA53B4C6062A" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/A01-BASELINE.json", + "mode": "100644", + "gitBlob": "b36e50c5d49e3b4639dc21acab3fe74df6a2e0d7", + "rawBytes": 288, + "rawSHA256": "712EC65DFCC9569BA355F40318911D3E7716E0F0B035FE9BA12A29A32F10A3DA" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/D01-NULL-DECODER-producer.json", + "mode": "100644", + "gitBlob": "42e764977304594739f9ec4cf5703269628b3f9f", + "rawBytes": 3803, + "rawSHA256": "9AB0DE276BA6F9B361462386451A6E25B6F334A45C6856F50DDBB703E78DCE1F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/D02-WRONG-DECODER-producer.json", + "mode": "100644", + "gitBlob": "d722d226522b00e14445f509c2f8f81e92ac941a", + "rawBytes": 3804, + "rawSHA256": "2891CC04C8D8C88C7FB2955549D40405CD995BFA4C1043AE744565F54437D6CE" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/D03-ZERO-SERIALIZER-producer.json", + "mode": "100644", + "gitBlob": "70a0284a157e35280ad0d22009c4c7c7a54f6cd1", + "rawBytes": 2851, + "rawSHA256": "3AAE58F5D38E558322255AA1420B437E9231D791CC05DAE73CDF25294BFFDB76" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/F01-DELETE-MEMORY-RECOVERY-consumer.json", + "mode": "100644", + "gitBlob": "0fe507d577b99e17d9bf611bb7186338ee3f8c88", + "rawBytes": 1735, + "rawSHA256": "1673359A432881002EDD754B19577266633995324429C539424BFF62E8329D8A" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/F01-DELETE-MEMORY-RECOVERY-producer.json", + "mode": "100644", + "gitBlob": "e184a8aba0d735ae126b9c275b7562e57ee7bbea", + "rawBytes": 310, + "rawSHA256": "41322BC61E93A76F80C7E231B91AC4304C0BD6AE47BB2FE88C28EF5F17524B32" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/F02-DELETE-READ-BACKING-consumer.json", + "mode": "100644", + "gitBlob": "ca7a30075d0adcb19175113ffb2f8e2dfdaa9fa7", + "rawBytes": 1092, + "rawSHA256": "23DF298F07E41EE2C0C63202ABA114DD792280AF2378040011FD9B2EA950D141" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/F02-DELETE-READ-BACKING-producer.json", + "mode": "100644", + "gitBlob": "667c60e8e5cef693288efbf0d487a8668961c0be", + "rawBytes": 307, + "rawSHA256": "5F09BF44698BD1F050EFB94264B4AC717EE4F8EF67E270D8F71DA962CDC610A8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/G01-LOWER-PROPOSITION-consumer.json", + "mode": "100644", + "gitBlob": "5fcceb46cc62cad390414281b7da700e3c8e38af", + "rawBytes": 991, + "rawSHA256": "F7EB104EAA1ECD664F10C46079E31E701D07A703F21FD9C01384E75FCE540B67" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/G01-LOWER-PROPOSITION-producer.json", + "mode": "100644", + "gitBlob": "a54a8e7fc010039cc5a51da7d35b041f5a795a60", + "rawBytes": 759, + "rawSHA256": "BAC840040065F8AC81BFDF2AF1A6F3FAE90B41030FD0B8D07E9B497D373523B9" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/G02-DELETED-EXACTNESS-producer.json", + "mode": "100644", + "gitBlob": "9d4b34aba9fefa6323d303dd0d6c5703634288cd", + "rawBytes": 6763, + "rawSHA256": "91068AF99B4E751E80E58AC3E72CB2172EF5F431886938A1C4FB6EF09C81873E" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M01-allocationResidualLittleO-consumer.json", + "mode": "100644", + "gitBlob": "5fdc54b384a5f1b998fe1d8fbd9ae2f9162a8243", + "rawBytes": 976, + "rawSHA256": "71D1DF5C907A87CE2BD5C035F73CB52F0FFEE526485345D36445DD0044A04C83" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M01-allocationResidualLittleO-producer.json", + "mode": "100644", + "gitBlob": "c7db240d3ce4c39108e43c7d663fbdcf6eac11a8", + "rawBytes": 313, + "rawSHA256": "8A1E7844ABAA65AA30027679BABCD13FC4EA299F78A92ABDFB2D4657EFD0106C" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M02-completeResidualLittleO-consumer.json", + "mode": "100644", + "gitBlob": "3ea4379fee98232b3d9208596b74fa926c215430", + "rawBytes": 976, + "rawSHA256": "CDC3E8A2EB0F138D8979E89AC9CDE1C31E7E9BBBF5F33CDAA65D360BEC167DE3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M02-completeResidualLittleO-producer.json", + "mode": "100644", + "gitBlob": "80db857dc1c1a8d5ef493b96b2a7e487c6eb7923", + "rawBytes": 311, + "rawSHA256": "B6F6E90CAE01D2C07F0FFA1F8D666719754D47886D3AACA1351E66D24D68FAF8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M03-widthBounds-consumer.json", + "mode": "100644", + "gitBlob": "dfa76663878f669419fb14ec7a80bd075d32e74f", + "rawBytes": 1064, + "rawSHA256": "4F5E49899FA2032FAF31C3A7791AD76431B8B23776A99AB607628437B20DA43A" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M03-widthBounds-producer.json", + "mode": "100644", + "gitBlob": "39b173eb0ab453ce658d1adaa1ac5f980b0dfc49", + "rawBytes": 298, + "rawSHA256": "8AD876E242FDC2DC288CE55FB93098A2B588CB27293DEDAB9C9A08DFF1DF13CC" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M04-dataCapacity-consumer.json", + "mode": "100644", + "gitBlob": "d8379c99b44e21a564d49bd87f83b03706a025d0", + "rawBytes": 1155, + "rawSHA256": "C98593CCE714DA7DB49813A7BBE861231A4C3908462928DC48CA2F773EA76C64" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M04-dataCapacity-producer.json", + "mode": "100644", + "gitBlob": "c156b356eb9462cbe6ce5fa8d09e8fcb1b31a751", + "rawBytes": 301, + "rawSHA256": "AD2BF81422144C5141EB5616D7D2D569AFB8DB9893137CDA832B2369756253DA" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M05-completeCapacity-consumer.json", + "mode": "100644", + "gitBlob": "0d2baa119663bf189d7a9cbf7af3ebcddc0b85ad", + "rawBytes": 1451, + "rawSHA256": "0141C4C7630F710B312F1C10454700C2B28AD9EAD50C669574FD39370E63BAFC" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M05-completeCapacity-producer.json", + "mode": "100644", + "gitBlob": "4981b35b9bcf919770e760cda93e0c9f33d7c4c1", + "rawBytes": 303, + "rawSHA256": "62559803035BA720A2349E4DBA44ECA652C1E5E04918429319B9AB7B4BFF6EA0" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M06-memoryWordsFit-consumer.json", + "mode": "100644", + "gitBlob": "43043e5030245bdad72735ccc5e1daca1fef6d19", + "rawBytes": 1091, + "rawSHA256": "7D6BBD1F3A2C31294E7A7249EBE684EF30A1E5B25E454E33550D9C6246959BBB" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M06-memoryWordsFit-producer.json", + "mode": "100644", + "gitBlob": "268ae7e9823c42f70c11225081c8ba8ad1c7845a", + "rawBytes": 303, + "rawSHA256": "C178B8606B69C1D5B6DB73FC6F39E1935257B191D54C1DFC9985C3746544EEBC" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M07-allocationAddressesFit-consumer.json", + "mode": "100644", + "gitBlob": "57e472d05d20b5c2175c3c708c15608165c2e4f4", + "rawBytes": 1185, + "rawSHA256": "88190A83300B391CA22CA9C7D998015AC4ECF4D9366BFDAE8A841DBC626CDF7D" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M07-allocationAddressesFit-producer.json", + "mode": "100644", + "gitBlob": "82fd86ff2830a0ee1822d5517ff2ec58b952d11b", + "rawBytes": 311, + "rawSHA256": "5019DC44AF5577D78C81211E45FEAC432F16309F446FD3F41EDBF1181C0E0B26" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M08-programFieldsFit-consumer.json", + "mode": "100644", + "gitBlob": "441b74d0546e7e3c131c78dc8c0582b51dea840d", + "rawBytes": 1156, + "rawSHA256": "EF16F170F686A289146B145C4075AF7119F6AA57674E2F4A2319C35EB4FB8C80" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M08-programFieldsFit-producer.json", + "mode": "100644", + "gitBlob": "885dc50550c0b89961162d18aaba36b24eedcc86", + "rawBytes": 305, + "rawSHA256": "9219BCC7A15020D2B10AC6C348A1BBB72AB810692617FB3444C7AAC69D495641" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M09-budgetExact-consumer.json", + "mode": "100644", + "gitBlob": "0bd6fefd7f17fa369f8c41041fd49d0af12d83b6", + "rawBytes": 922, + "rawSHA256": "C9DF567E6DD0CB566EE9FF40F60E7B48911236F85459778698B9E4DB3B2A0252" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M09-budgetExact-producer.json", + "mode": "100644", + "gitBlob": "b1aae881588c0b1760a32954a8ba9aebca5bfc7b", + "rawBytes": 300, + "rawSHA256": "1608E531132669D2AC53F2449BE94CC9B4CC47ADCAD3A31C224BAC4E08289631" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M10-programLength-consumer.json", + "mode": "100644", + "gitBlob": "68f6be23e09d4118f723c7b31a9ad1f8e822f4c9", + "rawBytes": 964, + "rawSHA256": "7271E232BF50F718DE1DEEF4BE06540D9442D4B366C93C894F9F371C8F5108EF" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M10-programLength-producer.json", + "mode": "100644", + "gitBlob": "0a67f656668449aa7d0b4323873f4fc3457efcd7", + "rawBytes": 301, + "rawSHA256": "25C1C950197E3CE1A468588BA4457D07501A1AF31B9AE20E680FCEAE576C97BD" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M11-encodedProgramBound-consumer.json", + "mode": "100644", + "gitBlob": "df1cbb5f4e14d868d445c169ea064d68a6e5b7ff", + "rawBytes": 1064, + "rawSHA256": "2328C18A6588ADAE098EADCD03B267D7ECBFD165C1D31278BCCD4E2C367E08E9" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M11-encodedProgramBound-producer.json", + "mode": "100644", + "gitBlob": "53110ef54fc1edbed50f76cb7dee386bfffde072", + "rawBytes": 308, + "rawSHA256": "C0921B3DA0680FBB7C441B5DAFE3B46DF160AD012424FD1422E28BE652E7EFB4" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M12-registerCount-consumer.json", + "mode": "100644", + "gitBlob": "1db13c308f3220b6a529098a13d1fc5f99d16515", + "rawBytes": 938, + "rawSHA256": "9FA45E657D51185E552067A412722AFB19AEF6AFB4E7128B8BB4462121EAAF7F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M12-registerCount-producer.json", + "mode": "100644", + "gitBlob": "c1c862b994a49cf198fa0aae5ebaa139f69cf95a", + "rawBytes": 301, + "rawSHA256": "D51903240B74DD58AF076986B53B0D0C23B9ADBF3FAFE9D6C1ACA27EE3FDD39A" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M13-scratchCount-consumer.json", + "mode": "100644", + "gitBlob": "bde1711ab097b93c1f8ee93c5b9f9c35f6b1b7d4", + "rawBytes": 932, + "rawSHA256": "54875D7954BD56C99B6B4D9358C28302D367A8F77380A47E3F05346D8B49B26F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M13-scratchCount-producer.json", + "mode": "100644", + "gitBlob": "5723049e23e9a155624dfa5ff49b64a0663bd476", + "rawBytes": 301, + "rawSHA256": "7601DA52430A58E68DFDDF10DA7E625E7B58BA1C0554AD2BCC8C241F13430685" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M14-unusedRegisters-consumer.json", + "mode": "100644", + "gitBlob": "6e8635bd36347f1428ec7a09a0f20462bd649f73", + "rawBytes": 1300, + "rawSHA256": "A374D680402D2B51C320CBA41BD609302936944174185957A4EAF42FBE846B0F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M14-unusedRegisters-producer.json", + "mode": "100644", + "gitBlob": "26f8d4c77c94d1235e9a143616e4f7c1ba9a4f43", + "rawBytes": 303, + "rawSHA256": "9EB1FA04C3583E90A646D59CAEED4F785029CB354F8C4854897A60C4F28AB181" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M15-validInputs-consumer.json", + "mode": "100644", + "gitBlob": "ce1392a09de6d1864837d31a5c41d96f5d7fa7de", + "rawBytes": 1398, + "rawSHA256": "2B56336F19D9FA6D09801359CA6C9D5E7F1B3A1C1FC12651B708DEE20E0F2469" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M15-validInputs-producer.json", + "mode": "100644", + "gitBlob": "3841bc888d610c5f1738af2eb0ccbfa85e683141", + "rawBytes": 300, + "rawSHA256": "78948C45E83E7714E0647673C8F168A773E61EFA5EF7DB693DE9572F4CD13070" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M16-natContract-consumer.json", + "mode": "100644", + "gitBlob": "c7ebb3c7d67b64de614a6ec3f13608eea168e5a0", + "rawBytes": 1294, + "rawSHA256": "A409BE6FEE756F258E69D03FAB2D37A14363A0ED9AB8571B6F01CFC31936A1CD" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M16-natContract-producer.json", + "mode": "100644", + "gitBlob": "23379a1093d0c9ba5d6765b97753bd883371c281", + "rawBytes": 299, + "rawSHA256": "807AB71CD7525D9330DC28E5CC4EF52157D5CCD0A5D309A763F96DBC8C48D980" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M17-leftmost-consumer.json", + "mode": "100644", + "gitBlob": "4afadb315e40a78c50a6467568167afff13ee833", + "rawBytes": 1201, + "rawSHA256": "603F8250B18880A96864A5AFD657C1140DE8F8B065384D576AB7449B06D94EBC" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M17-leftmost-producer.json", + "mode": "100644", + "gitBlob": "9178b679a9b0d9b89820bc763bf120ecd6972b69", + "rawBytes": 297, + "rawSHA256": "82380974EF079759BBE7E75B78DE2FAD505B6CD82FD40BF3407CB2E9F645072F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M18-result-consumer.json", + "mode": "100644", + "gitBlob": "715a27e818a8454507356ba9c78e0dcb83da4925", + "rawBytes": 1565, + "rawSHA256": "F91C22365E11068BE111F7B312299A562F502206EE995759A38AD915322C9CE9" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M18-result-producer.json", + "mode": "100644", + "gitBlob": "e46fb1ac92fa19dcc4be414b5e18a7a3cd924a87", + "rawBytes": 294, + "rawSHA256": "D480BC8FA9EAFF0A5AC0D37C52EF89347D7A22149626299E617CA2283DFF06DF" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M19-halt-consumer.json", + "mode": "100644", + "gitBlob": "b7d8aa589dbd8c6d015ef51ed4b09743ef22ce1c", + "rawBytes": 1589, + "rawSHA256": "0F795C0F1C0074FE2DB742BB107D38120F66E63DD155503B482EF2D9C9E556B2" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M19-halt-producer.json", + "mode": "100644", + "gitBlob": "3e771895ae91d98cbebd3bb308a22fbddde44db0", + "rawBytes": 293, + "rawSHA256": "982E151CFB0712D76CF4EF7A083475F0AC5E341895EBF0838CEBB18815DEF607" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M20-invalidGuard-consumer.json", + "mode": "100644", + "gitBlob": "a654ba5a34a25ac57327437cdd1b8f6d0cef5d91", + "rawBytes": 1801, + "rawSHA256": "4CDA65EF745B83CDB5BAF0CD9611DC0D94D74BE02B3625D72190153282A5E080" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M20-invalidGuard-producer.json", + "mode": "100644", + "gitBlob": "a41fc7386ea1803d4a5e18464eeb45094b94cf5f", + "rawBytes": 300, + "rawSHA256": "CAAE67214F6189A14E432147723496217BDDB6E6C8FA3BC493355EB5B0512F49" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M21-stepBound-consumer.json", + "mode": "100644", + "gitBlob": "42d41221b3b98d31f9ee8b459582cf7031e56b22", + "rawBytes": 1234, + "rawSHA256": "6EFA500C947041200A3CF7AD25657C54E12447FBFD2F5443CE415D19B192688C" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M21-stepBound-producer.json", + "mode": "100644", + "gitBlob": "41414ceadb3bd635a6f1414e54baaa8bee66f7c1", + "rawBytes": 297, + "rawSHA256": "57C034CA68EEB4826B1A2BAFE068D8CF9AA3A7107B5763BFED47066B0FE33829" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M22-categoryPartition-consumer.json", + "mode": "100644", + "gitBlob": "125ffedeef6786fe7a5205c64faab7105fb69547", + "rawBytes": 1950, + "rawSHA256": "A2119990B30012AFA64671101109F8CCE30D6FDEB5A7746ECEA5D1FF3E68B535" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M22-categoryPartition-producer.json", + "mode": "100644", + "gitBlob": "709c692dec1355e8a12471f2a5e2328bfc1c51e2", + "rawBytes": 305, + "rawSHA256": "981040FADBECBA59A70B959DBA4A058E42644FAE3AF11EFCF88ED6FBBCC37451" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M23-finalStateFit-consumer.json", + "mode": "100644", + "gitBlob": "95276423d9b9884463ba8757e41c20fe47ae0f5c", + "rawBytes": 1490, + "rawSHA256": "610693694F50EA05FA91F4AE101FDECAE13E925D9EBAD83F2D5E434B00D3AB11" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M23-finalStateFit-producer.json", + "mode": "100644", + "gitBlob": "13b195af966076d4a4c0ad97fc913b381b0ac7c6", + "rawBytes": 302, + "rawSHA256": "1C87A51CC9A7CAE61A62C747B987859096A785D6672D6CE82A95A67944FBE75E" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M24-transitionSafety-consumer.json", + "mode": "100644", + "gitBlob": "04e5e010781b81de0c7a56b126b49e7426d7c8c2", + "rawBytes": 1957, + "rawSHA256": "7D78E556A32D4446C8B29E444EAB5F66F123F090A30F4ADE1F5F96D77002DD98" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M24-transitionSafety-producer.json", + "mode": "100644", + "gitBlob": "c0241b261d7301268f4c3fee7bda7def50857890", + "rawBytes": 305, + "rawSHA256": "6B79612CBC2D452146DF208F23EBC465DA0081493D4BA6F2EC09EBB2D66C2EEC" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M25-prefixSafety-consumer.json", + "mode": "100644", + "gitBlob": "823206cab90b0305696dbff191120f89f20d855c", + "rawBytes": 1643, + "rawSHA256": "35444C870AA75B7EB8E3BA7E26C1D6B6028B6051E2E20B96F299C530A1A85F63" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M25-prefixSafety-producer.json", + "mode": "100644", + "gitBlob": "9547770cd87e21688eb2c550b119d289677adae3", + "rawBytes": 300, + "rawSHA256": "B95451295B9B85456A668553A59D03B82100078D5D66EFB49B7A67CCF4414656" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M26-readWidth-consumer.json", + "mode": "100644", + "gitBlob": "27f445d4fcb58e61b896f2c431ceb7d89d4550bc", + "rawBytes": 2302, + "rawSHA256": "016FB0EF469E88BAC1018FA6344695ED137BAAE1440C579B6E9CB9A6E6F037DD" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M26-readWidth-producer.json", + "mode": "100644", + "gitBlob": "c70e227168370b7273d81ac2ca412faeca71f13b", + "rawBytes": 298, + "rawSHA256": "55AF6B836CCA2AA24E9E5B8023078FD6E4C1B09355D415DBE1EBC9D08346966B" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M27-positionalReadBacking-consumer.json", + "mode": "100644", + "gitBlob": "f6628d222bb5f4b3eaa16f100aa8d30452d318f0", + "rawBytes": 2732, + "rawSHA256": "6C1FF48B31C44A8CBAF504AE600D0115583858E2A1A0028EBD85439D2897104B" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M27-positionalReadBacking-producer.json", + "mode": "100644", + "gitBlob": "64a5753982131fb587c4f523479589873113295a", + "rawBytes": 308, + "rawSHA256": "080AF5351A2CD5037B743D790D805826D03DEAFF01E8B7270ACEF43980D9E984" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M28-orderedLogicalRefinement-consumer.json", + "mode": "100644", + "gitBlob": "d7c8ce16126e3489080313ff526c226b4727059f", + "rawBytes": 2013, + "rawSHA256": "66E4B7A182D7793914F095E2C9041895E1B26BBBBFA4570B92C943A0898B6A5F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M28-orderedLogicalRefinement-producer.json", + "mode": "100644", + "gitBlob": "e6a003f4b64f816246e1d87ca55e87b51a44ab43", + "rawBytes": 312, + "rawSHA256": "9671362FFEC26BA86AE3F71E2176B07AAEB07D6C8330220980F687E5B0EA1709" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M29-logicalReadOnly-consumer.json", + "mode": "100644", + "gitBlob": "a4120726256164023548761592303f047b0262af", + "rawBytes": 1110, + "rawSHA256": "3A1011B6A80B914704A35357173B08311EA0578323E54DEBC6009E3FDD255AA1" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M29-logicalReadOnly-producer.json", + "mode": "100644", + "gitBlob": "3dc3c065a9c78a79c0ad6ad3fad5ec1797f91427", + "rawBytes": 303, + "rawSHA256": "3BD1A2488A0B1D856BF01D55FE49022C2B0A6B324E127CE7AF774FAE49F335B1" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M30-suppliedMemoryAgreement-consumer.json", + "mode": "100644", + "gitBlob": "52b9aa22ea1e2432aad05b10d0ecafff3e344d99", + "rawBytes": 1942, + "rawSHA256": "1C2BBAB15A8244915CA2C0DC82F3CF11A9392004792950B4444BF39CB87CE7A2" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M30-suppliedMemoryAgreement-producer.json", + "mode": "100644", + "gitBlob": "51608ee269331c156d358de25801e3624def894e", + "rawBytes": 311, + "rawSHA256": "2684AA2C25E2FC9DA94A4A237440369C66C02EC749EC46A85B2F52D96C0D6A24" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M31-specResult-consumer.json", + "mode": "100644", + "gitBlob": "51e67c3e1ba32d0351cce3a2d8e5ff9cbb672265", + "rawBytes": 1391, + "rawSHA256": "F69DB00C6D3314EF11A66FC7A02DF07C47C245A25163CEA3A33A421CADC94317" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M31-specResult-producer.json", + "mode": "100644", + "gitBlob": "c3bfb7ffa03fe20b9c72507876a87c47353475ab", + "rawBytes": 298, + "rawSHA256": "6296098DE870D6751744BBD682A9F2A8DEB0C681566F5001955104B50A1B0B5E" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M32-noFailedLoads-consumer.json", + "mode": "100644", + "gitBlob": "3c9e870173dd38dd34851e01c78b16601128e819", + "rawBytes": 1498, + "rawSHA256": "26EE8963319C82618845E90CD5D0DF747AF1A8E8CD735A4CB56E1787DEC2862F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M32-noFailedLoads-producer.json", + "mode": "100644", + "gitBlob": "e2ec911c0f913ba52b846c6539336024c2a0c771", + "rawBytes": 300, + "rawSHA256": "B1B9E0E5825029A2C5B359C8F9B22D32A4A1578816F63B5596A7D6FD4E52CFAB" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M33-invalidGuardSteps-consumer.json", + "mode": "100644", + "gitBlob": "8cc3a292cb6d36d823f2b2f81ad8c976ce134dd3", + "rawBytes": 1300, + "rawSHA256": "DFD47A5BE28BB4BD05589E3CB1DDA6C61F255B77CEAB2623CB45D710966ADF44" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M33-invalidGuardSteps-producer.json", + "mode": "100644", + "gitBlob": "3115df21a7faca671e2f7cd962e7c898b33a81ac", + "rawBytes": 305, + "rawSHA256": "D4467AA385CDB38C4772EA0BB5DA34BD1E65EAC3879F074FB1B06249730FD109" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O01-wordRoundTrip-consumer.json", + "mode": "100644", + "gitBlob": "e16045deb02e18c3ed46d4f16b79a07fbaa14f2b", + "rawBytes": 1296, + "rawSHA256": "25436D389FB8ABFFB4AA8EA39996882A1B812E9873059B8569F0AD2E77B91FAF" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O01-wordRoundTrip-producer.json", + "mode": "100644", + "gitBlob": "9365c1b52f7a42f53b024b3d38c04d0fa37397c5", + "rawBytes": 302, + "rawSHA256": "D6283CFBD841A7939C4ACBA52C828CBCEF540D4144DB87D58BD332B05362B133" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O02-wordSerializationInjective-consumer.json", + "mode": "100644", + "gitBlob": "4b7e74523bcca1ffc0ebadd7aac4fc1b5b7549dd", + "rawBytes": 1539, + "rawSHA256": "D4204EBE59276DB3FDA625575C3BA4393468C7A5409C9E988340994A780EEA7B" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O02-wordSerializationInjective-producer.json", + "mode": "100644", + "gitBlob": "b55bd4e4a1cf5e91efcb69dd167339ca6b2dad89", + "rawBytes": 315, + "rawSHA256": "AAB4C9363098F58D0CCED354122432B317D6154C77D89817BEF8D0776080EC94" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O03-serializedLength-consumer.json", + "mode": "100644", + "gitBlob": "b888736b968fc7510fa3b7de889094488e8b74cf", + "rawBytes": 2075, + "rawSHA256": "EFE0D627007D44F095AADB0AD8784235D99946D5A08FA943440DAC9EEB7CA6E3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O03-serializedLength-producer.json", + "mode": "100644", + "gitBlob": "86ef2d9cb4618a008bdcb659ef77b72e5b52c7e3", + "rawBytes": 305, + "rawSHA256": "76E0286104BD383586A629E70652485DA75A295FAEA743F886906B5E7F17430F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O04-memoryRecovery-consumer.json", + "mode": "100644", + "gitBlob": "2d3271b9911eb842c0127eef653f16e589b32a7e", + "rawBytes": 1921, + "rawSHA256": "E396D838D8FC9BE31E8C840AFB0C60D6FBE5913AF8C66FFE4A2A747A08F556BE" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O04-memoryRecovery-producer.json", + "mode": "100644", + "gitBlob": "e4378daeeb11603280e18971ca8f06c15838898e", + "rawBytes": 303, + "rawSHA256": "9651BA49EE2714497B8D5E549A449D26E0EDA7569AEB0610F1B3213FCF210A3F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O05-decoderExact-consumer.json", + "mode": "100644", + "gitBlob": "b5950d003b664f0abf13d39fe0660c1ab31e5ea7", + "rawBytes": 2531, + "rawSHA256": "C3309947ADFD7C38903B5C0D95375C19BDEF58981125C59265C2764509000C29" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O05-decoderExact-producer.json", + "mode": "100644", + "gitBlob": "5a0f3095248c56d5dacc34cb04bb8eac75d6e80c", + "rawBytes": 300, + "rawSHA256": "DA2573AAF016390BCFF800D081A8BF51DF4A56E375E5A644368FC96FA7C07498" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O06-decoderLeftmost-consumer.json", + "mode": "100644", + "gitBlob": "bf1200287b64483870daeeede375e87d99058993", + "rawBytes": 1212, + "rawSHA256": "0149BE9EB0BA4697A51BE013641188BF9CE982787034FAD8CCF9A321443A918E" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O06-decoderLeftmost-producer.json", + "mode": "100644", + "gitBlob": "45ddb98b882a82225494d9b6143bc9da7393524b", + "rawBytes": 303, + "rawSHA256": "B4EAF72D6E4C0F52253C5183B444B4467BA0A5C056EBC8B5E1308AC2F7399BC0" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O07-sameShapeMemory-consumer.json", + "mode": "100644", + "gitBlob": "2934cd287c527ee0374ed65e921ce13bffd12849", + "rawBytes": 1032, + "rawSHA256": "53FCA2AE56727669E398D3DDBED813DDCFDEEC90A1E923D1ACE40EB62650C6D6" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O07-sameShapeMemory-producer.json", + "mode": "100644", + "gitBlob": "f7a9754ab7b4bbe90b28d8aaed275b50d465c729", + "rawBytes": 303, + "rawSHA256": "57FD1836D25FF7DE7873C77A4AE79C565C95D5A6678501915B42A9727A9A4F4C" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O08-shapeInjectivity-consumer.json", + "mode": "100644", + "gitBlob": "16d5092d45d2519dcf8e26603dac008d9124c09b", + "rawBytes": 1361, + "rawSHA256": "DF53E542B880729EC6AEBDF07A3BD8CFEC7EC4C71E477B936979A8076E6535EA" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O08-shapeInjectivity-producer.json", + "mode": "100644", + "gitBlob": "5265fee757b9431b226db9a3baf163707a740d56", + "rawBytes": 304, + "rawSHA256": "F68612AC0380FA702AA6C2EE27456EFB7D0AC02C532BED36136E88D43137CD23" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O09-uniformBudgetCount-consumer.json", + "mode": "100644", + "gitBlob": "0e4abfcebbc003b854237369faced71116a99927", + "rawBytes": 1047, + "rawSHA256": "DA7AFB39C9AF4945126CBBD139F5DF244B2AC1F9C3A2B4F5801A5A3A3DB35E44" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O09-uniformBudgetCount-producer.json", + "mode": "100644", + "gitBlob": "913815a8ec799082c081155c4ef2aab99e74a3b6", + "rawBytes": 306, + "rawSHA256": "117B32A6CAAB0E48F647122EEC6CD8BB6D92549AFE763EDBDBCD68FD173E7575" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O10-uniformBudgetLower-consumer.json", + "mode": "100644", + "gitBlob": "5456d8004a1ed8365cfed40b5fd1ef30530a80b1", + "rawBytes": 2299, + "rawSHA256": "636C6393AEEA1A6B457DCB93F2CD35310CC351996A71D9E575C5E467E9731BC3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O10-uniformBudgetLower-producer.json", + "mode": "100644", + "gitBlob": "7414f705eed3d593e58a5a32722d16c3639d15d3", + "rawBytes": 306, + "rawSHA256": "33AF7F49FBCC886F4973D09C6E2846BF484335C8E4175F472CA498B74DE6325E" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O11-canonicalCount-consumer.json", + "mode": "100644", + "gitBlob": "7e4843e8d9e4fa0f99e0f3707cc1acd8729bff60", + "rawBytes": 1011, + "rawSHA256": "0BF6F0ECE3E66F670E380334BAAC904137B9B7DCDB19A52126F15D0F689AD18F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O11-canonicalCount-producer.json", + "mode": "100644", + "gitBlob": "b3d6b22413dab64521c382ef340b57cf010e3a74", + "rawBytes": 302, + "rawSHA256": "21713190071EA86D0EB9F75D0A85AEAF90079225D8DBEA863EE22F43985C9824" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O12-canonicalLower-consumer.json", + "mode": "100644", + "gitBlob": "dac62a2263fec74870fd1e4b01703a7102c60e95", + "rawBytes": 1061, + "rawSHA256": "908E54E31102B54F2ED731CB7439B88F2899BE7FE510F971812220745C474529" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O12-canonicalLower-producer.json", + "mode": "100644", + "gitBlob": "5bb0612a8ed31d08e6fdbad70860216bafc05b86", + "rawBytes": 302, + "rawSHA256": "31E97A7FC737852FF89F336CA237CE7DEE72B84CF8BA8709938DD7EC2BCBE8BA" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O13-upperCapacity-consumer.json", + "mode": "100644", + "gitBlob": "e169b6636c5419d6592c4188202a410a480e617a", + "rawBytes": 2128, + "rawSHA256": "29D8799807CA8E2C82D58599BC34FC697B4D6264D8AB4A82D43307572E54F83A" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O13-upperCapacity-producer.json", + "mode": "100644", + "gitBlob": "b3303e4d14c6002ea9d1b13a2e1fef6977ebfb10", + "rawBytes": 301, + "rawSHA256": "E8560D7501B44A5EFAE7D734AA706BD57FB2AF84E54E2191BB308B0446DD5760" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O14-allocationResidualLittleO-consumer.json", + "mode": "100644", + "gitBlob": "879fbde25fe62cf7fccaf0d7ba75dc4cc9476c0a", + "rawBytes": 959, + "rawSHA256": "4ED269205BE7D8AD960B0577C33D4462147EA16DE19345BAF25D25585396480D" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O14-allocationResidualLittleO-producer.json", + "mode": "100644", + "gitBlob": "9c2a7af08e1e437093bd363dbbed2af9201d8b53", + "rawBytes": 313, + "rawSHA256": "F636C9083DEC9423B7069074B8E7B2DAED40C4038C0E5DD7F58D9A16708C283A" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O15-runIdentity-consumer.json", + "mode": "100644", + "gitBlob": "a4ae87b8ac57e8ef08ed05c4b41e25eb69deee50", + "rawBytes": 1324, + "rawSHA256": "D8762ED56920649DD49EF8EA0B1912B853392F0174C61CC7A0A088EA2A0F0291" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O15-runIdentity-producer.json", + "mode": "100644", + "gitBlob": "cf2b040241c5a03cbd0469286e9b60d7bacef3dd", + "rawBytes": 298, + "rawSHA256": "1C1153403D51501E95AFE2BCC85AE00CBD3BC5F77D6C621305616616A680315B" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O16-machine-consumer.json", + "mode": "100644", + "gitBlob": "e428d1c078b91272f455427cb7288aedad8991ed", + "rawBytes": 19896, + "rawSHA256": "8DA50654B60E400FBFD53DC36DC0C2C54C3957094060D65D80B553809449429C" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O16-machine-producer.json", + "mode": "100644", + "gitBlob": "12997512a98507be7356179306504bc3bae9c781", + "rawBytes": 295, + "rawSHA256": "23118787B5DB8807E2DCE020CABC3AAA90237618FA4DA0E03A057888F0FDD1E3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/P01-PUBLIC-PROPOSITION-consumer.json", + "mode": "100644", + "gitBlob": "494d00ec08d7fa14256cbadbf34f9ae19fb0338f", + "rawBytes": 30173, + "rawSHA256": "C0DA99ECD914A8295528E3E63566EBB448D70651FD56E74B77ADB2C0E592F150" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/P01-PUBLIC-PROPOSITION-producer.json", + "mode": "100644", + "gitBlob": "06f0e3eb9674cf9c1354cad05e62dcfac0e257e3", + "rawBytes": 306, + "rawSHA256": "FDE7593ADA182FC3A19A22FBF5445AA0A1D4A314244DCDE79B6FC32405DBD34A" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/S01-SIBLING-MEMORY-consumer.json", + "mode": "100644", + "gitBlob": "1a474022340165ddb13a351dfa933b6e76ef221e", + "rawBytes": 2177, + "rawSHA256": "D38E762FA6D8AEEFC2565C43EB1E8A479AA4556FEE7FDC640475C422DB423C80" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/S01-SIBLING-MEMORY-producer.json", + "mode": "100644", + "gitBlob": "27726bcc57cccf604907ef8e3b740d92405fccc0", + "rawBytes": 302, + "rawSHA256": "F1557AD5988031F6598CB9B2EFBCC4A4DBFDAFBB5519C8246E020632A836AB03" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/S02-SIBLING-RUN-consumer.json", + "mode": "100644", + "gitBlob": "6a4fdc8b2ac79a4d6cc0ceec109a0019db84ba43", + "rawBytes": 1792, + "rawSHA256": "A746652C8E0A4F2BF0E02F9365945B13E70311DD5F7467DD961C28337F7AE856" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/S02-SIBLING-RUN-producer.json", + "mode": "100644", + "gitBlob": "03566145ef28a07025ec16b44ead4b0fb20bbf73", + "rawBytes": 299, + "rawSHA256": "02F78268B1133836FE2C87333A79A12E46A8308880D6648EF9D086074A4FE336" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/S03-SIBLING-BUDGET-consumer.json", + "mode": "100644", + "gitBlob": "d8b59b4420c91f991cbfd2f94f770b33c468953c", + "rawBytes": 889, + "rawSHA256": "85DDAFF9947135F7DEB02C69B99698A78F9ED2003D4FA17863F0408C42D4FE00" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/S03-SIBLING-BUDGET-producer.json", + "mode": "100644", + "gitBlob": "315cb225ccbd4f023f1575152879146aa2c34f76", + "rawBytes": 302, + "rawSHA256": "0C640F319F08F91E74398D6F77048B4A04D987CB8FA9457C6B2E2FFF67ABF19F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/baseline-consumer.json", + "mode": "100644", + "gitBlob": "377e01237906cacafd980185d7ee47b9bd4aa4e8", + "rawBytes": 293, + "rawSHA256": "4655295D1086E0AD8DC862CDC1EDF7512B577C1CC3E1C8668F7698BA5B93ED86" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/baseline-generic-consumer.json", + "mode": "100644", + "gitBlob": "7cc6d049b667ad6d4662249848ff6b37063499ed", + "rawBytes": 299, + "rawSHA256": "A3BC0FB07665C1D64444F12F942029C63D1F9F99C71E37C8B37C6A9BECD19C88" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/baseline-generic-producer.json", + "mode": "100644", + "gitBlob": "0d454b9429f04b1eb41fcd4f6a10126b1b476903", + "rawBytes": 300, + "rawSHA256": "E93155EBA9DC93E41F07759DD9D2EFD883FD9E630BC009336FA28201CD1D3B48" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/baseline-inventory.json", + "mode": "100644", + "gitBlob": "4218a40b84214145749c9e907352dd1eb2f2a912", + "rawBytes": 698, + "rawSHA256": "D67E6FCE332574D05C0EBC425117D842B90BCEB17B102E7C289B257D081235FE" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/baseline-packed-producer.json", + "mode": "100644", + "gitBlob": "bdd5e229b5b11a0135b302458b7b63b08553d5b0", + "rawBytes": 299, + "rawSHA256": "414F7F7D67E510BA2E48F069BCD80038AC58D3622988A2D397C6A92A01D817C0" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/candidate.txt", + "mode": "100644", + "gitBlob": "98de6cff20ed9739418d9fdbb549d8d137912f36", + "rawBytes": 40, + "rawSHA256": "DA3E11358B1CC9538B488DD85B61FDD57C44FB43641201CC68443BB56E377777" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/manifest.json", + "mode": "100644", + "gitBlob": "6f1731fb81a8be5d6169a107060dea1fb99558db", + "rawBytes": 41823, + "rawSHA256": "F2AE19631427F321E1E7878F17007A75DA916C4A555AA342AC00A1C5142A7D09" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/runtime-full.json", + "mode": "100644", + "gitBlob": "fa7892e018d86d7d457c2786e99008356a091c37", + "rawBytes": 1135, + "rawSHA256": "559F8A0C3ACC4CAA060A94A25DBF0D62B43D5ED3BE95ADBA327773152FF5A306" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/runtime-known-selector.json", + "mode": "100644", + "gitBlob": "5a6ef1280e13a0847e642016969d058e1a58d078", + "rawBytes": 576, + "rawSHA256": "E097E7ABF6891F6D04B581CABAA24537F3EA451DDB0DF74D56F94A8A643F3083" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/runtime-selector-empty.json", + "mode": "100644", + "gitBlob": "a5087e468bc4d73c17dbb73eb2535cce6c2b5620", + "rawBytes": 414, + "rawSHA256": "99B58979B5805894DCFC5B5A4614AF30950B986DB59018D598B467854F6434EF" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/runtime-selector-malformed.json", + "mode": "100644", + "gitBlob": "a6964d25774cfc79227833d24adabb122c236f9e", + "rawBytes": 442, + "rawSHA256": "15C77E77B560B2C3CFFC96A4C79FC70E3CE14A36B91DC4CFD0C00E4D31451E4D" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/runtime-selector-unknown.json", + "mode": "100644", + "gitBlob": "c94e6eb6f56a59fbb2087274a10d70438437bd73", + "rawBytes": 446, + "rawSHA256": "C15CF894B9B9BD4F24F0915BA81F2F5801937252EF6F0C291BF7D38A8FD9DABB" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/runtime-selector-whitespace.json", + "mode": "100644", + "gitBlob": "ff95bfeaab19ae74d737100b1095c5af2a4d48d1", + "rawBytes": 429, + "rawSHA256": "F11C1C023CBFB717B43353F3B2F3C30D29D821ECA20FBA5CE35B261DF0418B53" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/runtime-startup.json", + "mode": "100644", + "gitBlob": "e20df29d7483908806ff4255eddaa87a6a16335a", + "rawBytes": 705, + "rawSHA256": "ECB45140B2EE7E49C007E68FC36C63D80524417EA5FD54590A0C2FE2E3612FF6" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/terminal-receipt.json", + "mode": "100644", + "gitBlob": "6e205d103a39324845f4498f3a82030203672857", + "rawBytes": 848, + "rawSHA256": "19A0B34B0EC4E7AC5682B37F81D221EF3525573A6659ADBDCF7AC2CCDFA50D3F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/report-check-discovery.json", + "mode": "100644", + "gitBlob": "0deb8f140e24233cad9d31c8349418f31992206c", + "rawBytes": 907, + "rawSHA256": "F04AA797EB9B7E5CBE2F599291D5141F372981179615F27F942BA3F636924D11" + }, + { + "path": "docs/internal/extensions/lb1/evidence/report-checks.json", + "mode": "100644", + "gitBlob": "d137c85f81c3c22f8461d2d8a8dec507e6dbce45", + "rawBytes": 3703, + "rawSHA256": "26B8BE7E1F206C890F3F2212D24A2B60031FEAD2309EC807BE938442EC41C7D4" + }, + { + "path": "docs/internal/extensions/lb1/evidence/selector-controls-v2.json", + "mode": "100644", + "gitBlob": "bd0a3b0bbfdaf3e327cac7834e6aab0f5461a165", + "rawBytes": 8594, + "rawSHA256": "3A0636A0995AD0B132A9488309595B4ED23284896D477CC89E500E150C93C82F" + }, + { + "path": "docs/internal/extensions/lb1/evidence/selector-controls-v3.json", + "mode": "100644", + "gitBlob": "f83e78c3fa9770e9d73b383a0ced5cc87f340250", + "rawBytes": 8643, + "rawSHA256": "26C73B74BAF4EC5B56A9F8071EAA906594E1717C5D3AA972E2DA25D0BD814234" + }, + { + "path": "docs/internal/extensions/lb1/evidence/selector-extra-5033/REPLAY-CLI-ENV-CONFLICT.json", + "mode": "100644", + "gitBlob": "173e7e729b124707d64b710a8fc99e4592fad8d8", + "rawBytes": 2944, + "rawSHA256": "CB8D97B487D4BF17E375B1678603B3EB9A8DB2D50510231F63802E939B5B7B09" + }, + { + "path": "docs/internal/extensions/lb1/evidence/selector-extra-5033/RUNTIME-CLI-ENV-CONFLICT.json", + "mode": "100644", + "gitBlob": "7ec2bb4c9c6b3d0ad21c7a7134f8e736124f4b2a", + "rawBytes": 2484, + "rawSHA256": "492C4796A504E51A65EF1F97A0834742A0D354DC89B2EB4AE31004815520D345" + }, + { + "path": "docs/internal/extensions/lb1/evidence/selector-extra-5033/RUNTIME-MALFORMED-ID.json", + "mode": "100644", + "gitBlob": "1c3fd9f521e05bd9d03e6cca6a55f9bd2e0fe564", + "rawBytes": 2415, + "rawSHA256": "D788DD531D1AB304A0A7D999726513E21207E23D744993D4364B30306E7C665D" + }, + { + "path": "docs/internal/extensions/lb1/evidence/selector-extra-5033/summary.json", + "mode": "100644", + "gitBlob": "6cfdf835abd6d733bf82ed4f4fdf7d4c0748109f", + "rawBytes": 9276, + "rawSHA256": "61B0AE5B51BEA3FDDF89C998CE4F0E32D88315FA002A5A1518B87D4840E4A5A8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/startup-development.json", + "mode": "100644", + "gitBlob": "b542a4c4ad6fa1c9c8428cb782f523bb7fdd4a39", + "rawBytes": 2010, + "rawSHA256": "B430C3F819E0BC17C72D6D9186ECFF393E4D603A9FBAD4BB905C81FEE2CE062B" + }, + { + "path": "docs/internal/extensions/lb1/evidence/startup-preflight.txt", + "mode": "100644", + "gitBlob": "eb5bbe671fd725be5acbd57b43efb76d2aa3f610", + "rawBytes": 819, + "rawSHA256": "5F6D25B0E4B8CCC9D133EA718BCCD1044CC22A1DF380E8FD56C57FDFB840B0CA" + }, + { + "path": "docs/internal/extensions/lb1/evidence/trust-5033/axiom-inventory.json", + "mode": "100644", + "gitBlob": "fde873811886f8d46353b11ed14f5400f58ff2ba", + "rawBytes": 7453, + "rawSHA256": "C8F1257B67B481F8CCADEDD9073C96F550EF21AB683909E1F361477DDDC0DE70" + }, + { + "path": "docs/internal/extensions/lb1/evidence/trust-5033/summary.json", + "mode": "100644", + "gitBlob": "b73c763570f7286f7a02ffd152d383a906b21361", + "rawBytes": 5963, + "rawSHA256": "B3231DA95191829471F5D1110F2F4545E3B4D29EB56F05B145A5A2BEABDF5641" + }, + { + "path": "docs/internal/extensions/lb1/evidence/version-20260912T084142579.json", + "mode": "100644", + "gitBlob": "3ef45fe92b0ac9ef0eb7bf4cac5d389ae8df1434", + "rawBytes": 516, + "rawSHA256": "D5446F92B7C94981E647FED1649D3998EF199D61E0E6ED9C42AA8CB3CC2AE8AB" + }, + { + "path": "docs/internal/extensions/lb1/evidence/version-20260912T084243070.json", + "mode": "100644", + "gitBlob": "e02d64674b20315fb72ee5d23224eba5f9c99a44", + "rawBytes": 516, + "rawSHA256": "B17F4335522E25A27EA0698C699FC68B8B805B7DF8A76A6FD973EBAD83CFA0F3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/version-20260912T084355841.json", + "mode": "100644", + "gitBlob": "f236f7e8a6ac3f3d867710718bd1ae8d0703458f", + "rawBytes": 516, + "rawSHA256": "BFD6BE406D367887D822BF5DAFEE4160CE799A37ED9DAA36670EFF966F565574" + }, + { + "path": "docs/internal/extensions/lb1/evidence/version-20260912T100805553.json", + "mode": "100644", + "gitBlob": "43f2bfc477dc043484349663d3497205f8e631df", + "rawBytes": 516, + "rawSHA256": "0810B4E5EA75A3BF2299D0B16FD847D885319B647049CE155023F7797DAF558A" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/.gitattributes", + "mode": "100644", + "gitBlob": "32c5ed886b694aef66c38c0624568b9a0eb1b6cf", + "rawBytes": 94, + "rawSHA256": "452DE0B852AB4578105E47480AB75D7CFC9195F3619DDF189BA73AE2884DE295" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "9b07c65cd0250e29faa95ddc7d2fd7781b45e867", + "rawBytes": 18447, + "rawSHA256": "AEB07F3DF8638ED47705800B2F00DAB42695F35CE6678B95050DFDFB1F0FCA03" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/ACCEPTANCE_ROWS.txt", + "mode": "100644", + "gitBlob": "fe30a2239762f3a16070a093c759d471eee1ec3e", + "rawBytes": 8534, + "rawSHA256": "F45113AE6BF3F769105A748B3D0A61EA99532A05A715410F11EF29E7E518EC29" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/BASELINE.json", + "mode": "100644", + "gitBlob": "9cbf9adaa47ce7b79b4e534befc6c64d2de9d8ba", + "rawBytes": 5699, + "rawSHA256": "DA869E0C2AC50C3CC042C6C44ECCEF4E3DE9C59BF205AD8DBA888B9410C67238" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/BOUNDARY.md", + "mode": "100644", + "gitBlob": "f51cf6c0ea28f8476e953716e9755b3c2015133c", + "rawBytes": 10306, + "rawSHA256": "DA0F91F7DF36708936EF31E6C17F382FCB7A928E74D57A4B68AAE9B96B189F87" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/CERTIFICATION.json", + "mode": "100644", + "gitBlob": "00a9d01cbc85027ed88831617ccb6cb27025dae5", + "rawBytes": 9683, + "rawSHA256": "757F8EC4491F65A6D931B1D7E2F03C53F360FA6BE5A34F228BB43A6519E78B72" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/REGISTRY.json", + "mode": "100644", + "gitBlob": "79c348f3218c96576b58d9b37f68ba726fe92c30", + "rawBytes": 5899, + "rawSHA256": "6CD97F40E7C39D2212A8C8705D264D4832DCF2542815B72CD927906A01DC8B20" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/REPORT.md", + "mode": "100644", + "gitBlob": "1d81ea295c38e447102190c05afa08aad4f32a82", + "rawBytes": 25211, + "rawSHA256": "658652FEB62B1A5DCEEC2BCC030C3DF3A24B19B8D34933A8FA4561142C8CFD98" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/REQUIREMENTS.json", + "mode": "100644", + "gitBlob": "934885ad0379893486695c78dfcfe6ebf1773677", + "rawBytes": 4361, + "rawSHA256": "0983881A85F9A3B42ECD54C0BFB18170C3BE3E5A65602CDE66547042CA5421C9" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/RESULTS.json", + "mode": "100644", + "gitBlob": "bca831965f01334670c774b2a08b4a5191bef3f6", + "rawBytes": 63804, + "rawSHA256": "6440A963BE7A0E65222F86AFE3CFB89E4BEE1B6BDCD0226DC0D5CDA88D296FDD" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/RUNTIME_SOURCE.json", + "mode": "100644", + "gitBlob": "93989d23e91a6493da487e9f0ad29be9baefcc60", + "rawBytes": 1398, + "rawSHA256": "F32AA70D04AA8FE2A14873DA0E6B22501781187544B5335918A7925221C7E9A6" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/START.json", + "mode": "100644", + "gitBlob": "dd481854de39bee665b40c93320c33f1af90e5a4", + "rawBytes": 1174, + "rawSHA256": "1718F02C23F770AA00E288E27C355CA2D78D2CEC6AEBD4CC017C2300D6DA0F90" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/VERIFY_CONTRACT.ps1", + "mode": "100644", + "gitBlob": "67f044f96d61fad65566542e580d1196f558ed24", + "rawBytes": 2236, + "rawSHA256": "00D16569E407149CFAEA1A8C34CB81F72CFF6FBA02FF45841F67C91EEB2AB957" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "80a023437613d52c6b2bd30da914c49a0764b1e9", + "rawBytes": 13436, + "rawSHA256": "236480A9AB5A68AEF83824D3AA31DDEE8C170203F53C5F6C61CB8ED0AEF76925" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/ACCEPTANCE_ROWS.txt", + "mode": "100644", + "gitBlob": "64ba642be3e814192975653c6ab11de3bc5ad375", + "rawBytes": 10983, + "rawSHA256": "74982691E40EB56A10365F66E74877F6518C0A13E959F559E267047BDAC7130E" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/REPORT.md", + "mode": "100644", + "gitBlob": "24aa7738d5a920d2e0c2d9b8e23a1ce6044cdddd", + "rawBytes": 25981, + "rawSHA256": "2C260FA9AD51034B1684ED011FDF1CC7CE5E0B485CF3950061E7FD5CFAAC34FE" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/RESULTS.json", + "mode": "100644", + "gitBlob": "ff80bb068f63d4c7007bf503bfae5e8548beafdf", + "rawBytes": 98423, + "rawSHA256": "9313E4C20C4326B62F5CF4174BD5D57B54E300480AE48EB97D4AA74F8EBFF8A1" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/SOURCE_REVIEW.md", + "mode": "100644", + "gitBlob": "2ee84e9c7095f899e4ea47ae81dfb363db827320", + "rawBytes": 5495, + "rawSHA256": "2B865AB9AACB43A5BBA2FB7C5C7AF9D5A98FF005CCFE01937689DF6D49C2377E" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/START.json", + "mode": "100644", + "gitBlob": "4201934432978b7e31fe19811e8be4889e260586", + "rawBytes": 1004, + "rawSHA256": "9D6A31B3847994C4058625F5AEEE2014F222266BF91359610BD8B64E5A2594B0" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/dependency_controls.ps1", + "mode": "100644", + "gitBlob": "ba23024d2167bde1da22c7c018436be7030404b6", + "rawBytes": 5705, + "rawSHA256": "6BC73AD9F00C72A4E2A2D3EB4C38E8EFB33A2983A530AD70E5E9C4E6A10C38ED" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/final_checks.ps1", + "mode": "100644", + "gitBlob": "1454af7b0e52f13439a11302859a17ef4a2b8173", + "rawBytes": 2483, + "rawSHA256": "EEE489C244B35FAF8E1E480F439EB637937A4CCD33B64F889599C0B87A70DCBD" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/freeze_contract.py", + "mode": "100644", + "gitBlob": "94751a0515e077170217cffcebca381dcf0fc277", + "rawBytes": 5677, + "rawSHA256": "83FF711B0D2774690BBA99A6EC92C9E8D9C1AB5D3479716EBA78D3BEB62CFDB7" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/integrity_controls.ps1", + "mode": "100644", + "gitBlob": "2b3907ec07041d16f9f7130b337d670615121c6c", + "rawBytes": 16062, + "rawSHA256": "7D3C787D00E41C5639102FD9F4EDAD42CEAB621C7637DF36D8834A505192BF77" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/run_owned.ps1", + "mode": "100644", + "gitBlob": "248d2fdd07bf7282c76dd236ccf6989c07001ecb", + "rawBytes": 4728, + "rawSHA256": "7269C6500F6D04904A14F5C32E2AB000F702577BACFCC039DF5E4A24EAE5F3EA" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/verify_contract.py", + "mode": "100644", + "gitBlob": "d11ac3b94cb61384aff87608c79fdd961d258d37", + "rawBytes": 8376, + "rawSHA256": "6BF80F6082076BC6048C54B744C73E928657B5BEAF9A8CEDCE82F6EFF6771EF9" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "da57544cd45c79ab3f3ddd582a747ae205931f4b", + "rawBytes": 17755, + "rawSHA256": "35FC6D35710BED02B021A46A32C0682E9DEF2FB442B19263DCEC07E191CB677C" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/ACCEPTANCE_ROWS.txt", + "mode": "100644", + "gitBlob": "9bb864eb558401ced42b6d540546fbd597cf3041", + "rawBytes": 13600, + "rawSHA256": "7DBC035076EA9CACE20AC735B1AA85B099AEF3D5B5B1AFE514ABA2C0C63E237E" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/HARNESS_STREAM_REGISTRY.json", + "mode": "100644", + "gitBlob": "2838bb471f344dee355363663dfb053c9a257e18", + "rawBytes": 3395, + "rawSHA256": "227BE213E795A6FF037ABB1F67BEF328992D6284C56E0E427243EDE63C41428B" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/REPORT.md", + "mode": "100644", + "gitBlob": "cab207d14dae45ce91cee4d7fc0bcdebc85503ff", + "rawBytes": 27374, + "rawSHA256": "527CDE985093EE77F6EC02A5750D0A7943740C9D3D47D2A0359C4C739285F91D" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/RESULTS.json", + "mode": "100644", + "gitBlob": "07452a5a52c6f153a16519bed81e827f3bc1b533", + "rawBytes": 45177, + "rawSHA256": "6F73111913D67788775FDDC6D632D8DE34A38C3FDB56E88A6FA94D8ACF9D7B21" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/SOURCE_REVIEW.md", + "mode": "100644", + "gitBlob": "ed9226dc1fd88c4c9d5caf3efae5422753bb57d2", + "rawBytes": 14323, + "rawSHA256": "B57511DDC74FEE0CF37C9AB81496820D31F24BA537C42BEC9BD6834F26C5097B" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/START.json", + "mode": "100644", + "gitBlob": "6137e4772fbebdc88d73f7c6858d5f7f79bc1f46", + "rawBytes": 1008, + "rawSHA256": "A8190551F7523F5F9729B2331D64F8CA174EC99DEF7FD950814C3152C7CA75DC" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/WRAPPER_STREAM_REGISTRY.json", + "mode": "100644", + "gitBlob": "abbf7db1fec288b68505d13306bf7368f2b67b4e", + "rawBytes": 36673, + "rawSHA256": "39D047A36C138E34787BAB33731EF77BB29558233D218A1D76BE5ECC8E2B6DDC" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/certify_profiles.ps1", + "mode": "100644", + "gitBlob": "a3479c56bf51768109ffa342f36b5665a269323b", + "rawBytes": 2266, + "rawSHA256": "154BFE41DA5D9644EB01B2464E1FF1D2B98418694353922A97E633919008C06E" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/claim_expectations.ps1", + "mode": "100644", + "gitBlob": "f7e6ea23ffbac4f7ac0ce1830603a95125efca74", + "rawBytes": 13914, + "rawSHA256": "DDAF90D70F60C4E339AC4381A279FD0C1E430B2C7FC19C78186A74209371FCE9" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/freeze_contract.py", + "mode": "100644", + "gitBlob": "ff9aac13ad220cf2141bf94d9458634af678fcae", + "rawBytes": 5338, + "rawSHA256": "A29909E89320FA2E0F4627E84E0574F30CA0C4DBB882909548AEC6043DD39A92" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/harness_stream_controls.ps1", + "mode": "100644", + "gitBlob": "38cd26fdb0616b3f165ef5c556829461be2fb22f", + "rawBytes": 12082, + "rawSHA256": "FBF570C3F191AD6043CBDDB71223020166AFD842112E41C4709457BBF035249F" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/reproduce_old.py", + "mode": "100644", + "gitBlob": "3b5335044bab8702505b9c70fa673904d656636b", + "rawBytes": 3091, + "rawSHA256": "73949FCA39324FD9771F8F22A6F15B4B477D65613DD30EE77D5CC8F9CC74A787" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/verify_contract.py", + "mode": "100644", + "gitBlob": "3bbb81aaabdf71b7fd9103633e3e89281e2998ab", + "rawBytes": 27998, + "rawSHA256": "6F1CFB871656215513FA91F617EA563BC9B2EE4EBFBE04D77A7F2E7C30A69871" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/verify_results.py", + "mode": "100644", + "gitBlob": "586ca7815c343a0e398b8d1219e9bf7ab379ec22", + "rawBytes": 41462, + "rawSHA256": "CE931FD260A5FDA818E06BEEF1C66C6152189B46984FC4510EB445376244CAD2" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/wrapper_stream_controls.ps1", + "mode": "100644", + "gitBlob": "2590b0bb4da3f461a8edcb40b2a19fb6385a4907", + "rawBytes": 30059, + "rawSHA256": "1B8C9B2F95FA3AA9C88D8228D645B9A6C4A9A2B991DB81DE7A3A577EAA5B02C3" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "bb0e1811f3351876e93a5e13a4daa32f6c119ed4", + "rawBytes": 24776, + "rawSHA256": "7E8DE1B68D4F742FF59D6B39679875E6B59FEF9CDC543836BC041E5CE5B92858" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/ACCEPTANCE_ROWS.txt", + "mode": "100644", + "gitBlob": "57979fcf621af11fc2e9f6382b08ea80abee168d", + "rawBytes": 16030, + "rawSHA256": "D567FF2B9F861A6A910CC94A9E7ABB44D2D559893CBBC7293CEFBE798CE01ABF" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/CONTROL_REGISTRY.json", + "mode": "100644", + "gitBlob": "af6ac29ee4401fb3d82d8ac6fe97dfa6347be1bc", + "rawBytes": 14326, + "rawSHA256": "16E26C5B131BBE258B3813BCDB252414E8BED454EF6286EB2ED7F7EF3496261D" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/FREEZE.json", + "mode": "100644", + "gitBlob": "eb128030283818f71516c271f6d6100734557205", + "rawBytes": 851, + "rawSHA256": "8A78737CEC55BEA8E45BED9785E892CFB8691659BCA0CD958F7F12E1E93CA50F" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/REPORT.md", + "mode": "100644", + "gitBlob": "d3ab6bac49ca10dc54b76653c64e8d9c17087434", + "rawBytes": 25656, + "rawSHA256": "AC08AE4DC421C66012E645FD513034CF361B5CF09221C5D8D665F1815B5536CB" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/RESULTS.json", + "mode": "100644", + "gitBlob": "724d20cb7c7af15af36b2d48b2a98584342b4a81", + "rawBytes": 10377, + "rawSHA256": "12A080909522843A1826B9AA0A80D2B3C512996F6B63098B21B4BAC0AF9A9C8C" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/START.json", + "mode": "100644", + "gitBlob": "dec3323fcc0324529cf06aaff562f6337c712205", + "rawBytes": 1530, + "rawSHA256": "65F8E6A80C875A675C1FE893329351557D7BE41A99A7EDF53FD2D5554E1BDE78" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/certify_current.ps1", + "mode": "100644", + "gitBlob": "1d6412375943407c44742677c1fdc604606fb9ca", + "rawBytes": 6195, + "rawSHA256": "25CB6B0C49A82DFD57DE3ED605D7ABC32D2CA4520E4ADE16873DD17ECFBAFA6B" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/freeze_contract.py", + "mode": "100644", + "gitBlob": "d71d10df92f5af163f6050d201016030a616b102", + "rawBytes": 5932, + "rawSHA256": "4288C680F322509F330283347CC9EEE76200EE7FE7C3E83C776230AE3255F0C5" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/literal_selector_controls.ps1", + "mode": "100644", + "gitBlob": "a5272f8159f8374a1e56e6e5b8ec27f7508bcf55", + "rawBytes": 12112, + "rawSHA256": "1E4F1BED4FB59DA2B39A21B9D52B083651F499F6CFA59EC1310C95CF6D396E61" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/make_registry.py", + "mode": "100644", + "gitBlob": "33d142a544efde258f19feb6e41cb0bf672c7dd9", + "rawBytes": 3828, + "rawSHA256": "89DB0D436BD473B3651DD49611CD8F3F2A55888BA5BF322EC6208CF0397708F1" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/retained_registry.json", + "mode": "100644", + "gitBlob": "e92c8369c564f00655400591e455577151b0458e", + "rawBytes": 3340, + "rawSHA256": "521BFA0CD6DEE84383AB41F8B7D6CC0F226EEFABFC96113EF5EBE835A48A20EB" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/revalidate_retained.ps1", + "mode": "100644", + "gitBlob": "6726c86767028a16b156479db94949bf731a0d67", + "rawBytes": 16744, + "rawSHA256": "E5165926E21EC7E337A71902796D94A98B13E4AC99AA281FB2E813A517642B27" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/verify_contract.py", + "mode": "100644", + "gitBlob": "59e676b3221b665be192ccf84b925839991e27f0", + "rawBytes": 29089, + "rawSHA256": "E364EE4B4B4B867D231E9461260E1DD2FE44D2FB99A32B7A2A5D949B078E2D9C" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/verify_results.py", + "mode": "100644", + "gitBlob": "fb2b6138bef802b38eb4de9fdbae441e53c79ad4", + "rawBytes": 35096, + "rawSHA256": "A660CF4344A71FFB3E8E62E936836755598BA37FD483098C42E1733C4A61ADD4" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/ACCEPTANCE_MATRIX.frozen.md", + "mode": "100644", + "gitBlob": "95f3ade90e80e1c19fa2666fc2803ffa9b5bb261", + "rawBytes": 80822, + "rawSHA256": "7FDD184E2703A7DEE3F973C9C59138F74977581A2A315DB1B6D8EE87E312DA58" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "2097bfe2a372e9d451f5fe30477fe8360192506a", + "rawBytes": 88309, + "rawSHA256": "09DA841DAAAB4798C44871EA1FD0753991AAB593A48839E15CF29FCA386AB299" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/AXIOMS.json", + "mode": "100644", + "gitBlob": "3a0a09a2649982bc34e40f95d292e738b5bfc61d", + "rawBytes": 17904, + "rawSHA256": "98CDCE673E968CC354BD5DFE756257478615B9BCA30D023197796DEBB9C1B772" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/BASE_IDENTITY.json", + "mode": "100644", + "gitBlob": "7906711ffe9b407857cab89cfead42424b190418", + "rawBytes": 1178777, + "rawSHA256": "CFEB23F578E9EC014F2302220DE4C08960F2C96892F8BE5C60608FF8C4CB6997" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/CHANGED_FILES.md", + "mode": "100644", + "gitBlob": "c722f8e8a8801df4c46b2f7c4d43714871b12242", + "rawBytes": 6875, + "rawSHA256": "B9339ADCC855F641E092D220250FAE100A2B41EF27C2865779026DA0F8215F9A" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/COMMANDS.md", + "mode": "100644", + "gitBlob": "6269c65f7b8d925434e5c82f956fc6291cea447d", + "rawBytes": 16682, + "rawSHA256": "47F42AB4460B61C52E8A03494642E9D497AD18DD0CC58B75506B38B51A649833" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/COMPILED_ROUTE_EVIDENCE.md", + "mode": "100644", + "gitBlob": "8dc00b88f4a9c95e71210115bc268ae3b3efb5c1", + "rawBytes": 26636, + "rawSHA256": "B22E8BB763907C05B0DFA8FD74DBC3CEAC72EA8721DD97A3E4306BEE7AF50408" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/CONTINUITY.md", + "mode": "100644", + "gitBlob": "b438a37d0d71257c819d51bb8ad6732ddcf2dca5", + "rawBytes": 35547, + "rawSHA256": "8A24AFD773DDCADD44C0CD1D8564CAC1B39BAE7373A64709E8BBB7103A411F92" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/CONTRACT_AMENDMENT_01.json", + "mode": "100644", + "gitBlob": "6214ba37e119dc2056f9a7120ba18ae336f68aac", + "rawBytes": 1411, + "rawSHA256": "972BE976559F94FA513E106CFE4EC69FB452C4BD78F7F3440643B36EE1AA93FB" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/CONTRACT_REQUIREMENTS.json", + "mode": "100644", + "gitBlob": "fe5750d192de2b7de6616984aed790da926e8323", + "rawBytes": 375149, + "rawSHA256": "C770F70551674007EB7B6130F44C3CFB0BCD98906219B69B7112C61AFAF8F728" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/EXPORT_DIAGNOSTICS.json", + "mode": "100644", + "gitBlob": "07cc3e4b23c2a53924a02f3a477e50a4d9ccee7f", + "rawBytes": 56782, + "rawSHA256": "9EDAA765FE4AB69B0742F519AB818A2AF0CB2962F631CAE7D8105C16D5725835" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/EXPORT_MUTATIONS.json", + "mode": "100644", + "gitBlob": "761e1a4e49116e124a196f2cb6a06792153f4313", + "rawBytes": 62706, + "rawSHA256": "01B6C71C834FF4E29DFA4BDBB75C87CD602AE6934C566F939A85EF54ABCD00D8" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/FINAL_STREAM_CONTROL_MAP.json", + "mode": "100644", + "gitBlob": "4462fa13b745a53d454083e0e68c451a02998f89", + "rawBytes": 2384, + "rawSHA256": "92A0CDA169F378EBA27A9884E5ED4A9E147845EF80ED0D528A02E95BEB115813" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/FINAL_STREAM_MAPPING_EVIDENCE.md", + "mode": "100644", + "gitBlob": "8a13f776a02c5fb41eb4d319abc1d6d279b98731", + "rawBytes": 4013, + "rawSHA256": "CEF679B7D5EB23179EF37829714BCDFECFA97467928AB5ABCFE321701A35FFA2" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/GUIDE.md", + "mode": "100644", + "gitBlob": "4ea2ca326c09042814bf0adb9b8af1a7f5b87f18", + "rawBytes": 9273, + "rawSHA256": "015C633EF788D8FF966359705A5ACBB54B70252990A8E2D85463437C4153D4FD" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/NATIVE_CLIENT_SELECTOR_EVIDENCE.md", + "mode": "100644", + "gitBlob": "28bb274cf70e714b321697bdddf60e0a2f9b325b", + "rawBytes": 8637, + "rawSHA256": "9AB03F651E584C6D09AFD8DA2308160252366F20A194582168661E6B52642C28" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/NATIVE_COMMENT_AMENDMENT.json", + "mode": "100644", + "gitBlob": "fda381623e8c4d34b85c052766b6c92c65150df4", + "rawBytes": 4607, + "rawSHA256": "933D8DF34382ACDD2080EE75218FF06E3BEB2A1CD0A9235F9C450FA9CF21DE77" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/NATIVE_CONTROL_EVIDENCE.md", + "mode": "100644", + "gitBlob": "3c340ca82f8736fc4a4cfc84b9fe09b9c0f70aff", + "rawBytes": 28499, + "rawSHA256": "90C503028F4DAA9D7DC0C6F53973B30A79C06CBE11880F9D546851934206E4D1" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/NATIVE_EXECUTION_EVIDENCE.md", + "mode": "100644", + "gitBlob": "6a896b595ee8f134148a7af4f590db57a7bf2ba3", + "rawBytes": 22925, + "rawSHA256": "670C8520843896DC40B15EA46B3AD658D0E70E32727AD985FFB30FE833400D6A" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/NATIVE_EXPECTATIONS.json", + "mode": "100644", + "gitBlob": "949c6ca197ca1eb26958db19c3a6ed911c11e1d4", + "rawBytes": 645725, + "rawSHA256": "04FE22C209AED3DD88BA7036A563E4E757A6A28EC9497A3E72F8C275C493E1E2" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/NATIVE_REFRESH_EVIDENCE.md", + "mode": "100644", + "gitBlob": "a6c278b1dc13dcbb30f75c4b188b2ad9d4d689d8", + "rawBytes": 13490, + "rawSHA256": "F0DA827950A867DA7164832D1B740BFE574E3F87AB5B6D02C8F0B8BC737E8534" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/NATIVE_REFRESH_PLAN.md", + "mode": "100644", + "gitBlob": "8259d0231dbb7abdebb02af0e16f2e15a61bcc0e", + "rawBytes": 14058, + "rawSHA256": "3F9C990718AEDA2FDB00F53AA5371D278F41C6E02858396E314D94B8C9380AAD" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/NATIVE_SELECTOR_CONTROL_EVIDENCE.md", + "mode": "100644", + "gitBlob": "a0f1731e82d185621db60165b30a85d6ed78c1ef", + "rawBytes": 4973, + "rawSHA256": "5769A36A28A6862836B97CB29C62EA0B203B58E53C299A72083848F6F60E33BD" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/OWNED_DESCENDANT_CONTROL_EVIDENCE.md", + "mode": "100644", + "gitBlob": "57351676bb8bd8a2dffe0d54fe3f602a0ba72173", + "rawBytes": 2936, + "rawSHA256": "062954FE37BC618AE2A679D669382B20097FBC6BE96D37985DA7AA1B30011FE7" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/PAUSE_CHECKPOINT.md", + "mode": "100644", + "gitBlob": "ee7b173b5c85676e2e9dfe1d5a83495dc4d22bfe", + "rawBytes": 7219, + "rawSHA256": "DBAA1BE0BD6019469AEC1470E6129DE690DEE5576AD50C75F939C66340AA3062" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/PREDECESSOR_DLL_REUSE.md", + "mode": "100644", + "gitBlob": "cd1196b952657aeab0eb8585f1b485749f57db92", + "rawBytes": 3261, + "rawSHA256": "36DE1F3F35FDB686B26F19A97E3173F36D880DD7A695BC4AF043C6BD940A4C53" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/PROOF_EVIDENCE.md", + "mode": "100644", + "gitBlob": "f582f31fc9d10e5e7cff0d2fb994e948264007e1", + "rawBytes": 68769, + "rawSHA256": "0A47421080A38378CA723871BC2B0D6562915433500DB9B4CA87550AAE8FB5AB" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/REPORT.md", + "mode": "100644", + "gitBlob": "a4e4589ecc1fd6bf01431734ca6290f9e5aa7dd8", + "rawBytes": 28162, + "rawSHA256": "F0312BE8799C57A68FC60028DAF3A2AF64E47E44DC17F2AE0AD4936B9C3AB518" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/ROUTE_COVERAGE_EVIDENCE.md", + "mode": "100644", + "gitBlob": "cfdb43463fc7a3baf90f01889c93b64d40feeef6", + "rawBytes": 18724, + "rawSHA256": "79A75750E1F72197C87E17283215D8754659C8CC475584C326710285F107111B" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/RUNTIME_LAYOUT_SOURCES.json", + "mode": "100644", + "gitBlob": "9059738f1ffcdb9edba2a4ff5b1356939b887324", + "rawBytes": 1651, + "rawSHA256": "C8A716182A13ED8F15E40CA87C94A7FD0686A592D071CCB8532AEDB5F439171F" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/RUNTIME_LAYOUT_SOURCES.md", + "mode": "100644", + "gitBlob": "ed538b4f8c60211e74e6ab33bde3814b7502f7ea", + "rawBytes": 4229, + "rawSHA256": "48F0B18D437C1D1A4FCD8A35B5F41413C449A3771757ABB3FAABA1E254CF1E87" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/RUST_DIAGNOSTICS.json", + "mode": "100644", + "gitBlob": "c7534e977ceb3d2d30350f2c3f5e07f7e10fc333", + "rawBytes": 35617, + "rawSHA256": "59997583C31B3571C71B963708EEE6E7A2DD2BFFD9268E627FD6D6CA86FDFC41" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/RUST_MISUSE_EVIDENCE.md", + "mode": "100644", + "gitBlob": "cc6033833437d0d4bec98dd48e9fba83a1411452", + "rawBytes": 6466, + "rawSHA256": "710B4056C0DB5491DD13AC8BC42DB6D17A449C8D7DAF33B13FA2B7F8DC1A07B2" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/START.json", + "mode": "100644", + "gitBlob": "b88ec0051e94567ef05cfd32728063dd4f32058e", + "rawBytes": 2898, + "rawSHA256": "674312B1B4F16247BA8A2F757931AB0F34950A5A7560F00EAFDDB37EFE9213FB" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/STARTUP_AMENDMENT.md", + "mode": "100644", + "gitBlob": "2ce4c33452fc745b8dc26bf282457ed1e28901ae", + "rawBytes": 12105, + "rawSHA256": "D0D0BA5E61DD8290701D82611BA78313090F8AC1D35B340098EA5E9B86972A4A" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/STARTUP_AMENDMENT.patch", + "mode": "100644", + "gitBlob": "95a985f2f856685ae8860be343f5b4e9d7e91ac3", + "rawBytes": 1924, + "rawSHA256": "3D8F728671EBA5C41F9B06DAB4D40187B991B69DA842EF05A9B0185AF6F33A39" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/STARTUP_AMENDMENT_RESULT.json", + "mode": "100644", + "gitBlob": "7716a0ee77af760effd4c3f6b867e88d2fb3a5dc", + "rawBytes": 2022, + "rawSHA256": "A302312C58B93000724C6DA4C7925BB17EDD3A53762F21FFF0EF98FC81229D82" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/VALIDATION_APPLICABILITY.md", + "mode": "100644", + "gitBlob": "75623a0975bc11d91b6b21e3fda0974a3e3d8d22", + "rawBytes": 8084, + "rawSHA256": "E55FB89716C34D0A48B040E58FAAD56E99A4511C93CDBCE258F50BB645A69466" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/VERIFICATION_PLAN.md", + "mode": "100644", + "gitBlob": "a5b7cbc97c37a891bd168c1ed0f7b6b7faabfb03", + "rawBytes": 14282, + "rawSHA256": "8114212562E103D6CD4F49E81775AC93416C62AC6B80F4ABF8A216CF73D640E7" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/axiom_inventory.ps1", + "mode": "100644", + "gitBlob": "201fc2db187690b9e7d70cd233bf71a0ce30cac3", + "rawBytes": 14819, + "rawSHA256": "A25A00E4EAB932C48318A48919DB585C2D6E1E9A395E181718D3D2A4DFB174EB" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/default_build.ps1", + "mode": "100644", + "gitBlob": "ca6ddd75750a373d9d7e819af01b83b92c2933d6", + "rawBytes": 6387, + "rawSHA256": "19920175A7459B61CCCC028B96A162ECC0A069F5A837AC5A7C174B916437662F" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/export_mutation_replay.ps1", + "mode": "100644", + "gitBlob": "f0d4f7086e3b8fa28e95c12ea4161c111f891518", + "rawBytes": 37360, + "rawSHA256": "06D29609557CDF2E25445920CBE0034577E89A4BA89E6A4D2E5CAB7734807713" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/final_checks.ps1", + "mode": "100644", + "gitBlob": "0ad1e4fc143a4600945c92e162e8e6479358364e", + "rawBytes": 8774, + "rawSHA256": "8D631AF32FC764A125BBD89AE9B849583F633F432FDE05C1AC98588208C73291" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/final_stream_controls.ps1", + "mode": "100644", + "gitBlob": "fb054f1494ef0ad47a6fb49b2d92af850f6967f7", + "rawBytes": 20004, + "rawSHA256": "A527521E1C8539D84BA0722F091201A5DBAAFE04C60F385DC8448F0C83312F82" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/final_stream_controls.scope_seed.json", + "mode": "100644", + "gitBlob": "b0af2dbf919a22245b2ba89126d14a98de40bca0", + "rawBytes": 945, + "rawSHA256": "CBED0E740AF7C0F3AE48C6787BE7828DD268691629CEC7123CEA125281773EE2" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/final_stream_mapping_controls.ps1", + "mode": "100644", + "gitBlob": "8ebd6fb4f1c2d38c156c9a019147a57d3c9a990a", + "rawBytes": 8109, + "rawSHA256": "130FE206E743D8E8B7CDD890540334B1B60CED8D56D8363C2768163495E947D4" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/final_streams.ps1", + "mode": "100644", + "gitBlob": "075a3bb840f555b4ab34476c90120b3a831bd7a5", + "rawBytes": 18359, + "rawSHA256": "5CCC1A9C74024C75D7C23A87CAC1960C297A3F8F8BF81318757B4B78250FAE3E" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/init_probe.c", + "mode": "100644", + "gitBlob": "1e5d6bfa6be395b0c3a889bd2b668994ec48b015", + "rawBytes": 2478, + "rawSHA256": "BC2EF93BA74AEA5C52F7D1F18D03E34B07DD10F15E0C0004BA0C99ACA1E53E06" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/loader_probe.c", + "mode": "100644", + "gitBlob": "601fcd6bf8b7931570aa8dcd8f79c5f2b684da1c", + "rawBytes": 854, + "rawSHA256": "6DF8F2954E81A65D56970037BEBDC0DCD0B77AA52945FF381015E0AE5434B4B9" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/native_client_selector_controls.ps1", + "mode": "100644", + "gitBlob": "b55d86aac426edad55ab68e1e9455335bb910c86", + "rawBytes": 11856, + "rawSHA256": "5377BC3B6C703BFCCE48D322ED797172DBF5AD21F224340B260DB7BF070F754A" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/native_clients.json", + "mode": "100644", + "gitBlob": "0011c981ffbbeb1b48918b48ff193f3413dd4236", + "rawBytes": 3090, + "rawSHA256": "931F8286BA7D3FD251CDA2386375B78B1442EC4471C65D7CF7AE2E6B1876A327" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/native_clients.ps1", + "mode": "100644", + "gitBlob": "a8ed719fa5b731cb1466bb361d2e8844064edfe4", + "rawBytes": 17411, + "rawSHA256": "E32F7D8C83079C09127E853F720104BFD3CCF2F8F55FC6C973DCBAAC4133E2EF" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/native_control_selector_controls.ps1", + "mode": "100644", + "gitBlob": "bbb06ac10825a5e79e72950d1c1f7ca404e56b67", + "rawBytes": 14133, + "rawSHA256": "35F357328EE3300D98EC41941C47F001EF9620E3E09E691306CB5F89CAA4EFB9" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/native_controls.json", + "mode": "100644", + "gitBlob": "1cd95f6eaa2fbc6053145fa9a9b9cc404c431466", + "rawBytes": 13973, + "rawSHA256": "1F7476824F518B33790DA70E922E64E1985E07F4AAC50D74ABD35773F5CA8F34" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/native_controls.ps1", + "mode": "100644", + "gitBlob": "2fb2899382d5297e01ca6bdf30dbaf153b8aab28", + "rawBytes": 31066, + "rawSHA256": "6AC8B9493ADAC56AD57F621A6493751EA9F8570D8FC397CCF742481B8FC06009" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/native_recipe_controls.ps1", + "mode": "100644", + "gitBlob": "83cca98fb35a894ceeb2d49a844b19c6cb1ee10f", + "rawBytes": 10827, + "rawSHA256": "F038479291F9D96C10D7B8F816241BE00C771560EB82B4D9D1685ED5C20A45C1" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/native_selector_controls.json", + "mode": "100644", + "gitBlob": "428dea971b372b6eed85d1790b06cfefc379a10a", + "rawBytes": 7279, + "rawSHA256": "8C0A1631FE8711D9330CCAAEF46FD27A4A30796348C3E65EBF033C6C21ABD525" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/native_selector_controls.ps1", + "mode": "100644", + "gitBlob": "1473f334138be7d09e876e0e0590851044a96e07", + "rawBytes": 16736, + "rawSHA256": "F5B72BC3158C890C0F76187C6C963D37CBC284F7B73E5AD7804F715936B6ABA2" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/owned_descendant_control.ps1", + "mode": "100644", + "gitBlob": "2d37d483aa714acf546b50ced8b7d2470c77f12a", + "rawBytes": 13283, + "rawSHA256": "5CA26D58FA2D509566086C68667111142939626ACDD50E5C451003CC1A097988" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/rust_misuse_replay.ps1", + "mode": "100644", + "gitBlob": "f75d7315831dbba0dc796098390e6b97d0085b58", + "rawBytes": 11476, + "rawSHA256": "1589AA602966315AEAB3683B6C95D2022088F5B7A9E337A636CF6DEDD03EA76C" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/rust_misuse_selector_controls.ps1", + "mode": "100644", + "gitBlob": "2d8a105328198ddf17bfd9aa968709a9d01cb54d", + "rawBytes": 11049, + "rawSHA256": "D2BA267E82CBBADA10D25DD799E849E9A3F75743FB7902F5FB89064499E2867B" + }, + { + "path": "docs/internal/extensions/lifecycle-native1/scope_check.ps1", + "mode": "100644", + "gitBlob": "1f9511d4fb76a24a99729aebd55e10ae9623859f", + "rawBytes": 7460, + "rawSHA256": "5058C5CE403AB95815153376167934851951047C3FF6CDA62D0A17B1C453B426" + }, + { + "path": "docs/internal/extensions/lifecycle1/ACCEPTANCE_EVIDENCE.md", + "mode": "100644", + "gitBlob": "79ef9dcea341dd5906b0aa3b1f4fe864deeea1b6", + "rawBytes": 33319, + "rawSHA256": "F996EB73D4ACC9020B093E568521D7413B232ABA9D0D642376B564439CB22FAB" + }, + { + "path": "docs/internal/extensions/lifecycle1/ACCEPTANCE_MATRIX.frozen.md", + "mode": "100644", + "gitBlob": "1aa9b2139c05574b6256fff28aa8c3035e105e04", + "rawBytes": 43514, + "rawSHA256": "BC596CD8A4866CF8DB7BD06360D1C2E797E389C92237C9AC3A0B5E4145CD22AB" + }, + { + "path": "docs/internal/extensions/lifecycle1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "c6b2388371d564b24d9441f2a3489531012460c1", + "rawBytes": 73177, + "rawSHA256": "63B7EB6B7C01FCF9CA109BE9CDCBF67141BB83C3927C2D7F707B06E2DC482CF1" + }, + { + "path": "docs/internal/extensions/lifecycle1/CACHE_PROVENANCE.json", + "mode": "100644", + "gitBlob": "6b77739dedaa51dea5538caaac601ed77d4a0477", + "rawBytes": 669, + "rawSHA256": "6F803BE4FEDB148D054DCE987CD78146BB10687CC81EF6581B412D36F8FA0CAA" + }, + { + "path": "docs/internal/extensions/lifecycle1/CONTRACT_REQUIREMENTS.json", + "mode": "100644", + "gitBlob": "d8271d9a796dbbd5fec02b4169dee3098357e9a8", + "rawBytes": 54250, + "rawSHA256": "E47AB45ACAD51FE508CE9B8BE9983A136F8C9267D4D8FDD7888195BD0419E488" + }, + { + "path": "docs/internal/extensions/lifecycle1/CONTROL_PREDICATES.md", + "mode": "100644", + "gitBlob": "d41df3a79b34cb4adda997027e5f157030450462", + "rawBytes": 19654, + "rawSHA256": "8528F0ABE9FBBEA11077F02B6303C772400FC895575B0792A349C7769A13C2F6" + }, + { + "path": "docs/internal/extensions/lifecycle1/DEPENDENCY_VERIFICATION.md", + "mode": "100644", + "gitBlob": "4eadae2fe0e46eee875331a598c758c3dca685ad", + "rawBytes": 15665, + "rawSHA256": "C5A5805B520A5503C70D18A390F8011109381F3D16B2347E9801047B649ED4DD" + }, + { + "path": "docs/internal/extensions/lifecycle1/FINAL_RECEIPTS.json", + "mode": "100644", + "gitBlob": "b5573b9babc6083516bfabd1758e069c54b1dd1b", + "rawBytes": 80207, + "rawSHA256": "697397C8B6B06930393898099E226B576477CA1B1890CF9E5404093548139A5D" + }, + { + "path": "docs/internal/extensions/lifecycle1/NATIVE_VERIFICATION.md", + "mode": "100644", + "gitBlob": "29a4c789ee598f727bce1e0eeb6b8bc597e9020b", + "rawBytes": 14741, + "rawSHA256": "4CC702230F0D16839FA2B5087569D8E27E61FA3C154DB5231E52FE75260FFAE0" + }, + { + "path": "docs/internal/extensions/lifecycle1/PROOF_INVENTORY.md", + "mode": "100644", + "gitBlob": "2fec2352d7a2057cf147a5fadf487ab9cf66e810", + "rawBytes": 40258, + "rawSHA256": "CACD0C5A9A96F767AA9AAD585C0B19A7A98AD2583AC821966AF2A8AE384F5C88" + }, + { + "path": "docs/internal/extensions/lifecycle1/REPORT.md", + "mode": "100644", + "gitBlob": "996833fda5424ed6fac4e8b623b05ecb429be01c", + "rawBytes": 25629, + "rawSHA256": "F0A21EF6EB0F5992E5A9584877C65AFDB206F52679F40D98344F68C652371850" + }, + { + "path": "docs/internal/extensions/lifecycle1/RUNNER_REVIEW.md", + "mode": "100644", + "gitBlob": "7742b7998d2fe4b1db769629bdd54f8e1bc8ba23", + "rawBytes": 4980, + "rawSHA256": "B2E697FFB04183E56E10354C1CD34A28E67723101A129F21B8ADDE36E978F722" + }, + { + "path": "docs/internal/extensions/lifecycle1/SOURCE_MANIFEST.json", + "mode": "100644", + "gitBlob": "70ed6bbe243bab060987e8c3f3d4cde854abaf71", + "rawBytes": 16870, + "rawSHA256": "2B8500DBF3573BD4F2F7E6A27BFB7DC46A682ED4E59DE5411405A6BC60952CA0" + }, + { + "path": "docs/internal/extensions/lifecycle1/START.json", + "mode": "100644", + "gitBlob": "86b6ff30e72578b97d6664ddcf8ebcee6761272a", + "rawBytes": 1853, + "rawSHA256": "59F47921F87FE08FA92065257CC9A5230D96B8F299D0E9E207BDD6D2A8137ACE" + }, + { + "path": "docs/internal/extensions/lifecycle1/VERIFICATION_PLAN.md", + "mode": "100644", + "gitBlob": "c14d285ee06bc44a46d5f5e78623d3129e2eeb96", + "rawBytes": 17841, + "rawSHA256": "60A70BA7EAFA7A11584F23809A726D137A4A7538A18C823683B6E5D245A29A5D" + }, + { + "path": "docs/internal/extensions/lifecycle1/contract_integrity.json", + "mode": "100644", + "gitBlob": "7b80274dc93c9d3ec02c7180403ad03abcbdeef4", + "rawBytes": 22548, + "rawSHA256": "5E883A58C09DD23BB21713FE5ACF97A2697567BC693264AB1F46B58835389330" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/ACCEPTANCE_MATRIX.frozen.md", + "mode": "100644", + "gitBlob": "d1a682acd99207d855745d016d85eae0cdbda8ff", + "rawBytes": 46274, + "rawSHA256": "20B1DB9B99FB730E7075B4B6A4ABC0992E40DE29336AFE8375773EA062E8BFEC" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "07386b6f1e6fafd9b856a821f071d34bd722ffaa", + "rawBytes": 86187, + "rawSHA256": "3C2401957389BDFE894574A13AD9C626F038D2873975F61890D6942E3912AAC0" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/CACHE_PROVENANCE.json", + "mode": "100644", + "gitBlob": "58ebd6e210f206173ccb797adb33034f890b9aa8", + "rawBytes": 578, + "rawSHA256": "DD303F0F93E929651BB57BC3A3F66294624DCDB8C6FA15CBA594C1635C12408C" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/CONTRACT.json", + "mode": "100644", + "gitBlob": "4a7f4f984557cf7d391ba24952570ac2abe6dd09", + "rawBytes": 19993, + "rawSHA256": "3365D6D013EEE347385DEB2CB4DAB042700E7EC259F0CBD62FFBA3081F4520E0" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/CONTROL_REGISTRY.frozen.json", + "mode": "100644", + "gitBlob": "204d6c1d48268fdec3a3d369d9b3dacd38ecb8e1", + "rawBytes": 76654, + "rawSHA256": "68AB24530878BE76E030313AE4B3A17610B5BEC6F70AE3FE83351E67435F1619" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/CONTROL_REGISTRY.json", + "mode": "100644", + "gitBlob": "204d6c1d48268fdec3a3d369d9b3dacd38ecb8e1", + "rawBytes": 76654, + "rawSHA256": "68AB24530878BE76E030313AE4B3A17610B5BEC6F70AE3FE83351E67435F1619" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/EVIDENCE_INDEX.json", + "mode": "100644", + "gitBlob": "83a62a24f1a6a12c745e1a0e5c2e935c80a8e980", + "rawBytes": 2136062, + "rawSHA256": "AF8A32126DA5F24CE5D43ADFA2E4E8593BD2F6941480172C20A4FE62D9CF1CE6" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/INITIAL_WORKING_FILES.json", + "mode": "100644", + "gitBlob": "52501ead077dbe569e9676338ba569e0afc3b86a", + "rawBytes": 707591, + "rawSHA256": "BBE8B6278795FA2E29D4F68CFF348C483E6E44DC4004025C739A78090CFAEF0C" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/PROMPT.md", + "mode": "100644", + "gitBlob": "8c218b9b03b7b60753b0dd5b6c155d6fae241a35", + "rawBytes": 46818, + "rawSHA256": "2971CA834F06A62EB33B8589E718246938D8C703AB2211F83BE8DBCCC80BC895" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/REPORT.md", + "mode": "100644", + "gitBlob": "38ba7debc57f1452c02bfd705ab9bf62313bd87e", + "rawBytes": 23036, + "rawSHA256": "1C30FCF76880E4D275B2881F4074EC29C31C51E4BC80930D3D01D7CDB5A58892" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/ROW_DISPOSITIONS.md", + "mode": "100644", + "gitBlob": "4d6036cc9f01f6141cf8bb73f54a8a52092f459e", + "rawBytes": 39911, + "rawSHA256": "BC74804E65B18A2A08CD0ECA008BD763E85945B75111CE380647E91A892ACA9E" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/SCOPE_VERIFICATION.json", + "mode": "100644", + "gitBlob": "b823a4e6fed43598bbf4d97e51d8c7012abd263a", + "rawBytes": 33283, + "rawSHA256": "83002220AE3132A424A36E910A50D9C351F1A854D4BCD3E5938684454AE68392" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/SOURCE_FREEZE.json", + "mode": "100644", + "gitBlob": "6b883ce07a59c068a318f82b096085a2b1cd4afc", + "rawBytes": 347686, + "rawSHA256": "4527E51E7E9E5CEF2759957F7A1942A6BB6FAB89B784D572FA0AF3130A81606D" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/START.json", + "mode": "100644", + "gitBlob": "166a5b92fe16c8722237e995bea6f8c4a5522025", + "rawBytes": 2635, + "rawSHA256": "073AECAAE06126BF0E4F6EF1CA68450BE68A2C685515AF1359A43B711D121AF5" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/VERIFICATION_PLAN.md", + "mode": "100644", + "gitBlob": "87f0e01f8f3c92d6ae30f5004af7b3aacc04df1e", + "rawBytes": 4563, + "rawSHA256": "228E1AA0EEECA213CDE272E0F37AE2ED7A8DEC31DBFD94DF5BEEFD2BCFC5CB5E" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/build_row_dispositions.py", + "mode": "100644", + "gitBlob": "36c0bcdb41590781ed1d9b600ea4216b84b8164a", + "rawBytes": 37341, + "rawSHA256": "3202F14F3DCFEE4002B1EDD3170A8CE944C465B539B5D654141A380BDEDBD2C3" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/collect_evidence.py", + "mode": "100644", + "gitBlob": "94e8ac24a23e2b7edeffa898b1425eaf8d528967", + "rawBytes": 4350, + "rawSHA256": "D95377B9657E45226F3B894785411803051D43EB5169C9675E7208DF09EC4E6D" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/contract_verification.json", + "mode": "100644", + "gitBlob": "c985666c30fa9c5eafcc3aa4b91162df4010ec6f", + "rawBytes": 15966, + "rawSHA256": "1143B16F9ABCCBB5ABB4D0415B16248FDA5F730C66D82D55130088AF61462362" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/deadline_control.ps1", + "mode": "100644", + "gitBlob": "e985da4bb21ba3cb6646623fdc0efd0808fde264", + "rawBytes": 3226, + "rawSHA256": "4831CEF50CE6043F4AFB9F3E2971A34D53E2E0947D4C25B311E2B3B4C1A1E1FD" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/dependency_boundary_cases.json", + "mode": "100644", + "gitBlob": "c5e63fc9f4ce0f7ae97c41a5570e74019ad7cced", + "rawBytes": 28695, + "rawSHA256": "D9E56DC40888CFDB937F0ACBD9EC945846A5CAC585C99341D21DAA9B793D9ECF" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/dependency_child.ps1", + "mode": "100644", + "gitBlob": "b16c812db3acb30043ec470237b86833b9b62b56", + "rawBytes": 7959, + "rawSHA256": "5640AE40E34B05760F9E0FE71779291B8F23A4B053DA62408A12F8499454C67D" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/finalizer_cases.json", + "mode": "100644", + "gitBlob": "84c8df0b0339a48a60af93ad446532d2a186cb58", + "rawBytes": 4731, + "rawSHA256": "0F03F2EBEF9EFE9B8F305DB58E8E8636DAACCB063A3D87E6872CB0F88A939767" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/finalizer_control.ps1", + "mode": "100644", + "gitBlob": "76165bc0c27e07a7c9aa6874492a140cbb4c5195", + "rawBytes": 27003, + "rawSHA256": "91DF97E2042A6C3293632AF3DE6E0FEF4C61CA24C4FE9A34F07182E01134E098" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/finish_report.py", + "mode": "100644", + "gitBlob": "2e3c2ea92ed013b9768bdc21cd3e32976c83bc99", + "rawBytes": 6728, + "rawSHA256": "3EB0B4F946FE5665B87F3F54E09FAB8D4B9605B4891825CEB0E681637360DAA8" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/freeze_controls.py", + "mode": "100644", + "gitBlob": "b385c8f2f32d8d903c2c712771c272fc5ca2c457", + "rawBytes": 1779, + "rawSHA256": "58AA36C561F27F0B940308E6ADFA14AE01887BB0498811DC3B613980EF647C9B" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/initialize_contract.py", + "mode": "100644", + "gitBlob": "648be366f7ce6dec0636f00ee4238ccede69b2b1", + "rawBytes": 5497, + "rawSHA256": "5C6D2CA690E8CDFCAC247AA57353C17AFB8E18F9C3B4C9A978D365F8A1421209" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/make_dependency_registry.py", + "mode": "100644", + "gitBlob": "3992bc4ce288246c858771067667d37fa2a25041", + "rawBytes": 3747, + "rawSHA256": "A769606EC40F89A07884B255541864629491FD17A9A5C7D3225661F0C2368A24" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/make_selector_registry.py", + "mode": "100644", + "gitBlob": "1150b33fe1b2fca49f84159864dcdce8d8d0ded7", + "rawBytes": 5166, + "rawSHA256": "D46E862F6F3B408AE07A433AE1D54C6365DA6A5DD2CC2EB30422CF4805C49B21" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/old_environment_control.ps1", + "mode": "100644", + "gitBlob": "253b002ea3e9928a827e45430b2b63772dfd68c5", + "rawBytes": 2816, + "rawSHA256": "61AC0A6CCBA2BB25F2911418CE470BD5791DFE8DE21CB2DEA030F7C4DAD0047D" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/preflight.txt", + "mode": "100644", + "gitBlob": "79701ff2fbd7f1734c51fe124460577e9dc7c90e", + "rawBytes": 819, + "rawSHA256": "C64D1C2760F6BC3CEA8A5953F45078AD994EEDBF4E6D726FA344006140E8D3EB" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/prepare_cache.py", + "mode": "100644", + "gitBlob": "ba174899fc48bd9ad8e5c2b8c94036d54351c710", + "rawBytes": 3027, + "rawSHA256": "BD06BD2ED9AF5EAD748655AF6EBF805D18D89F98F8784598F80A0294A77732BA" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/prepare_old_root.py", + "mode": "100644", + "gitBlob": "172e0a3cd5bc49e103513f7c93919b6f606cb78b", + "rawBytes": 1698, + "rawSHA256": "B5C456E20BC975A12F5AA5A10E67B9475891C19898130C79E4CC0609728609AD" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/registry_control_cases.json", + "mode": "100644", + "gitBlob": "694154da863eddcb7823dd400c92eb4d4b6bb9ab", + "rawBytes": 12683, + "rawSHA256": "1B8627573B7B8E39944BC8B8F5E87E2595E055AF1D04B7CED7B53D2C6229A9E7" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/registry_controls.ps1", + "mode": "100644", + "gitBlob": "1615a4676738c90178f545a47904ffaee1978c09", + "rawBytes": 16273, + "rawSHA256": "833662925BC1986A650A4440FBC2A0031FD0D8DB7EDC27C0BFBCAD944145D13E" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/run_check.ps1", + "mode": "100644", + "gitBlob": "f21505428701c77abd2b6390b64cf127b9a267aa", + "rawBytes": 2583, + "rawSHA256": "70C86A6C07803D19F1092E182A35CC2B266DA94E6790E431D84BC53D7CA32F36" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/run_controls.ps1", + "mode": "100644", + "gitBlob": "288a0f4e70adfc3d613f2893e0cb293a2e12a667", + "rawBytes": 7672, + "rawSHA256": "885BBC7C8A5D356CDFC82920D208F7D2DE4CE3972ABF705B3F02BB518159B42E" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/runtime_profile.ps1", + "mode": "100644", + "gitBlob": "4f26065b241fc676c12249f56d0ea3025590101e", + "rawBytes": 1482, + "rawSHA256": "4F296DAD60179A23BA2D049487E29E02E4C78A873A02C8542C84B8FB918F94C8" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/selector_cases.json", + "mode": "100644", + "gitBlob": "0f14678abfb13f44af973d4a2f349b87da7e7bd0", + "rawBytes": 26312, + "rawSHA256": "407E9F8455AEC21EF6ECAD8098C0FD0FEBAF557D7BE423ECCAA0AF32F08FBE3B" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/selector_child.ps1", + "mode": "100644", + "gitBlob": "58ff6de108feb2389868e73bff49a32c788a4f39", + "rawBytes": 10856, + "rawSHA256": "F2A6663EBE067A9AB0F2FFD241DE92AAB0C57DB7CA0D8DFA73EF1A36A9D2DDCB" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/source_manifest.py", + "mode": "100644", + "gitBlob": "151d7031b30e62bbb0151c421676c4b0c2a43411", + "rawBytes": 23409, + "rawSHA256": "D3B173D5D74929DA4388476095A22F88BE71E0751A9B539DBAEA0636D092ABC1" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/verify_contract.py", + "mode": "100644", + "gitBlob": "2b353beb90079032a8a444a864664b1892265c59", + "rawBytes": 21547, + "rawSHA256": "FCCB2933DBB5C498D2CE57E52604DD9C958FA59E9235D8737CAAA5C505B5BD76" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/verify_scope.py", + "mode": "100644", + "gitBlob": "400f55963696731fb2874a4f348f840ebc890f50", + "rawBytes": 20768, + "rawSHA256": "A91052F6E4E49D78E7E2B7EE935C1871C67194440C6D5207A1AA62D86393E6F1" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/ACCEPTANCE_MATRIX.frozen.md", + "mode": "100644", + "gitBlob": "edf51bdd84f398ceac473075018fdc8ab4bc9dee", + "rawBytes": 49094, + "rawSHA256": "CF11930DED662D07714A5D024FF5B6A3D54923F8951EBE0338CC9A5A92464BF7" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "7ef99baff08d0dbeec2841f8ea9a9e93f321c32e", + "rawBytes": 136520, + "rawSHA256": "25B610B2568F76586C70605AE2009067901B1F653C7F148A1FDEFD80226F4927" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/CONTRACT.json", + "mode": "100644", + "gitBlob": "1b41a4f7c0de6a061443700a4b0732eb81f3b4d7", + "rawBytes": 23818, + "rawSHA256": "28FCE1D275A6A7D1E48A710173E8D3C7FDB182A819DC8BDC62DAA7694AFEBB01" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/CONTRACT_VERIFICATION.json", + "mode": "100644", + "gitBlob": "3ffcab6a83c00728c053cbea73b24d51119dd8d7", + "rawBytes": 28405, + "rawSHA256": "78F63515019858AFE8B4E030B064CE1386FED5CF9759487EFF9FC3248E76C783" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/EVIDENCE_INDEX.json", + "mode": "100644", + "gitBlob": "f94875756d11565d7392d4629f8a639a815edfe1", + "rawBytes": 808355, + "rawSHA256": "50F0B1329E91F542EE822CEE2955EBA136456DA9BDD4D4B2192D69C62BD736AB" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/FINAL_CONTRACT_VERIFICATION.json", + "mode": "100644", + "gitBlob": "550d2a36153857c9affbbcb0f537f9fca0ea63d7", + "rawBytes": 28423, + "rawSHA256": "BCB5C9AF80775193F48CEED3CCCD6BE6DEE5E97B15CDE12F39C0E5E293058047" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/HASH_CHANGE.json", + "mode": "100644", + "gitBlob": "266ecb432e6371b648895f186c94ec24b0d8574d", + "rawBytes": 641, + "rawSHA256": "B5459AA84F31D8263DA9EE3540312A09C07308F879BD46D5FC79533E75B76C71" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/HASH_VECTORS.json", + "mode": "100644", + "gitBlob": "1105b0851ce4cfec9203ee22cc5faa0f863f930c", + "rawBytes": 1755, + "rawSHA256": "1F8978A6C12865127C68244DA50CF434761A315405BA366F5282000DCC664DB6" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/HISTORY_APPLICABILITY.json", + "mode": "100644", + "gitBlob": "5c56e445a847530ea5d19be098435050f60ec47e", + "rawBytes": 73770, + "rawSHA256": "B74D30A4866E4723C02B2986433B21AA50493F496C35A42734ECBBDBF5036ABB" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/INITIAL_FILES.json", + "mode": "100644", + "gitBlob": "c1bbd17cda85a6fd054405cf88588b9f3e787962", + "rawBytes": 1860160, + "rawSHA256": "0B7ADC9EDF480BCA8E84D8FB2BB9BA3190827FC044D828AFB99DA3BFC25A9507" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/MATERIALIZATION.json", + "mode": "100644", + "gitBlob": "d6f0e1b6f8f6cd5ced82c3cf926fc2a7100f51e7", + "rawBytes": 8638, + "rawSHA256": "64F1082AFCCC82EC98952E94618CB0A52FF6F8E56AAD7A830B4B2EE363AFD1E9" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/PREFLIGHT.json", + "mode": "100644", + "gitBlob": "4024982fde5e08b3f7d9da31672c1c7efb908651", + "rawBytes": 1407, + "rawSHA256": "A12390EE2FCA59D5DBDF69C123DC44D4FC81F123E8CF5FCE9BCE5DF19AC46D96" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/PROMPT.md", + "mode": "100644", + "gitBlob": "88c4332107732eaf72257a90b23cc2dee67b1345", + "rawBytes": 42671, + "rawSHA256": "D265FBB7B634E9CD5DAD41EE817A51C32EC14E98CC57400C83E712140795E3E0" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/PROTECTED_BASELINE.json", + "mode": "100644", + "gitBlob": "b719f02e73bf7689d955874d15ce9b34cfcb10a0", + "rawBytes": 715453, + "rawSHA256": "EE37179CE6B3330A278CC43B044202151626A0AEC3E8DE49FEA46D177650CDAB" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/REPORT.md", + "mode": "100644", + "gitBlob": "ec46526b0209fa4d4409cfd50a4cede4dac0ae89", + "rawBytes": 25314, + "rawSHA256": "E56720F96B7A77B95D98A6A6E665BA433E0D89541DB2F370D49D6E44B7CC4684" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/RESULTS.json", + "mode": "100644", + "gitBlob": "695d2ccefaba960a568a901786d57488621936a1", + "rawBytes": 303999, + "rawSHA256": "827BC69B864B71CB49C26350890BD29E8D744A97E675177AD7D89DE59821DBA1" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/ROW_DISPOSITIONS.md", + "mode": "100644", + "gitBlob": "adfe856a75dc02bd9ab94d9b30356cb75e05c442", + "rawBytes": 87424, + "rawSHA256": "243CA8FC3E12F0A44E936055E340160F52280F7711CE6833084E65CE2F3FA17C" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/SOURCE_FREEZE.json", + "mode": "100644", + "gitBlob": "4cd65468038a78584195eb64018eb7cbdc232fb4", + "rawBytes": 51722, + "rawSHA256": "ED86CC527ED10E10164DDEEF437D4E8AFDB44C19CFAF59615670EF0975C8527F" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/START.json", + "mode": "100644", + "gitBlob": "e621a05e2a021300a9f3101504cb5ccf51765af6", + "rawBytes": 6623, + "rawSHA256": "EBD653A8108470D2BD735850D4E788052EF8E939424761F3EE556F6885855428" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/VERIFICATION_PLAN.md", + "mode": "100644", + "gitBlob": "c845f62d150d44a40b444776ee962183a60e8e98", + "rawBytes": 3312, + "rawSHA256": "105D7FA4C41700A1CEB1B8000156835C5076EA47868CCF62D361F4767688B79C" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/bootstrap.py", + "mode": "100644", + "gitBlob": "8cfa05738f6b9bd1f0257398ff1348d24c400666", + "rawBytes": 6784, + "rawSHA256": "8F9C9AEDEE035111B93D1285283C10EB213C3556781B435DF34641C23E9E2FB1" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/build_rows.py", + "mode": "100644", + "gitBlob": "cd0266a1d09b5f14db68bcb0c388304793dcedb8", + "rawBytes": 30931, + "rawSHA256": "73D72AA7051E9848152A81B516E4FFFEE2AFC21AD1228034179211F4EF27CA9D" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/hash_control.ps1", + "mode": "100644", + "gitBlob": "a8b24591062123e7977e1ed79f1da2e5cabfe0d7", + "rawBytes": 4695, + "rawSHA256": "633E6CD248567468CF7755EC7937802E698EAC25D84BDDC73B48F43427B2F4FC" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/materialize_contract.py", + "mode": "100644", + "gitBlob": "706fcc51dbb5d0e7523c53764daac7201160066c", + "rawBytes": 6584, + "rawSHA256": "881E0946ABFE4DE07664A67572E3C9FEF84DAC0C200CDA9EFD83A31A7FAAACD2" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/package_results.py", + "mode": "100644", + "gitBlob": "96c44881fbfe06ffb6b875b83b8afdd43d90613b", + "rawBytes": 1570, + "rawSHA256": "C2603BCE25D305AF2C46ACCA5931AE856AC71174D117AA2649476449322FB8A3" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/prepare_runs.py", + "mode": "100644", + "gitBlob": "72785f46b35e2aa37a661a6fdc6341cb3b3d9fe4", + "rawBytes": 3155, + "rawSHA256": "2FF59106EDFED101A68926F15A1301AE2E8D3B6B5EEA368DDB70D2E2488E9EB6" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/render_report.py", + "mode": "100644", + "gitBlob": "394b67a629e69e71035f9d548dc07e3ebb120f2d", + "rawBytes": 21128, + "rawSHA256": "943B4DCE27443E155472DCD6267848BF185DC4645A9D46D56AA053CBFAB03047" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/run_check.ps1", + "mode": "100644", + "gitBlob": "1377712ad2e86e8ea3ed0ab497c25960cdebb045", + "rawBytes": 3376, + "rawSHA256": "444EF5BEDABFBD29495A0556408A7C3FFA85F937F6857E99127760291E85DEEB" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/source_freeze.py", + "mode": "100644", + "gitBlob": "a68ca0066eea5c04af01e42b8c29a76236ea8165", + "rawBytes": 4562, + "rawSHA256": "F2391D3F5DCEAEBBF79E6B6BB4DDAE6A7DD60CD4EE5B907F1D8B0AFACCB5D719" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/verify_contract.py", + "mode": "100644", + "gitBlob": "aae2c76ea3d3f670b102cbdbeb33c350a14d8dbc", + "rawBytes": 25567, + "rawSHA256": "92FDA271B84D5286B7CCCD3277DB7B13B4DE5D0196FE26E6148DA864EB9321DA" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/verify_evidence.py", + "mode": "100644", + "gitBlob": "c6436243788fc270d2f5d7c34287182cdf4c5d6e", + "rawBytes": 30668, + "rawSHA256": "614081CB05F073121D02309A2F249DA8D27C6535D9B069776C45A57239656CDF" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/verify_history.py", + "mode": "100644", + "gitBlob": "9aa64b4988de69ecfb5a0dd0bcb08237b91c1b24", + "rawBytes": 41578, + "rawSHA256": "64E66A04A1E35486BF1CF35481B8B3FCA8D20B00B88DC46292D808211D2E47CF" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/verify_scope.py", + "mode": "100644", + "gitBlob": "d1e937a09cad712d6c9370560da77ea2e2ccde07", + "rawBytes": 4819, + "rawSHA256": "315751A3CF257382B104D7D7471AA2C9FD9BCD0E22C09E6DB6E62E96A6B2961C" + }, + { + "path": "docs/internal/extensions/native1/.gitattributes", + "mode": "100644", + "gitBlob": "0d06cba3191946218cf405cac707d12f0e0c0662", + "rawBytes": 1508, + "rawSHA256": "CCF135C40AADB273A2366D0E9DCDA2D80A792E246F77ECEC5DA894D32956B98A" + }, + { + "path": "docs/internal/extensions/native1/ACCEPTANCE_FREEZE.json", + "mode": "100644", + "gitBlob": "e9099d54833f90abd4660e85243e3ad1f526f816", + "rawBytes": 354, + "rawSHA256": "C049A24B55FD35BDF3EE33EB208B0D6016D332864409F9ACE4CD488119B49E0A" + }, + { + "path": "docs/internal/extensions/native1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "42c5ce5ade2640d21cf459520f3cb19fed7312db", + "rawBytes": 74021, + "rawSHA256": "F216C6F8DC13343807E126CE29F33333144306B59B60B270ABFDC5224AE80AF9" + }, + { + "path": "docs/internal/extensions/native1/AUDIT_PACKET_INDEX.json", + "mode": "100644", + "gitBlob": "453e2448c3f7881718908032e0dd98f402b03281", + "rawBytes": 36713, + "rawSHA256": "81B89157942D4C67A24E3E9885D4A6C51FAD0E39B1A0A95C4A5E7275D9C31807" + }, + { + "path": "docs/internal/extensions/native1/AUDIT_PUBLIC_CLAIM_PATHS.json", + "mode": "100644", + "gitBlob": "fcab64d73deea73405f41fe9df0cd88cc386dea1", + "rawBytes": 16613, + "rawSHA256": "6AC9F2B344D1B49C1D0432384BB78E6ED9EA6C04D017C811FA8B5A38517FD57A" + }, + { + "path": "docs/internal/extensions/native1/AUDIT_REQUIREMENTS.md", + "mode": "100644", + "gitBlob": "31c4785e33d5eab258a969bf0a0f96dc8bfdfd72", + "rawBytes": 11035, + "rawSHA256": "2EEB860936F15D1C189D23C67960B1679DFFF1FF6FEB2DBFE53D018C624CBA60" + }, + { + "path": "docs/internal/extensions/native1/BINARY_BUILD_MANIFEST.json", + "mode": "100644", + "gitBlob": "fdf336a77a930da0918b3bbff3e3c01ce6ca5223", + "rawBytes": 5601986, + "rawSHA256": "8ACF20E470E6247E3E415FE283F909C7BDE2F968518F76F0CDA0ED7F988954FD" + }, + { + "path": "docs/internal/extensions/native1/BINARY_LEAF.md", + "mode": "100644", + "gitBlob": "906e2a024425992b1539a005defa668d808e9669", + "rawBytes": 28485, + "rawSHA256": "91D2E40E3FE5B4F39C715F4B519AA59FBBBB32B4958DAA3448E8F7231C2C7132" + }, + { + "path": "docs/internal/extensions/native1/BINARY_V3_BUILD_MANIFEST.json", + "mode": "100644", + "gitBlob": "d63988821bd58840a9c2c2848a78ee034e599aed", + "rawBytes": 2779460, + "rawSHA256": "A4C20BCAA5E35402293DB522CE8736A81BD84FBC67FC2648693475504E5E1069" + }, + { + "path": "docs/internal/extensions/native1/BINARY_VALIDATION.md", + "mode": "100644", + "gitBlob": "df6b7c855d910159f5901fcef5f073bef32f9a20", + "rawBytes": 47551, + "rawSHA256": "B3CAF562182BCAE69162D9F00B9563D5AB14DFB8B2320A62BF8A620F1CF19B63" + }, + { + "path": "docs/internal/extensions/native1/CLAUDE_ASSISTANCE.md", + "mode": "100644", + "gitBlob": "f42799175956bfcd92fd01aa3aa5f7b07238f8af", + "rawBytes": 3830, + "rawSHA256": "3570F033F75FE6C181E561616C45C184930B867E165305484FDE817969A12CDA" + }, + { + "path": "docs/internal/extensions/native1/COMMANDS.md", + "mode": "100644", + "gitBlob": "ba3d2bc55c2bd429a6683017e91f85cc76fc70ef", + "rawBytes": 19228, + "rawSHA256": "DC6A7DDAAC59AC4CCB2581175400F08813AD41BC577A81CCCB661E72C0354B31" + }, + { + "path": "docs/internal/extensions/native1/CONTINUATION_CONTRACT.md", + "mode": "100644", + "gitBlob": "77e254fdd06d9dc0ad05943adc523486acf7bddd", + "rawBytes": 6940, + "rawSHA256": "41D73E461D330DE2306879AC9B30CA6E455832D039C1E9FFBC57942608465ECF" + }, + { + "path": "docs/internal/extensions/native1/CONTRACT_AUDIT.md", + "mode": "100644", + "gitBlob": "925ec8558db396a78dc27b509289eeed0269e095", + "rawBytes": 6559, + "rawSHA256": "8478BF15BE3EC6E9B9FBF1EC411B4E6DAEA98830271E0C8AA63E5925C79294C0" + }, + { + "path": "docs/internal/extensions/native1/CONTRACT_VALIDATION.md", + "mode": "100644", + "gitBlob": "cd3e5d2a00095a22706ab9fc93fbe38e6d663b68", + "rawBytes": 12138, + "rawSHA256": "7C22845D4FF64AA27D2D849B7DDD0A646A1E16F15F83CBA452DD8474577025A4" + }, + { + "path": "docs/internal/extensions/native1/CURSOR_LEAF.md", + "mode": "100644", + "gitBlob": "67447ee823e85bb016d4099f87abdf2d3769fd92", + "rawBytes": 14440, + "rawSHA256": "C50BA238172C0148705B86FFEE7155DFD7E97B71FE2F017351E9DA0113A78932" + }, + { + "path": "docs/internal/extensions/native1/DEFAULT_CACHE_PREPARATION.md", + "mode": "100644", + "gitBlob": "32cdf20bc2676f7e91279f30d3894c25b174158d", + "rawBytes": 6732, + "rawSHA256": "42CD1EE4543E267F2173DC66827B7D3A1917BA2396A85C85365080C0C9154D32" + }, + { + "path": "docs/internal/extensions/native1/FINAL_SOURCE_MATRIX.md", + "mode": "100644", + "gitBlob": "577c669e14fa5e5e66a61a7b5357765a08740165", + "rawBytes": 43376, + "rawSHA256": "AC9259FB49DC6E0CBCDD83760AFE61FD2E76AC27979B8E2ACCDC17782C9395B5" + }, + { + "path": "docs/internal/extensions/native1/FINITE_LEAF.md", + "mode": "100644", + "gitBlob": "41841889fe74394a0cec52bc91e7ddfa9c4d5b1d", + "rawBytes": 14613, + "rawSHA256": "621881F7683AE6F0DE9D8CCEA6AB9B08373F77F832F6AB0CF738F170DE47D325" + }, + { + "path": "docs/internal/extensions/native1/FRESH_AUDIT_PROMPT.md", + "mode": "100644", + "gitBlob": "2af3f1e9c2987ec4e1dd9d32a8c1794e7e021809", + "rawBytes": 15782, + "rawSHA256": "FB993699B9E2CB96C1732251DA874038C1CE62872622DF2543952349A6DC36DE" + }, + { + "path": "docs/internal/extensions/native1/GENERATED_SOURCE_PINS.json", + "mode": "100644", + "gitBlob": "8d42156a171f2bde876868bd715dc54613e9fa8b", + "rawBytes": 7756, + "rawSHA256": "2B577ED972455CEE40096A1A7BED5BCA2E7805631A159D4F239EFF332F06A56F" + }, + { + "path": "docs/internal/extensions/native1/LIMB_WORDS.md", + "mode": "100644", + "gitBlob": "45ee7501d48f5099c29ed1ac1e1842fcdaa87d95", + "rawBytes": 13338, + "rawSHA256": "B6764E1D0F6543756D19B8DD663944193C2FF4BA9571ED2D0B61F76A39A0718A" + }, + { + "path": "docs/internal/extensions/native1/MACHINE_LEAF.md", + "mode": "100644", + "gitBlob": "229f9e7dccb6ede588d1e5ce09c6c0e1531a4b73", + "rawBytes": 20405, + "rawSHA256": "C47A57211500F386E61AA8F5DF67D8DAD101AFDB48EE0746B14F8E2526AB884B" + }, + { + "path": "docs/internal/extensions/native1/NATIVE_BUILD_MANIFEST.json", + "mode": "100644", + "gitBlob": "b40c37c7374b19eca80683b6a23ede34c224086c", + "rawBytes": 2637, + "rawSHA256": "2F2C3FB554CA57D8A1C086460B55817940FC2B238DC6CF00813BA59D54D3F162" + }, + { + "path": "docs/internal/extensions/native1/NATIVE_WITNESSES.md", + "mode": "100644", + "gitBlob": "f107832be50704f9a15dbf5a30238d82adba4b90", + "rawBytes": 17296, + "rawSHA256": "35D66A3ECCD53E5F9015222E72B23E0061C9C61D4789AA93FF7253832D4965F4" + }, + { + "path": "docs/internal/extensions/native1/PHASE_RESULTS.json", + "mode": "100644", + "gitBlob": "4004049e42a5c9a650da2753c1f0657f65c883d1", + "rawBytes": 702, + "rawSHA256": "AD6EE54D2D7190DCFEF8E352C2F657129664CC712AF3F2C58B63F2B6BE8358F4" + }, + { + "path": "docs/internal/extensions/native1/POLICY_REPAIR.md", + "mode": "100644", + "gitBlob": "d3418e6ad186d99301fd33ca91038c128f919a44", + "rawBytes": 22255, + "rawSHA256": "5587FC0CDC6E76F136316791FA41B8534BFD30E134B633A8554F9C23C7DAB4E9" + }, + { + "path": "docs/internal/extensions/native1/REGISTRY_REPAIR.md", + "mode": "100644", + "gitBlob": "7fff40370c66141aaaa5801e099d2277cd7d3c0e", + "rawBytes": 21980, + "rawSHA256": "7065D9B248D8B1131F4F8446BFC29A58BB7984366228B15989662D61948943D9" + }, + { + "path": "docs/internal/extensions/native1/REPAIRED_BUILD_MANIFEST.json", + "mode": "100644", + "gitBlob": "0cb4b6d21fd8ee965a2ac2a90c2804863ecb5008", + "rawBytes": 954536, + "rawSHA256": "B07F660A24BA5966D7CD5BDA3D2C7C7D90ECF6FDD4192DE0B709C486D5F006F9" + }, + { + "path": "docs/internal/extensions/native1/REPORT.md", + "mode": "100644", + "gitBlob": "15952d1a5fb792c7acdcbe04cb3aa9a25f1f90e4", + "rawBytes": 14049, + "rawSHA256": "2FB3D34A27414A796CCCBA0C4483B25A0435C8A8ED03643A60BFA1880D2877CF" + }, + { + "path": "docs/internal/extensions/native1/REPORT_ROUTE_HISTORY.md", + "mode": "100644", + "gitBlob": "98b3e5b65fe1414bd2071200a1d17ee648ede257", + "rawBytes": 21192, + "rawSHA256": "D6C362528D5FF2DAE2FA929C1C9A3A05B5E681F2C2E4EDF72451CB7D3F5FDC00" + }, + { + "path": "docs/internal/extensions/native1/ROUTE_EVIDENCE.md", + "mode": "100644", + "gitBlob": "57a292527d926f9290ee17c8c0d08cb9ee1c0fe4", + "rawBytes": 12810, + "rawSHA256": "94E4F0C210B219C251188174BC0A0D34B7716BDFC551A9D87C22429E5C300405" + }, + { + "path": "docs/internal/extensions/native1/SOURCE_CONTRACT.md", + "mode": "100644", + "gitBlob": "5ecea9aa6d125a7b3ba6dfb9544d37a257382c5e", + "rawBytes": 18526, + "rawSHA256": "8D9833471C76FD84E7C93E1387A755B063EB3307CD6ABE4B604564FAB6ABE94D" + }, + { + "path": "docs/internal/extensions/native1/VALIDATOR.md", + "mode": "100644", + "gitBlob": "7447bffb343045e1d80629d3a9bd6af3c4b0927c", + "rawBytes": 16963, + "rawSHA256": "A67D9F80ED923B4B87D6A3ECE5223FB6277D0E0BC8BA0B58F56407637F0AB6FF" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-controls-20260912T130603847.json", + "mode": "100644", + "gitBlob": "326e720be96cf37a5eb8d6c9f7e455a6d2f1a782", + "rawBytes": 1045014, + "rawSHA256": "2BEAD2557D7CD8EA6056265636B45F05E0AF68F4E39F848441EF51F9226C06ED" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-early-guards-after-v3.json", + "mode": "100644", + "gitBlob": "bca4d41da9036fbde6e1aabff0cdd5fd6ed3958e", + "rawBytes": 9893, + "rawSHA256": "E9F857F0D2C190F5DAAC6FBAE58353745344388C1258CDC90B8CB5160E06E432" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-final-extraction.json", + "mode": "100644", + "gitBlob": "d5fd40c383d3a7445ce6e56899dcfc469d6659d3", + "rawBytes": 37882, + "rawSHA256": "82DE67D23A1D730CE1C42B434EE5C9EFFAA87B543A8D7982FC6B251AAF461EC2" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-final-static-checks.json", + "mode": "100644", + "gitBlob": "661c7af52d71464325f41b4a17e058e85e1945e1", + "rawBytes": 1490, + "rawSHA256": "6CEC80BED0022446D33BA641AB88FAF11A9D369A3E275B74ABE6EAA5D511B00A" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-first-selector-v1.json", + "mode": "100644", + "gitBlob": "b4ace9c6762a54b0ce5fe2b3fb62e5ba82ffe097", + "rawBytes": 1503, + "rawSHA256": "B97BC00109328A43F2AA70C27C147B9C2EFC95C043FEC4000EBD4D92633F78E1" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-replay-20260912T114513436.json", + "mode": "100644", + "gitBlob": "9393bd83f0dd5dd2f66232883d4cfffeb2f14f3e", + "rawBytes": 2936, + "rawSHA256": "28B9AB5DD8FAAED00E96F2EF4295032DF9630DDB397F77D8F19167DD28C5B4D9" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-replay-20260912T125636041.json", + "mode": "100644", + "gitBlob": "d7d478c73b8d691ea657e768cd764c519bc4d9c0", + "rawBytes": 41411, + "rawSHA256": "38040FEB491E40E1360433730DE8AD727DFCDBC712E319E5800A22A9B94C91EF" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-replay-20260912T125916442.json", + "mode": "100644", + "gitBlob": "8e713bc6a67aa891ff6f4d8c46548fc550b9747b", + "rawBytes": 111203, + "rawSHA256": "B1D9822DED4D34540E665CBA932506EC251842924AA467BA58C5B1196E2348AA" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-replay-20260912T131637038.json", + "mode": "100644", + "gitBlob": "5dcaca368ac5e1a7f85140b3ade22c57244835e3", + "rawBytes": 41497, + "rawSHA256": "02D81FDE724FE4E567BF2E6BC3E5E3592F053174B626EBCE68F8BD52A87482FB" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-replay-20260912T131712734.json", + "mode": "100644", + "gitBlob": "4eb3cbb2a0acb3ffe4e62a593d2ebe6da862a5a5", + "rawBytes": 3016026, + "rawSHA256": "C159656B68A1C1757EB439277D21C36C485D39A228A516BD47995E69C8CD60EA" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-static-manifest.json", + "mode": "100644", + "gitBlob": "d09d54defb4553e8597d7dfc74ade1c2e106146f", + "rawBytes": 11606, + "rawSHA256": "3FEAE48A9FF7EA86DC7BA570D3FAA023E2AD590B9DF69A4CD768EBBEA6D04C12" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-v3-calibration-pq1-n9-full-20260912T125906228.json", + "mode": "100644", + "gitBlob": "330b72a88a12accc0a5cad4e49500fde030f512b", + "rawBytes": 1206, + "rawSHA256": "93DFD7505E6E855E831F87251EE803C5980CDA2F54BCE3D012728CF5F77C11BD" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-v3-calibration-query-smoke-20260912T125624257.json", + "mode": "100644", + "gitBlob": "b1c334503dd7e850b696168b48e7da72e200f143", + "rawBytes": 1205, + "rawSHA256": "60DCBD76700765AF369DF952A5E789C9782DFD66A436EE4C9132D55A3CFAD5D1" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-v3-final-128-20260912T130558739.json", + "mode": "100644", + "gitBlob": "60f0f27cbba293033cdd97d30d9a183be61dd4b6", + "rawBytes": 16722, + "rawSHA256": "ACB96574D5D43E5FAA61B1571591CBCA9AE41D29C0B27DEC3377F30C6E5CD9C6" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/contract-inventory-20260912T132610808.json", + "mode": "100644", + "gitBlob": "d00aa02b41bbf2aeab6a40e357023c0daf356dfd", + "rawBytes": 149868, + "rawSHA256": "F96D0EC22C7331BF5EEA3F66182529B6E54CDDF9AAA177BBA5BD4B13FE13FCBB" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/contract-replay-20260912T131025801.json", + "mode": "100644", + "gitBlob": "c4a0829b17bfe80eefd7d69b70abf9acdaab793b", + "rawBytes": 4465, + "rawSHA256": "C3CDC436AC6ED19165C874E991960017D15F88BD5B47CFDAB3B4FE62DD289C4C" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/contract-replay-20260912T132003337.json", + "mode": "100644", + "gitBlob": "220317ca7408bc5dd3f5bdf0204152a9a42f5822", + "rawBytes": 133438, + "rawSHA256": "00DFFEB5097288A4F76D7236C933A0E11B0628C979A62A4BE3126CCA16460F6E" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/contract-replay-20260912T132210348.json", + "mode": "100644", + "gitBlob": "a5ec0ac57d279049b8f7a241eeffb62579001163", + "rawBytes": 135008, + "rawSHA256": "363AF8BC6FE34E695C65F019B518B52A125383F26FA069DA655B9CCC97F9217C" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/contract-replay-20260912T132516703.json", + "mode": "100644", + "gitBlob": "54e3631b1603d368f7bef1b78d98e9bd3c316b03", + "rawBytes": 40265, + "rawSHA256": "65909FEE725067FEFE4D46EA196F81878A95942B399AF613209EA99A825F2C50" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/contract-replay-20260912T132541948.json", + "mode": "100644", + "gitBlob": "caf0b6c62fe229593d1a885fcc143b3396548c61", + "rawBytes": 133437, + "rawSHA256": "82EC95A14CF0B13143AAAD7C0ACE1EC641894791FB313B6CF39DF389D0C6A6A4" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/contract-replay-20260912T132610808.json", + "mode": "100644", + "gitBlob": "9dca171773b7df7e7d7fa182a623cd6616e467a8", + "rawBytes": 539593, + "rawSHA256": "F98F12D881F0FAF1B13A6159ED1F116009C2CD5878771093B892152ED9F894FE" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/cpp-effective-discovery.json", + "mode": "100644", + "gitBlob": "888a90a860c7b2e6a182adeaa3785580e035df7a", + "rawBytes": 14934, + "rawSHA256": "DE098CE9A3F2CCF498D3677C3F00AB68C9D87730AAE35BB05E2E0A0851C3DE57" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/draft-producer-summary.json", + "mode": "100644", + "gitBlob": "2087c3f7cd3e9cbbad3c6287713a17bed6a90071", + "rawBytes": 533, + "rawSHA256": "3F684196ED68D147CFCF0CD3CA173E22D5904529A4A37137CF0BABFA547ED506" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/empty-argument-byte-capture-control.json", + "mode": "100644", + "gitBlob": "746b5b00cfcd20906ff2b89556be053fe1fdb66b", + "rawBytes": 2313, + "rawSHA256": "8CB6D96EF0C1D56914662C5620E7F1E1CC7C374EAFCEB10314C6F317C0FDA21C" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/empty-argument-capture-control.json", + "mode": "100644", + "gitBlob": "1c8c1a1e383540f8d13c4b9e0af30b4dfa3533b6", + "rawBytes": 2209, + "rawSHA256": "86230516F2600704250D2D66FAD5F5C01DDA3D45DD358FA5163484190165D8EF" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/final-field-span-preparation.json", + "mode": "100644", + "gitBlob": "208111f9899f7e87a9c8ab76903b23d7111500db", + "rawBytes": 38263, + "rawSHA256": "58D84DE4102BABC4F0398133F2C45F97BE66B6CF233159872DFF6C183785A71F" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/hash-buffer-benchmark-owned.json", + "mode": "100644", + "gitBlob": "a509277ab2c477afd9198813d8758b9da5446388", + "rawBytes": 2499, + "rawSHA256": "64F568F7CBFB21FD2EA05D426245DCF03B89A86F7ED7FBDE34E5BCEECB791B6F" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/hash-buffer-benchmark.json", + "mode": "100644", + "gitBlob": "768f505b0afed2ecd471397812679a50427e9ee0", + "rawBytes": 3257, + "rawSHA256": "BAE105FE253ABFDD8EC2D9B1C710859C6609AA8EBAB6C40E542138A1F40ED49F" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/hash-small-file-benchmark.json", + "mode": "100644", + "gitBlob": "e40953ea57a6aa7c44baa2404d2c3c87832b2974", + "rawBytes": 61222, + "rawSHA256": "19A5AC6BC0EAF3881767215413DFAC6615329889C3F4E38D2101562C959E9B8C" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/hash-small-file-owned.json", + "mode": "100644", + "gitBlob": "b84a392556361a50bf8da110d09ff543c36d5886", + "rawBytes": 2583, + "rawSHA256": "5763A9A03B6F344D7F8620E2BB45AC6DDE0B7BBCDDDCBC93DA33BA302BF324AA" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/identity-v3-controls-20260912T120225336.json", + "mode": "100644", + "gitBlob": "d1b78d71be00f6fb70ed2c310f5cf62441e88991", + "rawBytes": 1992, + "rawSHA256": "7367E3FD75B3BD7C8765DEC88DA9AE4B36FA14560B1707E3771B547A6426E9F1" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/identity-v3-controls-20260912T120438830.json", + "mode": "100644", + "gitBlob": "682adc55652aa5aad612e5de94d61017d5a36e97", + "rawBytes": 24996, + "rawSHA256": "ABF91F122E4266ECDEE2252755769874C3DD9CB92EDF71AACA01867B11242C4A" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/identity-v3-controls-20260912T120609886.json", + "mode": "100644", + "gitBlob": "1b72cbb15f8cd98d728e718f988ee7ef9b200487", + "rawBytes": 1563, + "rawSHA256": "4D5A6D18B0E74B8684440547E0ACCB10FAFEA8B4144E4C17129C10E248A0F2CE" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/identity-v3-controls-20260912T120637882.json", + "mode": "100644", + "gitBlob": "680a11638d1eaa9a437009e8c48b760e1b8142e6", + "rawBytes": 15253, + "rawSHA256": "BE853EC667DE2DEF2694DDB1CE5F0F25D0B9BAD6A6191CDD82031B32BA5C94DF" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/identity-v3-controls-20260912T120706093.json", + "mode": "100644", + "gitBlob": "8ff3585417100f70076b723fb9cc0572b5acd42c", + "rawBytes": 2496, + "rawSHA256": "19C94FD2EF575B3B2AC0FC04F276185A5C12A6246FDA7BF8F99068F7538D6028" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/identity-v3-controls-20260912T120722287.json", + "mode": "100644", + "gitBlob": "14edf2705a43fd15538b50719f74c9a4dcd5e003", + "rawBytes": 1661, + "rawSHA256": "660F4C60340033EA224EFC5E6D6779B2F6AD40AFB8B29F410AE235BBFAD1D4D1" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/identity-v3-final-wrapper.json", + "mode": "100644", + "gitBlob": "a7cf9e13ec3838790beba3b99061994b03301cd2", + "rawBytes": 1129, + "rawSHA256": "F1034B215937BA41AFBC4A7495BB060087E284750CAB4EA3F60FF0B8A77ABF95" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/property-span-all-draft-check.json", + "mode": "100644", + "gitBlob": "5396bc0997f963ff3bc68789b61ae8d9f920f564", + "rawBytes": 33001, + "rawSHA256": "D9C0B544446B8B439CC445C0A0CA15A1F10A3355D12854C15C73C68A21D602F8" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/property-span-draft-check.json", + "mode": "100644", + "gitBlob": "a6ddfd38e67460cbb9d870b69cecb376a2cafd3b", + "rawBytes": 10505, + "rawSHA256": "C8D59B7851454D93ABDEEFD8CAF7C030D58C7967A4C56E2E3646618221D0E49F" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/raw-byte-capture-control.json", + "mode": "100644", + "gitBlob": "276b7a70b048bb9c6f36e4c14ec0d0e9a88b1b48", + "rawBytes": 2177, + "rawSHA256": "22F86D139B9A5BC99BB64075B0AC5951CD2417704E2381E47E2E018543865901" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/startup-packed-rmq-native-cpp.exe.json", + "mode": "100644", + "gitBlob": "72711ad9b04fbaba83c061a1c14e648fafe38df4", + "rawBytes": 3331, + "rawSHA256": "AEDC6C3534AD0DC03EBBCE629748330A4FA80A0A2588793F2781E58A6C53F21E" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/startup-packed-rmq-native.exe.json", + "mode": "100644", + "gitBlob": "a5d0e59b6fb52ca0edcd7a7bf0e0372588647cf3", + "rawBytes": 3313, + "rawSHA256": "89482AE63CC190F1379C76FADE26820DA142BB8FAEBB15FBA72DC48B0A9B5757" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/toolchain-mismatch-actual-v2.json", + "mode": "100644", + "gitBlob": "ecb79f5bd4f052f42c32b7c9cad9597fd822c469", + "rawBytes": 2641051, + "rawSHA256": "AF8459AC7377D3353E5EA96D362A16EF4309D8A2F2A93B9EB1820ED9594BDA11" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/toolchain-mismatch-diagnosis-v2.json", + "mode": "100644", + "gitBlob": "cbc8c6bd8ba3f92621cad0587313176a905d3e28", + "rawBytes": 30725, + "rawSHA256": "A2235AF69884771CAA39B9C9F0B74DE1CBEBDD4743FFDCBE73ECCAB27C3A6DF9" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/toolchain-order-delta.json", + "mode": "100644", + "gitBlob": "39c96869b3569aae39f67e7718849bfc4416b561", + "rawBytes": 7124, + "rawSHA256": "3B0A9A92D9BC501E8E4FDA443B2246757ED11FE128864098F7D372D489E5D229" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/witness-independent-inspection.json", + "mode": "100644", + "gitBlob": "c6a57c4c338d72baebedbb7da4ab3830ff225580", + "rawBytes": 9790, + "rawSHA256": "29F34CA018DBE14D142AD56DADDE96039487D9B34E6A14BBFAB45C31862E5190" + }, + { + "path": "docs/internal/extensions/native1/commands/audit-contract-extraction.json", + "mode": "100644", + "gitBlob": "caa7945b0a9fb76c403e27844e7e456a27dac013", + "rawBytes": 1398, + "rawSHA256": "D252CD1CD73C44C3EC3EB610B1042455488BD8A384E1B82E03DB28A862B0D306" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-bounds-01.json", + "mode": "100644", + "gitBlob": "efa05dcb931d2d9aa65c6462797d432d9188acd9", + "rawBytes": 6054, + "rawSHA256": "5F0F7D0561FB11237D3EA83F0308C43369F086D9DCC95A2733A8045B78E64828" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-bounds-02.json", + "mode": "100644", + "gitBlob": "39310162b4c11cb93e4d37d4d34d0f673a7ac31b", + "rawBytes": 3199, + "rawSHA256": "BA374D694A6394A152ECC67B509B00C772D7CC8BBA65A07BE2067A13FF6DCB93" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-build-20260912T111100924.json", + "mode": "100644", + "gitBlob": "3ced7ad136958437920d00f6090baf8e5b429ee2", + "rawBytes": 5692692, + "rawSHA256": "8486C0C039365DE086E651FBC1686531D1DCA4F000C75C62BE6A65E70E6C53EB" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-build-20260912T122050486.json", + "mode": "100644", + "gitBlob": "665b38c6255eb2da1c8d6cebea79f4b29d04c49b", + "rawBytes": 2827735, + "rawSHA256": "C62F6EC8198AF6636D0DDAE410CB6D122F520F784C8CEAA0FF69F2F539252BB7" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-checks-01.json", + "mode": "100644", + "gitBlob": "d0279a328047eaace7f465f9e51d1e20f2e7f632", + "rawBytes": 69557, + "rawSHA256": "9FFD5314D0505914E68580ABABB3867C93732929A4703BAF0CBB75914692C080" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-checks-02.json", + "mode": "100644", + "gitBlob": "8c96a9a12ad916ed14def10610bdcb7babbea1c6", + "rawBytes": 64553, + "rawSHA256": "A059B23E8873E407583578D1EF839615F35529225829106D6FF82614AB6DC39B" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-checks-03.json", + "mode": "100644", + "gitBlob": "13623c1fdc028ca3803b5699645d27f63236d248", + "rawBytes": 24568, + "rawSHA256": "A87CE7B52B29152565E0DE733FF43433D3980A6074D478F96690E00F5698051A" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-checks-04.json", + "mode": "100644", + "gitBlob": "00e474c8316e56e636d969b1926e98b6042b11cf", + "rawBytes": 17971, + "rawSHA256": "C982C3A3B379807A63D530B2B93C8E4BDB7E2957C2FDDEA2D42163B632BE1161" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-checks-05.json", + "mode": "100644", + "gitBlob": "6063d8d1bf9c067e931d05041a9f4ff9ee69b0e3", + "rawBytes": 7644, + "rawSHA256": "776FA98083C7470CAF1A437649F5110A985300D48BDEB1999C1479A4C0DEFF3A" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-checks-06.json", + "mode": "100644", + "gitBlob": "fc8dc5f20e810732c66a63b3ada1a6babccf3ea6", + "rawBytes": 6741, + "rawSHA256": "5A76F1353958B4594DAED08A700604C44EBBFDCDC803384DA1BD20E6CD36E5C2" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-codec-02.log", + "mode": "100644", + "gitBlob": "027068d19f7ebc8513ae861b56bdd6bea2a6cf90", + "rawBytes": 10849, + "rawSHA256": "C43248BB7E6199FE5C23B46BB092005004B2E548D144DA6F9D9EE42470A37039" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-codec-03.log", + "mode": "100644", + "gitBlob": "694a7ea331980e652579416f5be98a360642027f", + "rawBytes": 703, + "rawSHA256": "D4F080C782E70768B9B4ED4EE6F444FEB2532E2AE6611B18E64AE7FFAE2B042A" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-codec-final.json", + "mode": "100644", + "gitBlob": "a2b5c0cefc65e24eecda8a96e5685b9c4d43dbb2", + "rawBytes": 1717, + "rawSHA256": "58C84CFB005A4100DD2AD0B0F499721F260E2B736C722B6CD01E589286E5D066" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-image-01.json", + "mode": "100644", + "gitBlob": "597979ef9a23525a53b96149dee23416a211d832", + "rawBytes": 35990, + "rawSHA256": "230B0EBD39B5AA079C248EE3435E5DBB8133E69851E217C2146C04F1144AFB15" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-image-02.json", + "mode": "100644", + "gitBlob": "4633303c35e579e6ae4fb00b13de24a7c24db8a6", + "rawBytes": 4908, + "rawSHA256": "0E1EDD93B4CFA9E78C3A70CC5F11457C1DC8947AFDDB750B6D030BA8423FDEAB" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-image-final.json", + "mode": "100644", + "gitBlob": "5442e49bb00fefa831a07dc8f2ef855bd83745b5", + "rawBytes": 4913, + "rawSHA256": "E7C5D827F4F78602F28C7C7D589E00399D4319B55ED027B622E870C1B35A7AEE" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-v3-integrity.json", + "mode": "100644", + "gitBlob": "943e33c5325b6c21258274217e7d670e5b592421", + "rawBytes": 5730, + "rawSHA256": "34C2FFACB61D00B49C2C3B9AD2976BC23C43B97B86E3A19AA5F0BC1851EBE2F0" + }, + { + "path": "docs/internal/extensions/native1/commands/build-20260912T072514256.json", + "mode": "100644", + "gitBlob": "027a9462093ae5bd2907b68be5a0a8ff4b17b885", + "rawBytes": 11309, + "rawSHA256": "CDFA19D6BFE316D21D38C2018EA1F2391A87A1D3E55018978ABCA5FA8573C24D" + }, + { + "path": "docs/internal/extensions/native1/commands/build-20260912T072850050.json", + "mode": "100644", + "gitBlob": "f8ef49c956b626beef871162c75eb96924302149", + "rawBytes": 13518, + "rawSHA256": "716D8F31995FCB1FC1FA95BE385ACCBE0E6AE3D6640FBEB70436C1F3CFDE7B5C" + }, + { + "path": "docs/internal/extensions/native1/commands/build-20260912T073559261.json", + "mode": "100644", + "gitBlob": "bf7fb224703dcb2e37937883368a8cac59f4e50d", + "rawBytes": 18304, + "rawSHA256": "2FADA50AF95C282E6D240262497DE7D8A23DD1E70E01CD94DCBB22FB9EF0B5A2" + }, + { + "path": "docs/internal/extensions/native1/commands/build-20260912T074002536.json", + "mode": "100644", + "gitBlob": "35280ea77c463763c86c71baaea3b233eff8aa01", + "rawBytes": 16037, + "rawSHA256": "91738BE73B9D27EB8A6B6C0C15133FFA8FA419FB429DC9641108C8E1C60F616F" + }, + { + "path": "docs/internal/extensions/native1/commands/build-20260912T074238729.json", + "mode": "100644", + "gitBlob": "e237565f9856312c7f10583f031633b0d6114c99", + "rawBytes": 17512, + "rawSHA256": "B08FD8BDEA1BCF2DB8C2979A50F462E6FE3E8255AD9C7254D08D4D88A04840C6" + }, + { + "path": "docs/internal/extensions/native1/commands/build-20260912T080927170.json", + "mode": "100644", + "gitBlob": "adb28ecad7cdf3f9afa9117a2462f7763bb8c1c7", + "rawBytes": 17510, + "rawSHA256": "09A40460D3A0455E77DAE576A772D4167A67E559ACE4FE075FFA74B4914331F6" + }, + { + "path": "docs/internal/extensions/native1/commands/build-20260912T091755276.json", + "mode": "100644", + "gitBlob": "155476a9309744fdfdd008add73910ef375125ac", + "rawBytes": 970501, + "rawSHA256": "518CBBF1F1DDA3446628B653EBE4CDB8FC0A47F89D2F920F36D40CE1245EE82A" + }, + { + "path": "docs/internal/extensions/native1/commands/canonical-01.json", + "mode": "100644", + "gitBlob": "b203543bffe16dc0c56f0743d22d2acad6733fa9", + "rawBytes": 2145, + "rawSHA256": "A2A87A167918E68AA7EDF30DB9AD262E8743819E614CCF265DCF029ECAEB28C2" + }, + { + "path": "docs/internal/extensions/native1/commands/canonical-02.json", + "mode": "100644", + "gitBlob": "531132e7df2386d918f77a0d205401398f495e3d", + "rawBytes": 1866, + "rawSHA256": "A77090B43EF13CCB2773EDA954B134A5EFA7C7744028C4F468A5D5E4ED0CE9E9" + }, + { + "path": "docs/internal/extensions/native1/commands/canonical-03.json", + "mode": "100644", + "gitBlob": "2ccf00150cf52a90488f59369bc71daf67056732", + "rawBytes": 1384, + "rawSHA256": "41532868D2D6E9189E94C2C0F006B6D784220DF7B42C5A154D250255CA8EDEF2" + }, + { + "path": "docs/internal/extensions/native1/commands/canonical-04.json", + "mode": "100644", + "gitBlob": "8b9ff18a4afadeed22fe7ae8e4fd2ac0744ca0c4", + "rawBytes": 893, + "rawSHA256": "29C28D07C986E2045812E3DC24FF023ABB05F3068F386D68A86F4FBBF7218FC5" + }, + { + "path": "docs/internal/extensions/native1/commands/canonical-image-01.json", + "mode": "100644", + "gitBlob": "7eeb0c2ac7804c3ee625e78315ec800541c74859", + "rawBytes": 914, + "rawSHA256": "A16C289A697D602A40FD8D43CC83805CEC4AEC2B717C125299CC1BE9BE9D561A" + }, + { + "path": "docs/internal/extensions/native1/commands/capstone-01.json", + "mode": "100644", + "gitBlob": "43fc416c31e9cc4e1fe3c19952eb824ba6c010b1", + "rawBytes": 2182, + "rawSHA256": "C8A9C7F515E9D83A4A838B9CA32960231B6492C18DA6B8E9FE6928C903007A26" + }, + { + "path": "docs/internal/extensions/native1/commands/capstone-02.json", + "mode": "100644", + "gitBlob": "fdbcfad71717c0364e47ed07dc81e98683f4d26f", + "rawBytes": 890, + "rawSHA256": "C1FB7B2B933E77A6B20CCF403E5D703A847ECD9644A0D76613C6575490F36186" + }, + { + "path": "docs/internal/extensions/native1/commands/capstone-03.json", + "mode": "100644", + "gitBlob": "6ffacbb56b9b9c53b2c63eecf95a7a0d2e7e12c9", + "rawBytes": 889, + "rawSHA256": "79C760E7B620EAE8B914E4676268601A04C04400C639D2E58162A08E6F63D648" + }, + { + "path": "docs/internal/extensions/native1/commands/claim-current-report-draft.json", + "mode": "100644", + "gitBlob": "5786a7a79202aecad5199f80e23d94bc90255f52", + "rawBytes": 1110, + "rawSHA256": "5D6717A693063C92451AA5BA0070F253893DB8B329EE238114CEB1DF3A1679DB" + }, + { + "path": "docs/internal/extensions/native1/commands/claim-drift-native-readme-fixed.json", + "mode": "100644", + "gitBlob": "43227ea215e360a251effd9c37281b35250d6257", + "rawBytes": 1013, + "rawSHA256": "DAFE8EF920D080A8D949F947B5272D60C398973EFB581AF3B93F474DA6213E52" + }, + { + "path": "docs/internal/extensions/native1/commands/claim-drift-native-readme.json.gz", + "mode": "100644", + "gitBlob": "83332cc415c43d07ae5da8ca434d7bae713b08e5", + "rawBytes": 621, + "rawSHA256": "13C39FCF08BDD46E3FDB735A57244E9D087220BA59433746BB20A0DD849FFBCD" + }, + { + "path": "docs/internal/extensions/native1/commands/claim-drift-packet.json.gz", + "mode": "100644", + "gitBlob": "745ad9f58c2db54286824e555afccd14224e8d43", + "rawBytes": 1558, + "rawSHA256": "1C7D2F500130E861CA6288C32739533B449956C19A130EE85B8CA78D346A8085" + }, + { + "path": "docs/internal/extensions/native1/commands/claim-drift-report.json", + "mode": "100644", + "gitBlob": "8444768244cf7062281d13c2aa2484a9173a0cbc", + "rawBytes": 1047, + "rawSHA256": "96084C9E3458CFF2AA8EAA579A9FF19E7EF07EFFBD3AE510693AC6A4036013D2" + }, + { + "path": "docs/internal/extensions/native1/commands/claim-drift.json.gz", + "mode": "100644", + "gitBlob": "015a6bd866d06ad9885968c4605cf00af80739bc", + "rawBytes": 1165514, + "rawSHA256": "6FD28FEE71221A7361929A73A31F4C87369031CE06168A5EA017DD921FD62FF4" + }, + { + "path": "docs/internal/extensions/native1/commands/claim-drift.summary.json", + "mode": "100644", + "gitBlob": "29ac03a67b49a786904c15a2b09154e7edd46115", + "rawBytes": 939, + "rawSHA256": "22DEFE87BC6B2F5844037BEBEA7AE766372849629413209671F9464E2E63B80E" + }, + { + "path": "docs/internal/extensions/native1/commands/claim-native-readme-fixed.json", + "mode": "100644", + "gitBlob": "1a02deb8a709d2614794cb8a1ce15674cf11e279", + "rawBytes": 998, + "rawSHA256": "8BA05507455F7E0DACCD6E3ED4F5B59421A7928B9DD92FE9F22E53A5F8EF3CA4" + }, + { + "path": "docs/internal/extensions/native1/commands/claim-native-source-checkpoint.json.gz", + "mode": "100644", + "gitBlob": "d7a77d4310b420f0316fe60395b0d7f4fdcb42d0", + "rawBytes": 5812, + "rawSHA256": "3677A12060580E070DE15972EDC4C7E562DFD82D2BA56FBAAFA1CA86AB518386" + }, + { + "path": "docs/internal/extensions/native1/commands/committed-diff-phase.json", + "mode": "100644", + "gitBlob": "2ce215bf8bf63d030182734810aae05b3cbf1402", + "rawBytes": 698, + "rawSHA256": "9A77C15895AC6ED8F7C43E73448782D7816DCCAB6A6FB6BEA2556FB0B5CB2CCC" + }, + { + "path": "docs/internal/extensions/native1/commands/contract-01.json", + "mode": "100644", + "gitBlob": "9ebd0b3336e6d121476a265366bda717ceac8d7e", + "rawBytes": 817, + "rawSHA256": "F2129745A97A78C844CC7671E1E88AB681D69378CDD9A8FCFFB9613E7D4572CD" + }, + { + "path": "docs/internal/extensions/native1/commands/contract-02.json", + "mode": "100644", + "gitBlob": "8256ac56ef17f10a47a0f7f8f8174e206348df6b", + "rawBytes": 817, + "rawSHA256": "F58F85AC723523AAEC9131AFB175762665CD539379069C20F61F35DA560D6B58" + }, + { + "path": "docs/internal/extensions/native1/commands/contract-baseline-01.json", + "mode": "100644", + "gitBlob": "11386d5fea9aff9d0aaf3bb559b3e8c298a6a7c1", + "rawBytes": 1656, + "rawSHA256": "B75AB7AB72EFA0128B2E88C68BB29509D1A1A891AC9E4307AD7D5387B0BF5FC5" + }, + { + "path": "docs/internal/extensions/native1/commands/contract-baseline-02.json", + "mode": "100644", + "gitBlob": "081a0480bccf08737d6d6166dcd328adb9acbd48", + "rawBytes": 975, + "rawSHA256": "5B5B691636626F3A91B1CBD2F8815E45569D2C7C65DB1C5D747D2357E0F56F3B" + }, + { + "path": "docs/internal/extensions/native1/commands/contract-controls-all-01.json", + "mode": "100644", + "gitBlob": "8e2b00704346a975db7dca1f78836e08e4b9456c", + "rawBytes": 1872, + "rawSHA256": "68AB2A0A1092EC8CB70FAABBE8692B84C2358099AA80D339E5DF3B26F5531005" + }, + { + "path": "docs/internal/extensions/native1/commands/contract-field-n01-01.json", + "mode": "100644", + "gitBlob": "e066bbde6f2150edaada2e3cc1c37e35a4e7309c", + "rawBytes": 979, + "rawSHA256": "1D02AD7662043E8336DAB9FA5B863ED26AB1B03A51060FA17BDB3DA66416B246" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T075336106.json", + "mode": "100644", + "gitBlob": "f6e5593755bc5247a7c306066b98248cbb8e4676", + "rawBytes": 1489, + "rawSHA256": "F142F9FB559C07E7B0DCBE79458E7B4AAD0D6F3911F2E2DFDE6903EA93E7B6DF" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T081542413.json", + "mode": "100644", + "gitBlob": "a82cd72f8848b2880cc6249a162f8b2c6baa6533", + "rawBytes": 1489, + "rawSHA256": "E13681A3D3CAF0E317E65F8667AA47C06B3734DD63FBF785293A5341EB27FACD" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T091008993.json", + "mode": "100644", + "gitBlob": "fc878aeffc1e0dfbd26d5e27104cd78df47a6d1f", + "rawBytes": 3705, + "rawSHA256": "C7A84F1AAB452D7C00D86C45FC2359CF2B364609C1A507F9081D8F91358CB9C6" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T091026831.json", + "mode": "100644", + "gitBlob": "109c661ad194fd7583d5e5ab944c59976d0bea19", + "rawBytes": 4039, + "rawSHA256": "64CE34453F0F45CA745B5F3C659ADA5D39FD560ADC1973CD63CF540159E7B04B" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T091036366.json", + "mode": "100644", + "gitBlob": "5021cb241399a19ef75e3c823cc0cc2cd4d351ec", + "rawBytes": 4039, + "rawSHA256": "BA31DF84823C979D8E4618CAA41B5E7348D410AA71F2776277AC95F8C2FB20B7" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T091459085.json", + "mode": "100644", + "gitBlob": "c3bff1d4a3961f6a3b4056b9e4bb88d541ef63c8", + "rawBytes": 4467, + "rawSHA256": "3F6C3E2D39D6A5CCADF2E0F40F6A7FC7DF52AFAC2D9E5BA45778582157329770" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T091719835.json", + "mode": "100644", + "gitBlob": "af121f92448ff16ab7194e59ae48acafda0813dc", + "rawBytes": 4549, + "rawSHA256": "A31C7AEF2CEB3D1660EC02DF775EC37BFD707AE96E78F22D218B7E8403BFC869" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T091847484.json", + "mode": "100644", + "gitBlob": "44adec12f968c014ecf440d248696fad7574d7bc", + "rawBytes": 4494, + "rawSHA256": "C2650BE432ABD4F5D7AC3A05ECD540B250BEDF2E052EC5FEF1F3E5D837EEB84E" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T091900870.json", + "mode": "100644", + "gitBlob": "bee88d4f509b8a6f42eb4d4a6c0daea3f5cf0aa9", + "rawBytes": 4549, + "rawSHA256": "16AB16B81CAF93DEE6FA46A21C7CEEE4DF06A896D2B9B4CE605A780F4A9515CF" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T094238749.json", + "mode": "100644", + "gitBlob": "52e9bd7384a646a1ba2f9d9aeac0a97565a904d5", + "rawBytes": 116103, + "rawSHA256": "30C8F47E755E1F596816E7CDCC88C373EB7BE6AC9AE5DEA0391A5BAC7CAE8C66" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T094700539.json", + "mode": "100644", + "gitBlob": "d0df86b610102eff98154b8f48c76028ff2f9099", + "rawBytes": 4692, + "rawSHA256": "065C71B31F95F0ED44F56E07475F11F5F7D2AB7BCFEE956D09DC2991B5D93689" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T094711304.json", + "mode": "100644", + "gitBlob": "3bb10cf434d424a2604e459bd0febd84e866265c", + "rawBytes": 4692, + "rawSHA256": "9C5DBDF25A484ECBD183A9EDF42F234A2766D0B60F0B4092C2226986A57975E2" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T100023269.json", + "mode": "100644", + "gitBlob": "7db16ed953a4903110842c6842554df03222b57b", + "rawBytes": 126710, + "rawSHA256": "2F81170ED3D368B2B0ECD87343C9BBF6CCCC4A284B3ECBAF0C94E2EEFE6E8679" + }, + { + "path": "docs/internal/extensions/native1/commands/cpp-build.json", + "mode": "100644", + "gitBlob": "35545f754dfa7bb135772ad0e876f73ecbbb4446", + "rawBytes": 825, + "rawSHA256": "AF65DDD8C7218E4A314B7DEDBBA4EB201949D021AEF05C408AABAB406C7FBC65" + }, + { + "path": "docs/internal/extensions/native1/commands/cpp-import-library.json", + "mode": "100644", + "gitBlob": "030f734b2918d4dff32efb00e39841c8ce30a23d", + "rawBytes": 1053, + "rawSHA256": "537450226645A9EA017795E8147B6E31EA2FE715FB187AD7D01F0621C48C747A" + }, + { + "path": "docs/internal/extensions/native1/commands/cpp-n9-full-final.json", + "mode": "100644", + "gitBlob": "362786874bab9290c3751a1291037bd5a797bea7", + "rawBytes": 14727, + "rawSHA256": "F5B341434848A0D7EBF6C77B9717557BC204B8E36A760802C5AB41673A94163E" + }, + { + "path": "docs/internal/extensions/native1/commands/cpp-n9-full.json", + "mode": "100644", + "gitBlob": "cf35d32da34f2562def188367e919aee90bf4acc", + "rawBytes": 14719, + "rawSHA256": "7AFE9992E7EA59C424BE191E5C69E481C45BA642684CB358F9E47C760076FFB5" + }, + { + "path": "docs/internal/extensions/native1/commands/cursor-01.json", + "mode": "100644", + "gitBlob": "1fb5cccf299a8e6083fc32d83563dc92e206126e", + "rawBytes": 31789, + "rawSHA256": "975C8B63985E2CF68D31175A3D394EDD8DE757FD7B355EE3FFCBCDA2F9190686" + }, + { + "path": "docs/internal/extensions/native1/commands/cursor-02.json", + "mode": "100644", + "gitBlob": "09ae7dacd1a8be658d49cfb4943134d5e908c758", + "rawBytes": 7669, + "rawSHA256": "453F59A5FD780D29A3374A23037ED56DAB1DB2C1FA8F36CE85DDDD4226B7CAFE" + }, + { + "path": "docs/internal/extensions/native1/commands/cursor-checks-01.json", + "mode": "100644", + "gitBlob": "05b955c77f62b75069e19a53ec468b26b088d9bc", + "rawBytes": 27427, + "rawSHA256": "33DFD5B67DFBFBC32BCB8723AF453C320835C8E8CE4C1DF262C6EB853882DABC" + }, + { + "path": "docs/internal/extensions/native1/commands/cursor-checks-02.json", + "mode": "100644", + "gitBlob": "f18a129af7b5c5b41828e0b033b1d5ce0b33e949", + "rawBytes": 3764, + "rawSHA256": "3CDF88BBA30D632AF09CABCD10CF1D7C20F1CC615AEAB0B69CE70B364A863067" + }, + { + "path": "docs/internal/extensions/native1/commands/cursor-core-01.json", + "mode": "100644", + "gitBlob": "d7b7afcd9c17161627b09b19b8d3878ea8b04f75", + "rawBytes": 34569, + "rawSHA256": "6478DEE3397B27D2AAD897EF816559C93753198ED68ECB49CE0A0DAF6BA2A801" + }, + { + "path": "docs/internal/extensions/native1/commands/cursor-core-02.json", + "mode": "100644", + "gitBlob": "3e149f566c06d99153fa136a3c88afb54dd09cb1", + "rawBytes": 18102, + "rawSHA256": "D091919F9F2EB30872E90F8E57A0AA3E616243E8C4D089F4EC28686A9B016E20" + }, + { + "path": "docs/internal/extensions/native1/commands/cursor-core-03.json", + "mode": "100644", + "gitBlob": "7f59a15d2d1034c8185b39027bdb71e6d8238b13", + "rawBytes": 9149, + "rawSHA256": "7C6289F1ECF7A20F8B832D5C458AEE5DE46597BDBFD28A50BF3DB15EE8F68F66" + }, + { + "path": "docs/internal/extensions/native1/commands/cursor-core-04.json", + "mode": "100644", + "gitBlob": "dec441e107455b5a61e796731b9d7bbfb9ae3229", + "rawBytes": 5467, + "rawSHA256": "4D62B4866F3646C63974AAC450F73E4B74571DC7F1BFC512A9857B30DF0C0F26" + }, + { + "path": "docs/internal/extensions/native1/commands/default-cache-validation.json", + "mode": "100644", + "gitBlob": "ebc948ef80cb3676e8a0e11d014ce02b9d7b6d30", + "rawBytes": 245760, + "rawSHA256": "8CA79F5DA6C1CBBFBAD7F5AE895D86F5BD5060F589BE72D4CBF8B3AD8D7C9C5D" + }, + { + "path": "docs/internal/extensions/native1/commands/design-final-candidate-commit.json", + "mode": "100644", + "gitBlob": "7c43253af1506bbf280b1506ef1851ceb04e09ac", + "rawBytes": 1189, + "rawSHA256": "403C66C0684AD1F896C9AC6306E962988AA79E2F085CB1810AFAD31FB2EF36EF" + }, + { + "path": "docs/internal/extensions/native1/commands/design-final-path-precheck.json", + "mode": "100644", + "gitBlob": "cd36a59cadb0f0ded72d68d9ca5226db0229965f", + "rawBytes": 1054, + "rawSHA256": "01842A48B4D6DFA6436F91CE5FF730470C367E2304D5BABB56FCFC702278A2A3" + }, + { + "path": "docs/internal/extensions/native1/commands/design-native-source-checkpoint.json", + "mode": "100644", + "gitBlob": "d741eb4bc0dbb7c7bd6305ca0b4410065f8faf0a", + "rawBytes": 1091, + "rawSHA256": "36527457E222DD9B43BC098621BF8B104BFECEF8DF8F68F35507BEA6BE7AD293" + }, + { + "path": "docs/internal/extensions/native1/commands/design-phase.json", + "mode": "100644", + "gitBlob": "8c248ea7c85b16b5a487828451f7fd7940dbf422", + "rawBytes": 4866, + "rawSHA256": "DAB5EFEB67DE1EA2931B8532281D9722EC7BBAAE12D61516EE8E685BEC6F96ED" + }, + { + "path": "docs/internal/extensions/native1/commands/entry-01.json", + "mode": "100644", + "gitBlob": "4badf57ff474ce4629593bfbb4e31f8f4af454b1", + "rawBytes": 878, + "rawSHA256": "70FE462AB91F374E65DE034A7FC7E68BD8BC06FCA38DA145D8B2E47F0529BE65" + }, + { + "path": "docs/internal/extensions/native1/commands/exact-types-01.json", + "mode": "100644", + "gitBlob": "477a51194813d6e3c3bfa633b42c3d63088ee63b", + "rawBytes": 3382, + "rawSHA256": "4ABB38C5871334B8E568757FD434A7B6885EDC6AB610D96BBBE0BAA930AF0F6A" + }, + { + "path": "docs/internal/extensions/native1/commands/execution-01.json", + "mode": "100644", + "gitBlob": "ea40e446472ad8e1cd365cfe640ee28b3b3c8544", + "rawBytes": 2624, + "rawSHA256": "0C85343488D3110FDB123CB47B1DAF9267AF38F8E30A4D3F0BE7E481BBEADEC0" + }, + { + "path": "docs/internal/extensions/native1/commands/execution-02.json", + "mode": "100644", + "gitBlob": "ad2ca7cc98c8ae5cdbfa33ab4251450b912b1be5", + "rawBytes": 894, + "rawSHA256": "067229AD45C1764D903242847F80AB60A09291E1177BF234F61424B79E89BD12" + }, + { + "path": "docs/internal/extensions/native1/commands/execution-03.json", + "mode": "100644", + "gitBlob": "d73d1fc6fd3232bc9d7b87ba65111f84263ea34f", + "rawBytes": 894, + "rawSHA256": "A1B1CBD3157DB3441D0F3DAECA627583753A6881918A9BFF0B063D545CBCBBB7" + }, + { + "path": "docs/internal/extensions/native1/commands/final-claim-surface-inventory.json", + "mode": "100644", + "gitBlob": "cb589daac0c8037b581880d78353de4b900d94a0", + "rawBytes": 43648, + "rawSHA256": "C228D2A29EE3F860DB2A4B803F3FBA0C362FCC0FFD4F271827E7DCB7D030757D" + }, + { + "path": "docs/internal/extensions/native1/commands/final-claims-process-command.json.gz", + "mode": "100644", + "gitBlob": "b88169b2f7ba939b9ee43431c0d710c1e879c6aa", + "rawBytes": 1353, + "rawSHA256": "471EC10A7974D0BBB805D20FD4D62374611F73210C192E6EE16B2EB1BCB3DDE1" + }, + { + "path": "docs/internal/extensions/native1/commands/final-claims-process.json.gz", + "mode": "100644", + "gitBlob": "0cd0a4d09ea85f8c35feebc42b34c43d68c5307b", + "rawBytes": 22256, + "rawSHA256": "0C50B6A46D0277023FE9635A7D8A8F6C32F3251B54091A66F896911AE16DFA6F" + }, + { + "path": "docs/internal/extensions/native1/commands/final-claims-public-command.json.gz", + "mode": "100644", + "gitBlob": "59c551b04bd6a217e1d06e801dd13dd98736ce85", + "rawBytes": 789, + "rawSHA256": "771F4654B086D65F2A401FDEF3BA7D0E19933ED9F0D5A979EF92787738B49779" + }, + { + "path": "docs/internal/extensions/native1/commands/final-claims-public.json.gz", + "mode": "100644", + "gitBlob": "8fabc5911802f23a31488eda0c09ec75b9a9fcc1", + "rawBytes": 24569, + "rawSHA256": "5D4DB70088AA5FB163C2B7C918CB754F482B03678DCD13ABEDA068D7F96410C2" + }, + { + "path": "docs/internal/extensions/native1/commands/final-default-build.json", + "mode": "100644", + "gitBlob": "4cf9b592b205fad732b779c3453e50d97fcfd840", + "rawBytes": 245718, + "rawSHA256": "0285F7F1F721E8AD4B06F3124D1186120C2AA8DF7E68A4D06D9A6D4D1A731AC9" + }, + { + "path": "docs/internal/extensions/native1/commands/final-design-base.json", + "mode": "100644", + "gitBlob": "7183f522e441d7ca5f58ea0d2db7fb645a17e2a3", + "rawBytes": 1109, + "rawSHA256": "F76498183650F9F487BD445683DE406280D3853C7F449317FA0C295B82DAEA88" + }, + { + "path": "docs/internal/extensions/native1/commands/final-diff-checks.json", + "mode": "100644", + "gitBlob": "2eaa063c93e6699259962f85ecfb36af89c38efa", + "rawBytes": 1197, + "rawSHA256": "4B6D90F35ABB62F76455540005F2A609F32EA3DC88D02643866ACDA9963B243E" + }, + { + "path": "docs/internal/extensions/native1/commands/final-freeze.json", + "mode": "100644", + "gitBlob": "e4ae8611a986e7609f49b06ce000d369d67bb176", + "rawBytes": 2907, + "rawSHA256": "9B16C39CB13CC91AA2437655254AB31F27C6BBFF6C415113DC87B2A0A56A2865" + }, + { + "path": "docs/internal/extensions/native1/commands/final-integrity.json", + "mode": "100644", + "gitBlob": "e8f17e6fe9fd674dd2478d885096988cb1966f13", + "rawBytes": 20221, + "rawSHA256": "71E5D1D9E8A79527D0CE39DCD4C5C5BC3DD45EE527CD0E6825B8261399514181" + }, + { + "path": "docs/internal/extensions/native1/commands/final-metadata-check-command-02.json", + "mode": "100644", + "gitBlob": "b5076a2f6e8f2ac7091c440c4826199174694955", + "rawBytes": 1033, + "rawSHA256": "34263D52C1F34A87F4010333B1725DEE54C52911C235A95F170BA7674B545DF5" + }, + { + "path": "docs/internal/extensions/native1/commands/final-metadata-check-command.json", + "mode": "100644", + "gitBlob": "592ce9384938c430b481ab62fdd87bfd985046d4", + "rawBytes": 1028, + "rawSHA256": "EE987818C166A0AE0CB2B05D96ACC3A377EE0AF7B3852AFC88400A52B6C2808F" + }, + { + "path": "docs/internal/extensions/native1/commands/final-metadata-checks.json.gz", + "mode": "100644", + "gitBlob": "a021ad3a3834ce9b037c538df3933135106307ed", + "rawBytes": 5384, + "rawSHA256": "AF13F3AD9EBD8FDFACE7D7F02DEE89CAD1700D84FA101E15AB120D06850F3C43" + }, + { + "path": "docs/internal/extensions/native1/commands/final-native-imports.json", + "mode": "100644", + "gitBlob": "9a8542eafb7a97f9358ef3c1f0cf402a75e88463", + "rawBytes": 2924, + "rawSHA256": "B2FD1913C4D42BF9FCAC481BCAC45F108DBF687B57EAE54DE9138B0C2FE15DED" + }, + { + "path": "docs/internal/extensions/native1/commands/final-static-command.json.gz", + "mode": "100644", + "gitBlob": "fb1f1ea9f3a5b161b86a7adfe91e08fc63724b8d", + "rawBytes": 1114860, + "rawSHA256": "FB288DCBED23770DC9C45E35BF7A00D8434A064F21ACE1BC8946F93263CE79C1" + }, + { + "path": "docs/internal/extensions/native1/commands/final-text-claims-command.json.gz", + "mode": "100644", + "gitBlob": "484a29b7032308e5076c5772cc97c6ca49f21558", + "rawBytes": 1358, + "rawSHA256": "F9B8E8610C08D3A300CB09BA8112402E060309581C0BA916D08BE8EE6463AA97" + }, + { + "path": "docs/internal/extensions/native1/commands/final-text-claims-process.json.gz", + "mode": "100644", + "gitBlob": "e7eb406d00663913127a8165b206861d11e036a6", + "rawBytes": 22238, + "rawSHA256": "9441834D18427E7653D0157EBC6973710E159AC76128F7F1642FE98543507D30" + }, + { + "path": "docs/internal/extensions/native1/commands/final-validator-import.json", + "mode": "100644", + "gitBlob": "3468ca899fa6614bfe8e56a253d10ebe1ea64c0a", + "rawBytes": 1273, + "rawSHA256": "EEB93871B11D3FCB04346F2CD5931AF460A561449BD0FD0DE040ABA2DA0EF033" + }, + { + "path": "docs/internal/extensions/native1/commands/freeze-before-public-blob.json", + "mode": "100644", + "gitBlob": "e900e1094a35259526360cbbf5b304acbfd6649b", + "rawBytes": 2907, + "rawSHA256": "BD084EEF9F66048CFFD91246C837E009ADC3DF48E072752152794A0FAF87B921" + }, + { + "path": "docs/internal/extensions/native1/commands/host-01.json", + "mode": "100644", + "gitBlob": "d124d4b10973990954f3674d37d9f3a444f49470", + "rawBytes": 805, + "rawSHA256": "40BBC538EFE3BC9763B61AAFCB86E7DDD3F4AEF4BFDCB4F728FF3343FB4707A4" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-20260912T101354869.json", + "mode": "100644", + "gitBlob": "e4145f6d495740cabe42bccbab6d13f84b9a9b87", + "rawBytes": 41547, + "rawSHA256": "F363D6F308F45562DD164EAFF190EFFA1D2CFAD81E331EEC7FEE8CA5CB6D5285" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-20260912T101530710.json", + "mode": "100644", + "gitBlob": "00a7de273312d62a5dd5908b2b30bad9f844da60", + "rawBytes": 351693, + "rawSHA256": "987973262FEA98973124D58C65E547DE1084511621DFF07B42F98154AB7CDD72" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-default-20260912T124121657.json", + "mode": "100644", + "gitBlob": "7fac2326fa031299f3adb60143b8f11f56d78378", + "rawBytes": 39879, + "rawSHA256": "0E617CCA970D58564D56748BD471E70D09E4945F0DBBEEFFD54BF9CF654E4AEF" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-default-20260912T124531692.json", + "mode": "100644", + "gitBlob": "44455d8310637fb331202fad5b4522a30441ca28", + "rawBytes": 272517, + "rawSHA256": "81740862E330845822FC1340E04B24B10545C50927EAC7995E6FA587E79C0935" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-default-20260912T125020579.json", + "mode": "100644", + "gitBlob": "f6a289b0e5d5b4cae9a34f7d581ef10827c11854", + "rawBytes": 663953, + "rawSHA256": "7C9CE0DB64D31F075FCBE16CF150049048E86BACD43B38AFD73C6432164D9A78" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-default-command-01.json", + "mode": "100644", + "gitBlob": "59bd857f4703d13ed79dc57b820f97bb427ee929", + "rawBytes": 1405, + "rawSHA256": "BC4B5338AC4430F9720699067BDE3F81F9E1815D346F1F82D9AA62858C362235" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-default-command-02.json", + "mode": "100644", + "gitBlob": "38f2d52ee49eafbd2ccbdc590b2fe0256c84f509", + "rawBytes": 1630, + "rawSHA256": "5A6D45A3A7E2F7D2AB503DDA9C97DBF77528E4CC14FF423676D7E675DF9AB8E0" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-default-command-03.json", + "mode": "100644", + "gitBlob": "271bcd28d2d962273084ff58a64a4a723d20b7b8", + "rawBytes": 1918, + "rawSHA256": "E82A25C7F15FB900A3CEA534B1BCA7E2239505B0B62C54CD70FFE7768D787AF0" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-default-parser-02.json", + "mode": "100644", + "gitBlob": "690433fa81a63decad9d9f1d7fe4e53db066b9a5", + "rawBytes": 1509, + "rawSHA256": "AE0D2D0FA597B5EBCB627B4195B2BE610C44777D316F476715DBCADEDA39F04F" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-default-preflight.json", + "mode": "100644", + "gitBlob": "b7bf9ece5da39cc33895dabcc255721fef42541c", + "rawBytes": 963, + "rawSHA256": "319D11EBDAA71EE8EB324A7D74C588968BFC6C472AE658F1B13330D5034F6E80" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrated-lake-check-01.json", + "mode": "100644", + "gitBlob": "449cb44d580b909ee7b65d9fc7b87710ba915aad", + "rawBytes": 204092, + "rawSHA256": "5A3E710D6CEB6F59B4F9BF5A99E7EEA5585597FF226EB631E47AE0E8F41FA73D" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrated-lake-diagnosis-01.json", + "mode": "100644", + "gitBlob": "8db73bc2b01b12ed26ec82dbf95d94b8073c7d82", + "rawBytes": 519294, + "rawSHA256": "58C1D0DC8EC0CE78F720AD27A21536760599432B66EF22026179226CA76DCFCA" + }, + { + "path": "docs/internal/extensions/native1/commands/hygiene.json", + "mode": "100644", + "gitBlob": "21be97def5fe407f40a05357110d1b2f71889480", + "rawBytes": 158, + "rawSHA256": "7A07CBCDAEB5BBBE1B3DE4553A43E067463C01CD59DFB5A20B443B477552001A" + }, + { + "path": "docs/internal/extensions/native1/commands/identity-controls-20260912T091130182.json", + "mode": "100644", + "gitBlob": "9a770017877cf45d548a2af264724dae6dc12484", + "rawBytes": 3083, + "rawSHA256": "A20567EDABFEF552937D49B9DFF216825C7E6CBA5204F1262048CCC99070BE38" + }, + { + "path": "docs/internal/extensions/native1/commands/limbs-01.json", + "mode": "100644", + "gitBlob": "f1404af42fa187f09ae3934bd9388b0e81f14a63", + "rawBytes": 1500, + "rawSHA256": "FA6B4FC3071986966E7A40A2AE0D0AC03281F594AA089E0BEB18EDCD3A262EDD" + }, + { + "path": "docs/internal/extensions/native1/commands/limbs-02.json", + "mode": "100644", + "gitBlob": "e56abf4c8c9d4d8b03e727fe95dbead2fa323fce", + "rawBytes": 889, + "rawSHA256": "9E9A382AD2410C5CA1A98E327C8FFFE60829E550CF360D9FC01C5685A7E47113" + }, + { + "path": "docs/internal/extensions/native1/commands/limbs-03.json", + "mode": "100644", + "gitBlob": "51cc8bdd79e88fd37a24bc562fcb3b38135f254d", + "rawBytes": 2361, + "rawSHA256": "CE160E1652942F38DB1CEF9677F8F2ADB3B197E5904A3D95C2F226E31CD1E0A4" + }, + { + "path": "docs/internal/extensions/native1/commands/limbs-04.json", + "mode": "100644", + "gitBlob": "bd9e9019158ca5d6b58f61fd8cf1e217de7e3116", + "rawBytes": 878, + "rawSHA256": "88EE4B7D9E50AE9B37E3EF5BCA15FB053462C5125788202B9CDA572825BE2939" + }, + { + "path": "docs/internal/extensions/native1/commands/limbs-checks-01.json", + "mode": "100644", + "gitBlob": "154e2f96038ceb93ef29340355182c564163e837", + "rawBytes": 19329, + "rawSHA256": "EA06111BB1299639F6FDE0380B3B06D819FCA5C323083678882D65B9579F22CC" + }, + { + "path": "docs/internal/extensions/native1/commands/limbs-checks-02.json", + "mode": "100644", + "gitBlob": "2a7c8745f93a5aa2b0840b16b0596315b5acbaca", + "rawBytes": 4321, + "rawSHA256": "68A44E93E81334A746AD7F0A878435A234C429BE046191A257D42E727E0ED5F3" + }, + { + "path": "docs/internal/extensions/native1/commands/loader-emptyargs-host.json", + "mode": "100644", + "gitBlob": "6dcafda5c219e06c9d3728beadf1fc847824d8c2", + "rawBytes": 412, + "rawSHA256": "F636D0113804CF6DF0149F3D923781EA9B73C9DDB6DB061C0A5644A87695079B" + }, + { + "path": "docs/internal/extensions/native1/commands/loader-emptyargs.json", + "mode": "100644", + "gitBlob": "276e6c13b2d048868aba34611e3942c762b7b8f8", + "rawBytes": 310, + "rawSHA256": "AA498BB8431127B128F8489A838F38D0F676095C0974F8D0BA8588973A36B4D2" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-01.json", + "mode": "100644", + "gitBlob": "60ad59f47443bcaea67c8edbe4458753d4e77c23", + "rawBytes": 37354, + "rawSHA256": "CB0D103A24748AD8F393D03AC9CDA8A21F197C10D550D3B6E9C73206C0690D01" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-02.json", + "mode": "100644", + "gitBlob": "bd31a2f0b2f4767325af2da683d52a6c95157ed6", + "rawBytes": 4614, + "rawSHA256": "96842353CE8A33B968092AFF6AEAE27C413EA0C0EE15C93F678A72D2F3D89F66" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-03.json", + "mode": "100644", + "gitBlob": "5017f46ed9c458dc9313181e2a5d4bec33ea1de4", + "rawBytes": 732, + "rawSHA256": "92A31E3966E5C942429D715565AB1101A1B4F86AAB008EC8B5F9470274944D89" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-04.json", + "mode": "100644", + "gitBlob": "9959f026279cbe310489ca9b3276d92c764fccef", + "rawBytes": 10348, + "rawSHA256": "7284595EF24B34D589E2557B744FAEF8310D65BA61F2053A8050ECF1BFDC5BF6" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-05.json", + "mode": "100644", + "gitBlob": "a7b36780860980d18775f70a02f2df8ab9e8f5c8", + "rawBytes": 886, + "rawSHA256": "68A3B8AE4780B28D4AD2850AD8886526B57E6C49C755DA2550C6F638F761C13A" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-06.json", + "mode": "100644", + "gitBlob": "6104079fe8ce0529f4b2762b2bccc264e23e8638", + "rawBytes": 886, + "rawSHA256": "EC21C7078772AEA09F4712A742F0D814B218F4290D5CB62420332BA298CFED42" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-checks-01.json", + "mode": "100644", + "gitBlob": "5418786417e245933e612ac82fdc9a3a0443a7ba", + "rawBytes": 5345, + "rawSHA256": "C6A59D79CF9171CDBA43262E4E843A900679205005F106A2CFC1C91008D9BBBF" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-codefacts-01.json", + "mode": "100644", + "gitBlob": "1739f25579cda4082e26d0eb24cf8100e42d9c99", + "rawBytes": 2214, + "rawSHA256": "F0EF60EBBB8F62814E7EDCB266826C9DE59BB9D9B4E081210467F271CAB80C73" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-codefacts-02.json", + "mode": "100644", + "gitBlob": "d16d029ec9e9de69a42bb257d3e4e8ac9c5bc943", + "rawBytes": 9244, + "rawSHA256": "5121D1B2F99F7048B8940F2713A69DC42ADAD44AED48E5EC920574B40AC7FB1B" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-codefacts-03.json", + "mode": "100644", + "gitBlob": "080028cea7ce79ec72185a1dea2fe9f356c234d4", + "rawBytes": 1874, + "rawSHA256": "B230F552EC24D0E9203C231B1F0432937B1F6D4422EB421B339E23D18B1A7B46" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-codefacts-04.json", + "mode": "100644", + "gitBlob": "c6a035bd855833959307d9b3d88b0c1900935cdd", + "rawBytes": 1693, + "rawSHA256": "DB8A1B4D7615400CCFE4FCC761A56875F60BA31E5893DBABFCDACF702449D649" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-codefacts-checks-01.json", + "mode": "100644", + "gitBlob": "caaf6813892a0abb5ecf4b611647b8a42e1b94fa", + "rawBytes": 1509, + "rawSHA256": "32DEAE513DDD17A82F8ECE515BFDE7850239D9603998CE06A3A860BF7BB6B281" + }, + { + "path": "docs/internal/extensions/native1/commands/metadata-checks-before-public-blob.json.gz", + "mode": "100644", + "gitBlob": "129720d72ce3cfea87104fa8bb0dc94dc4e56273", + "rawBytes": 5430, + "rawSHA256": "414976873974C97840A1FF89454F858FB8D75F06A61704CD91FEAC56D6A07886" + }, + { + "path": "docs/internal/extensions/native1/commands/native-axiom-probe-01.json", + "mode": "100644", + "gitBlob": "8fde9ddf99757e77c6d3270b7ff13cbc0471f645", + "rawBytes": 2220, + "rawSHA256": "BFFE11FC0A82AAA85C2F9F0FFF9718DEC1067C239AC72EC470C7647789F1F22D" + }, + { + "path": "docs/internal/extensions/native1/commands/native-axiom-probe-02.json", + "mode": "100644", + "gitBlob": "f3091d4d755bac910f4a929b9120d0f531cbee92", + "rawBytes": 1230, + "rawSHA256": "AA7DC555DEB6C8A142D5D53BE91F923D5F780E9522A222159E3C21C3779AE058" + }, + { + "path": "docs/internal/extensions/native1/commands/native-axioms-01.json", + "mode": "100644", + "gitBlob": "3029d2095b6931465635451f073c61940f12cc98", + "rawBytes": 861, + "rawSHA256": "E077DFB9565E1E41CC6025EDAB73864BE2968F78A470D7F342747766F8C02D52" + }, + { + "path": "docs/internal/extensions/native1/commands/native-axioms-02.json", + "mode": "100644", + "gitBlob": "78d1f83cece6197b57d545b053816354635eb12d", + "rawBytes": 22834, + "rawSHA256": "CD3E9C38C4FB0388C53FCBD6DFC9C836B6A5EC9FCF485F8E174130C45468BB2F" + }, + { + "path": "docs/internal/extensions/native1/commands/observations-01.json", + "mode": "100644", + "gitBlob": "08119f753459c409eebadd31d45899ac812b1aaf", + "rawBytes": 19966, + "rawSHA256": "19B7DE745AF11653A67E30F94858754DA46ABDA49EB3908FE4ED4935E1C3491B" + }, + { + "path": "docs/internal/extensions/native1/commands/observations-02.json", + "mode": "100644", + "gitBlob": "8270bf00016d8200cdbbf399355758546d088b39", + "rawBytes": 5873, + "rawSHA256": "E8B81CF994D2826128BA72F97D7E0A1638C04B81CF68F04B3798F1DADCF87DF5" + }, + { + "path": "docs/internal/extensions/native1/commands/observations-03.json", + "mode": "100644", + "gitBlob": "010ffee0ade80632c73f09069aed79ee2b529c13", + "rawBytes": 2999, + "rawSHA256": "17710CA133DFEB57997C72C99B8CFA9D35190CB273D51B04554EE556F432408D" + }, + { + "path": "docs/internal/extensions/native1/commands/phase-integrity.json", + "mode": "100644", + "gitBlob": "6e13a94e69460da38c8cc8f6bc6a2559fde4fdec", + "rawBytes": 5519, + "rawSHA256": "7F59E0FD7EE158FD7957A3FA570DDB321149494C0CF6D3093DA0A6CE090EEF13" + }, + { + "path": "docs/internal/extensions/native1/commands/policy-certification.json", + "mode": "100644", + "gitBlob": "30ef3e7c6deaedda5ba8ba4453ff0c6b78483c34", + "rawBytes": 5163, + "rawSHA256": "859404C6508357D550F351E49CCCBCEA934B44A91612DFF51C0470931440CF31" + }, + { + "path": "docs/internal/extensions/native1/commands/policy-final-certification.json", + "mode": "100644", + "gitBlob": "30ef3e7c6deaedda5ba8ba4453ff0c6b78483c34", + "rawBytes": 5163, + "rawSHA256": "859404C6508357D550F351E49CCCBCEA934B44A91612DFF51C0470931440CF31" + }, + { + "path": "docs/internal/extensions/native1/commands/policy-final-focused.json", + "mode": "100644", + "gitBlob": "e68d46866d1231ead8ec9403d2f55d58bf0849b9", + "rawBytes": 10102, + "rawSHA256": "A99ACAD7DF46F5A5021AB4283E827E89E23307441CAE7738D577FECBCB6D9153" + }, + { + "path": "docs/internal/extensions/native1/commands/policy-final-full.json", + "mode": "100644", + "gitBlob": "1a78ac4262e74fabffd40657f80bd4f5a9676d4a", + "rawBytes": 28062, + "rawSHA256": "8D17E7C151F589D881DBDD687DC9D2479530C083E1DC12FC85B8FF28501A0A22" + }, + { + "path": "docs/internal/extensions/native1/commands/policy-final-preservation.json", + "mode": "100644", + "gitBlob": "8b44f6cfb3068a4b4fb0b73909678b4bbaab39b5", + "rawBytes": 174, + "rawSHA256": "A76F7A66714C793C7E7660D70036B53CAAB852D8DDB6311989FA32440EADF075" + }, + { + "path": "docs/internal/extensions/native1/commands/policy-focused.json", + "mode": "100644", + "gitBlob": "e68d46866d1231ead8ec9403d2f55d58bf0849b9", + "rawBytes": 10102, + "rawSHA256": "A99ACAD7DF46F5A5021AB4283E827E89E23307441CAE7738D577FECBCB6D9153" + }, + { + "path": "docs/internal/extensions/native1/commands/policy-full.json", + "mode": "100644", + "gitBlob": "1a78ac4262e74fabffd40657f80bd4f5a9676d4a", + "rawBytes": 28062, + "rawSHA256": "8D17E7C151F589D881DBDD687DC9D2479530C083E1DC12FC85B8FF28501A0A22" + }, + { + "path": "docs/internal/extensions/native1/commands/policy-preservation.json", + "mode": "100644", + "gitBlob": "8b44f6cfb3068a4b4fb0b73909678b4bbaab39b5", + "rawBytes": 174, + "rawSHA256": "A76F7A66714C793C7E7660D70036B53CAAB852D8DDB6311989FA32440EADF075" + }, + { + "path": "docs/internal/extensions/native1/commands/registry-kind-downgrade-coordinator.json", + "mode": "100644", + "gitBlob": "9a6a5fc8f4516f2f2aa85ff01d8b4afcfbbe92c1", + "rawBytes": 747, + "rawSHA256": "0781EA8258D7A66EFF322CE0F4E1740007A546EEA27532C420FC7B5F30A7FA89" + }, + { + "path": "docs/internal/extensions/native1/commands/registry-repair-baseline-pins.json", + "mode": "100644", + "gitBlob": "62180ebe9dcbe7fb314be7dcdc3b0299e71bb018", + "rawBytes": 691, + "rawSHA256": "93083056FDA50FBA0142B6727DF37D22EE170FB0854EA0515A3132612EE160C8" + }, + { + "path": "docs/internal/extensions/native1/commands/registry-repair-final-summary.json", + "mode": "100644", + "gitBlob": "d54f22823be46c02be6c1a92530abced7393ebf9", + "rawBytes": 1585, + "rawSHA256": "0BF9C9ADA5311923AA6E6CE977D1AA2C5D26D734DACF6FAA8B8A81C0E6C6E433" + }, + { + "path": "docs/internal/extensions/native1/commands/registry-source-pin-positive-coordinator.json", + "mode": "100644", + "gitBlob": "e0f371cd192610628d1c0598ff7547da54801c9d", + "rawBytes": 753, + "rawSHA256": "01CC7A0BEA50E8C08608D59B0F9D5916BF31CFB4AE3369D3C615F62D679E8F19" + }, + { + "path": "docs/internal/extensions/native1/commands/repair-controls-final.json", + "mode": "100644", + "gitBlob": "70ae6fbc7edf09bd80b741eb324a70bec7cd5120", + "rawBytes": 7610, + "rawSHA256": "3CF01553B7D38456FFAD18D0C92DF60A7C5432BB86BC764116B927B4816A00FD" + }, + { + "path": "docs/internal/extensions/native1/commands/repair-controls-v3-final.json", + "mode": "100644", + "gitBlob": "b52fb1e3cf7ed96818ccf75103cb6f4a50de945a", + "rawBytes": 7515, + "rawSHA256": "1548C2D5FDC8D259EC6E4C1D531C0338109813C218C5A625CB9C191CFAFF5A0E" + }, + { + "path": "docs/internal/extensions/native1/commands/repair-known-smoke.json", + "mode": "100644", + "gitBlob": "1100618bd3965cb9ed10c452525bedd936f2116b", + "rawBytes": 1315, + "rawSHA256": "F576201C872C50B149BED107F0CE63048E934733D0039E7D3A215B34149D0A9D" + }, + { + "path": "docs/internal/extensions/native1/commands/repair-native-startup-binding-failure.json", + "mode": "100644", + "gitBlob": "aca3b363ac5032523ee95127135aef25571e2bf6", + "rawBytes": 515, + "rawSHA256": "E7DE9EB8FBB91B7F0D4C75B14C66BD04ACEA488DA8ED86448C71BF8B262D6C15" + }, + { + "path": "docs/internal/extensions/native1/commands/repair-native-startup-owned.json", + "mode": "100644", + "gitBlob": "ebbdcc7691d0aad354230feebc22f4ac58e421a9", + "rawBytes": 705, + "rawSHA256": "1FC18B0C5E1E388AA1CF4697E8540E56A6B6A076284AD70830307050821152ED" + }, + { + "path": "docs/internal/extensions/native1/commands/repair-native-startup-runtime-path.json", + "mode": "100644", + "gitBlob": "264938fdadf21cd6dd3b5dc45524e83a2fac2e70", + "rawBytes": 933, + "rawSHA256": "E99AEF78D440D29B325C195864855AA54FBD3667AF4128A34F7CD1579FD684E1" + }, + { + "path": "docs/internal/extensions/native1/commands/repair-v3-control-unknown-uppercase.json", + "mode": "100644", + "gitBlob": "04a9955884a4eccddec3550f8ceaead4df3dc889", + "rawBytes": 1674, + "rawSHA256": "FC2A5A9D524D3CE083F5409C459C0651D91FD738F885629023818DAFBE6B87D7" + }, + { + "path": "docs/internal/extensions/native1/commands/repair-v3-cpp-error.json", + "mode": "100644", + "gitBlob": "9a1e8877f778efbd6116424f070526f5a6053b76", + "rawBytes": 1376, + "rawSHA256": "493E45D2C36A76FCA99D65A016F1848E08CF665D4F3621A10E06DED289980963" + }, + { + "path": "docs/internal/extensions/native1/commands/repaired-route-build.json", + "mode": "100644", + "gitBlob": "726dedd0bf62c9fde9249f1ee1763e8aace8606a", + "rawBytes": 3361, + "rawSHA256": "20C6D7F7156F0EB7AF6A3762BF50C8E1EB834C398EA417BA7C760F59F254A0BC" + }, + { + "path": "docs/internal/extensions/native1/commands/route-01.json", + "mode": "100644", + "gitBlob": "8a77e47032ed6aafff4feb5afc9427d295a47ad9", + "rawBytes": 780, + "rawSHA256": "1B212649AC414F2E985B3C4F72C97623994D5BC9FC5E0681530B9078FF579CA8" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T074345564.json", + "mode": "100644", + "gitBlob": "a990afcda12550da3c8a10d980040b1bb50acb20", + "rawBytes": 941, + "rawSHA256": "CBBE37C0F61122199A34D45146F0B45E30EEE36F45DD87925E864330708DE211" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T074851905.json", + "mode": "100644", + "gitBlob": "4e1e05e5f0888ac5811ab46dee5376e7c9c6ac05", + "rawBytes": 1118, + "rawSHA256": "BCABE60CFE0E56470266094F21F1EDF3E66D0954B572AD47F80FCB23873CB963" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T074921501.json", + "mode": "100644", + "gitBlob": "dca2426fe6650447d03093342a836116b50f162b", + "rawBytes": 18107, + "rawSHA256": "056292AD4999142D1E8A39D2DAF455E5E4259A667D04E19BF0587E00427F4621" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T075047091.json", + "mode": "100644", + "gitBlob": "096b0acb57ceac9d939bd4c7b6b1016c3871de4f", + "rawBytes": 83637, + "rawSHA256": "4341EDA40739ACB0239ABCFEBF0DE088B262184F9AE72CE716DCCAC94C113725" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T075325959.json", + "mode": "100644", + "gitBlob": "3f6ffb49d2e9547b5c88da8b610f2a6e7842fb71", + "rawBytes": 1118, + "rawSHA256": "D39DF64DE00B994C287DC7A003426450C6801218BDE899DE473051B4EDAD0DF3" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T081311355.json", + "mode": "100644", + "gitBlob": "666b330a9652cca38fc80c8352cd1dc73ffb1f6e", + "rawBytes": 83647, + "rawSHA256": "82BE145305F5BE3A6C897F9D2D43F73E1EB8AE6E8FC5916FBB295DFFFA5D502D" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T081538732.json", + "mode": "100644", + "gitBlob": "0280b83ec35a76575bf5bd78e779cac9dac3a16e", + "rawBytes": 1118, + "rawSHA256": "E0A424883AB7528B9645F2A4D8B1B692F70C8F097582B5B92941B98A9CEBD7D9" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T092619569.json", + "mode": "100644", + "gitBlob": "af944abb9d631227d1b58c9e290b88691bdd4191", + "rawBytes": 2024, + "rawSHA256": "2D5851B9EC55DF957E49AD290EBEB0D9B844960DAD04EAD754218D36BE8C95A0" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T094044361.json", + "mode": "100644", + "gitBlob": "dbb032fab9ffe54e5c614a24c0854e5e26606c72", + "rawBytes": 2165, + "rawSHA256": "83D1602C1B234644D8E938E5A46B9228F77A26C99338F150F38EEA78A2DE86F0" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T094135118.json", + "mode": "100644", + "gitBlob": "be1e3aa3204a959fd0cd932131df50f4c6fcbbca", + "rawBytes": 112175, + "rawSHA256": "621E211AE77E3DB4F97EEBB2C2577E7E84E8721481569C9D045EE22F0968037B" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T094834598.json", + "mode": "100644", + "gitBlob": "ff515bb32f59fcc677a178a62de8122fa95feed8", + "rawBytes": 2468, + "rawSHA256": "789C8174E0496B4CFCC68247F3A73E9D66B1A762820B7A2C73EDF11771F061AC" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T095846357.json", + "mode": "100644", + "gitBlob": "da49f21a7ade75aff1b58d8e6c5bbbd0753a960a", + "rawBytes": 2344, + "rawSHA256": "23A2C407B17E336388C1323CC28B3A48D0A02D757D6A89E07794A920AF08E6B8" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T095926516.json", + "mode": "100644", + "gitBlob": "6276cdd9fe5378140068b1a54cb7d503993153ad", + "rawBytes": 121289, + "rawSHA256": "5A31BDDA30A5026EDD27ED3374E4354B4AD5928C2A75591DB0BFCF780B1EB647" + }, + { + "path": "docs/internal/extensions/native1/commands/runtime-01.json", + "mode": "100644", + "gitBlob": "678cc884231638a0fe4c41adde4b31c87e97b2b7", + "rawBytes": 3410, + "rawSHA256": "36188FD19AD55CE119B5B822FB1579BDDF170D178675B83D314D1EFC028A097E" + }, + { + "path": "docs/internal/extensions/native1/commands/runtime-02.json", + "mode": "100644", + "gitBlob": "f2c5e5910e8148b7841098789bb7fc5d2dbb444e", + "rawBytes": 884, + "rawSHA256": "2E23D7CD6098EBA99971AD49BF416DB6082936A4009D4E39E324718CFF8A57C6" + }, + { + "path": "docs/internal/extensions/native1/commands/scheduling-inference.json", + "mode": "100644", + "gitBlob": "827a3fb46ad9f0bacec145cfd09a705886a529c3", + "rawBytes": 828, + "rawSHA256": "5BD275F9ED0C5C35920CAB8FFDD3E76B1050BA3ACC61D9C468F310FBB97C42CF" + }, + { + "path": "docs/internal/extensions/native1/commands/thin-01.json", + "mode": "100644", + "gitBlob": "234718ce07423d20fe5d989c93cbdcbd954212ca", + "rawBytes": 2548, + "rawSHA256": "C495339D8A01D960460C2293CA81211D1A9CEB1E9DA2E7E1FA1144BE7B8FE4A3" + }, + { + "path": "docs/internal/extensions/native1/commands/thin-02.json", + "mode": "100644", + "gitBlob": "2d62e04d31b48c2ae4c0b4e9195bcd5b5d07b6ee", + "rawBytes": 778, + "rawSHA256": "42311F28E41DD4310841B0833EC930F34B66BC3382AF8D1AD0097F15F47995A7" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-01.json", + "mode": "100644", + "gitBlob": "b8165ae385dbdad8e47a8646730439f786d05f66", + "rawBytes": 1537, + "rawSHA256": "8E5B1F77AD44301F8C03760BC77F3AAA6F18028792DB466D325D78383AC58D41" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-02.json", + "mode": "100644", + "gitBlob": "a62973a5892ff57069f177f189b5f8cfdd702c82", + "rawBytes": 1566, + "rawSHA256": "B92803F61981FFA7B64DE060568B7543ED54BCAE50FFD6018D96374C9B778E85" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-codefacts-import-01.json", + "mode": "100644", + "gitBlob": "1a7b7376f849a361527b47297ce038875573e50b", + "rawBytes": 1610, + "rawSHA256": "9167C0E94E36CBF1B81953F792AC33216EA9EFD4EF8DB09B64E2B784DF0EC40B" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-compare-positive-01.json", + "mode": "100644", + "gitBlob": "491699db5062d95a44505cf939ed38e223368c74", + "rawBytes": 1075, + "rawSHA256": "A053EB2383542434D5BCB067EBBE0BFC985630875F63218A7165249AEC917979" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-compare-wrong-01.json", + "mode": "100644", + "gitBlob": "f470945588e36d5fb1e19f1c11675bb8c26aad3c", + "rawBytes": 1072, + "rawSHA256": "2D4FD0F4F1C4C0B590481620FE8AED396107C580D8A2D79154C1547B60806099" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-controls-20260912T120702123.json", + "mode": "100644", + "gitBlob": "ea0e3e9298aa4183e514d92ce6a39b321398deff", + "rawBytes": 16514, + "rawSHA256": "BB8E08BD2DF3C0FE9A305678C4B3C355CDAED10C67DE69E8C2CFEDD91796B470" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-controls-20260912T121157154.json", + "mode": "100644", + "gitBlob": "fd6d5b1a3287b86cf96cb01c1a0b41cfeb691325", + "rawBytes": 16477, + "rawSHA256": "945970E3ED008F8796E5CC517433865ED13D4E20023BF778B5ACA620626365C9" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-controls-20260912T121837285.json", + "mode": "100644", + "gitBlob": "3a1ccee3ffae46fe493ec0f6249c916ae44e1308", + "rawBytes": 43834, + "rawSHA256": "71690B65E283EDBAC82D6A9171A1CF4C4A33E0145890271AD8BE47AABA05C756" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-controls-20260912T125248495.json", + "mode": "100644", + "gitBlob": "a366681004ddb47259a9049531ff352925725192", + "rawBytes": 25130, + "rawSHA256": "221705A5887506CD1709EAC76A0B82EC92F7513C05ADA001A30B15817D9C2992" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-controls-20260912T125634462.json", + "mode": "100644", + "gitBlob": "730d6281e9d64efec2ac3d11635d562d6c08f569", + "rawBytes": 16497, + "rawSHA256": "FBAD7181AFD653A53442AE21833BF42F74B1F5759D75FBB45659C36EC823E1DF" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-controls-20260912T130117776.json", + "mode": "100644", + "gitBlob": "453cc8bb63c459ef888407f573666090a53855e6", + "rawBytes": 53360, + "rawSHA256": "ED0A09875DDB653270F58EA7FE7DF6D16C938E70E6CA0DC963F7124A2AF1D6CA" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-cursor-import-01.json", + "mode": "100644", + "gitBlob": "f6501551bd7214658d105c4bdededcd6633899a4", + "rawBytes": 3870, + "rawSHA256": "859F0FC56FD63848B8D4B80942B073B9E498286B63E1D3AFFA543F57A13782B3" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-default-01.json", + "mode": "100644", + "gitBlob": "f814c2d93bdfc6db4f37d576b944e1b5154a4b72", + "rawBytes": 3318, + "rawSHA256": "E575A1A4DF67BC4F60E05F23C1E246D89BBF95A792611BFAF68A3A4C689E0A13" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-durable-all-01.json", + "mode": "100644", + "gitBlob": "4692b2877c5ba8e6ba1cb5f383a96af50f7ea027", + "rawBytes": 4258, + "rawSHA256": "6F6471042A86F7F39252E1B8467E03284A2E9E451F952D054972D36B81621F9C" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-durable-all-02.json", + "mode": "100644", + "gitBlob": "adaebc2d070b895f8e9e20aea768669a92527879", + "rawBytes": 4374, + "rawSHA256": "3B3688DD7842BB0EAA8E2567BC1083EACC2BC3A433A674C8F25496748DDDA46F" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-durable-positive-01.json", + "mode": "100644", + "gitBlob": "44c77b31ae446fd3e6bbd8573b2a6e424014ec37", + "rawBytes": 2096, + "rawSHA256": "D22E83D84D7F162FDD863890F82CE0B3C52A9E130FB6D62BE77BF3121DBE28C3" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-durable-positive-02.json", + "mode": "100644", + "gitBlob": "b4d7d2205dc7a5dbb2608b836c8d990f6d6f3bd2", + "rawBytes": 1522, + "rawSHA256": "D2ECC69928C5DC84A55CFF87C8B873D3BFD37363A483AB36568630D4A716624A" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-empty-channel-01.json", + "mode": "100644", + "gitBlob": "870830d9c7d9caa9c07844136d9730f621b11226", + "rawBytes": 879, + "rawSHA256": "D7B1BD126FEA79213681E3FD465FDDF46FFDA54EBFE9522239586DB88B52CF12" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-fuel-format-ps5-01.json", + "mode": "100644", + "gitBlob": "b3c1321e24c4c1b1a49699a26727b286b503e880", + "rawBytes": 1487, + "rawSHA256": "224BAE7D1DE24398DBBA908F6C5CACC02F678B92F3DE092BD641E52EF330B21D" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-fuel-format-ps7-01.json", + "mode": "100644", + "gitBlob": "22494f60abe206ecb55565cffae695d96aeff173", + "rawBytes": 1527, + "rawSHA256": "E840EB738FDC50FE9066ABC8E6DD1010C238057E17114D571C79DC5D42FB63D5" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-limbs-import-01.json", + "mode": "100644", + "gitBlob": "1e0b797f09b348502a0e8e3732879c20ffbebf41", + "rawBytes": 4784, + "rawSHA256": "33685CEEBDA2996B3F8426E8BEA29036EF1AAA5D84E49BD5BAE8EC50F69ABA44" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-limbs-import-02.json", + "mode": "100644", + "gitBlob": "e95741ea8a9a65cf2315955ccd7a29351b017b4b", + "rawBytes": 4416, + "rawSHA256": "441DB3E4F086CF53D5213DC33DF8FF5F1552709FCF7A7AF3E004A86BA58A2DA4" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-machine-import-01.json", + "mode": "100644", + "gitBlob": "a72627da3f1d56c8b1df62a158f2ab103dfca94a", + "rawBytes": 5445, + "rawSHA256": "A75CE0ECCB285F4A81F83895F511F7AC337F45F5CE37697832CFC2028A6E506A" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-malformed-01.json", + "mode": "100644", + "gitBlob": "65181b5fbd6f905504a534e1366757476c600c07", + "rawBytes": 893, + "rawSHA256": "84CDB0F418B2676A0C6D32FE46A66E8DC9A168491AEA3326BA80743464C1BA3A" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-selected-01.json", + "mode": "100644", + "gitBlob": "381d4ad585270a3db6d8a4085907d588f0b25586", + "rawBytes": 1112, + "rawSHA256": "4F446E84A08E9AA61F81B5A5BBF1EF29DC621A862B312A0855B85F6C890848F5" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-unknown-01.json", + "mode": "100644", + "gitBlob": "a141ba4b0fae4a2d8b76d5bce737cd3e870447bd", + "rawBytes": 924, + "rawSHA256": "7AB2B57754B40CE04A9B089A3849F0A7E2BEC7EA1C6B217EEF3B1892D4E4EB99" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-whitespace-01.json", + "mode": "100644", + "gitBlob": "20f02b73dcf9281219069367cd7c0c18772cc3fb", + "rawBytes": 907, + "rawSHA256": "08C2535425D4DBA8BF72DF102C56B43C917FCF93154A8746362BC58CF5EF54C7" + }, + { + "path": "docs/internal/extensions/native1/commands/warm-20260912T095318994.json", + "mode": "100644", + "gitBlob": "67b1f6f957d88d22fd688b4dff9c58e0069784fd", + "rawBytes": 54492, + "rawSHA256": "622481FD9D2ED43EBCFF87576E7053B09AE78B0106E568EE5073AC3778467EEF" + }, + { + "path": "docs/internal/extensions/native1/commands/warm-20260912T100814051.json", + "mode": "100644", + "gitBlob": "cfa336fe4d5c71859b648f0fb053512d1a0b315b", + "rawBytes": 65114, + "rawSHA256": "87EC19B2BF8A1FAE3530B1938D09749549F2CCF7992CB1F865710635B046C142" + }, + { + "path": "docs/internal/extensions/native1/commands/warm-20260912T102817544.json", + "mode": "100644", + "gitBlob": "df2b5e4cb34630b475cdc95e758df7e1903cd877", + "rawBytes": 312751, + "rawSHA256": "2DC7707ACEAF228446F82A8B526205D26499BDB269E66BBD87AC89D12F678568" + }, + { + "path": "docs/internal/extensions/native1/commands/warm-20260912T104121341.json", + "mode": "100644", + "gitBlob": "c29954ec612ce8bfaea4b80563298681e9b79e4d", + "rawBytes": 13540979, + "rawSHA256": "5F00B0F44E9B539D4AF2D1C4D36B4BFC3852844575741D03FFBF87482D1EE339" + }, + { + "path": "docs/internal/extensions/native1/commands/witness-arrayrun-01.json", + "mode": "100644", + "gitBlob": "947ab5599ae5616370fbd03122d03ff13e03d6de", + "rawBytes": 2150, + "rawSHA256": "94F9D8F398A3BDB3DACB0CFC14031DA487142532DF2479AD4279A477FC4718E1" + }, + { + "path": "docs/internal/extensions/native1/commands/witness-export-01.json", + "mode": "100644", + "gitBlob": "282f5420a5d639da8854fbcd89e2f3b51300ec7b", + "rawBytes": 5554, + "rawSHA256": "007A3B6070D8FBA5BE4A043C3715CBAA58F7070AA1F6C8B2CFE53AA7B1745506" + }, + { + "path": "docs/internal/extensions/native1/commands/witness-export-artifacts.json", + "mode": "100644", + "gitBlob": "aa20762de62562624f00c298ad4274a923c177c4", + "rawBytes": 12512, + "rawSHA256": "129A39464B161895861F54203FB6A7D6D6CE39D4FB1B259B658437322062C049" + }, + { + "path": "docs/internal/extensions/native1/commands/witness-export-check-01.json", + "mode": "100644", + "gitBlob": "f6377d07fb812d0f84d7b301f16b3d9835d4cb54", + "rawBytes": 2973, + "rawSHA256": "1AABC6F50CB4A809A8B525DD4E7B7214BC898DA293A327A925252C88798883BE" + }, + { + "path": "docs/internal/extensions/native1/commands/witness-export-check-02.json", + "mode": "100644", + "gitBlob": "bbe2e4d628b8278e0f3858a5f966c7b8c895215f", + "rawBytes": 2837, + "rawSHA256": "EB43E98C8C88170BDA3206CBED8BBE56615FB42C7822CE2DCF1A554B9212150C" + }, + { + "path": "docs/internal/extensions/native1/commands/witness-export-check-03.json", + "mode": "100644", + "gitBlob": "4680e2c1757edbcb73512a71b309665262e62752", + "rawBytes": 2163, + "rawSHA256": "08AF20A323B2B5DC2A212F42F016F2A27D14540325EDD5164B470AA17DA12192" + }, + { + "path": "docs/internal/extensions/native1/commands/witness-proofs-01.json", + "mode": "100644", + "gitBlob": "4e7cfcf00fe1b4b98e40d139c1924d36ac914604", + "rawBytes": 2721, + "rawSHA256": "2FF9BF1DD18315DD953B3C4886286C1F0BEE2625B5A802C4C41E26D47DC5D4DE" + }, + { + "path": "docs/internal/extensions/native1/commands/witness-proofs-02.json", + "mode": "100644", + "gitBlob": "6610c039af75585c633cf3d4fd8208a38cd8b0dc", + "rawBytes": 7336, + "rawSHA256": "DFF7CC33C162C3698A148366E9A57227D002A40CCAA28C37A53EA861E91CFA6A" + }, + { + "path": "docs/internal/extensions/native1/repair-r1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "4fb7f8a30aacea56c760ce337e9b7fa5be4e46c1", + "rawBytes": 33351, + "rawSHA256": "59509FE6779A33DCFE541A6B182456C5A28CF390EBB765F68CEF3E7FB4753B08" + }, + { + "path": "docs/internal/extensions/native1/repair-r1/CONTROLS_RECEIPT_d0b4cef.json", + "mode": "100644", + "gitBlob": "2fda8946dbcdfa6ee9b36476002de6b5124f409d", + "rawBytes": 140190, + "rawSHA256": "15E0E8CCE044757D22634C8FD3DD21CED04A28A1F641DBF3CC434E4E94E820A4" + }, + { + "path": "docs/internal/extensions/native1/repair-r1/RECEIPT_ARCHIVES.json", + "mode": "100644", + "gitBlob": "8f98c063aec5df552809bab100b4cd6fb3f588b6", + "rawBytes": 11895, + "rawSHA256": "9D43E4372C04C5ECC5EFB88A8BCD8E7FD9F862DBD8054D5AE8F5D55237ED4329" + }, + { + "path": "docs/internal/extensions/native1/repair-r1/REPORT.md", + "mode": "100644", + "gitBlob": "9be8139b4455e9c0b006fff15e45ad0cda466e8b", + "rawBytes": 30747, + "rawSHA256": "BD83C87ED4B5B82FE34B98635A041E51B6C326FE4B0CBAD01C84D9C7E2D24880" + }, + { + "path": "docs/internal/extensions/native1/repair-r1/receipt_archive_control_helper.py", + "mode": "100644", + "gitBlob": "5cb77df82f8d7eb0fb72d775096a969f0083de3b", + "rawBytes": 9081, + "rawSHA256": "ACA55BC949B7F1034908AF84204E214493F7F7B3A2D3F958FA17C833EF0434BA" + }, + { + "path": "docs/internal/extensions/native1/repair-r1/run_receipt_archive_controls.ps1", + "mode": "100644", + "gitBlob": "fe8eed9044c30de12ef6a9e9a2722078035f5528", + "rawBytes": 23630, + "rawSHA256": "71A0E7E382E15C66015B40579A5B903711F0B4B2DF1155D065920C485CB8464F" + }, + { + "path": "docs/internal/extensions/native1/repair-r1/verify_receipt_archives.py", + "mode": "100644", + "gitBlob": "de451edbe3e44a9a60672b24eaf0b430d4e05b2a", + "rawBytes": 19448, + "rawSHA256": "5805CC886B3FFAA7C149EAF2EB903B88E71247EF103B0C0EF99863A16334458B" + }, + { + "path": "docs/internal/extensions/opt1/.gitattributes", + "mode": "100644", + "gitBlob": "85d70dcaa28b954b72e266f4bc41a4c9ac85b1f5", + "rawBytes": 1115, + "rawSHA256": "3764865B0BA810E09327B9059E2A4E0A044E4CBD61553003074F8020DEF95780" + }, + { + "path": "docs/internal/extensions/opt1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "bd5d0eb38fd4a301eb89b027fcc434fc18dbee75", + "rawBytes": 35888, + "rawSHA256": "E21A7B6658E170DEEABF01A4F9A4C8593C5642F6048D2662A93306F002ABDD5F" + }, + { + "path": "docs/internal/extensions/opt1/AUDIT_DISPOSITION.md", + "mode": "100644", + "gitBlob": "49b2840079bc11aa66d3d67a863b6a4c12f851ab", + "rawBytes": 4625, + "rawSHA256": "C7A68E9ACE42B2CA1962A249EB7917A458810753494E12F6258000A91CF032D4" + }, + { + "path": "docs/internal/extensions/opt1/AXIOM_ROOTS.json", + "mode": "100644", + "gitBlob": "4c9314d23730f318c1a4f99ca13e2156912f277b", + "rawBytes": 9189, + "rawSHA256": "CA2908657FE00CF4E0527BF81AA6D095285C18BC5FC66F098C532A1CF812B6EF" + }, + { + "path": "docs/internal/extensions/opt1/BLIND_SOURCE_AUDIT_PROMPT.md", + "mode": "100644", + "gitBlob": "217dc766f8e52f7569d2e6a8ecc19e8e7a4d3117", + "rawBytes": 26357, + "rawSHA256": "5665D4A273C0F0CBE44388DE1C7CD76245C415EBB7457DFD5D630B52462E6AC6" + }, + { + "path": "docs/internal/extensions/opt1/BLIND_SOURCE_AUDIT_REPORT.md", + "mode": "100644", + "gitBlob": "dc7287787b5bb1761ab13e241d1e342a9222ffef", + "rawBytes": 44217, + "rawSHA256": "D40BE15F651E4F640DEFD4455E594BCCAC7C92AFCD0A915F0CACB37614C342CA" + }, + { + "path": "docs/internal/extensions/opt1/CAMPAIGN_RECEIPT_REVIEW.md", + "mode": "100644", + "gitBlob": "9d6c6bde769d71133936d1abd79c1d2d3c4dcab7", + "rawBytes": 3647, + "rawSHA256": "934F5C864359BC9FD3099B72E6FECF1DA98E00BC6FB0A4A1A6C52EED7CA6BCF6" + }, + { + "path": "docs/internal/extensions/opt1/CHECKER_REVIEW_15E.md", + "mode": "100644", + "gitBlob": "a9b53fd910842a4d03c32986a166ac58dba1bef3", + "rawBytes": 7087, + "rawSHA256": "EDC45AAC39301CBCEF8DBF36EC0EC9117CBC7A914E0DE2B123E8104CDC8233BF" + }, + { + "path": "docs/internal/extensions/opt1/CHECKER_REVIEW_BBBE.md", + "mode": "100644", + "gitBlob": "10e4fae7249456bceede7049d6703d539f944342", + "rawBytes": 3686, + "rawSHA256": "3B6C124E626C19F8B01EF00D573819C41301DF9F404DD9237F3C24A565D1C66C" + }, + { + "path": "docs/internal/extensions/opt1/CLAUDE_JOB_FINAL.json", + "mode": "100644", + "gitBlob": "0207d51f68ce44bc7ced77c10b317adf8e77ca08", + "rawBytes": 2169, + "rawSHA256": "98A2970B0A6590E1779D11FC7CB8BADBD782298EA2016A33ACFB65090A90B303" + }, + { + "path": "docs/internal/extensions/opt1/CLAUDE_JOB_START.json", + "mode": "100644", + "gitBlob": "aa6bf247e3a05638860c99381989204a5355f5de", + "rawBytes": 5012, + "rawSHA256": "DFEB56610EBF38E32AD72625C0B90FFD6AB6B10D1E590E94D92F0F48A578C6EC" + }, + { + "path": "docs/internal/extensions/opt1/CLAUDE_SOURCE_IDENTITY.json", + "mode": "100644", + "gitBlob": "40f6910d098b23f2f8c1e00c0e10424bec1b928d", + "rawBytes": 63023, + "rawSHA256": "4191CE36ECE567D8E60F135A2704C194A536DE38D990C654056245C15A43A768" + }, + { + "path": "docs/internal/extensions/opt1/CONTRACT_AUDIT.md", + "mode": "100644", + "gitBlob": "938ff30aaf3e77cf6ab3491b9546f22281e2e9ae", + "rawBytes": 9657, + "rawSHA256": "1CA92DB80E82224BE124381AF07A57B69331D5B13C515BCD940F7BD0624BEB13" + }, + { + "path": "docs/internal/extensions/opt1/CONTRACT_ROUTE.md", + "mode": "100644", + "gitBlob": "c18e698ca2d220a8b04900f48ac750124cf02410", + "rawBytes": 7355, + "rawSHA256": "F9837CA963710FE1074E6CEC40877BF06C53338F6CDD1B5A5AF0F80539EE4E22" + }, + { + "path": "docs/internal/extensions/opt1/REPORT.md", + "mode": "100644", + "gitBlob": "90a3972aa286c5756ebee789b08725cc31e39f6b", + "rawBytes": 28729, + "rawSHA256": "8FB2E742FABC26BEC9C6912078721D5CA8910769A7500C494C46BA15D0EA68D4" + }, + { + "path": "docs/internal/extensions/opt1/RESOURCE_WAIT_20260912_REPORT.md", + "mode": "100644", + "gitBlob": "ccef83c82e964b41a96e992642cbab6b0d9516b7", + "rawBytes": 15469, + "rawSHA256": "BD63F061CBB4CE2B2335F844F2975CBF9620ADF403692AA1C25FA93FDFBA8997" + }, + { + "path": "docs/internal/extensions/opt1/ROOT_COMPOSITION_PLAN.md", + "mode": "100644", + "gitBlob": "cb72d557c7078a3a099f1114a4601cbd480fc928", + "rawBytes": 5242, + "rawSHA256": "64BD687F1F7EC0F9BC3105FFF2B03FDD7D2DA4DD101B9E42FE67C9CABF102151" + }, + { + "path": "docs/internal/extensions/opt1/ROW_EVIDENCE.md", + "mode": "100644", + "gitBlob": "92c79d9f5cedb0b54efda2a59020b16448396c72", + "rawBytes": 16496, + "rawSHA256": "EB2C96CEE98722B28C77CC33004379BCC12855B7943D381141F988B24450B667" + }, + { + "path": "docs/internal/extensions/opt1/SCHEDULED_FINAL_REQUEST.md", + "mode": "100644", + "gitBlob": "ac71ee945d0448942f34cb7a377cdf872c96b347", + "rawBytes": 3669, + "rawSHA256": "AF193708B14B767C6B429ADCF5FF726C5C219F2D23C62DA5315498C84A565624" + }, + { + "path": "docs/internal/extensions/opt1/SOURCE_FREEZE.json", + "mode": "100644", + "gitBlob": "620e639a1c54b2dd23453c8b0e0ff2bb90ef209f", + "rawBytes": 1206, + "rawSHA256": "D966E19EE39C8480522D7BB83041FF71C49BDB608E90EAB23FB43D52B329A29F" + }, + { + "path": "docs/internal/extensions/opt1/STORAGE_REVIEW.md", + "mode": "100644", + "gitBlob": "5d2ef3c1a9b09f5a904b56a758403085450f3965", + "rawBytes": 2429, + "rawSHA256": "8E42B3D1A20D051CBB37F30BD4FD3AEFCFC2DFB4CD6E4B85CA65AB6E89954B76" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/20260912-071055-038-Primitive.json", + "mode": "100644", + "gitBlob": "b824d62d53226888491100e26799f98c79ae1e81", + "rawBytes": 875, + "rawSHA256": "F8020A2342DFEED3DFFC2E7B284BD51E12C75A9D017D09A81934571995327B40" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/20260912-071115-933-Calculus.json", + "mode": "100644", + "gitBlob": "d146706c96891dca436b1b42b919bcbefb526ed5", + "rawBytes": 871, + "rawSHA256": "38E04345BA342D0D011496EDA044B4EAA976A6BE552F036C6FB380DCBD87CBBC" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/20260912-071129-992-Structured.json", + "mode": "100644", + "gitBlob": "0299c42c75e3117be2b5f4f5ab8ab015915c307d", + "rawBytes": 878, + "rawSHA256": "CFA30A9035AE69DAE7AE1250979462CD2AD687A3ED4CA362A0E5E66FA06F41B1" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/20260912-071153-549-Compiler.json", + "mode": "100644", + "gitBlob": "fba970005ea09b207ca5a35e43e0777ca84e845d", + "rawBytes": 872, + "rawSHA256": "D85CDB5E6196CC721B7B3A5E2319A5BB02631E0FD195748DEFFF70C5370E2A81" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/20260912-071244-077-BranchBound.json", + "mode": "100644", + "gitBlob": "a6dd3c4c551ea476c63d87cfbd542b1e2c409e47", + "rawBytes": 893, + "rawSHA256": "9BDB7B18AD7BAD11264C1F1BD7D26E2AD0F6524359D8FBDBCEBFCC80B3EE71A5" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/20260912-071445-906-BranchBound.json", + "mode": "100644", + "gitBlob": "cfaa99022c5489ec534b2df310c3c1e2e2d2dc4d", + "rawBytes": 892, + "rawSHA256": "332E373E584BBBC6EF18853A7ABF03139C20ED94536827F98C07C88934D67C1F" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/20260912-071538-136-Axioms.json", + "mode": "100644", + "gitBlob": "1c24879b4d19c439cc9b1175af82e453c99c5bcf", + "rawBytes": 4075, + "rawSHA256": "CAE51FD3C00C37850B356DF3B3AD80708E393E9B22C17143CE929F2506CA9160" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/Axioms.lean", + "mode": "100644", + "gitBlob": "e646384c06e39b3e8521fa12e39fe1844c98eef6", + "rawBytes": 1119, + "rawSHA256": "049CF6714D76FD11C55EAC8D0C91D077DE99B3B7C3F298E268D3B095B0A81D4A" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/PLAN.md", + "mode": "100644", + "gitBlob": "9777bbfa5e0a40ad20f625e55e28a6c1f5523a92", + "rawBytes": 2653, + "rawSHA256": "E95727B250B6E1C26FC502B93697BAA9166FCA2FC637546AA783DC1A21C18A2F" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/REPORT.md", + "mode": "100644", + "gitBlob": "8587a9c9cd119ec25cea2a0e3f2bd24ef19a9303", + "rawBytes": 10932, + "rawSHA256": "01FFF26B2CFD45553AC9B8F023041A788F6E6F8ABF046E55CF0AD11796AE3CD2" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/check.ps1", + "mode": "100644", + "gitBlob": "8bad7fa61764e3deef46d1529a4fec7e4f6fb48d", + "rawBytes": 1837, + "rawSHA256": "44A8DA036E2E21970DA6B7DDD1E2EAE43A944523372459BAE1E97B466BCC9126" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/hygiene.json", + "mode": "100644", + "gitBlob": "fddf13ed138175b53e5c863f3105ac95abc5baa1", + "rawBytes": 643, + "rawSHA256": "75D11784E82E6A9915082AC86332AB0D2E724B86852426D151B91C2D1626BAAA" + }, + { + "path": "docs/internal/extensions/opt1/capstone-resume-plan.json", + "mode": "100644", + "gitBlob": "45d560887eb3374f879292a65cf88dec562709bd", + "rawBytes": 50, + "rawSHA256": "F4966F34774C32685C9E035EB2CA0AFF71201E5F8BD20D52A6BFBC4B417BD123" + }, + { + "path": "docs/internal/extensions/opt1/certificate-consolidation-check.json", + "mode": "100644", + "gitBlob": "dcb1a220faa731f8a2c0a0054b7ea40c38190197", + "rawBytes": 312, + "rawSHA256": "437E61892C2E21B52D6CB493D393836A692988C4D24BA4616862409A28F17A39" + }, + { + "path": "docs/internal/extensions/opt1/certificate-freeze-claims.json", + "mode": "100644", + "gitBlob": "ca948837a05f7b450554171971155b70bee8cd7c", + "rawBytes": 541, + "rawSHA256": "55FEAFC46968B2F0C5D67F2CDF7401B748EFE840ECF41FDEE6D75286B64A00AF" + }, + { + "path": "docs/internal/extensions/opt1/certificate-freeze-design-base.json", + "mode": "100644", + "gitBlob": "19a1121f3d8b22d11d86057b82dbde0765a5899a", + "rawBytes": 623, + "rawSHA256": "BFB0808DDF0C28DD1BA231BE3A76EC34236DCFE98CA44B760E91220ECE34F956" + }, + { + "path": "docs/internal/extensions/opt1/certificate-freeze-design-phase.json", + "mode": "100644", + "gitBlob": "17b198fb3dfab718ae1d899b1b2bc783c0c409b5", + "rawBytes": 839, + "rawSHA256": "3FE5B1BE8EA1FFA748CA4125484F57A8A471D478160AFB4D0669A28B7AAC44ED" + }, + { + "path": "docs/internal/extensions/opt1/certificate-freeze-whitespace.json", + "mode": "100644", + "gitBlob": "1c814a9fc9cdc727a578635d50b81b62fd501eca", + "rawBytes": 371, + "rawSHA256": "FFC8EA84C6E52733BC8EA4E4C1570F1EDC9979D9B8C0D0FECB2E85707C956B50" + }, + { + "path": "docs/internal/extensions/opt1/certificate-independent-check.json", + "mode": "100644", + "gitBlob": "5b12e2995f8ff1a6d1ee8b2e6e21dce5bba41081", + "rawBytes": 30666, + "rawSHA256": "D4464B694C3DDAF56DA4B62BE53CF91D6B26DA25678DD0E76D47437870F86D8A" + }, + { + "path": "docs/internal/extensions/opt1/certificate-independent-check.py", + "mode": "100644", + "gitBlob": "2c8b91e81ddd2635259112c1aee9390ae652849c", + "rawBytes": 5436, + "rawSHA256": "AB31A997FD0EA861F105FDA617858D8824956CCCE0B310836687FB2C733F9200" + }, + { + "path": "docs/internal/extensions/opt1/certificate-refreeze-claims.json", + "mode": "100644", + "gitBlob": "3ceb53061c4b527dd743cd719ab587dd831aceef", + "rawBytes": 541, + "rawSHA256": "536BB14E8ED5C1F10F4287FFBA541D7FEFD869570C59BEC2B31822F1FA0DC3F6" + }, + { + "path": "docs/internal/extensions/opt1/certificate-refreeze-design-base.json", + "mode": "100644", + "gitBlob": "a294ddae75e64bc636bbf8f0b50a3b5cdb0a5dd9", + "rawBytes": 623, + "rawSHA256": "F1BD0367BA82A5BB713FEE5DE51F290DC6782E5C68EE131B52D917EB63F9152F" + }, + { + "path": "docs/internal/extensions/opt1/certificate-refreeze-design-phase.json", + "mode": "100644", + "gitBlob": "fc7d93a473d118557146b1cfa27b07106e14e7f6", + "rawBytes": 621, + "rawSHA256": "D9076DDC0F60F601B4968B2C2D7BEBEA8BFE06DF49DE7024BE2363FD706F2361" + }, + { + "path": "docs/internal/extensions/opt1/certificate-refreeze-whitespace.json", + "mode": "100644", + "gitBlob": "1a3055e8eeec2352aadaf5279a1ca53fd649857f", + "rawBytes": 371, + "rawSHA256": "4DFDA2FE7512F4D522D070C3EB01D616CF494AB4B8D18412344340F5D4C66925" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/FIELDS.json", + "mode": "100644", + "gitBlob": "3760470717560aafc5ae4652522eff1953d001e7", + "rawBytes": 11640, + "rawSHA256": "0D1529C98D35B6FF2AC53D58D107F0A47EC8F5D263F51819C085827C055A63BB" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/REGISTRY.md", + "mode": "100644", + "gitBlob": "8785623d792ff3dbcb9b65c15dee10567f940efc", + "rawBytes": 5953, + "rawSHA256": "997C8A493E5DD368044349BAD691D40D498A78ADAFA66F2EA5AFC51D7908721A" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/RUNNER_REPORT.md", + "mode": "100644", + "gitBlob": "65cc59d0c73fd836ee4af9d825d16f21ea54f23b", + "rawBytes": 20159, + "rawSHA256": "EB59209616D32284AC4370B8A8D26E629A4BFE38E904BAAC508C76260BE534C1" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/evidence/a01-import-root-failure.json", + "mode": "100644", + "gitBlob": "de971a9e1a77729b4d48805f66bef0f8e0b95edd", + "rawBytes": 153256, + "rawSHA256": "5F987FAF04FA40BCF2319ED2F9C3063D389C0F7411BA21C4FA6B82F1F4FB6A5A" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/evidence/checker-boundary.json", + "mode": "100644", + "gitBlob": "642e34da0a57e5c7e8f44e515abada6ce4f45c7f", + "rawBytes": 3502, + "rawSHA256": "6870368241743AADC3E51882F46FF4368D9B72E6E939A831C71C6F9D8D7ADDB0" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/evidence/focused3.json", + "mode": "100644", + "gitBlob": "1cfa5aaa9d43e2924be229c8b07ee92254447209", + "rawBytes": 934903, + "rawSHA256": "85EB9C4F2F4F5D964FE4722E4D55E5DE9FA1196C62CCC0392988B558F261D6FD" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/evidence/full80.json", + "mode": "100644", + "gitBlob": "6c97d253ebdb58eaab48a4c8372ecf908426bd6e", + "rawBytes": 1382859, + "rawSHA256": "451E108122B077310137E8A2CA206062BB83274EC01A3CE7387FEDC271EA66EB" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/evidence/library-controls.json", + "mode": "100644", + "gitBlob": "55cd321fe6eaf8263440652724a3562897a5104b", + "rawBytes": 286241, + "rawSHA256": "A2DA227FB1CA66A0403E2F17160F746E84124FC5EB75B2E48098AB8395379FF6" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/evidence/prepare80.json", + "mode": "100644", + "gitBlob": "ed0855b11765dd4c099e49f137273c6b28a17532", + "rawBytes": 127479, + "rawSHA256": "B2E4FECABF82CFBB9E04FE4732B3FC9F0E59178FAEF22306D6E09E8E0382BD10" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/evidence/selector9-final.json", + "mode": "100644", + "gitBlob": "cbe2ceb9432f1586499d06f67dc5dc2030da9eac", + "rawBytes": 20351, + "rawSHA256": "A9CA2C1BB3CEDA7CE2834ADB5109DC0536815AA3E655B5C95E8602D72461E0B4" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/evidence/selector9.json", + "mode": "100644", + "gitBlob": "2895c7b7dba8da08cd406207e55bb2a8b2dfc6de", + "rawBytes": 24907, + "rawSHA256": "C4C5301A38D52BFB88A525FE1111A78B2F5598B1DF4A9358ECD5E6232E91D13A" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/evidence/uncaught-boundary.json", + "mode": "100644", + "gitBlob": "b845007c7087a632e4b51258b50d1d41030190d1", + "rawBytes": 2821, + "rawSHA256": "9E089837103FB2A1D968789C46725F61D7B312744265E13AD376AEDCABAAE507" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-build-snapshot.json", + "mode": "100644", + "gitBlob": "169622f89d468902a1328a8faf22f9529095445e", + "rawBytes": 424, + "rawSHA256": "04AE861A4C82AF33DD59849287DEC4F48E34E1BA61F31C8388BE03E1D04CE09D" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-claims.json.gz", + "mode": "100644", + "gitBlob": "0fae86e162e6f220a31d747520d45e1620788fdb", + "rawBytes": 11761, + "rawSHA256": "08167E54224598F390183A4EE2038ED8A69BB2E72CD52C5B3BB8506474C9C141" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-committed-design.json", + "mode": "100644", + "gitBlob": "4013ef9ec5deea669fa145690d6c9e71878ea3b7", + "rawBytes": 589, + "rawSHA256": "BAFA5C9497EABCE97A1D056382B7CF958F707AAC094F772E7733FF0E14CDC90C" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-committed-whitespace.json", + "mode": "100644", + "gitBlob": "54c0eead4715bb094c6b886222dd94e1ab60872e", + "rawBytes": 372, + "rawSHA256": "FC37E45574095D4E0121759A46511BD14A6AF3CA1660AED5A1133617CCF7DCCE" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-design.json", + "mode": "100644", + "gitBlob": "71ebe17e3f16d184b8c85b50023f1e23e31fcaa0", + "rawBytes": 568, + "rawSHA256": "A5A3C2AAD2A1E2273FF15D384B0F138FF02F881D72A0AFA2EC4AC56B66EF0B57" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-frozen-row-check.json", + "mode": "100644", + "gitBlob": "416725a794e0ccc27eb7d95ed2834c4361f6ef0a", + "rawBytes": 311, + "rawSHA256": "4F52FCD1D9D8EA212A8B3735E9C477CC7F2E249CA84920989FDB93078B6D0318" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-native-trust.json", + "mode": "100644", + "gitBlob": "71487dd5d5376ed1f839a2337d50b3b96c783d85", + "rawBytes": 310, + "rawSHA256": "C80B8BAB7ACDC4394FC1B66923798686A38FDBE4D509EA7B720074C05B8B13B9" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-phase-design.json", + "mode": "100644", + "gitBlob": "5c9d14840b1616d2ce37337f143511cab1940139", + "rawBytes": 585, + "rawSHA256": "7A82E852E03320FED52C5FC8B971C4FB046B290B2C16B5A8F3250ED2F397F195" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-report-claims.json.gz", + "mode": "100644", + "gitBlob": "4dbace32334765620f1ee094405b12c11e2c5ad4", + "rawBytes": 3724, + "rawSHA256": "718E2FA06AB7547546D5647B0A02536C11ABC81FD0A916DB2F6DC890754BFC41" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-report-design.json", + "mode": "100644", + "gitBlob": "ad93f155cbca988e0190fdab5e8dd3530024716c", + "rawBytes": 544, + "rawSHA256": "B252537DE31CCA61C0F59E7517302DA86F4E8FD1C3287E8874071025099D9B35" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-source-manifest.json", + "mode": "100644", + "gitBlob": "363a1255d084e9a04b37c5f3b91c864a10e8a0d1", + "rawBytes": 3447, + "rawSHA256": "C5BEFB4A98E2A66FBB1E7597E8A22550B2E3A4712A6BEDE1B113EFBDF4A554AA" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-trust.json", + "mode": "100644", + "gitBlob": "92fbc475a3bf7e00b29b00bcac7f86d88845559d", + "rawBytes": 390, + "rawSHA256": "15D186460818D17DC5CFB1EDE5AFCECD2998A23DD60AB071CF289BC22794E881" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-verification.json", + "mode": "100644", + "gitBlob": "833358983e832f377c395900737a43355ba08471", + "rawBytes": 3149, + "rawSHA256": "CB1963CEF206F5CAECD05466DA4D2CA2F7ED684A7BA8C6100DD86E44D973BCF3" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-whitespace.json", + "mode": "100644", + "gitBlob": "0a57d1e62ed751042f56d2b0a095d8006d4cfd71", + "rawBytes": 424, + "rawSHA256": "3F6E286DA95D014E9F3C6BE7DBC67C472B9BB573D8AFA481455838376B969FC3" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/20260912-084823-803-Compact.json", + "mode": "100644", + "gitBlob": "f3b4b17b8dc30c54b917b56f9236b2fba9b7b7c3", + "rawBytes": 895, + "rawSHA256": "7AFAE6BA26D203B4A912FC66C856E1F398B8AA65B0C72EDB5FAFE9247AC29C45" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/20260912-084901-469-CompactProof.json", + "mode": "100644", + "gitBlob": "dc2d2203d0fa5e9a89309affa3713a0535c91735", + "rawBytes": 4506, + "rawSHA256": "4279C74414260141F185461D4D3F2E1478F403B1E7A81C9D8690EEA637D640E6" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/20260912-085040-423-CompactProof.json", + "mode": "100644", + "gitBlob": "dc45b16f48f7320e1be6d2a289c8440b0321e8cf", + "rawBytes": 2571, + "rawSHA256": "FDCF0A010EF71BF76958441531A36393A204822F152F3C9EDCFE893A17E956F5" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/20260912-085200-649-CompactProof.json", + "mode": "100644", + "gitBlob": "2363ef8d9c0500880a2956ade10ff5a896c354c1", + "rawBytes": 908, + "rawSHA256": "562AF6A0A915F68F436523E93D070C622AA12F466855B423E1EE09FC94ABCB62" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/20260912-085248-004-CompactSafety.json", + "mode": "100644", + "gitBlob": "272b1fa495cae1929802f68540137e9cd72c49a0", + "rawBytes": 1447, + "rawSHA256": "59A09BF8D0BD6693D776D199ED40B03EC5FCAFD725F1082CC36EB53EE66A6240" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/20260912-090310-823-CompactSafety.json", + "mode": "100644", + "gitBlob": "3397478fdcc4d11e01b7743a603bfef1a9c0d265", + "rawBytes": 912, + "rawSHA256": "7F79CB02A40F01AFAD43965972DF4683C8F1B648325733562EDD53520AE47A49" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/20260912-090340-416-Axioms.json", + "mode": "100644", + "gitBlob": "dc13facb14702bd6a7596281cdda2a5d15f41f17", + "rawBytes": 5649, + "rawSHA256": "F93AA3A26B117AB1E73E0E38AA1EC7B0DC73B000CCCC49267CD66B2BF628E889" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/Axioms.lean", + "mode": "100644", + "gitBlob": "8eced0c19d2b6935b2f3dc64b9966774f14ab724", + "rawBytes": 1466, + "rawSHA256": "727E2C58C62040B3C5800219FEDDE8B566FF3EA2D5C49B12546612F66EF2935F" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/CERTIFICATE_SOURCE_REVIEW.md", + "mode": "100644", + "gitBlob": "31874cbbfa23d50f1d73a99f911870965f947a9c", + "rawBytes": 2580, + "rawSHA256": "92654FC7D2B5720C8A40EE2E26B2461377A53680B830033FECA0F64E6E32B5EE" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/PLAN.md", + "mode": "100644", + "gitBlob": "f3bed146a135b3dcc8d2582737a15b63f8c84a75", + "rawBytes": 2584, + "rawSHA256": "4AE090C92041861EC7A63D2B7F69440474C4FBFEA36EAD561D95498BD7DF633A" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/REPORT.md", + "mode": "100644", + "gitBlob": "01b860f56d432053ff667f71a740126b3bf3e249", + "rawBytes": 18304, + "rawSHA256": "3239E7EADF1E0E2AA03ABD96AA9DC5BD2F305C4C7BE6C7F7A1AD3C8E1CF9CE6B" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/RESUME.json", + "mode": "100644", + "gitBlob": "77088bab230c467df2f2d116fb2822a707d8394c", + "rawBytes": 884, + "rawSHA256": "8F51968010D6CE363B72C4FC8510A0CE4C46E796872B9C8FCB76163816FD5695" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/RESUMED_DEVELOPMENT.md", + "mode": "100644", + "gitBlob": "8fd8ae853ad34108d8444b13838cb35589497eb6", + "rawBytes": 3356, + "rawSHA256": "EAE19A4AD99FB2B3E7E86B6030A5916B896ED34BE1074EE90F1B5DB1FC381858" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/certificate-source-review.json", + "mode": "100644", + "gitBlob": "e7409051cd704df0cc63e28dc43bf917266eddc4", + "rawBytes": 425, + "rawSHA256": "AE6BE09AEF5867926EED53871DA2EAB02EDB6AC78334AC4F2B4DC0532CC6C63A" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/check.ps1", + "mode": "100644", + "gitBlob": "5c11dbdaacaa7a16bb8c382a93391d0a0e90a864", + "rawBytes": 2380, + "rawSHA256": "08422A0A46060F662DFC22675282CCCBF6C5FE98A415C7366988CB069330513E" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/final-leaf-checks.json", + "mode": "100644", + "gitBlob": "986b39ec3abda768e5601dfe7cc87322eaf2618c", + "rawBytes": 3377, + "rawSHA256": "F3E20ED546ECE012062A99EB856613DF5E09559BCA67ABD79930FBD2CA838CBE" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/phase-static-checks.json", + "mode": "100644", + "gitBlob": "e2285e7ee5967ff12dad9e3a97d13540ae789f67", + "rawBytes": 425, + "rawSHA256": "6743C04B38F81EC56EC0D57CEDF936D9FA557ECF5CB46F44EAB3028E1C15B72D" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/20260912-085342-909-CompactStatic.json", + "mode": "100644", + "gitBlob": "9d9e2aea9e1ceb88f90457a19724d693f2b11095", + "rawBytes": 5604, + "rawSHA256": "421330AFADF3460947326D3CFD2293C00F86C496300ED44483C47B49D225943D" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/20260912-085459-926-CompactStatic.json", + "mode": "100644", + "gitBlob": "e5b34d2c418870aac2c7b0385d54ad5eb0819b49", + "rawBytes": 908, + "rawSHA256": "FE696B23BB8AD9E1F82F34C04DD2CFED288123D0F263EADBD279F19B7FE892C3" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/20260912-085506-634-Types.json", + "mode": "100644", + "gitBlob": "919eb3a8dada239c3536458e306a50afebe6dd73", + "rawBytes": 14437, + "rawSHA256": "19356B94B9AD3A6C8316467255F2758D02F14004AEB228A4C1AF23456FD9D58C" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/20260912-085620-197-Query.json", + "mode": "100644", + "gitBlob": "70155a96a334c27eb380dd8f436286c40f9f6451", + "rawBytes": 2935, + "rawSHA256": "0A71CA87BE84A7B3F09300708006066C37B63536D9DC994A4BF1B12E455B3045" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/20260912-085823-722-Query.json", + "mode": "100644", + "gitBlob": "e39ed459c830f1ae11507052f4cb3abfa525ffaa", + "rawBytes": 884, + "rawSHA256": "4B7A66D6E0022E9DEFEC7AB6564B504847A406A79CC1BC24AC61EE0C8004B4D8" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/20260912-085851-734-Measure.json", + "mode": "100644", + "gitBlob": "22c9c568c941ebb743646ad5c6c89d2d03d857dc", + "rawBytes": 1526, + "rawSHA256": "9712E297C60EB5C8ACB75EBA3EC3014B3CF288753D5AEEFC0BC25419ACD4FD66" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/20260912-090142-761-Query.json", + "mode": "100644", + "gitBlob": "62fee6ade232109db2e917f330e6647854f1bea8", + "rawBytes": 884, + "rawSHA256": "FE9E2FEBC97B6E5C59D3433EE3EDE1BDCD0CA03AEC8E733FDC4FF28FA4CD106F" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/20260912-090148-784-QueryTypes.json", + "mode": "100644", + "gitBlob": "c8fd47fbb0e4e521b83cedba30700f6d22cc2b8d", + "rawBytes": 10976, + "rawSHA256": "FE18BF368397FCB26B11267210B9ED708A7F3CF790395DCE0D7DD80B2C46B3D8" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/20260912-090227-589-Measure.json", + "mode": "100644", + "gitBlob": "849950f2ffd88755587edc009db1bcdb61b85923", + "rawBytes": 1528, + "rawSHA256": "780A78C18CBCA37BF789E0FD1CA5845FDD65D4C278749641DF4697582CA2F8FB" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/CONTRACT.md", + "mode": "100644", + "gitBlob": "6e0056a8585797b14633fe41e1c6a2392898bf6b", + "rawBytes": 6628, + "rawSHA256": "5FF9AC6B1A64F64320B3AE2F45CA8585CDC6999F13D9EBCAFF482C6D91C22B59" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/Measure.lean", + "mode": "100644", + "gitBlob": "3972ba630c8c04334bc041a025e12d5194e60ec4", + "rawBytes": 969, + "rawSHA256": "8DF1007BB02C218EBC4F04C56B46F90C03D486BD59727C1BE485AC1C9AA434AA" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/QueryTypes.lean", + "mode": "100644", + "gitBlob": "1f56d6ad857e174cb816e82e64f9870a5304dd50", + "rawBytes": 1361, + "rawSHA256": "19ECA8B5FE4478DC99DADD8CE03BA3777CFFDB97486CC6AE6EB4430ABCAB3159" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/REPORT.md", + "mode": "100644", + "gitBlob": "4f5fa21952ed36377bf47f5f328bf33985d723ed", + "rawBytes": 13704, + "rawSHA256": "DEE26E3F2C8B90F87C9FF9D4B9D3F9E8663E8DFFDC066C9FAED0FA903D797B0C" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/Types.lean", + "mode": "100644", + "gitBlob": "c4a311a494a6b1d18f32e5e5ac2488d3b8eb2427", + "rawBytes": 988, + "rawSHA256": "06495A99FB8D5C825B5B3718CF82887FC29595E029380835158FFF42C1AACA24" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/check.ps1", + "mode": "100644", + "gitBlob": "a0ba77d50fa2cd521e5c703e312734989dc04c1c", + "rawBytes": 2068, + "rawSHA256": "03F3017AD766A9B2D194C58692FD304481B40C5A0BA10AE094272DF3A55BD666" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/hygiene.json", + "mode": "100644", + "gitBlob": "fcb6c1765b6739b9843504bf466bfbadabc36264", + "rawBytes": 1488, + "rawSHA256": "781E058040A8FE4061C2CF2F28C52B21C0CF24F736112D68419346EE9F996B6F" + }, + { + "path": "docs/internal/extensions/opt1/composition-checked-manifest.json", + "mode": "100644", + "gitBlob": "8eee99fcda53122ed6cce566a4051e2e43b3915a", + "rawBytes": 1584, + "rawSHA256": "F03F3263E6957895EAD692C09336C98295B983375EC3B74C14215AC7CEF18E45" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/20260912T0909250020255Z-axioms.json", + "mode": "100644", + "gitBlob": "c57f5ed18279ace9964c8a96cd80aebf7e2a2368", + "rawBytes": 23017, + "rawSHA256": "F1C2DC0F11CBDA559D47ACE223A5C0806629A76399A768B9C751E13643F7C4C2" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/20260912T0922141726079Z-axioms.json", + "mode": "100644", + "gitBlob": "8a897c23ab987efee67cf7732e39a917b5826d12", + "rawBytes": 52220, + "rawSHA256": "8E8E84AF416AAACE4328706C360210B4A48E24D306DEBA20DCF057481D4ECFD8" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.Capstone.20260912T0904477547021Z.json", + "mode": "100644", + "gitBlob": "415ca4349b8892f64d5844c438b53287f8cb0f52", + "rawBytes": 1425, + "rawSHA256": "23BC4401036411F7B453B34F8EEF86C42C514E947D088968327E64542D637C89" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.Capstone.json", + "mode": "100644", + "gitBlob": "415ca4349b8892f64d5844c438b53287f8cb0f52", + "rawBytes": 1425, + "rawSHA256": "23BC4401036411F7B453B34F8EEF86C42C514E947D088968327E64542D637C89" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.Certificate.20260912T0904184780573Z.json", + "mode": "100644", + "gitBlob": "b0bd8dd73100fe945e59f3b59b53474dcfec80eb", + "rawBytes": 1436, + "rawSHA256": "83EAE680D8E3CF57BB0A7F02561883BC82577D651D0E7628C5B221FE5A76A26A" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.Certificate.json", + "mode": "100644", + "gitBlob": "b0bd8dd73100fe945e59f3b59b53474dcfec80eb", + "rawBytes": 1436, + "rawSHA256": "83EAE680D8E3CF57BB0A7F02561883BC82577D651D0E7628C5B221FE5A76A26A" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.Consumers.20260912T0904550751995Z.json", + "mode": "100644", + "gitBlob": "166a894dfd994882fc928efc74c5d77cb2054988", + "rawBytes": 1428, + "rawSHA256": "A99865249022A28CFF6831744BCBD1521D304A7B6A49413922BF69C5D14C2B8B" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.Consumers.json", + "mode": "100644", + "gitBlob": "166a894dfd994882fc928efc74c5d77cb2054988", + "rawBytes": 1428, + "rawSHA256": "A99865249022A28CFF6831744BCBD1521D304A7B6A49413922BF69C5D14C2B8B" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.QueryProof.20260912T0904107871054Z.json", + "mode": "100644", + "gitBlob": "902a79d976572ff8df611e8ec4470add495bb622", + "rawBytes": 1432, + "rawSHA256": "BA05922219808E78C74EB9232DEA3E2476D08048D2B21FEA34F49D38A74D4EEC" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.QueryProof.json", + "mode": "100644", + "gitBlob": "902a79d976572ff8df611e8ec4470add495bb622", + "rawBytes": 1432, + "rawSHA256": "BA05922219808E78C74EB9232DEA3E2476D08048D2B21FEA34F49D38A74D4EEC" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.QuerySafety.20260912T0904137135959Z.json", + "mode": "100644", + "gitBlob": "c75cecbd31885ba7a09aad2781077352553c7d23", + "rawBytes": 1436, + "rawSHA256": "6408E084C7EBA6F163DDE0E5D5D097810EEDDBF4835C8A7A57C2B1C85592A9B0" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.QuerySafety.json", + "mode": "100644", + "gitBlob": "c75cecbd31885ba7a09aad2781077352553c7d23", + "rawBytes": 1436, + "rawSHA256": "6408E084C7EBA6F163DDE0E5D5D097810EEDDBF4835C8A7A57C2B1C85592A9B0" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Packed.ArrayRun.20260912T0907263701277Z.json", + "mode": "100644", + "gitBlob": "de2ed5960461ecb5ec1bf81a009c26688f5fb12c", + "rawBytes": 1400, + "rawSHA256": "2FC6881D3579267B1540F8F6A51406B5056D4394BAD1DCCB28834F2F5AC1F63B" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Packed.ArrayRun.json", + "mode": "100644", + "gitBlob": "de2ed5960461ecb5ec1bf81a009c26688f5fb12c", + "rawBytes": 1400, + "rawSHA256": "2FC6881D3579267B1540F8F6A51406B5056D4394BAD1DCCB28834F2F5AC1F63B" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/scheduling-overlap.json", + "mode": "100644", + "gitBlob": "cccd889a1f2d69b749bdd009899da9fb116f2fe0", + "rawBytes": 1137, + "rawSHA256": "E9A2253E539EF1D1278F116BB5D0C45081DF26EEFD1516245EF014915130257D" + }, + { + "path": "docs/internal/extensions/opt1/continuation-entry.json", + "mode": "100644", + "gitBlob": "49e9bfb3dcd2832f08792ad96405d381248aea0d", + "rawBytes": 824, + "rawSHA256": "014F6DFF932F672D844C8356AF342A012A6E48C70C9CACB2A23F665787BAD352" + }, + { + "path": "docs/internal/extensions/opt1/final-evidence-identities.json", + "mode": "100644", + "gitBlob": "8f116678395084dba455e2a03274cfb52677da52", + "rawBytes": 1306, + "rawSHA256": "82D15A8BA8B269E591CAE01EEDA2D787123DB5568D94A2F32C1777A5A17728BB" + }, + { + "path": "docs/internal/extensions/opt1/final-report-before-storage-claims.json", + "mode": "100644", + "gitBlob": "90e6089a88717a56f9fb68d2542881faf216f472", + "rawBytes": 762, + "rawSHA256": "BAC4A2BFA2BDF2C428C6323DE0CBB61A6A4BC4B51BC248D7F9B0E1A625346F0D" + }, + { + "path": "docs/internal/extensions/opt1/final-report-before-storage-design-base.json", + "mode": "100644", + "gitBlob": "410865ef2d90360c1203173cd43f4ccecec8dbf7", + "rawBytes": 647, + "rawSHA256": "75B0103370BF4D78F900E7B0EA336847E26DB7BA8DE90666D44146A687EF30E3" + }, + { + "path": "docs/internal/extensions/opt1/final-report-before-storage-design-phase.json", + "mode": "100644", + "gitBlob": "099fc61d39ade54a165913c4c2de9ef0c3df9cf3", + "rawBytes": 645, + "rawSHA256": "EEE3B65442C7F5620BCEB7D28D88795A5338FA1BA83115358A30B070C641D136" + }, + { + "path": "docs/internal/extensions/opt1/final-report-before-storage-whitespace.json", + "mode": "100644", + "gitBlob": "484a74b92e4d25732c1fbe07333623809c3eb7a7", + "rawBytes": 387, + "rawSHA256": "D2F94D08A72EB97CF489FC9DCF844B91B272B3C25AC8622EFD3A5E5668A37AB5" + }, + { + "path": "docs/internal/extensions/opt1/final-report-claim-check.ps1", + "mode": "100644", + "gitBlob": "60209b954bdca870141958cf0c6f1fccafb9b731", + "rawBytes": 2499, + "rawSHA256": "30F083CA9C59B4397E2879B69D89241432E29C0AC8C33590A5803F130668429F" + }, + { + "path": "docs/internal/extensions/opt1/final-report-claims.json", + "mode": "100644", + "gitBlob": "543b3e23e81be5bbbcff7847203b1baabc3fa44d", + "rawBytes": 1242, + "rawSHA256": "E1ABB075A6761C3704F2692750F1748A63EB47ECE9533324524D96F475BBB152" + }, + { + "path": "docs/internal/extensions/opt1/final-report-design-base.json", + "mode": "100644", + "gitBlob": "66f063f4b046851d95178bcfaec4ba429b0963a8", + "rawBytes": 684, + "rawSHA256": "5493B1B594C865453689C0453D574E9662467A58A928B0B8248D80B4D2D15547" + }, + { + "path": "docs/internal/extensions/opt1/final-report-design-phase.json", + "mode": "100644", + "gitBlob": "10df1327fd3e01f736ec4f99fe97bf654e8ecb33", + "rawBytes": 682, + "rawSHA256": "3ACCFF510040F90091AC6EFFC872C2DF156ECF3B9E8724A037C51C39FB2D2703" + }, + { + "path": "docs/internal/extensions/opt1/final-report-hygiene.json", + "mode": "100644", + "gitBlob": "aab64100860cd228030f9bd902cbee4d44819313", + "rawBytes": 363, + "rawSHA256": "FAB0D5E37B57B301F9E424B5F4C6CE5B930D3E6BBE5D5CE7FFB674B828E5BE05" + }, + { + "path": "docs/internal/extensions/opt1/final-report-index-bytes.json", + "mode": "100644", + "gitBlob": "eadd023731b30598b073375b9d8f3c50556fa676", + "rawBytes": 2275, + "rawSHA256": "06D4E94B6E69BA7736BA6521922A4F71F3B476E03DA8EB504CC640786A9C1A9B" + }, + { + "path": "docs/internal/extensions/opt1/final-report-index-whitespace.json", + "mode": "100644", + "gitBlob": "24a4ddfea3de9bd653d52f3e84bc4445ffab6eb2", + "rawBytes": 505, + "rawSHA256": "E3BF5FECA3B8B7D9FD798066C41767791331BEA7997B999DC88C982B2D7F0B48" + }, + { + "path": "docs/internal/extensions/opt1/final-report-storage-whitespace-first.json", + "mode": "100644", + "gitBlob": "8ca9d3fe1134a254924f78d112ad3ac3c3919c9a", + "rawBytes": 489, + "rawSHA256": "F6D62405DF797CB6CF0D19518E6708C5D3DE063D2D8211B949DC5CD4F3343319" + }, + { + "path": "docs/internal/extensions/opt1/final-report-storage-whitespace.json", + "mode": "100644", + "gitBlob": "6df6613d743bfc6e7ef88a9490eb994b83b7e3d4", + "rawBytes": 361, + "rawSHA256": "F00DB22CE9D17D37D8115000BEF33219ACFB9986C475588744BAF49BF8BF3CC5" + }, + { + "path": "docs/internal/extensions/opt1/final-report-whitespace.json", + "mode": "100644", + "gitBlob": "04fa0595a8793c0b859e869d55efa3cb855f2fc2", + "rawBytes": 399, + "rawSHA256": "745C78AB1141C8333CDBFDDBC144B86A381CEB89D14574CCBB8E63F81B0EEEEA" + }, + { + "path": "docs/internal/extensions/opt1/final-source-manifest.json", + "mode": "100644", + "gitBlob": "5c718ee22a5b7a2f4cb0800e229a864e962226f7", + "rawBytes": 9411, + "rawSHA256": "41F867CB8BDBA0AC528974842A131853574E5B5BB66361A5EB9CEEAA75A5608B" + }, + { + "path": "docs/internal/extensions/opt1/freeze-claims-attempt2.json", + "mode": "100644", + "gitBlob": "7652e2e38705107c1a3ca25f2285461c7ec8e16a", + "rawBytes": 711, + "rawSHA256": "C455BF7D69A6719CE8FADE81D29B94105C101F753A2968C3638ECE6AE6DA80A5" + }, + { + "path": "docs/internal/extensions/opt1/freeze-claims-pass.json", + "mode": "100644", + "gitBlob": "8c49dc5348bf6a743a9d36fb9aaf5f26efd82891", + "rawBytes": 484, + "rawSHA256": "6B7E373FD244252C1189AE0EB3CDD265F45C48F14E2CD862CFD4522A7D44564D" + }, + { + "path": "docs/internal/extensions/opt1/freeze-claims.json", + "mode": "100644", + "gitBlob": "eabc08c5f28248eb43b3fd6bf0a7c5cccc20b569", + "rawBytes": 835, + "rawSHA256": "F9AEABF228081DF4CB95CA6CC6901D8276F956347ADF335A4573567C4DC0BAEE" + }, + { + "path": "docs/internal/extensions/opt1/freeze-design.json", + "mode": "100644", + "gitBlob": "0f68730eac79f68227c2c847c36917c05b3836b0", + "rawBytes": 518, + "rawSHA256": "73E4CC9DA66CF41B9E69FEDDB1C656E3E20779E47259A6C287E99AF803507823" + }, + { + "path": "docs/internal/extensions/opt1/freeze-native-trust.json", + "mode": "100644", + "gitBlob": "ea0e827fe53d266a9e766ee7abb605b5f45bf8f2", + "rawBytes": 120, + "rawSHA256": "4046AEC39A9489A8B4D83BA9994B9E39250E8EEACB03E005B94E69CB35292616" + }, + { + "path": "docs/internal/extensions/opt1/freeze-source-manifest.json", + "mode": "100644", + "gitBlob": "4df002e53576e7e63b24035e35144344c6aa6640", + "rawBytes": 3778, + "rawSHA256": "96700BE0F86DBF7ADD1202380CAFE33360D2297F54F8F2335CBB465D08E7103A" + }, + { + "path": "docs/internal/extensions/opt1/freeze-trust.json", + "mode": "100644", + "gitBlob": "c8c5fb79528344f8ed05e0c84815ed18ded9b55b", + "rawBytes": 120, + "rawSHA256": "0B6E7FB93852D5CEB7022F5DCCFF39F42B661164B4B760EE6D6F34FA49253E7B" + }, + { + "path": "docs/internal/extensions/opt1/frozen-row-check.json", + "mode": "100644", + "gitBlob": "d9d937d0b9068009b2c96bc074eccafa0f534063", + "rawBytes": 1185, + "rawSHA256": "0F9AA7E67576C7CD62C7B616BC7A99C27D9AE4D4A9BAFBD73E25C321D434E5C6" + }, + { + "path": "docs/internal/extensions/opt1/import-repair-hygiene.json", + "mode": "100644", + "gitBlob": "7ca895bd081903a25390458c6832b475e216b2ca", + "rawBytes": 338, + "rawSHA256": "AF74D3F0921C4B02B341BB80B06FDF0EE335057815EB668BBCACEF9B51C56686" + }, + { + "path": "docs/internal/extensions/opt1/import-repair-refreeze-claims.json", + "mode": "100644", + "gitBlob": "6e1e6f2e3d0221f0878a18685d29e81192e680ef", + "rawBytes": 563, + "rawSHA256": "84C44752B086CAD72ABDD715A11BB6F17DEBA856C05378C79E59C28D06784A56" + }, + { + "path": "docs/internal/extensions/opt1/import-repair-refreeze-design-base.json", + "mode": "100644", + "gitBlob": "f394b8d16b5eb829698f5cd641ae97a96be8b53f", + "rawBytes": 647, + "rawSHA256": "5D9893A7C3E5AA4AE54628117E7B5629A73C99DAE286A1AFB72AE4A96B9AFAFD" + }, + { + "path": "docs/internal/extensions/opt1/import-repair-refreeze-design-phase.json", + "mode": "100644", + "gitBlob": "cd7afb2444cec0d8b4e36605b69cf5beac6bffa2", + "rawBytes": 645, + "rawSHA256": "3D1BDB4B32748A5474D0658054E2A3EF2291A9FD887C7333A1D9427B6D825785" + }, + { + "path": "docs/internal/extensions/opt1/import-repair-refreeze-whitespace.json", + "mode": "100644", + "gitBlob": "6856b5661f5966d364f3c4f0a81e2b16225631c0", + "rawBytes": 386, + "rawSHA256": "841596819014C1CD21441DBF8C776CBC177F3D841AB4F9AD20B3061CF8AB309C" + }, + { + "path": "docs/internal/extensions/opt1/import-repair-source-manifest.json", + "mode": "100644", + "gitBlob": "9aa4177063eb13717c9482772390fc551c4b636d", + "rawBytes": 4763, + "rawSHA256": "8143B412B8CBEB6C90C8EE00FB17762FA708A47831207913FED9C0A3F5FABC5E" + }, + { + "path": "docs/internal/extensions/opt1/local-final-scope-check.json", + "mode": "100644", + "gitBlob": "8317750eab45995f58973e78a69a81e762072714", + "rawBytes": 415, + "rawSHA256": "3E0617F0025B6F1646283A3692180FA5319B7767FDA9AEC8AB22AD96C5988475" + }, + { + "path": "docs/internal/extensions/opt1/query-build-plan.json", + "mode": "100644", + "gitBlob": "e405d726e143e3596a6ea2fc20b496bb7319a988", + "rawBytes": 12999, + "rawSHA256": "799C039592DDD8D42293BED5F94AEB4846EDC113FFDBB8EBF60E17D48CAFA4F8" + }, + { + "path": "docs/internal/extensions/opt1/query-development/BranchCapstoneChecked.lean", + "mode": "100644", + "gitBlob": "33394feababc91b760f64cd1d44c680f751496c2", + "rawBytes": 4034, + "rawSHA256": "F56C0D5D62B0BA4E480108BAE36CC11CAE5F3CEBF4772EFDA813D2BB4DBB2D65" + }, + { + "path": "docs/internal/extensions/opt1/query-development/LAUNCHED_BUILD.ps1", + "mode": "100644", + "gitBlob": "5fe81d41eb776c3c0c39b836ac9997bc86708b96", + "rawBytes": 3292, + "rawSHA256": "C6A5A2FD340FBEC6EEF66D1E014B28719F81DFFD5498CBBB5F50EE13C22F5E33" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Backend.json", + "mode": "100644", + "gitBlob": "fc8b37f478652827d44f6e9bc1883c2c78a639bf", + "rawBytes": 1332, + "rawSHA256": "F552EBA7694CC8BEB494C2CCBC27871E87BB2BFB7C974EC0CA91275DE6DAFD59" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Cartesian.json", + "mode": "100644", + "gitBlob": "b39da338e9d4ed550ed7d73cbed4604c9a2d5626", + "rawBytes": 1341, + "rawSHA256": "576FFB263966B0FBE7FD2EF75AC59C17D951E0E994D9DB7A8B26FB1347863392" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Cost.json", + "mode": "100644", + "gitBlob": "7143d9bb0d7338073a64b2250416d0e121fd8862", + "rawBytes": 1319, + "rawSHA256": "3307EA82D5CD1AB3AB50100ADD3850165C13F156435E6380C04238B5EEDA0E23" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.EncodingLowerBound.json", + "mode": "100644", + "gitBlob": "d2b93cc6a8ade999714c27398a0a76ef0580b23f", + "rawBytes": 1376, + "rawSHA256": "09FA3092E5DE54B04E373AE277D7EA368C5B318DEEFF9AF10C4A728F7B196ED7" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.Arithmetic.json", + "mode": "100644", + "gitBlob": "c3c591a49b17b748698d7d578929b785e837b7a6", + "rawBytes": 1402, + "rawSHA256": "305DDC7722CBBC3BC514F3162ABEDC71EF48F2F0F16901EF03D52C6034FB48B7" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.DenseEntryTable.json", + "mode": "100644", + "gitBlob": "ff4c670218916970ba0f0df6aca6744fbdbbdd5c", + "rawBytes": 1421, + "rawSHA256": "20C0325F4957A136BCFC045B52D137A1E4C56E1F3F61654128C79B388616E594" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.DenseWord.json", + "mode": "100644", + "gitBlob": "d005994b40833eabbf4dfeaf4b8aadcfa48f8db6", + "rawBytes": 1398, + "rawSHA256": "AB9F876246C881A74F216AC68C7DA905BE0DB60EE6C90078B768F8EA5B586072" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.Directory.json", + "mode": "100644", + "gitBlob": "7a39177e03b686e0715d9df0f48d33a29604f01a", + "rawBytes": 1398, + "rawSHA256": "60F22B9378D56E1FD6DE78B3D52C7392C91F559AEB56405D2754996D601527B5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.Entries.json", + "mode": "100644", + "gitBlob": "eee679f21b55c07bd474ec93db36bfcd7979691c", + "rawBytes": 1390, + "rawSHA256": "6C2DC392B4CE382977CC42434BB98525848BAD1EFF340FE118BA8B60FA8E4A06" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.Family.json", + "mode": "100644", + "gitBlob": "6d66a6d1c2eb9750c8421fe926ae406ef23d83e5", + "rawBytes": 1386, + "rawSHA256": "91F5F033935C02CD9D2F1CD4DB868091DBAE57DD79AD8C9C6256E7D1C4DB9B5D" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.FlagRank.json", + "mode": "100644", + "gitBlob": "abb06712fa224f3dce352570b9b5c070773d2c67", + "rawBytes": 1395, + "rawSHA256": "6782CA57FA4E8FBD4FAA236AFE3D9FA9C108E3DBDC8205B7D0A2B8842AA92641" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.LowLevel.json", + "mode": "100644", + "gitBlob": "df6ae7f22e6b51e69d5fab6e3567d5435ddf3c31", + "rawBytes": 1394, + "rawSHA256": "7CE68787B168F7AEA023564D781D805745B06CD5FDCF65404CF8760A2422C308" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.Params.json", + "mode": "100644", + "gitBlob": "3f99157c3fd58086bbbeaa27644a11292fc098d9", + "rawBytes": 1386, + "rawSHA256": "A03AB8A2AA91035FA3558ADC197223A295D2C0EFF9B9745A3B41D1F32516A394" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.Primitives.json", + "mode": "100644", + "gitBlob": "10a7836a0f5d23a9b5158e2d75320e2cf18b8110", + "rawBytes": 1403, + "rawSHA256": "20AA4AED043CAD0E989C317D4D657CD0BE95C799AA61484FB9D9957497897169" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.RAM.json", + "mode": "100644", + "gitBlob": "39d1df7eec47042f3d9110afbf6fbf5b263b675a", + "rawBytes": 1375, + "rawSHA256": "5FF389CF709189694F43F3F38F3FF24E4AE9714293B12AEA1A9CA5BD9E0FC4F5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.RAMStoreParam.json", + "mode": "100644", + "gitBlob": "209a678afae4b7cb78a066639a4494fe6a3362b6", + "rawBytes": 1414, + "rawSHA256": "159BD2A552CE41E98C2C2074603CC9CAC4AC8F06CDAAC24EA3BAE6B62B9ACB9B" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.RelativeSplit.json", + "mode": "100644", + "gitBlob": "b87d962f1530867c92243c86343504b7d1e4b64a", + "rawBytes": 1414, + "rawSHA256": "BCA933CC2F8A05B0DA672C5C713786E3329987F81E381B5B908F05737963BF4C" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.RelativeTables.json", + "mode": "100644", + "gitBlob": "bfd45589057a82e0f8e11312c8b426a3d02103ad", + "rawBytes": 1419, + "rawSHA256": "1FF092E5F06FF7564107341E6B74DB309D9700B2BBF733418DE2D944C1C120AB" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.SelectFacts.json", + "mode": "100644", + "gitBlob": "f46aaebffbb564f5e162dd351af1a1308235ddaa", + "rawBytes": 1406, + "rawSHA256": "481EB52FF7D42BA8276219D6EC34731EBD21E267F54AD22423E1B4E83AF33832" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.SelectSource.json", + "mode": "100644", + "gitBlob": "19618c2f0e437f845d03dd1c50bdb0ba5b78128c", + "rawBytes": 1410, + "rawSHA256": "26D124D13AC84D0F8B1812B01134488998050433A85D066F3BF89AF9348346A2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.Slots.json", + "mode": "100644", + "gitBlob": "27be1523f43b10c3e726b39a82e2d71187aacef3", + "rawBytes": 1382, + "rawSHA256": "86F0569A02C5033DD113A64943D34CEFD726517D6BEE586D0B5F6284F86474EC" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.Source.json", + "mode": "100644", + "gitBlob": "7b4392eb0e386cee47a492e14d86f01aa969d4fc", + "rawBytes": 1387, + "rawSHA256": "50323DB24CD8F4DF8FD1F7B067CF1210B57D1C24F85A0033AFF356E47CFBDA79" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.LCA.json", + "mode": "100644", + "gitBlob": "6eb3dd08cc636eda63bafc794f04e3f7d2599068", + "rawBytes": 1317, + "rawSHA256": "05855E1541726693D26B2616E12DAE17C10ED209672D6BF6B9A9DCF0EEC93B54" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.ListLemmas.json", + "mode": "100644", + "gitBlob": "28b9af5f992ab2e69cd9477d9537d2b6aa07179c", + "rawBytes": 1344, + "rawSHA256": "780D6C1FEEF1E4D6E1341ED5D73B9995F72433B1C4933CE576F76DAC30CA6300" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.LowerBound.json", + "mode": "100644", + "gitBlob": "a55bf6560265ce0443832aa8913b6dd95d3b424a", + "rawBytes": 1344, + "rawSHA256": "6AC5E1F5DF205034DB724ABA3AB9D1BD94BC6C8C78FB79E568B71E81A93A7F0A" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Microtable.json", + "mode": "100644", + "gitBlob": "d6e5bcf129a10cf92b70c717b480800e99c5e327", + "rawBytes": 1345, + "rawSHA256": "55A6AFC8E17D0EB7E66D90B223A4BA2E87AC4C14EC20139FCB95904F35D32AE7" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.PayloadLowerBound.json", + "mode": "100644", + "gitBlob": "687cc612d76ca9a4526e1d2a293ca03a4ad28e5a", + "rawBytes": 1372, + "rawSHA256": "18B0436ED703E16B13BD181F83724FC52BBF39ACD56BE7494CA884BDC674F317" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.PlusMinusOne.json", + "mode": "100644", + "gitBlob": "69ebad9b61f1fead3991f863f5d0f42b563b97e4", + "rawBytes": 1352, + "rawSHA256": "AF81C051C6C50B139C8D3BEFE6101BB56D14E663ED3B7E56B62C6DD6EF2DD185" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.RAM.json", + "mode": "100644", + "gitBlob": "ca1130e89bf9fc2892e26cdc269bfed8d65423e6", + "rawBytes": 1316, + "rawSHA256": "7FABAD833C2DB00EE229F71F090CAF691A7FF7FA1254961143A78411E197D387" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.RankSelectSpec.json", + "mode": "100644", + "gitBlob": "8695d6edb78586e330055ac7731f0fc69c508ade", + "rawBytes": 1359, + "rawSHA256": "28F8CA078412A61BCC24D8639EE44C86EBE153050C9D6A7EBEB851EB0CE16C84" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Reduction.json", + "mode": "100644", + "gitBlob": "91deef3b22db05bde6587d480e7a04f3c61efd0a", + "rawBytes": 1340, + "rawSHA256": "689FE67DF50F007769A5861519BDA38FECCB1CB37E84927939847B14BE0F6087" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Refine.json", + "mode": "100644", + "gitBlob": "c110565ad4d72a55c51b0e17d7634aaec1c206a0", + "rawBytes": 1328, + "rawSHA256": "476C2C2DB42A878D3C4B4C22500ECC035C7FC9A3955A6D2ECD9B3DB81C3796E9" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Shape.json", + "mode": "100644", + "gitBlob": "9c94d72b5fdbc22212b78741d6e6abc0f650a985", + "rawBytes": 1325, + "rawSHA256": "841A514AFD4A3729D2CDCDADE8BD65B16EF5C2502B099159CD787817F25859DC" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Spec.json", + "mode": "100644", + "gitBlob": "1d60209816a15dbfd028f0e58cab31dfc844f5b9", + "rawBytes": 1320, + "rawSHA256": "DA6CB769E81DEFABC8B84EF2FCAC0ADF57EE787E2F83F9F8303252A360637C92" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Succinct.json", + "mode": "100644", + "gitBlob": "18b9101f26fe0984f83baf6525846bd56e156f4d", + "rawBytes": 1337, + "rawSHA256": "125EC94BC3DBD57AB20D6A38EE5FE77E4959DEAF1F4AE0DBCAF69AF95B1318B9" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.BlockLocal.json", + "mode": "100644", + "gitBlob": "8d068786a714586be8daddbb04fcd162f02300ff", + "rawBytes": 1403, + "rawSHA256": "45F9D77D4C717EB41AFC61CD4DBCCF8551FD9F86BBC02C449AB10A23AB5E8B4C" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.EndpointMacro.MicroCodebook.json", + "mode": "100644", + "gitBlob": "2c4b4f588d51b3b36a16e89636505a66dc80812b", + "rawBytes": 1534, + "rawSHA256": "A830185571883BA013C91C819C51A9BDE0DF16657F8E3707BD36E589A5BACF62" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.EndpointMacro.RangeMacro.Concrete.json", + "mode": "100644", + "gitBlob": "8ffce50c833a0fd73db26bf31497045bc6442d66", + "rawBytes": 1560, + "rawSHA256": "4CACBE0C07E692FD73684D1C27BD545AF4D158F69D7200F48B0FAEC5939D8973" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.EndpointMacro.RangeMacro.PayloadMacro.json", + "mode": "100644", + "gitBlob": "3f8de5f24cf3e461b2bdfa215fdf216b1a4e560e", + "rawBytes": 1577, + "rawSHA256": "2D2EBF7779B03511EC6E74E90565CB4811FADEDF781354576CE30765A9B2078D" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.EndpointMacro.RangeMacro.RangeTables.json", + "mode": "100644", + "gitBlob": "fb5fa68fde18c37fe4cbf819aca956bf13beb6c3", + "rawBytes": 1572, + "rawSHA256": "BC77306132B43F7CC1C1419919494B1A9A067C55F64768E1A975DE6FC62F8B72" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.EndpointMacro.RangeMacro.RelativeMerge.json", + "mode": "100644", + "gitBlob": "8d461230213a014aea682f84918bd8381f844413", + "rawBytes": 1579, + "rawSHA256": "CDC399E4381FE07026BE723F4803893CA58D1385A02A11811AA1EAEB0218F51A" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.EndpointMacro.RangeMacro.json", + "mode": "100644", + "gitBlob": "527042f2b31c6e98e15f24d4324344ce1cd5955d", + "rawBytes": 1521, + "rawSHA256": "BBA26B07F5510DD539B82315FAFE8B983668664FAB1E2E902FB0C7702B79B6AC" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.EndpointMacro.json", + "mode": "100644", + "gitBlob": "7947fb44b6a8717968a494f3e32cb92801ff34e9", + "rawBytes": 1476, + "rawSHA256": "597598F62E3FE1FD04DE27F471F309DB5E00B85904BF735CC2CA8408D2F1361D" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.Candidate.json", + "mode": "100644", + "gitBlob": "fa267201976c3a72ac44b7031168e9197ed30422", + "rawBytes": 1534, + "rawSHA256": "1DEDAD8E67B173727753BD3005039DFA952718F1FB1643F0098E335FCDEB4D39" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.InteriorDirectory.Base.json", + "mode": "100644", + "gitBlob": "491db58b6115ba927da4ed5b2d832878c4a1226b", + "rawBytes": 1589, + "rawSHA256": "D428EFB3DF8AB401FBAD3A5E4BB6198315A59DA3699DEFA8EFF643729746742A" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.InteriorDirectory.SparseLevelWidth.json", + "mode": "100644", + "gitBlob": "042e3d574b7ab687911cf53a6cdd10add5878142", + "rawBytes": 1637, + "rawSHA256": "60FA3E067E3089D054A5C834FE69AA292B506DA461C6B6C0C82CBDC90E70A85F" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.InteriorDirectory.ValueDependency.json", + "mode": "100644", + "gitBlob": "ef6bf8ae229952e5f5735fc725383b3bd9325b74", + "rawBytes": 1633, + "rawSHA256": "090540424063E0D596C3F4B5C6149178732CCADD58D039E9FDF9B7E2FD2964A4" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.InteriorDirectory.json", + "mode": "100644", + "gitBlob": "4d844cda97ca32d5ff50ff3b5ae8e83274097b13", + "rawBytes": 1566, + "rawSHA256": "2A1AAF8ECA5773713ACBFDFF8CFBA1954861E8C84264D093915453CD3AF3DD07" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.InteriorRAM.json", + "mode": "100644", + "gitBlob": "951fb498cfd6b30bfb68570ba27440210644d764", + "rawBytes": 1543, + "rawSHA256": "63CC3979C2B79A3850B9CEC05851734696A186176B6DA98B6CE4F07F1B6DF73B" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.LocalGlobalSparse.json", + "mode": "100644", + "gitBlob": "cd93adfde80bbb7c0ec5219625b783ad961f2073", + "rawBytes": 1567, + "rawSHA256": "7F890B48A45BE67DB8631808BF9E9F34E3F4375EE4E7F7C2DACAE30925CEBB0E" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.RelativeScan.json", + "mode": "100644", + "gitBlob": "c65fbbffe9c487232175610d4b839fd998626668", + "rawBytes": 1546, + "rawSHA256": "73DF4276FB6B7E3E02CDA9823859672FA1B883B2C1B3A5D5C0F46DA5C885F3BF" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.TwoLevelCandidate.json", + "mode": "100644", + "gitBlob": "0ecafd1d25faec6fe034667c45f05a50c11ab0d3", + "rawBytes": 1567, + "rawSHA256": "B4A0471ED7024FBFE4B3E1970042CFA6AED143AA1A1ACF1CE34829F7AC94A545" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.WordReads.json", + "mode": "100644", + "gitBlob": "8bad9e4df745595228a6991c63f9c98dc0361717", + "rawBytes": 1534, + "rawSHA256": "E47AB1CD46089C57000D0EDF4E56A30A35EC5C9C2769F982816848EAB7614DAB" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.json", + "mode": "100644", + "gitBlob": "0c4a5813cec704f527b603323912ddbdeb40afa8", + "rawBytes": 1492, + "rawSHA256": "D20E8610FD33E030DE4CEC47B815F53969A7D55139C6CD169E64FF283E537B89" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.PrefixRange.AnswerSemantics.json", + "mode": "100644", + "gitBlob": "845ee3cf13160596acd6d931c8ac964999fad070", + "rawBytes": 1535, + "rawSHA256": "2CFB592E5499D61AF578BA93B8BACC25A2F4B5A63A49508DC0CB561C4D80BE5D" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.PrefixRange.LocalSparseOffset.json", + "mode": "100644", + "gitBlob": "2667638cb78545ebd8a7acba3e484a97374ecfd5", + "rawBytes": 1542, + "rawSHA256": "3F3D02D1C51A424E114D9F16A52C87DF0EADE3A5E8158CB98F1995ACE5D556D2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.PrefixRange.PrefixArgMin.json", + "mode": "100644", + "gitBlob": "8425454d725660f97466ba6a3d0bbef8fffc3ddd", + "rawBytes": 1522, + "rawSHA256": "EF13B0581791BC6EFBA57F382AE0FC6884C566A28A4BFAFA7AFFD35C72126DB5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.PrefixRange.PrefixWitnessTable.json", + "mode": "100644", + "gitBlob": "303c32bcd0104a7c73b9c3fab02a9efb757b399c", + "rawBytes": 1546, + "rawSHA256": "761610B731F19915C36DE7347AD182368306D2A394511C1D2FC6A1C90AD556D7" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.PrefixRange.RelativeSummaryCandidate.json", + "mode": "100644", + "gitBlob": "a392323cf4e1d08e325fcdc643b4c89b0ea0bf93", + "rawBytes": 1571, + "rawSHA256": "B180D7E7746C11D3FA8AE35B54668EEE8ED431E5B77BE781F9C0E2636C2057D0" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.PrefixRange.SparseArgMin.json", + "mode": "100644", + "gitBlob": "7b3408f57cc64e32cc13ae627c909a1570d6f781", + "rawBytes": 1522, + "rawSHA256": "C8630B6292756A2EF04DA2253AC146C6F5C841E298C188D4993E8DF9F0F0997D" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.PrefixRange.SparseLevelTable.json", + "mode": "100644", + "gitBlob": "36203883d6d7ceb985b6c46607386d28165a37eb", + "rawBytes": 1538, + "rawSHA256": "990BAC4DFDDE10607D95CC12F6635E40E0B92265BBC1B147395E5E3A45672E8F" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.PrefixRange.json", + "mode": "100644", + "gitBlob": "5db6d097f144dade6005ad1f5c4bf78d7e55c775", + "rawBytes": 1468, + "rawSHA256": "2E4E7429623CEE6EBCDDB24238E3B04222C4DED254D33E1B97C2B566047E9162" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.json", + "mode": "100644", + "gitBlob": "0240ae20690433f6addad8d2a05aaeb2a7545b39", + "rawBytes": 1418, + "rawSHA256": "88E72EAE767B52F4D9609FAA74C583DA071EAED7B5F44DD8B23CB56D496B1FC6" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RangeSummary.json", + "mode": "100644", + "gitBlob": "aa533aa807901782da880eb190db6f4a1e2e3ffe", + "rawBytes": 1410, + "rawSHA256": "AD8948EBCB5D6784B1E0EAA142C7F70E71A102F6FB16D68330A2A8D16D23B587" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RangeWitness.json", + "mode": "100644", + "gitBlob": "6335b4dc1b4293d3cf5e22abbef7569c39ef878c", + "rawBytes": 1410, + "rawSHA256": "333E352E3B537077B244750C29F828B4D679E72712C88A9E2EB4B54CED7BA74B" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.AbstractMacro.json", + "mode": "100644", + "gitBlob": "e3177728985efb3756cbab7b5bf0d0c9b2abbfc3", + "rawBytes": 1483, + "rawSHA256": "8089D9106DC081565B41D0FFA82B0CAE95D71171642951C355D62F8064EC7864" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedFringeChunks.json", + "mode": "100644", + "gitBlob": "5b573096459d1eb95db704e379188479341b54ee", + "rawBytes": 1509, + "rawSHA256": "D17BB4EF5891B68AE4D22E310E80EA70A6FE4A3EAC0974BA57E477D63364DED6" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedFringeSubstitution.json", + "mode": "100644", + "gitBlob": "1bad1190b855dce3bee58963e682c823d6a754bf", + "rawBytes": 1533, + "rawSHA256": "B00D8428BB9489B3A7CAE6CD951ECC8EEC8EE5617B5CA209C6054DABBB4AA7EA" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedFringeTableFacts.json", + "mode": "100644", + "gitBlob": "f7080e63df9a792cf8c06810cee911cbb7e1d392", + "rawBytes": 1525, + "rawSHA256": "ED6905D5489C2AAE0CF94F6893D7F045D33134BF9E5883365FD48D47020D51C2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedFringeTrace.json", + "mode": "100644", + "gitBlob": "220d54084ed75f23771137ab18bd8eb7fc9406c3", + "rawBytes": 1505, + "rawSHA256": "4CB282B436C4A8F66D4C881BE5EEB277DEDFA2BA7EDA9DB1EF496ECED88C7A88" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedFringeWiring.json", + "mode": "100644", + "gitBlob": "ae868ea5f09acd37f3590ee7881fc0f387794a75", + "rawBytes": 1508, + "rawSHA256": "A3ABBE6BA3B2F002B3D0ABF7E57D5D3327EA76421ED6748F1E1D0F350B140D43" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedRankSelectLeafTrace.json", + "mode": "100644", + "gitBlob": "64499d3edbca0a4e147c9fceacd0aed237b49e93", + "rawBytes": 1537, + "rawSHA256": "8C85D5333BF216766F984D2239201F101AEA1AAD0025709DACF8F5E2637D5A3A" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedRankSelectLeaves.json", + "mode": "100644", + "gitBlob": "9e4f4f11fb42e505138918221cf144abb398e492", + "rawBytes": 1525, + "rawSHA256": "5605F6B6964DBD9D8CD7AA83286B3E697791CAA0831B7B52CE6A99564C9E0491" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedRankSelectTrace.json", + "mode": "100644", + "gitBlob": "448e3dbfb772d6f8a8e1fe2402fd5847b240310e", + "rawBytes": 1520, + "rawSHA256": "05A742D6D6E184C7AC179D85A446ECB03C7A6CAA968301E7632758C6BF862CBB" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedRankSelectWiring.json", + "mode": "100644", + "gitBlob": "39c8404d545a74bd587ee3c4234fc47c65560ad0", + "rawBytes": 1525, + "rawSHA256": "3FBF1133F36A6C3669044E540DAD75D185A1A917D89CC60007882EABCDD98C04" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedSameBlockChunks.json", + "mode": "100644", + "gitBlob": "b42611ac845acc5566039cb476d905198f4fa952", + "rawBytes": 1520, + "rawSHA256": "FFD4DD7ECB8395C10AB8C79CE48441E678F8D099B54088F887A5B891933F258D" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedSameBlockSubstitution.json", + "mode": "100644", + "gitBlob": "4fdab1898341817ea4bd34e21eb2d46cfef979c8", + "rawBytes": 1544, + "rawSHA256": "89914CB16D58EACFA7CA1CE7C33D236A616ADD2756E4861C544C8052CBF436D9" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedSameBlockTrace.json", + "mode": "100644", + "gitBlob": "58669ecc1f358b8604291dff420f9966d0b9b981", + "rawBytes": 1517, + "rawSHA256": "8D5B6579BED8870B99C17E6A4C236733F706394EDD424A8BB268D9486D279E27" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedWordChunks.json", + "mode": "100644", + "gitBlob": "9aa99ccfbd8b98e4d6db9faa26f6d9e8237f418a", + "rawBytes": 1500, + "rawSHA256": "C2389CEB6EE5C04FBF540315E1B3E2F3F605B49BEDC4814140984492E679333E" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.CompactEndpoint.json", + "mode": "100644", + "gitBlob": "30558460daf8c588ade0b1c1131d9b029e0ff02f", + "rawBytes": 1493, + "rawSHA256": "A7A4903D1F465F48BC63194F9CE3B0C8F22A8545370299C834AE01F6CEE90810" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ConcreteDirectory.json", + "mode": "100644", + "gitBlob": "ce678d684ae74b735b41ee1d3a141e6f590717cb", + "rawBytes": 1501, + "rawSHA256": "5E170AF6F6C4C8817B8F873B3D7E45A8907431FEC212E66767A4109AE80A4EE9" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ConcreteDirectoryRAM.json", + "mode": "100644", + "gitBlob": "db3b0649ca382865f4e0760ef98bf86d6e092c79", + "rawBytes": 1513, + "rawSHA256": "932FBB935D9AAFDAC7625F919B6E7F23CB70CDD8E7CE2DF55B20448887E76F79" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ConcreteDirectoryRAMStoreParam.json", + "mode": "100644", + "gitBlob": "f23904209a65d82d05e2a655c67450f6789c8c60", + "rawBytes": 1553, + "rawSHA256": "EE79999223211A0E6A8DD8E1DAD7CAD44C13E78146719A4C8AB0DCABDABD7FDE" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.EndpointCodebook.json", + "mode": "100644", + "gitBlob": "d211397ec6672c6fa3f2f788fbe7007449145e65", + "rawBytes": 1497, + "rawSHA256": "F5E9C74ED3704BA3D02A09FE382543AA05EAA43EEF0E44F8DB70EA07E5D8097A" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.LocalBPDecoder.json", + "mode": "100644", + "gitBlob": "eeb7e83686c28e906d1aaf2aac76864318b236d8", + "rawBytes": 1489, + "rawSHA256": "93C9769AD371942901498F1BCEC257DC257689BACCF2FFDD134F6124A0EE3FE2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.MacroMicroFamily.json", + "mode": "100644", + "gitBlob": "946918c6148d1b0c23fc3164e87d5e7130434b77", + "rawBytes": 1497, + "rawSHA256": "136952B867DD66A5FA93F17B81B5DFC83FF702884807431D1D5EAF7B2469072B" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.json", + "mode": "100644", + "gitBlob": "1cc833be7e1207f4a3774b3f9f5c65ba04e17362", + "rawBytes": 1426, + "rawSHA256": "94B5308448BE19F2BE37317827CD804AD23717A55383BA5720A9E53A43D892CD" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeSummary.json", + "mode": "100644", + "gitBlob": "3174abf336e3bef317fc5c8417b06231942210fc", + "rawBytes": 1423, + "rawSHA256": "39F8594194AA15BAAEC5F0D0B3ED3E1007B08612E2A8F1EAB044F6FCD83F5C53" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.json", + "mode": "100644", + "gitBlob": "1bf1a72d6aa6e10724d1950a8c9e8d0f73cdcc10", + "rawBytes": 1356, + "rawSHA256": "916A33F82B5A44610C6D2DC31594E1E119C95C765EC70C47FEF4DCD6617DB36C" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.FlatPayload.json", + "mode": "100644", + "gitBlob": "797b09530e624ab7229e7aaf9afdb514d1f524ff", + "rawBytes": 1426, + "rawSHA256": "642B1FA7140FB9433FEB4606DFC54CD4C6D79EB385F45BC22CAEE70560CA42F4" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.GeometryClosure.json", + "mode": "100644", + "gitBlob": "445c115256756fcebfd19da390426c541a543e8b", + "rawBytes": 1441, + "rawSHA256": "1D30CED4E031CCB3982E84ECA899473297630DE8E2802212494204AEF49DABAE" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.Address.json", + "mode": "100644", + "gitBlob": "3d3192a8844722c20c5f0dbe44305f0213959043", + "rawBytes": 1473, + "rawSHA256": "BB4A64A66BB0E19DECB8170B7CB344A334A147D7CCA02CEC67B0BAFDFB984C49" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.Boundaries.json", + "mode": "100644", + "gitBlob": "0ece9834f23c8f7000bd340b892f06cffe3a9eed", + "rawBytes": 1486, + "rawSHA256": "470236C88FBC04B9652D084FFA26677774EA6E5AC1964EF31E897D399AE3A179" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ExecutedUniverse.json", + "mode": "100644", + "gitBlob": "0786f57d76b27824b2c79831377bff74778f2706", + "rawBytes": 1510, + "rawSHA256": "BBF0F69BEE22BE8287F46A9AD10EEC5278BC57A8FFB3956E22B5CD17D4B21DF5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.Header.json", + "mode": "100644", + "gitBlob": "688d24122fd296acf8e17c24467886804d43b248", + "rawBytes": 1470, + "rawSHA256": "B6E49DD7B546192A1DB968790F545215E173855B8E9ABFC778469415AAD3C036" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.Memory.json", + "mode": "100644", + "gitBlob": "95ad78d4a14a006f04520db8311f5c50decc2490", + "rawBytes": 1471, + "rawSHA256": "FA4F404603E7416D5DB9074B45D5B5A8E8DC4034DE1135A91D69F6C3DB599794" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.Payload.json", + "mode": "100644", + "gitBlob": "60593c8c0caa58de453aa556edfcce8d94a29cfc", + "rawBytes": 1474, + "rawSHA256": "E148142B9167887ABDAC2B24D3CFAA8B5E399695DBB1E8F8E524644659354942" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.PhysicalRead.json", + "mode": "100644", + "gitBlob": "b1169950ef0f48f7cbbdfe72e0e1f9a004ab2bb7", + "rawBytes": 1495, + "rawSHA256": "95CF7F8E718F7016B253D63A16AFE24CDEDEB21729BE45609C7FB60283D9255A" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.Probe.json", + "mode": "100644", + "gitBlob": "dee31bde665f5d6ad67014f228dfa2a0d94f0daf", + "rawBytes": 1467, + "rawSHA256": "0F67582C28D14B2122AB155AD91C078BDC623BACAD293D01A5DBED1B24AD135F" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReadProgram.json", + "mode": "100644", + "gitBlob": "31041fa7a447464ffd7960dc2806c4aa55cd9cb8", + "rawBytes": 1490, + "rawSHA256": "C7D10D342A7F296D2E0A2AF5589902F8FFA874F37CA1A7B13DF03968D2D91BDB" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerCloseGeometry.json", + "mode": "100644", + "gitBlob": "4c328c832570b376ade5a8c48f45bd78221a6f13", + "rawBytes": 1530, + "rawSHA256": "A50158C20449F603074C7C85C671E6B77826D7A7497FCD3CF244836FB9B3D655" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerCloseRead.json", + "mode": "100644", + "gitBlob": "8df02575878c6c0ad69c5f6d34f8ca4a15cec1d6", + "rawBytes": 1513, + "rawSHA256": "3023A618C930190B1F4A0AA7C7169AFE4750F90D5F95035A601B0795FDBB8035" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerCloseWidth.json", + "mode": "100644", + "gitBlob": "1b6d9d6bb2e25130fcee39976e40f1f929b9c179", + "rawBytes": 1518, + "rawSHA256": "B05F7DCF5CC5C068428A599EC210F52817C980A162CCE68586A59BE6FF8F6317" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerClosedGeometry.json", + "mode": "100644", + "gitBlob": "0d8ec69d47556926c2a16a7c673c0825a22aa668", + "rawBytes": 1535, + "rawSHA256": "BF6A540D4BFDDE1F090A86835FFD5D71590FCF106CCA7C62E0E8A6C4F5CD34EC" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerComponentAccess.json", + "mode": "100644", + "gitBlob": "b8989c36d30ddb06deeba5ba9c871d32c0fbec9d", + "rawBytes": 1539, + "rawSHA256": "495EE76E6821C046C975D210BB366A3CEA9D3471FB395A456EBD86F8DAB1D0AE" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerConcatIndex.json", + "mode": "100644", + "gitBlob": "203843f53e8333f76b53b8d4cd6454e72844a1a8", + "rawBytes": 1522, + "rawSHA256": "1431A3D0ABB26B8AA0FF54523F12BAA1643B8FE1DDABC11C01BCDF828E73D93A" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerController.json", + "mode": "100644", + "gitBlob": "45590db5b68e02bafaf57026b2d5677544e96b7a", + "rawBytes": 1518, + "rawSHA256": "F09FAB76829A4A973FD3F9A4E5D81E74A0BEFEC8A4E1AC134EA76871799FB08E" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerControllerProof.json", + "mode": "100644", + "gitBlob": "fd763e000c7c98466a07857fdd14dadc101e0989", + "rawBytes": 68549, + "rawSHA256": "D7DD2AA276709B68E642665E2B28E0964B1DC19A1F118AB321DEDD82A90277E5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerCrossing.json", + "mode": "100644", + "gitBlob": "14f31ce19b36a28d7e5c3c4c5b3e236fab169adc", + "rawBytes": 1510, + "rawSHA256": "572D4ADF695FB3955B83FDEF8B39256928F5AA2ADB87FB123C655E834017270D" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerEntryAddress.json", + "mode": "100644", + "gitBlob": "16861314d401347c3651b504c0a6fc820add364f", + "rawBytes": 1526, + "rawSHA256": "91B503B3B8F26D5A72BCF8D4E4C3165E2E853FA6034AFA700F749A008EA421A2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerEntryChunks.json", + "mode": "100644", + "gitBlob": "ee80ac72052f6c3966bd625e2bb5f44dabdf2329", + "rawBytes": 1522, + "rawSHA256": "EFCC312367AF907C7723876273FB2852EBD188F62C6B9D269F2D57C4103D1BDF" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerInteriorCount.json", + "mode": "100644", + "gitBlob": "571e46589acbdf5f370d9e4ccb9ec1e428ed710b", + "rawBytes": 1530, + "rawSHA256": "FF7D4FE2D7231A58A24F5A1A7F753B7DFD92E99F55B4E524CFCED44EC851A6CE" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerInteriorProtocol.json", + "mode": "100644", + "gitBlob": "554897ede3091d42ba91ebfe619f12a62e1e98f2", + "rawBytes": 1542, + "rawSHA256": "C7D3C3BA339B74280678A73CEBE7CD5E6CEF4548610A13DDCFD6FB2A8103071E" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerInteriorRead.json", + "mode": "100644", + "gitBlob": "c2a9e39b718ca564cdca0af455e6db807736a16b", + "rawBytes": 16129, + "rawSHA256": "5CEDA7560BAF01A1EFE2C68538D3F99C8EB2D674CBE7132897BD5640868B4377" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerInteriorWidths.json", + "mode": "100644", + "gitBlob": "0de56b383212ad099ea476e607f715a557625cdd", + "rawBytes": 1534, + "rawSHA256": "8E6E0BD6F1D63A63B9ECDF6429CD715E86DD2423A8DA80EFB094C415B727460C" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerLcaProtocol.json", + "mode": "100644", + "gitBlob": "7000c1eb92e0a9bd4781c2249beac7c63e1d19a5", + "rawBytes": 1521, + "rawSHA256": "2047F53C68E7F95B24D4F58941DE2F851856E5864DFEE3A1523BAC9F677725E6" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerLength.json", + "mode": "100644", + "gitBlob": "370deb694c782db12bc6bbac35142287604142b3", + "rawBytes": 1500, + "rawSHA256": "F8CEB2400D67F57E6F9EEB7F591D330785691210A777ED073EEBA26038C5868A" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerLogicalLowering.json", + "mode": "100644", + "gitBlob": "27e60d3dc11f44ae86692e2986c46b751baa992b", + "rawBytes": 1538, + "rawSHA256": "B29A7A63389BEB5A3091AF6E349DFB44EA0AC06B770948C7B92133AA7A3BFD1B" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerLogicalProtocol.json", + "mode": "100644", + "gitBlob": "deee4ace73a4c7b683443f90393016ccaba5ad7d", + "rawBytes": 1538, + "rawSHA256": "5B1F1F9C6B79133974CD64FE7CB52372318742D4D1F3086DF9BCCC2119EEF359" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerLogicalSimulation.json", + "mode": "100644", + "gitBlob": "591d330c4f65968ed91ea7afd168d8bb521a1155", + "rawBytes": 179274, + "rawSHA256": "C31DE51BE143FA756E4F65A173FFB5FB6D5E518EF6D0D6F1DE62D04107B17694" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerMachineWords.json", + "mode": "100644", + "gitBlob": "8bf1e03e1da89d0aed780ee4fad15d810bca9958", + "rawBytes": 1526, + "rawSHA256": "DBBDC8F635236E1B34BEF4C38EB674D8F52788F76AA81B1A27782E87F16873E0" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerMemory.json", + "mode": "100644", + "gitBlob": "82a6d2ea26b2ce8407aec0fdfce33c629a535c73", + "rawBytes": 1501, + "rawSHA256": "EBA3A83095EC4D14A80E33AE65B53311214EDAE3F367895777F5DACC9FEBA52C" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerPayload.json", + "mode": "100644", + "gitBlob": "9ae5d4bffd1c92f73a5f5be27c0658a3b3ea62e0", + "rawBytes": 1506, + "rawSHA256": "7880C63EA1CF8E9342058B0D1E2CEB801CAF8F7F2FC04928EB20C7CF83FC11DC" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerPhysicalRead.json", + "mode": "100644", + "gitBlob": "cf20405edeff008e3390aef01711b4bfc3efc20f", + "rawBytes": 1526, + "rawSHA256": "7F93DB89A5E5CA6F7F26C077C8B27307D5C82BC8FC76583DC548B318C1D81417" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerProbe.json", + "mode": "100644", + "gitBlob": "988b049b14307cad472adf08fe7b0fabea3cfb1e", + "rawBytes": 1498, + "rawSHA256": "1698483B4BFE100920CCD8081B115F5760B929D6B2B5DC47E13C7D6ACAF74FBB" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerSelectProtocol.json", + "mode": "100644", + "gitBlob": "38c64d44551fd266d40c88275019ba14e9a10301", + "rawBytes": 2194, + "rawSHA256": "8ACB45993066E659E2075CB4B6A8FCE7FCCBDDDBC7EB3FE1451E1216DEB9DC47" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerSourceAddress.json", + "mode": "100644", + "gitBlob": "4acf0a106db154ae89a7b95d81373a4606927bbe", + "rawBytes": 1530, + "rawSHA256": "81A380847C57330C63D9B2A29B51A856BE92691F862E673F891AF2B3E83CB7AC" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerSpace.json", + "mode": "100644", + "gitBlob": "4b8b446f9eb7a44e86ac8a26cddf777186cae47a", + "rawBytes": 1498, + "rawSHA256": "B99DCA338704134B6CF5F59C8C7DA8F21907B91AD70B28E322C6DA96D69F2281" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerSparsePrelude.json", + "mode": "100644", + "gitBlob": "ad2a8d0b5b62c37bd4b0c3677974ef5cc2ba2713", + "rawBytes": 4648, + "rawSHA256": "C02B88E49D8077B32F94A07FD496175B97636C264D8547071699745386B621DF" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerWholeProtocol.json", + "mode": "100644", + "gitBlob": "4f06c9d2ad048c24bddd02f9a47992e51ab12f59", + "rawBytes": 1530, + "rawSHA256": "E583292A7BA104CECA87076D7C51E87548063B39FAB7AC071F832D6A7831086B" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerWidth.json", + "mode": "100644", + "gitBlob": "7afb2ecb76687d013c090d3e26c4de424e05d2f4", + "rawBytes": 1498, + "rawSHA256": "FD87D4D11F4F8E90429CB42E3C20D0F96270B6D6F47871E356F91D01B110E387" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.SourceFactorization.json", + "mode": "100644", + "gitBlob": "7b409f2a4a7368904fb621113733761460c50989", + "rawBytes": 1522, + "rawSHA256": "93D9AFE9F76694901A82AAA33B76E417D7901DFBE6FCAB5163F8E392A46B2011" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.SourceGeometry.json", + "mode": "100644", + "gitBlob": "cb576e88b3790479428ac67dcd2d8e70d6033173", + "rawBytes": 17783, + "rawSHA256": "2F5B540FB561112204EE042DF16338D8436BA6A22730144D85C28CBC50223E27" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.SourceWords.json", + "mode": "100644", + "gitBlob": "58ef1a0c1a598a9fefb73cce79bdb169ea984744", + "rawBytes": 1491, + "rawSHA256": "C0BF6493D2BAEC45960815BFA8275DDFC1CABA115A6EC134F8C7CDE96A25113B" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.Space.json", + "mode": "100644", + "gitBlob": "d5c8db5162fecf6a0bdfc65077fda76d73c76548", + "rawBytes": 1466, + "rawSHA256": "7EC30494B447969EE113B90C05480742060390F8925796543F9CEBBF991F05CA" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.WordWidth.json", + "mode": "100644", + "gitBlob": "a61b79e1df0444f6050cb05cd1fd9512dad081c6", + "rawBytes": 1483, + "rawSHA256": "31587DDC00F9263375D4A28B2728DC77B0B906A1A0A364D193294FE926544094" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.ReviewerPhysical.json", + "mode": "100644", + "gitBlob": "466d7f9ef64199276eb620e0268db8661b109675", + "rawBytes": 1446, + "rawSHA256": "F4EF49DF91C8872E52234A87BF3CD864AEF9CD128DFFFED5479AE3DF50EE498A" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.ReviewerReachabilitySmall.json", + "mode": "100644", + "gitBlob": "7eaf2164cac3509ef0266e1c2b0268e926578f5a", + "rawBytes": 6795, + "rawSHA256": "A4AA061121D1A1DF7036D4EEEBCD6417F3B49BFC2816FDC0B362C4D6E840715B" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.Segments.json", + "mode": "100644", + "gitBlob": "d501dff94636ba0b8edcc94cba72e4cde858feda", + "rawBytes": 1413, + "rawSHA256": "F0CF5E5285F71EA6E2E4AC19FACD4E528D5CD2C84D8DEBAD4F3CA942AEAA01B5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.json", + "mode": "100644", + "gitBlob": "8c887b0c92ba6235abde9dac91ab6a7d6d2b93a6", + "rawBytes": 1357, + "rawSHA256": "73179AC088A67FE38574982F0C6CBF91D78960F5B29BC472B7479B8F2210D3FB" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinalModelAdequacy.json", + "mode": "100644", + "gitBlob": "24f21569f99aff1c0795c595d3fa2df78e4b6c71", + "rawBytes": 1408, + "rawSHA256": "D75DA48F48C3F14982B1121A6740FBF4BD762C49F14008A9C00DB4E2951F3268" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinalRAM.json", + "mode": "100644", + "gitBlob": "96109bab0992f25de18dbca1c3ab86fd678e4524", + "rawBytes": 11616, + "rawSHA256": "EE1B4B355735844D8881BBF7819D4664CBDA6FCB31C5D781147C2A0685C5CBA6" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinalStoreParam.json", + "mode": "100644", + "gitBlob": "4d47e32a8dd842b6b987ea1530cb7ea9b57a9d49", + "rawBytes": 1397, + "rawSHA256": "B3933C7627209FAE908E3109163B0AC7A4D6C10A5B2A85621802578B5F899079" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctRMQClassic.json", + "mode": "100644", + "gitBlob": "1f0a029b3edc091d23e40e4f2b414c1d8e88403d", + "rawBytes": 1377, + "rawSHA256": "0B1CFF823990EB558853B943B60143E7D6B43C210DB491151446B6E39AFFC601" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctRank.json", + "mode": "100644", + "gitBlob": "969580e45ef6ad72169b86a0cbe35a1055f2a484", + "rawBytes": 1353, + "rawSHA256": "83171FD7B15F1E3C115AAC65E0CDC87B5BC69E256F9A8B3075108234DE1E23BD" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.AsymptoticFacts.json", + "mode": "100644", + "gitBlob": "fa5989710e51be9d8e9e877bfe7bf5ff1febeb3d", + "rawBytes": 1426, + "rawSHA256": "07A833E17514C37FD9E1DEF6ED20B542BF96EAD765D7EC027C25B783F9B9E0E1" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.Basic.json", + "mode": "100644", + "gitBlob": "610b16e078fd371d6f953592b8a37f2bc7b3464a", + "rawBytes": 1436, + "rawSHA256": "E251D8C86752931B560B58A8B7114E64C88836535FC18F47B9884B4C0A620CD5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.BuiltRouting.FlagRankTables.json", + "mode": "100644", + "gitBlob": "6b0283275366f0e5255eb889e0fc333a587cb0e9", + "rawBytes": 1527, + "rawSHA256": "EAF45DF9BB3B1EA9997C5DB252BE6AEA0D1F96AEC0A2947E34445A291E092FF4" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.BuiltRouting.LookupDense.json", + "mode": "100644", + "gitBlob": "08f46517d741411e16e9d3f979202beb97236019", + "rawBytes": 1515, + "rawSHA256": "C2E2C8E85F9EA12AF081A8D3703C65266337D257C2524D1A5139B48556AB1C8E" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.BuiltRouting.RelativeEntries.json", + "mode": "100644", + "gitBlob": "4060af0fb50c50347ce13adb3fc029d61ddcb554", + "rawBytes": 1531, + "rawSHA256": "5517BB0DD5A2E0985CC475197D1173F80926AFB167B27146D247B1F36C78EB74" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.BuiltRouting.SlotBasics.json", + "mode": "100644", + "gitBlob": "bbbb17ac34fe3b42d43f7482b95fe4faad876a91", + "rawBytes": 1511, + "rawSHA256": "507FEDB7DE01DA41DD0D7266BC8C54BF5077B2B7887020F51A39E4FE4967CE70" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.BuiltRouting.SpanBudgets.json", + "mode": "100644", + "gitBlob": "24c862455adcb69a15e395921b1208321d940b88", + "rawBytes": 1515, + "rawSHA256": "77A12A2D44A8FA2887D97E655E9BDA0C1564ECF9E1DD736162A585DE7008DDEB" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.BuiltRouting.WidthBounds.json", + "mode": "100644", + "gitBlob": "81136611dff718f262954dbf279678eaadab2f22", + "rawBytes": 1515, + "rawSHA256": "38C94ECD8AB9EFD59A118E474AE845B7EA80D6E3CE49DE08F03E83AD81ADB70F" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.BuiltRouting.json", + "mode": "100644", + "gitBlob": "ccd1c235d572ad558db67a0b517c1a24b2204eba", + "rawBytes": 1464, + "rawSHA256": "88D2C8F5E9C88A20B67F250A776B3DF5C5524109D25F96515C20BE89490EE637" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.RelativeSplit.json", + "mode": "100644", + "gitBlob": "f627143e7f24f7e3bc06d318a80ffc0604fe5e24", + "rawBytes": 1469, + "rawSHA256": "FCA4A688626002535C3EBA96AD61173CD023FA84ACCC90B62B07648B5C70D38D" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.SparseExceptionCloseData.BuildProfile.json", + "mode": "100644", + "gitBlob": "f943c93efb491fb9cde8950579b3b2f16cedfa6c", + "rawBytes": 1566, + "rawSHA256": "658D63E5BB7CB6FE3EBEEBA69057E143E122F3AC665A80A15113827885F2ABF6" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.SparseExceptionCloseData.BuiltExact.json", + "mode": "100644", + "gitBlob": "a13b4cc2c0af25b7852fd759d71a0cabe84ef4bf", + "rawBytes": 1559, + "rawSHA256": "C73662BF33FE5A50457E47AE098204657539DFFEFAAD63577C6CFE84F34BA7F2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.SparseExceptionCloseData.DataSurface.json", + "mode": "100644", + "gitBlob": "f2413173561ec8d4f7c4304ae52ffc4b6401f8d0", + "rawBytes": 1562, + "rawSHA256": "79B16A1CAFE051A34DAF8D3C5F61C53E3A77724D71E65D63402C734B3A88E474" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.SparseExceptionDirectory.json", + "mode": "100644", + "gitBlob": "44c2244e0e83c13175981dfd9629aec44b75c54b", + "rawBytes": 1512, + "rawSHA256": "694F1E35E694CB0DF38E77DFF461496036A669D617C75566DE24AF56D32EFF66" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.DenseLocalTables.json", + "mode": "100644", + "gitBlob": "83583cdbcbd2aa47a45ec88b8415901d5f75d670", + "rawBytes": 1430, + "rawSHA256": "0CD5B2A754495155A1E04F6E6237D9F39BE852CA120343F9FBFFA71CD2C42A3C" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.TwoLevel.BPCloseNavigation.json", + "mode": "100644", + "gitBlob": "dd0fd994f1eb47385cd48538f77c15f51ba662be", + "rawBytes": 1472, + "rawSHA256": "DBB710B986C84C40351FD05C3F5289189758E76E4F8646BBE62C9135B803A345" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.TwoLevel.ClarkSource.json", + "mode": "100644", + "gitBlob": "f54518383df1d2c3a5cad9a810e9234a992a9fa4", + "rawBytes": 1448, + "rawSHA256": "1D1EC4F6C6568DAAC2EDC54AD02152F8B3EA438FEEAFDAADBE60601CEB0CEA7C" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.TwoLevel.RankSelectAdapters.json", + "mode": "100644", + "gitBlob": "72491b91e927ff2194861c8c08ee30f0f88f7a6e", + "rawBytes": 1476, + "rawSHA256": "C23D5BC5A6EA56E68CB8CCFA6ECD6215C148185CDD0A3279F15E9E87C9BEEE35" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.TwoLevel.SelectData.json", + "mode": "100644", + "gitBlob": "987f22d89a15408186ab543b831d2368ec3af6d1", + "rawBytes": 1444, + "rawSHA256": "3A2E67A0195D1AB8F924C137C8B74FB0151CC9A9240A46840FD525E061ADE891" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.TwoLevel.SelectSamples.json", + "mode": "100644", + "gitBlob": "7429102cb26d89c33064fdaf8b5b317b59374d7a", + "rawBytes": 1456, + "rawSHA256": "1E533DDDAD7EC4018AF1629D504D1704711D62678E8A14EE14B73D7F05B493EA" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.TwoLevel.WordExact.json", + "mode": "100644", + "gitBlob": "60b5af4a40b7f00b787ba489b6ba229a3a4ac4f0", + "rawBytes": 1440, + "rawSHA256": "AD330EB7487BC8BCCD32BB010CFD1DD4C67B8B41180100E3B3F3B5E7B63DF9B6" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.TwoLevel.json", + "mode": "100644", + "gitBlob": "a75a0a1b97f9dd0575679c6a8d7eb127f95d0921", + "rawBytes": 1398, + "rawSHA256": "EB17436F02B6C542732E4A73DDB7C106EC74C699348D50E97B92CD400A3D7325" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.Asymptotics.json", + "mode": "100644", + "gitBlob": "49d17e90b1a27c618d9d91afb2de1006e581b388", + "rawBytes": 1407, + "rawSHA256": "67792DA386B44107B60B58C7EF4EAF0BFD8A36E9FB7579DF2E127B31D1B9F6D5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.BPAccess.json", + "mode": "100644", + "gitBlob": "b4077c4920b1024cffd4751f78eb749125f475a9", + "rawBytes": 1395, + "rawSHA256": "51B62F6B5F57D323F23AD8019679032DE0D1813C2DDECEF76A1B32410DF4EE7E" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.BPCloseLCA.json", + "mode": "100644", + "gitBlob": "5e1d617c3286faee83e1866158e3dd747a5e49d8", + "rawBytes": 1401, + "rawSHA256": "65EA446CBD627E98A1A647A367B3CCBEF6F0B822C12E9D622612F238959799FD" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.BPCloseLCARAM.json", + "mode": "100644", + "gitBlob": "f0855d08671f2d8db0c071e09616555c04dce573", + "rawBytes": 1413, + "rawSHA256": "807E6DB4A785B4F8DD1473CE54881D51E32D26C3E42DDB1B8298A3FFD99D1023" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.BPCloseRMQNavigation.json", + "mode": "100644", + "gitBlob": "22395603697572b50648314e1ea80b752a840f1b", + "rawBytes": 1443, + "rawSHA256": "321779A2BD88B590F78C4BCD72AB0D03242F767649AE8091FDB3918806821EB2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.BPCloseRMQNavigationRAM.json", + "mode": "100644", + "gitBlob": "cd15657634655590937890dab806c68e0ca9cdaa", + "rawBytes": 1454, + "rawSHA256": "34CD5F2BF41BD39196538C6505AC2F8DC33F74CC07805305B6ECE82965B5449E" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.BPShape.json", + "mode": "100644", + "gitBlob": "7b2a0d9bf8dd66ee3ad6b8f3a98055f39ee459b0", + "rawBytes": 1391, + "rawSHA256": "BA62C2F0A4755D443050C34C5C08D7C16B8997851ACAA925A3DCC0856EF4891C" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.BroadwordRMQ.json", + "mode": "100644", + "gitBlob": "1fd99ae7b77886d3734d3cd48c8203de46403a59", + "rawBytes": 1410, + "rawSHA256": "902947DEE39B45846E3F0D2AA9158ECBE7D2DFF7006819B15D2D91190522E219" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.MachineChunkedTable.json", + "mode": "100644", + "gitBlob": "d372d8fd9a7c42d225cd771a7b9aac831ad99b56", + "rawBytes": 1438, + "rawSHA256": "32B1E62774330C9931F39F714A51515934CF06EE38FCB909F64A77617EFA465B" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.MachineChunkedTableProgram.json", + "mode": "100644", + "gitBlob": "f0101d0d00d48edea302361df5f8bee450917716", + "rawBytes": 1466, + "rawSHA256": "A29ED495753953EE08AE6C8F240AA293ACF3B44CCA924E3B2C8124C4FD6BF0D9" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.RankSelect.json", + "mode": "100644", + "gitBlob": "62ef334d97b3ad1c29c6cbf3511ab038c8f09071", + "rawBytes": 1403, + "rawSHA256": "CE3878BCBF38663D74A02EC5C8EB7BF4E47280DC3FE48CFB535C89ED3254797B" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.RankSelectRAM.json", + "mode": "100644", + "gitBlob": "43ff79be2651d6774b56bf87575a697f50467667", + "rawBytes": 1415, + "rawSHA256": "75E347A0A14988955C7369385694EBC31210DF83FAF2734BC2F6643E1CA016E4" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.SelectSamples.json", + "mode": "100644", + "gitBlob": "e0d7313e9e9e9b0742fc71d24f2ac4cd000f899a", + "rawBytes": 1414, + "rawSHA256": "CEB94F839CD97086D1DA9C969A4E3C87167C346615A0D11E2BDF340E575CF2E6" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.SelectSamplesRAM.json", + "mode": "100644", + "gitBlob": "82db0ec85247b07821e311929039e30a44814582", + "rawBytes": 1426, + "rawSHA256": "E71C10583F681996FE0170D349A6CDFBC9A0935D237ACB2E07C1B6A605EB4375" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.Tables.json", + "mode": "100644", + "gitBlob": "023ab2a580e6f92dc6c8530f2016a9311349db7c", + "rawBytes": 1386, + "rawSHA256": "F458963611CB56C40F836A3E6A1783E9CA7D8A3BCB9D29346CEBF68A487DE0A9" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.TablesRAM.json", + "mode": "100644", + "gitBlob": "ae4fd0482bb418132a76c28dee86b43cd22761b0", + "rawBytes": 1398, + "rawSHA256": "44263766E57751AE17772B8C08DA5A2A61129D21A7D5F849014D251B25FFBE40" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.WordStore.json", + "mode": "100644", + "gitBlob": "b53a1a59554646ab6e8ce7d52b87e4ce92132637", + "rawBytes": 1399, + "rawSHA256": "832CF7FD9D9528B520D5A9929A4DFC38E8F0E303C6B8E49492217E0AB87E27B4" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.WordStoreRAM.json", + "mode": "100644", + "gitBlob": "862a533dc45d916a00a74fc5432d8e2468f10921", + "rawBytes": 1411, + "rawSHA256": "92814826F32CF4E2273D08B91BC66066A65F3E3B644DD2C8158297BF12FAA523" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.json", + "mode": "100644", + "gitBlob": "01e3cda7add36373bcc56b262c617143ddc6ec83", + "rawBytes": 1356, + "rawSHA256": "EA7DE8AD3DBCAFD8C37114672B0AE21E688AB7EEC3F98ED618934D21905003E4" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.TableModel.json", + "mode": "100644", + "gitBlob": "b52018b5b2c140c7e0d39addf0de52f60125ce83", + "rawBytes": 1344, + "rawSHA256": "F32E20CEA4B6A82B7296BF4ED1DA6CEE2095E0664B8B04696FB98E2210ED9E09" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Window.json", + "mode": "100644", + "gitBlob": "9a4856eecfa16ee5a2550807193963153af9b80a", + "rawBytes": 1328, + "rawSHA256": "007875DB33D34813A3AD8EAB40D14D07EC2AC9A12E99DC9A0A08B7CED436029B" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.E1FringeBridge.json", + "mode": "100644", + "gitBlob": "8459d8462c59fb86ee8a6ae8737ea07b1a1b65f3", + "rawBytes": 1395, + "rawSHA256": "AF76838A21B4FEC5DF4516DEAD76798B873E01793137547E7BC7F40CAE55BD8C" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.E1Machine.json", + "mode": "100644", + "gitBlob": "63be4a91194e3967684b403d7c2d16656be5d66b", + "rawBytes": 1375, + "rawSHA256": "1429F043964D8655F8B9C629B67138D54392DC78CC6DF4DDA1C1EB01DC6C13D0" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.E1MachineCalculus.json", + "mode": "100644", + "gitBlob": "11a40ded0093bc4a7311c25847157320d7841231", + "rawBytes": 1407, + "rawSHA256": "22DB5A189E91B4D5610919FB8F138E9F0D3C9F28CA9BC589CE6AB8D4E9D4E7A7" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.E1RankBridge.json", + "mode": "100644", + "gitBlob": "ccfc90b5ab96e1bdafe205cdd5dd36a97a3cbe77", + "rawBytes": 1387, + "rawSHA256": "3A6E81D154544D319032F3F6711152BC7A8E9A348133D10FD5F21FAAD3597054" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Optimization.BranchBound.reuse.json", + "mode": "100644", + "gitBlob": "33dd5080fa0d571ad14328a9e345237da7404fee", + "rawBytes": 293, + "rawSHA256": "30A28DBEFBEC72B7E074714003A961E301F3C0DE0CD8065A5258B1251CEEBF1B" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Optimization.Capstone.json", + "mode": "100644", + "gitBlob": "f0d38d670be6e2c7ce6eb15739e35bef4460bb28", + "rawBytes": 1425, + "rawSHA256": "A5D3AAB6C1ADCC2F2E67138F9857A6E3A904B64E735E2DC87FFF9375F5F83D10" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Accounting.json", + "mode": "100644", + "gitBlob": "ceb285c2ad70b4544899695afa1d3d25451111db", + "rawBytes": 1408, + "rawSHA256": "3820AAA6C079836EAA54D861D1C88FC4FCF04ACB2AB87F9E949F93BB1B212B27" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Allocation.json", + "mode": "100644", + "gitBlob": "8750443193994a1b5c45f32828e059ccd9661938", + "rawBytes": 1408, + "rawSHA256": "23FE620862A385903145297DBAC9F7DD6E1B1838C685C988DFE85A6B3519712F" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Calculus.reuse.json", + "mode": "100644", + "gitBlob": "4808c931173fe3b5fa15fcd93a7de36b212ae3fe", + "rawBytes": 284, + "rawSHA256": "AAFCBBE218D4D48DB72C9369C1401E73DADABB61E2943C670E2310E26E5A1485" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.CandidateProof.json", + "mode": "100644", + "gitBlob": "ef824bfca876931f2a2d5c4e282a9676294174e9", + "rawBytes": 1424, + "rawSHA256": "22FD10A93767BBC85E1B8A1E90953BBCFBADE646C3EB70F49C99064FC95BAFE1" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Capstone.json", + "mode": "100644", + "gitBlob": "a874728c0624b8e13a65cd48787ae51d9cc6c3a6", + "rawBytes": 1400, + "rawSHA256": "974C32F67814A77C3D501352B6DE73E62F070343AE4E9DE2D9E093A9815CCC21" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.ChunkArithmetic.json", + "mode": "100644", + "gitBlob": "800a827f34d15f44c62a590d9dab01eea4bcf22b", + "rawBytes": 1429, + "rawSHA256": "2EE2B8FE4783EB3419AB851F523C83261E5F0692C1E59B7016F45202597B9CDF" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Compiler.reuse.json", + "mode": "100644", + "gitBlob": "53b32e3b1b2c7fefe2a7f42552ff19559381b5be", + "rawBytes": 284, + "rawSHA256": "5FCCF89BF4053F9FA578A49A44A1A5078629F446B7A88D615F516A4909DC83B5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.DensePacking.json", + "mode": "100644", + "gitBlob": "b701c74b733e5f02e29bac15cb2c6f5144d0e2cf", + "rawBytes": 1416, + "rawSHA256": "F106CD6E3A739838CC51652329E73F4E07D935BD14CCE167D21546FD819AF6E8" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Frame.reuse.json", + "mode": "100644", + "gitBlob": "feb47b9ceb002bb6ff5a5555c753f785d7d38524", + "rawBytes": 281, + "rawSHA256": "434E6D03518C0FE925011293CB969450367B861B12D1DF9227BC16BE368BA879" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.FringeProof.json", + "mode": "100644", + "gitBlob": "2dd074446b0eb8c03affb82aa2cf87f9046fad5b", + "rawBytes": 1413, + "rawSHA256": "D5D106F807D8A17BC918826AACECC38921A261E31BCA1E1FFD462E697D5363B2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.FringeSafety.json", + "mode": "100644", + "gitBlob": "f5195c0ffe2eb0880c417e58a6e906dc4ac734b0", + "rawBytes": 1417, + "rawSHA256": "0BBADE0F7F66D0C8304E35E4FEEC0DE177FFC3B992BA7B75758D0F12DD4FAA26" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.FringeSource.json", + "mode": "100644", + "gitBlob": "add2ff40b1a6015d3240b7750bda3632645b80b9", + "rawBytes": 1416, + "rawSHA256": "537B89158D75ABE4914D6A58AE9D6F5B62BFFBE372B3DF270827BC3C82B376B0" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Guard.json", + "mode": "100644", + "gitBlob": "192902e6c01b00db791e0822608c3f959c5d0a9d", + "rawBytes": 1388, + "rawSHA256": "BCB254C65C4BAD5C498A44BCF3FE5432DDE4C5D27EEFDEDDF90EEA8818D71C1F" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.InteriorCandidateProof.json", + "mode": "100644", + "gitBlob": "bc55829349174919a7d36bde659a450dff329a38", + "rawBytes": 1457, + "rawSHA256": "FBE72F95B65418D724D1ED327CCE0280529328C7650B81648A090EF0A6E2A658" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.InteriorLocate.json", + "mode": "100644", + "gitBlob": "94103f1c4f8aa0e72025d04dd4158b37a2b88465", + "rawBytes": 1425, + "rawSHA256": "A99AAF33860C1F65702901355471CA488E92776ACC3B0439475053C8E543F4A0" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.InteriorReadProof.json", + "mode": "100644", + "gitBlob": "6f28fffdfe398a69cfce721a2fc6ef2b03c716c9", + "rawBytes": 1437, + "rawSHA256": "9640C0B4D2CACEBADA6B146C599D66485EE639A138A0F19170A0E4307C31716C" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.InteriorSafety.json", + "mode": "100644", + "gitBlob": "5a9df64a5c676f839ae6cec8411695a624fcb744", + "rawBytes": 1425, + "rawSHA256": "8119DC9B8E3F9082CE34E572500F22C6B6E32067BD44344D3CF5541C89009E98" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.InteriorSource.json", + "mode": "100644", + "gitBlob": "148bffdf15e8021add9d7213d6b4f79cf6db9358", + "rawBytes": 1424, + "rawSHA256": "481E8F45AB62E35A8F7F864A6F6C19B6FA0F111368178909308DBD437E3122A6" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.LCAProof.json", + "mode": "100644", + "gitBlob": "92cf2503c3dc7170bdffeade855a293081669e80", + "rawBytes": 1401, + "rawSHA256": "D6F67F8497858819560A8BF4F1304E2313BA2557975DEEF748C41E6379DB9952" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.LCASafety.json", + "mode": "100644", + "gitBlob": "d1b540852e3da17d9e3bba96bd0ce23de37b219c", + "rawBytes": 1405, + "rawSHA256": "00089953D612B68E7014ADA243A336531313727052EC48688DE1CB00BE9446D1" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.LoadSafety.json", + "mode": "100644", + "gitBlob": "e816a52b3fe7b67b091a3a9c69fcd012b16dab4a", + "rawBytes": 1409, + "rawSHA256": "B04F7E5872F09727AFF7D67A51A532F38C83B6BA3DD890BFDEC94FD219A52ED6" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Locate.json", + "mode": "100644", + "gitBlob": "36c736086a5cf85bf1b88f12adadb5a9ecc362e6", + "rawBytes": 1393, + "rawSHA256": "7F923D313677C16413A63E7B213D3A6D91B53AC95F716A8E33A3D3B270F1FF1E" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.LogicalSpan.json", + "mode": "100644", + "gitBlob": "d1931f6cfa406ac949ae3de52307b0ffd37498e2", + "rawBytes": 1413, + "rawSHA256": "537ACD62714B8298AE958B765A4E66C2EA59C9FE7A3FBF482B9C6C97531DD869" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.PhysicalRead.json", + "mode": "100644", + "gitBlob": "a1d10b209c6388f7861a445e50d241919c2fb1f8", + "rawBytes": 1417, + "rawSHA256": "2F7CE20361C58624B20B061CE2FE8D600ECB3B24BC52959A3605D0EC96838DC5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Primitive.reuse.json", + "mode": "100644", + "gitBlob": "6a36eb61ff2d858a3b67d1f63ef7691ce2c4bbab", + "rawBytes": 285, + "rawSHA256": "27160E8474DE25B1C484393A2AC04B273289DE6E6823F857D02B4C58A13C4187" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.QueryCertificate.json", + "mode": "100644", + "gitBlob": "eeb5c521cdf5bad950b56b63ab864ac272c6369c", + "rawBytes": 1433, + "rawSHA256": "91EA66A9EB4FFF083C64B1D6931164A24C78E2BB0637FEACECAF32193932D1C2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.QueryCorrect.json", + "mode": "100644", + "gitBlob": "9c2d697117fa9055c2aa10f2d4ca1a04a46f0ff2", + "rawBytes": 1416, + "rawSHA256": "ACB83CBD09B5511903340BFF79055ACBC7582E03F01809F22C543A715DBB54F4" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.QueryObservations.json", + "mode": "100644", + "gitBlob": "51a7c35b2d52f4cdbf42c27f42dde2473b87b7ed", + "rawBytes": 1436, + "rawSHA256": "B6C9DFF685B5BF01FEB6F054392DBB58DBEFC4AFAA2E5B47C03DC52D62F04AB0" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.QueryProof.json", + "mode": "100644", + "gitBlob": "aebfbcb8faf53385801aa2026dcf103893178873", + "rawBytes": 1409, + "rawSHA256": "19515482C720D60AEC70DE5DAE561649EA9EC01DEB95646C9E2D6A5984ED87FE" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.QueryReference.json", + "mode": "100644", + "gitBlob": "e97bb982c443da3c592a6aef13518da196758df6", + "rawBytes": 1424, + "rawSHA256": "2C287489EE2FD0ACEA9CBD8D864C433BB52D6B2BED133ED31FA21259C71D020A" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.QuerySafety.json", + "mode": "100644", + "gitBlob": "704f9c06e53c8b1c6e78e3e48385e3254ecc1717", + "rawBytes": 1413, + "rawSHA256": "C5D282CB3269C23B65B19F4DDCAEC274D1433CBF6105677A68FCF4D31CDA3286" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.QuerySource.json", + "mode": "100644", + "gitBlob": "74a44ffb88b3849b42b487a6515dbc960a89ea09", + "rawBytes": 1411, + "rawSHA256": "62D6B043D741244A4039321B1A466EA261D835DBB6187F04583F6A991517D7DD" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.QueryStatic.json", + "mode": "100644", + "gitBlob": "755e32ad57c188a67270b5e817940484adba36c1", + "rawBytes": 1413, + "rawSHA256": "BE08344EC8386D02D0943C08F423338851C41261088DE07C701FE368A2D2779D" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.RaggedWindow.json", + "mode": "100644", + "gitBlob": "6a84f9b01cce890877c14d20aef4aea87012d65b", + "rawBytes": 1416, + "rawSHA256": "A09B3647A5588363BBD947DDC39F266F34ECBA82EA110CFEAEB580CCB17CEF58" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.RankProof.json", + "mode": "100644", + "gitBlob": "ca1cd4c47706178f3d279946e195942c17bb3283", + "rawBytes": 1405, + "rawSHA256": "E14FD56728049CEF192B9D2DEFA6FF2C915251D25F0E0DCEB5DD2F6090542729" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.RankSafety.json", + "mode": "100644", + "gitBlob": "496849b0a60d2473f5cc61175de4745fc8914250", + "rawBytes": 1409, + "rawSHA256": "EC8BAA545B3B7EC0E3FE5D72DA0969E76821B8525D308074868EE5E5BFCB926B" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.RankSource.json", + "mode": "100644", + "gitBlob": "7101cf560258731760e826dec86ecc0740a1ad04", + "rawBytes": 1408, + "rawSHA256": "160A1EDBA0701037FDED801F631CCC019C73777CBD03CB7391B3137FF88474FA" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.ReadInterface.json", + "mode": "100644", + "gitBlob": "7d84123b8911ee28b1c63635e70b0de7508b2b14", + "rawBytes": 1420, + "rawSHA256": "19F7BF4948DC871B79AC4599148765AF4F15EB6E739A44FC33286D853F341014" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.ReaderSafety.json", + "mode": "100644", + "gitBlob": "4858994ad2bc8533223dd68591dd35a2619f3a95", + "rawBytes": 1416, + "rawSHA256": "C117551D92269F0E043C1439804999B94CC50809D02035CE6548BBBE9873BBAC" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.RegularLocate.json", + "mode": "100644", + "gitBlob": "8a38a193560292da2c07a5d864357562f9f7705c", + "rawBytes": 1421, + "rawSHA256": "292EB3017D185D3D353470EF4DDB2536E889BF4613A232D0EB13B7D4DEB106E2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Safety.reuse.json", + "mode": "100644", + "gitBlob": "f7415c96e1ba46167c9f9878017a77386d16f584", + "rawBytes": 282, + "rawSHA256": "D87E0834D269CD7760FEB8E3E7350840EBDCB333C13330FCA70DC4EE5C195471" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Scalar.json", + "mode": "100644", + "gitBlob": "37240e9ec726d154160f2ecf5ed1ff584ea3f4da", + "rawBytes": 1392, + "rawSHA256": "4D7D93A5FE17DB61E0F9134252E21FC892517947AA632B08B47769F7E57D12C4" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.ScalarSafety.json", + "mode": "100644", + "gitBlob": "ed96862d0996b42e4de803cf972a477074d93dcf", + "rawBytes": 1416, + "rawSHA256": "5A06C8D1614BC35D717DD8A75A4028B492E1310D785F1AF933C2F0B9358137EE" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Scratch.json", + "mode": "100644", + "gitBlob": "12d7509b548e7d514888c76bcad5dbf9615f11e0", + "rawBytes": 1396, + "rawSHA256": "F327FA2FCE2F98D5ECB48564BD234F687502179EE5ED270827492F97B6EF6966" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.SelectProof.json", + "mode": "100644", + "gitBlob": "abf86d75ffebd2b0958351eced0fc47b9e91729a", + "rawBytes": 1413, + "rawSHA256": "AA52EB32126C0C8EAD33C7328DCFB39C4B8A9D8D6FB4EE142D4608DA38549DFD" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.SelectSafety.json", + "mode": "100644", + "gitBlob": "386ddd97c861fa76b7d53a131a2bc1d6354bc0fc", + "rawBytes": 1417, + "rawSHA256": "DBD5DFA43C75F513D1075874A6DC8C4BB32BD9B5B8F19DFFAEDEB1C3F8F101EB" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.SelectSource.json", + "mode": "100644", + "gitBlob": "1801518f2419f437f96efdb10e32ae4b49b26e0f", + "rawBytes": 1415, + "rawSHA256": "B9ABB6ECBEDAAFEE00C6F5A0091DE26ECBFBBE2A479E4F5D6C61F25077C2EFF4" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Setup.json", + "mode": "100644", + "gitBlob": "b25149d329a92b5f0fd2c322acd223f62755e767", + "rawBytes": 1389, + "rawSHA256": "4D28643EC4E3CDD48144C574A1015947C9273172B09D59E00FAAAFF79AAEEC6E" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Span.json", + "mode": "100644", + "gitBlob": "dcd9801035c7c7914e7b0d5fe496e063966a9c99", + "rawBytes": 1385, + "rawSHA256": "1F83993AD157550B62AE22C2580ED35E3EE4E1974368107ED8BB1FD6A186401E" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.SpanAssembly.json", + "mode": "100644", + "gitBlob": "353ddc004d79d5842bb2765b5df4f6ffadc51214", + "rawBytes": 1416, + "rawSHA256": "7352B35462D35448599498600656EDEF8A36745460F567F50664D85D073CC49E" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Structured.reuse.json", + "mode": "100644", + "gitBlob": "66b870dfc051f2e4dc6076789f278624fa60e437", + "rawBytes": 286, + "rawSHA256": "A9D4F5ED3AB28D84854D3A3C7AB4AA70FEBC0F86359A34042E951499F5D90C0F" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Width.json", + "mode": "100644", + "gitBlob": "3e27685779f25fe2a94b869e9a1da0121cd5465c", + "rawBytes": 1389, + "rawSHA256": "3E861BEAD0479F755B02C5B7F959DBEECF5FCE80156A06B1A330AE2BED67C353" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.WindowProof.json", + "mode": "100644", + "gitBlob": "75bdf66ed853ad526579c6bf84db05c42eb69720", + "rawBytes": 1413, + "rawSHA256": "36CC07A9D42C9DCE5208FCB8699A18AEC4804715044A47047DBF60BB32BB8908" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.WindowSafety.json", + "mode": "100644", + "gitBlob": "4732f2bd78e062c3b2b5dcde3a20f4836a912b99", + "rawBytes": 1417, + "rawSHA256": "E23CC414E1B16B4C64CD294A02BBC528864664E402C46FCD1D878F0C3B36D237" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.ReadStoreEval.json", + "mode": "100644", + "gitBlob": "515f9130bcf916a4f50a7595180e0daa2944cdc7", + "rawBytes": 1390, + "rawSHA256": "C39B048966E6E3574B9973CFD4762F438A06A91EDA73AA1FB25E5398260C0881" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Register.json", + "mode": "100644", + "gitBlob": "bd56ce1b896b0af6ba85ae15348f34ee78812864", + "rawBytes": 1371, + "rawSHA256": "EDC909AB8CE627C64754C40F3F8CA0E2583629FEAD640E671D31BAF0137994F7" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.json", + "mode": "100644", + "gitBlob": "25e42af93b4d716669dcbba4f6be0b4f1db289d0", + "rawBytes": 1333, + "rawSHA256": "81F7B54FFD1C1A6BB27AEC4F19342332DA94BDA0C8F925314EE738810C4F4181" + }, + { + "path": "docs/internal/extensions/opt1/query-development/capstone-branch-pass.json", + "mode": "100644", + "gitBlob": "f0d38d670be6e2c7ce6eb15739e35bef4460bb28", + "rawBytes": 1425, + "rawSHA256": "A5D3AAB6C1ADCC2F2E67138F9857A6E3A904B64E735E2DC87FFF9375F5F83D10" + }, + { + "path": "docs/internal/extensions/opt1/query-development/capstone-first-failure.json", + "mode": "100644", + "gitBlob": "4de1b64e6c7f3a4fde87af320d015a86c1d9bed8", + "rawBytes": 4356, + "rawSHA256": "DFD5855BED02484DE412A08C8F0D14C23382B3C748284358A47852A4D150D27D" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/20260912-072230-413-Frame.json", + "mode": "100644", + "gitBlob": "443a7fc9cf442eafbeed9c7ecb96b6acbbef4136", + "rawBytes": 867, + "rawSHA256": "C74B47994C1EC8FE7190DD2E8CE913E1F2A2A819478D823DBB0F74FAF40DE992" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/20260912-072257-771-Safety.json", + "mode": "100644", + "gitBlob": "811235951ba585b6da784fefb5424fa11eb9f0df", + "rawBytes": 870, + "rawSHA256": "674B48DCF1A64CF4EA090FC85F732745D5878EF9F8D805C6BEC90E1934117AFE" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/20260912-072317-427-SourceRelations.json", + "mode": "100644", + "gitBlob": "e7999cc18729469fe1c1f231feae4d7b7994476d", + "rawBytes": 16589, + "rawSHA256": "B95F15697EBD770F7AEE0785E0DCBCC81245F163736F4ABF59F584063CC69299" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/20260912-072444-505-SourceRelations.json", + "mode": "100644", + "gitBlob": "6d49f30a0a42216918cfb3c45f0a0eed398ee9dc", + "rawBytes": 6579, + "rawSHA256": "69D751008A709BCB74008C56B281C08B872803ED5D073706EFE94D5F0E1259A6" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/20260912-072545-457-SourceRelations.json", + "mode": "100644", + "gitBlob": "861252f274d70fd8a4ec4f6ff2c8c5b8d620f225", + "rawBytes": 909, + "rawSHA256": "375352F4DE6EA39228D30727866687FDB57710A2119124EC75539561AC277380" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/20260912-072553-584-Types.json", + "mode": "100644", + "gitBlob": "a55faf41f5a160a3da98db23ff0f3ad73f9fbbdb", + "rawBytes": 11888, + "rawSHA256": "7F2EFC270064FD650077C650900397F7BEDF6C57C0D8E42E2889C27236140DD9" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/CONTRACT.md", + "mode": "100644", + "gitBlob": "33364ec377f79ed9f7ce2560fc0e837ad3e0c5b9", + "rawBytes": 4223, + "rawSHA256": "A94F7323C282CDB0B8D1512699771AC71C5C457EF51AF374A000AF08179F8978" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/REPORT.md", + "mode": "100644", + "gitBlob": "83bf754518156cf720ea7ac693e2aa56c463b0a1", + "rawBytes": 13348, + "rawSHA256": "95799A33B9DCB129F8C4541408A40D2319D7203DF1FA0F2B8FFEC8B130AA1636" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/Types.lean", + "mode": "100644", + "gitBlob": "0c17956936cd2bd84fa5fbbea2ab3feac87101ad", + "rawBytes": 835, + "rawSHA256": "BFAF00282DE4A909D7780D1AFE71C960ED693D3F109931A8FE503B3AAE1A86B2" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/check.ps1", + "mode": "100644", + "gitBlob": "4ee7b37c363bebb8371f9c5877ac5de4bad1f9b2", + "rawBytes": 1997, + "rawSHA256": "BD95F3B065521B0A0CE2A5C36EC3EE3FD10E8CECAC32F5B3BAD0C698FC31ABF3" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/hygiene.json", + "mode": "100644", + "gitBlob": "145f47243dc09ab3f897494bd848a9c0755c529d", + "rawBytes": 652, + "rawSHA256": "2807F552D290C853F7494453F397D1BE25938717EF16606BB58D39A8222BD0FF" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/.gitattributes", + "mode": "100644", + "gitBlob": "79251caef4b743f3bdf7b268f8b66a859601fb77", + "rawBytes": 801, + "rawSHA256": "8E4F9BB9284238F2BCF3B17D0AE28FD631AC2957B3A1C48252D9CC9CFAD676F1" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "9fd9cace09ceba1058f83765405762c0fa5e1d2f", + "rawBytes": 64577, + "rawSHA256": "690D9FF348D86C2AFDB93016D2626E837721BA1B633A7916DDA55284672B4561" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/PROOF_IDENTITY.md", + "mode": "100644", + "gitBlob": "81708677bf85742da2e43a4811507aabded1bf9d", + "rawBytes": 37806, + "rawSHA256": "719C068F469729787700FBA2B6C9BC90F9798C0D8E8FBA944B7DACC1A68B91DA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/README.md", + "mode": "100644", + "gitBlob": "b4481a512b232a951abfacd500a57c7f1a710d0f", + "rawBytes": 12669, + "rawSHA256": "291E115D5AC35CEC517AA3F6199BD7CE7224A181E1FF949E918A418131ABC007" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/REGISTRY.json", + "mode": "100644", + "gitBlob": "bcda60d2bb7c3f924b2257897b2fb99e66e5b453", + "rawBytes": 9334, + "rawSHA256": "59DB124F0A3B42057977E2613BC0FB841EC62C8CEBD2E0E5BFD5003CFE4F9C0E" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/REPORT.md", + "mode": "100644", + "gitBlob": "cfa93ce3d770e4953c4bef86d68be7b64e0a91ae", + "rawBytes": 28707, + "rawSHA256": "C137409DB5E11A51DF193174739BC38D003FBC03F63EC1BA42CA75BE898EBD3B" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/axiom-union/20260913T0055245605662Z-axioms.json", + "mode": "100644", + "gitBlob": "94c3d85757336e599409388284e1d6a8b9d0bce7", + "rawBytes": 42084, + "rawSHA256": "BCDAC03A4B240DD7A7692847E419722F35470DFC38E2715F41DE9819B75C4D06" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/axiom-union/INVOCATION.json", + "mode": "100644", + "gitBlob": "8a3905684a62865001028bfd0e02c23bc9da55c7", + "rawBytes": 751, + "rawSHA256": "FFE20603A4D0A4693E52734D70993E05B1B0EE1D173DC7AA56B56911D54B3E61" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/certificate-80/IDENTITY.json", + "mode": "100644", + "gitBlob": "fb6ecc9164e1cbb17d17f3aa0df5aa4dc3fd1876", + "rawBytes": 397, + "rawSHA256": "C5A11DD73189B0A9F556B1B5DB3D2A91C86EFF586F0585C343E9334F22BA0BEF" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/certificate-80/RESULT.json", + "mode": "100644", + "gitBlob": "1e5dcd778a1bb7f313b972bd9523f9b0442ee92e", + "rawBytes": 53830, + "rawSHA256": "BF5A0C0A008C7BB0F57264E759B0985B16479208F721327E8A2D249F5FA17D6B" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/certificate-80/SPECIFICATION.json", + "mode": "100644", + "gitBlob": "28420455353fd77f14530c9ae8429bbfb6f3ad29", + "rawBytes": 2236, + "rawSHA256": "28A3C24F5396D6350D47F45E264096107CC8ABD5D40C7483005A6DCA039741BE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/certificate-80/stderr.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/certificate-80/stdout.log", + "mode": "100644", + "gitBlob": "a2e0e2b5ee3ae49a4e6d8b99863a416cc7455105", + "rawBytes": 19674, + "rawSHA256": "34A7303E3AB6EC7E220C701B5E4EE4611B4F6C7089B938E4583F61DD6E9E8AD4" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/claim-scan-a/RESULT.json", + "mode": "100644", + "gitBlob": "36353a42de92be2be299ead0798059524cff46b6", + "rawBytes": 898, + "rawSHA256": "260284C3B1416D6A13BFF273D8ABCF3DFC4A65EF95A8ECF81D6A3CCFBFA5CFBF" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/claim-scan-a/stderr.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/claim-scan-b/RESULT.json", + "mode": "100644", + "gitBlob": "a87bc97350effb2dc59113098c2cf543ad0f6b52", + "rawBytes": 902, + "rawSHA256": "5BE7F4732147008B02C5988592A61F38FA43F15C29530EF19A2FDBD636DC8F1D" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/claim-scan-b/stderr.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/claim-scan-c/RESULT.json", + "mode": "100644", + "gitBlob": "b991c08ab2d1899700683a77db57b7f199d44146", + "rawBytes": 1322, + "rawSHA256": "97C2C038310C2E9FC26C6764F9453008D00B2746DA771B1AF67EEDC8BCD5C74C" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/claim-scan-c/stderr.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/claim-scan-d/RESULT.json", + "mode": "100644", + "gitBlob": "5ef991a7826c77bd5378d962a3bc802c919a11cc", + "rawBytes": 1322, + "rawSHA256": "3F946D4C9DCAB28A99BAE40DD0C94902DCFB6FB5C02A94B15EDE5A5D82B479B5" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/claim-scan-d/stderr.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/lake-build-attempt1-wrong-flag/RESULT.json", + "mode": "100644", + "gitBlob": "13162dca4d09b0d96e8d1334e087a7569d78e376", + "rawBytes": 2475, + "rawSHA256": "298FD5F5C236AFCF40FD8F428228DF319D2AF2E528D830E2FC9D3598A5C51109" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/lake-build-attempt1-wrong-flag/stderr.log", + "mode": "100644", + "gitBlob": "63d0f6e646c4911b219ebdde29a48adddd34950f", + "rawBytes": 34, + "rawSHA256": "0CCBC6FE2A3EA0A8F40382DCEF8AC918F83AD1A42A2EE363D36650A75C6EB05E" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/lake-build-attempt1-wrong-flag/stdout.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/lake-build/RESULT.json", + "mode": "100644", + "gitBlob": "455ebd0473f8efc7a1d2e90cbb7da9287a401822", + "rawBytes": 247426, + "rawSHA256": "CCFA0C741F0962C634A741DF1E059BAFCCE26ED2AA3FEE5EE15713FBE5FE1499" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/lake-build/stderr.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/lake-build/stdout.log", + "mode": "100644", + "gitBlob": "4a65b2fd1c88ccd712e74d3b1aa39e4cd370e5f1", + "rawBytes": 109246, + "rawSHA256": "A387E1527714D4AEA2D9CB737D26AAFB211E1EAC41A99632E40B27BF91383F37" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/plans/certificate-80.json", + "mode": "100644", + "gitBlob": "28420455353fd77f14530c9ae8429bbfb6f3ad29", + "rawBytes": 2236, + "rawSHA256": "28A3C24F5396D6350D47F45E264096107CC8ABD5D40C7483005A6DCA039741BE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/plans/regression-49.json", + "mode": "100644", + "gitBlob": "b0539e0eeae181a576a1d73a8f847dec0a81908a", + "rawBytes": 2123, + "rawSHA256": "F407ACCE0CF2F8664B22B71B977C4A274DAC95CCCCC5B68A8C6DA18D2FF1CA5E" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/plans/runtime-27.json", + "mode": "100644", + "gitBlob": "ceb23f7621537bfa90f5904503da6c1365f746be", + "rawBytes": 1701, + "rawSHA256": "F1D68FA8AA2B83ED96D90B1BFC9C5A897211E01E98E36E38459F6A70C5DAF02B" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/prepare-r1/RESULT.json", + "mode": "100644", + "gitBlob": "b9bc07504ccd107854d482e5314566ec1f599cf9", + "rawBytes": 465592, + "rawSHA256": "33712034A1C59B72D7B35D9907284113B3D3768165E3EC9E6DC159E1FCF25FF2" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/prepare-r1/lf-install.json", + "mode": "100644", + "gitBlob": "0ef395f5aff1230dca1a7612872124903cb59c1c", + "rawBytes": 214771, + "rawSHA256": "2DE395E8BA6E8909F62D49DD6AEAFCBBBA647A0694A64039551A4B7F73AC7551" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/prepare-r1/windows-install.json", + "mode": "100644", + "gitBlob": "4350d933d81b251a17853c5e4a5881dab0d40108", + "rawBytes": 214796, + "rawSHA256": "A3FE7EC7651FAB0B85AEDA340F8A9A477519B0BB543435B9B5900B34C618F0AB" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-001.json", + "mode": "100644", + "gitBlob": "0bbcf3809c53e91d9fdd45d4d836b86585c57b0f", + "rawBytes": 1190, + "rawSHA256": "AE111322A7686833E3D26FE029E3E36A2C4780E11D160073BDDC71863B11E1ED" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-001.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-001.stdout.bin", + "mode": "100644", + "gitBlob": "97b9d54bfb7a66330592e4d63951318547a2e5b7", + "rawBytes": 41, + "rawSHA256": "813E228511628C4ADE08271DF3ED679170F9801E4C383428A8B492D3F3EB33EC" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-002.json", + "mode": "100644", + "gitBlob": "aa16e87650f6724da55fa1b71dfd5a7cd8437512", + "rawBytes": 1234, + "rawSHA256": "53A2EE9B09B22DBEE88591B82964AD67EC9D771B87C55AB1A2F1AC1BA33E016C" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-002.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-002.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-003.json", + "mode": "100644", + "gitBlob": "bc477d6af301e8a40e1f6ac3c611abeeac7828f8", + "rawBytes": 1235, + "rawSHA256": "F8349B143A3B648A7E031293C3B13293C83761EF8A15F893C27EEBDA9D8D82F2" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-003.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-003.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-004.json", + "mode": "100644", + "gitBlob": "f2ac69902a1dd7f3effd52cffc31b3c0af3b01c2", + "rawBytes": 1497, + "rawSHA256": "AF1847C9EE46DF0A45E4FB8652CD73728A1BE32C7AE3DDB83D346C512D399AB0" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-004.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-004.stdout.bin", + "mode": "100644", + "gitBlob": "539328d7c4bf06ca53176deec58e39608dc48900", + "rawBytes": 68359, + "rawSHA256": "954F4354774E6571FC392A678B8CFF302A7C2F361166558BC2D5607CB400AB20" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-005.json", + "mode": "100644", + "gitBlob": "6892b3a825d33befdd1e7daeb02073ba79d0d769", + "rawBytes": 1454, + "rawSHA256": "17136E974059CA690F1E8F9CA5E60CF8281631BD314A919C46944B33C1FCC74E" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-005.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-005.stdout.bin", + "mode": "100644", + "gitBlob": "c8f6ee5e6632fd4c7317d1f703251e0d7de74491", + "rawBytes": 88876, + "rawSHA256": "19B0B3EAAF3E9F799247595A21C7988AB4B917F8952730C65E7B5EF98A200F38" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-006.json", + "mode": "100644", + "gitBlob": "f6ada55b0ec526cf8911f532f53ba427b6836f42", + "rawBytes": 1230, + "rawSHA256": "CFAC88AEB900A63D0B9141CE8A9B8B1CD02C38034C18E5181277D5A846712658" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-006.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-006.stdout.bin", + "mode": "100644", + "gitBlob": "96d856ad8ad44f4bd84f862ee5275fb3b57015a9", + "rawBytes": 24783, + "rawSHA256": "BDD50082D978815E9005EDE9C34A9757F83693806307EE766E4CCD3C8472AAEA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-007.json", + "mode": "100644", + "gitBlob": "bc609170914a9ed242967fb88a91e8c232e77333", + "rawBytes": 1230, + "rawSHA256": "DE72B2864CF8E6A72EEEA8FA16D1FE4685F86147909E079BE9C58DD3E7BBBF28" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-007.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-007.stdout.bin", + "mode": "100644", + "gitBlob": "bd5d0eb38fd4a301eb89b027fcc434fc18dbee75", + "rawBytes": 35633, + "rawSHA256": "486420760DD5C43312DD0A0E9432771B55ADDE1953088B70597269E057A06051" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-008.json", + "mode": "100644", + "gitBlob": "dac06935abf70780dab2d6167553744428ede2d4", + "rawBytes": 1240, + "rawSHA256": "5603248F79E5BFCE523E71E379EB70CB7DBC07480F567CEB1BA18805AC9CD307" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-008.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-008.stdout.bin", + "mode": "100644", + "gitBlob": "3760470717560aafc5ae4652522eff1953d001e7", + "rawBytes": 11640, + "rawSHA256": "0D1529C98D35B6FF2AC53D58D107F0A47EC8F5D263F51819C085827C055A63BB" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-009.json", + "mode": "100644", + "gitBlob": "403a49c67d287cf967f30845def55739d4a514d4", + "rawBytes": 1223, + "rawSHA256": "1BA3DE52603EDDB20C81669EFF3C0BA5F98186FF31CA4B8DB7E6C1718B70C456" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-009.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-009.stdout.bin", + "mode": "100644", + "gitBlob": "7a78c403e548df7ba7e7782ab081f08c4f4ad32b", + "rawBytes": 24706, + "rawSHA256": "6A435EFF7E3CD2A2DFEA248B3A8ABEBABAF10FF643927C5C3FCAE52E666E7CB5" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-010.json", + "mode": "100644", + "gitBlob": "b65099f9cafaaf0973ef0868e58c230201f5ebb4", + "rawBytes": 1224, + "rawSHA256": "9C4936BC7D04181C049D09C8E64617BFA6BA4A71D4A9F83C19B2FE15663AA597" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-010.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-010.stdout.bin", + "mode": "100644", + "gitBlob": "4c9314d23730f318c1a4f99ca13e2156912f277b", + "rawBytes": 9090, + "rawSHA256": "0D4F03AC19F890B67894B74042FF7559ADD574A8D160539AD3565A48289BA0AE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-011.json", + "mode": "100644", + "gitBlob": "02ff154131de2fa6bd4687664d655baa160a1cb2", + "rawBytes": 1496, + "rawSHA256": "75FAF48D86B9477BD0F4E6B1315D2DDA3AB5A70CCE47403C4B9AC92E4B94CE80" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-011.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-011.stdout.bin", + "mode": "100644", + "gitBlob": "9e115d5f5c9e0eeea83a9e31f475494c216ad144", + "rawBytes": 90913, + "rawSHA256": "250C459FCB35FAD451C65861B7FDB6B7D5A771550357DF7322159AF8CF48BDDE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-012.json", + "mode": "100644", + "gitBlob": "966d0c6b228862cb3f82b8c4d957bbf398d50fa7", + "rawBytes": 1230, + "rawSHA256": "5A394E7D202947CA8F15A4C10D54E36C904CFEB33ADECD8295961EF0FDACA5A3" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-012.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-012.stdout.bin", + "mode": "100644", + "gitBlob": "bd5d0eb38fd4a301eb89b027fcc434fc18dbee75", + "rawBytes": 35633, + "rawSHA256": "486420760DD5C43312DD0A0E9432771B55ADDE1953088B70597269E057A06051" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-013.json", + "mode": "100644", + "gitBlob": "4c7368036a1b189a50710dc5e07126e136bebbda", + "rawBytes": 1240, + "rawSHA256": "46150E8FB8BEF365F4B027B3839B1581B03BE6BB9160A1E5D6CB07ECEDF13F26" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-013.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-013.stdout.bin", + "mode": "100644", + "gitBlob": "fdd3690e0af9cc8322aad33d5bafe135ca970a34", + "rawBytes": 32051, + "rawSHA256": "58387DF5DC955C5634A0E2BCCCCDFDB7CC72552D4B1FB89F2F68577F9BFF0706" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-014.json", + "mode": "100644", + "gitBlob": "e7b3d7e4209d752a8a2742a29f7118a1f92fb55a", + "rawBytes": 1236, + "rawSHA256": "23C6F70D4415DD966F5BE6A549E7855E22E50BF04CAB11D57F75851B9673E0B4" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-014.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-014.stdout.bin", + "mode": "100644", + "gitBlob": "81708677bf85742da2e43a4811507aabded1bf9d", + "rawBytes": 37806, + "rawSHA256": "719C068F469729787700FBA2B6C9BC90F9798C0D8E8FBA944B7DACC1A68B91DA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-015.json", + "mode": "100644", + "gitBlob": "2ef24344290a8adc1a271a8d8ca24d203f999025", + "rawBytes": 1521, + "rawSHA256": "A00A7501778F2EB1F58CCA6CCB036FC5C86330F4E42BA135776C94C0C456411D" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-015.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-015.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-016.json", + "mode": "100644", + "gitBlob": "f63b5715134fc138bdb300561d5f219bf5ccbdb1", + "rawBytes": 1481, + "rawSHA256": "ECC7B302E2C934C3A228AD77DD29CFC0B9946B252C26FADB2A9922E542A3A0C2" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-016.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-016.stdout.bin", + "mode": "100644", + "gitBlob": "b101dc308c09d6126c80b402ee0c8a112277b237", + "rawBytes": 4611, + "rawSHA256": "5160689EF625A76112CD3ACFFCF8CCE0488133A14E88FAC5800CE967EFE44256" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-017.json", + "mode": "100644", + "gitBlob": "68e69625dd6c0d6ced1a3f225f7fbbe1921c3a5f", + "rawBytes": 1454, + "rawSHA256": "87E787AB208FE5397610C13D31BAC03F470F8855DFBBB4005B069281F3BB2656" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-017.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-017.stdout.bin", + "mode": "100644", + "gitBlob": "c8f6ee5e6632fd4c7317d1f703251e0d7de74491", + "rawBytes": 88876, + "rawSHA256": "19B0B3EAAF3E9F799247595A21C7988AB4B917F8952730C65E7B5EF98A200F38" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-018.json", + "mode": "100644", + "gitBlob": "a96bc2c725c6c652d8688084591b8e80f2b23637", + "rawBytes": 1454, + "rawSHA256": "F72924344C69571A28569D35E718E0839D3C9D9D8933DB26360E9A7B4FA249AA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-018.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-018.stdout.bin", + "mode": "100644", + "gitBlob": "c8f6ee5e6632fd4c7317d1f703251e0d7de74491", + "rawBytes": 88876, + "rawSHA256": "19B0B3EAAF3E9F799247595A21C7988AB4B917F8952730C65E7B5EF98A200F38" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/process.json", + "mode": "100644", + "gitBlob": "dcc45f954f4257ce328cb34ae8c1f549cbd4bb25", + "rawBytes": 1046, + "rawSHA256": "A765A87BCEC496108746469643592D2B0A415101F7EEDA3E4B8C69DC36D3D89E" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/result.json", + "mode": "100644", + "gitBlob": "d926f955b3ebd1fb86b64697eef547fa3129809b", + "rawBytes": 543685, + "rawSHA256": "0F80FEC5E49D0FAE83C498C87B6D30A1973ABAAC955070E22B3ADDB11290CD58" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-001.json", + "mode": "100644", + "gitBlob": "8fbc18403cbef3eb7578872d5dbad860e58b94bb", + "rawBytes": 1190, + "rawSHA256": "379CC5AB46DA03C965043564427E7F93F251D89305F7F5CA3A9FB9C0BAD14205" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-001.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-001.stdout.bin", + "mode": "100644", + "gitBlob": "f12142ba38d47f2798b766f01c3cef9e7e9735d0", + "rawBytes": 41, + "rawSHA256": "F33BE2901E99D992A7CFB2F8BD5C41A270F222A087090A9AA5A2054627CBB64F" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-002.json", + "mode": "100644", + "gitBlob": "489fe089aec6b6ca11b9c956f0f3d2fb37fed2ef", + "rawBytes": 1234, + "rawSHA256": "BDDCD471D0ACC5C9D216D5C683571C49FBCF34B85500328E60E93B86BDA7417E" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-002.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-002.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-003.json", + "mode": "100644", + "gitBlob": "0529f1fb349413702391a66d23421d70afcf34a2", + "rawBytes": 1235, + "rawSHA256": "C2F5F4BF651AED8ECD5A4881D5EF63570FD125FD7DC40D7E046932DDE4F777D6" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-003.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-003.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-004.json", + "mode": "100644", + "gitBlob": "89d6fa9d10c6d8ecc296f8aba0bfb8c3af6cb0e6", + "rawBytes": 1496, + "rawSHA256": "DA6D02E05C78A31D58CAB66F1FB67F47F26F4B8A9E3B1D3511F324573F8C96CE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-004.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-004.stdout.bin", + "mode": "100644", + "gitBlob": "539328d7c4bf06ca53176deec58e39608dc48900", + "rawBytes": 68359, + "rawSHA256": "954F4354774E6571FC392A678B8CFF302A7C2F361166558BC2D5607CB400AB20" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-005.json", + "mode": "100644", + "gitBlob": "4abf1a0ed0ad2c9d93eed64473e7eef97e441704", + "rawBytes": 1455, + "rawSHA256": "0B7C20C98642DDBA9E83E704582B9213BBD68B9ED58ABB1D5B30A1151E076A11" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-005.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-005.stdout.bin", + "mode": "100644", + "gitBlob": "c85dca28255babeb1670c4526e2576c1ae561b7c", + "rawBytes": 107590, + "rawSHA256": "3956F3032D7DC6429DFABFCA34ED853C478FD9C3D6EB9BB6D4D1C985A9D5A78A" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-006.json", + "mode": "100644", + "gitBlob": "f913fbd0f7d06dff739c06193b1651356720c086", + "rawBytes": 1230, + "rawSHA256": "F52117FEA2E30BDF0F097D69D9D4BA3E9F9575EF0A03C41BFB338223D1F59BD1" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-006.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-006.stdout.bin", + "mode": "100644", + "gitBlob": "96d856ad8ad44f4bd84f862ee5275fb3b57015a9", + "rawBytes": 24783, + "rawSHA256": "BDD50082D978815E9005EDE9C34A9757F83693806307EE766E4CCD3C8472AAEA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-007.json", + "mode": "100644", + "gitBlob": "486481e790317d33eff8bc5d11ddc4c62e831b60", + "rawBytes": 1230, + "rawSHA256": "98944A95A35250BADA9329E90764EFEE9A20DE52E690ED684121B1585AAF5D0F" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-007.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-007.stdout.bin", + "mode": "100644", + "gitBlob": "bd5d0eb38fd4a301eb89b027fcc434fc18dbee75", + "rawBytes": 35633, + "rawSHA256": "486420760DD5C43312DD0A0E9432771B55ADDE1953088B70597269E057A06051" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-008.json", + "mode": "100644", + "gitBlob": "b9fa3dd0375dc20397027b0608bd698e89c55ce7", + "rawBytes": 1455, + "rawSHA256": "FD35CC640994A065803FFC325B07CA0D7930C977C263653DCFD531C1237C5BD3" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-008.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-008.stdout.bin", + "mode": "100644", + "gitBlob": "c85dca28255babeb1670c4526e2576c1ae561b7c", + "rawBytes": 107590, + "rawSHA256": "3956F3032D7DC6429DFABFCA34ED853C478FD9C3D6EB9BB6D4D1C985A9D5A78A" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/process.json", + "mode": "100644", + "gitBlob": "b038c7e18cb8315c99944cd85a8c70b53680b5bb", + "rawBytes": 1336, + "rawSHA256": "049620067C9B191E5420F18929BDF35E4E17D780BBB47FF33655FD4704CB6F11" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/result.json", + "mode": "100644", + "gitBlob": "5a9458361594def433e3462faa51daaeb25dae77", + "rawBytes": 236051, + "rawSHA256": "2A4F3A10EA0048A22ABDBA9B8B81FC249325A0D9DEF42EBBC56B3F238D294CBE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-001.json", + "mode": "100644", + "gitBlob": "5678264e8f6da757e825514a7a6e9abfb9b32a5f", + "rawBytes": 1190, + "rawSHA256": "EF9BA0562D6904D076E4209D4390AFBD1A8FA4544B3701A249AEDABEE9F2EBF6" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-001.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-001.stdout.bin", + "mode": "100644", + "gitBlob": "c5dba678ffcd745862e13c731b2698463ca3bf9f", + "rawBytes": 41, + "rawSHA256": "8A9C659661F0FDCEF1DB9A753156CAE7577A8A8162B64C2268511D7CB62152F9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-002.json", + "mode": "100644", + "gitBlob": "bf7594f59d6639605e6a5b37cd2890d7640ab304", + "rawBytes": 1235, + "rawSHA256": "A2A3C0B55BD05507049E3DF8F4AD58BF4164EAD158455AAF06D5554C76E70AFC" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-002.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-002.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-003.json", + "mode": "100644", + "gitBlob": "cfd8cedf529da933957e51fbb17796d636108e95", + "rawBytes": 1234, + "rawSHA256": "896FBAF7AAF52B8FBA486EA3FA6B02E04E2586046D5D08BADF4C525FC418538E" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-003.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-003.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-004.json", + "mode": "100644", + "gitBlob": "f04559f95da3376c6d45e46d8ea416620c60d779", + "rawBytes": 1497, + "rawSHA256": "4B0DC08262F5BA641CAECBCB94061E387EDB2D7A12F5CECAD3F453CB5DFE7D63" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-004.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-004.stdout.bin", + "mode": "100644", + "gitBlob": "539328d7c4bf06ca53176deec58e39608dc48900", + "rawBytes": 68359, + "rawSHA256": "954F4354774E6571FC392A678B8CFF302A7C2F361166558BC2D5607CB400AB20" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-005.json", + "mode": "100644", + "gitBlob": "72fc018d6c72349d5233d1e4d108d953dc6d330d", + "rawBytes": 1455, + "rawSHA256": "A4D2D3716117482BDE7DC14A20F5BF0C3296E91EC87199D14F5A17A7E6246D64" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-005.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-005.stdout.bin", + "mode": "100644", + "gitBlob": "91a242f75d835a0c123040f5cb2b67c2ccea051a", + "rawBytes": 111272, + "rawSHA256": "324A4B9D41064758DEDFD3E46936FC54B8107FD1B903F24A20BC2CCBFC663826" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-006.json", + "mode": "100644", + "gitBlob": "8ea4ed198a130c58cf78b40de82f0a31424789cd", + "rawBytes": 1230, + "rawSHA256": "410525760542D3EFD72A4B6D10209BAEA6BAC32479150AB5E899A2808C3B51F9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-006.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-006.stdout.bin", + "mode": "100644", + "gitBlob": "96d856ad8ad44f4bd84f862ee5275fb3b57015a9", + "rawBytes": 24783, + "rawSHA256": "BDD50082D978815E9005EDE9C34A9757F83693806307EE766E4CCD3C8472AAEA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-007.json", + "mode": "100644", + "gitBlob": "cd379992ea3af1e8cd28a7611638b593a888ee7f", + "rawBytes": 1230, + "rawSHA256": "D1C1CC3677BFCE2529775BCD921C2A84CD34DAAA2C61B06A178FCAE447267074" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-007.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-007.stdout.bin", + "mode": "100644", + "gitBlob": "bd5d0eb38fd4a301eb89b027fcc434fc18dbee75", + "rawBytes": 35633, + "rawSHA256": "486420760DD5C43312DD0A0E9432771B55ADDE1953088B70597269E057A06051" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-008.json", + "mode": "100644", + "gitBlob": "e25f5da50f46b930b3777d5a91dbad4f1edc5b73", + "rawBytes": 1239, + "rawSHA256": "878708D2AE422020A36780047859EE199001DFEA8B717E9A0CCBE013DC9A2382" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-008.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-008.stdout.bin", + "mode": "100644", + "gitBlob": "3760470717560aafc5ae4652522eff1953d001e7", + "rawBytes": 11640, + "rawSHA256": "0D1529C98D35B6FF2AC53D58D107F0A47EC8F5D263F51819C085827C055A63BB" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-009.json", + "mode": "100644", + "gitBlob": "0e16f68664fd66251bd931f2f923fab64db1f30e", + "rawBytes": 1224, + "rawSHA256": "223551B9C7BDD44FB306016FED93BF7AFAC19E280C30869FAB62D1065E41A1A7" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-009.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-009.stdout.bin", + "mode": "100644", + "gitBlob": "7a78c403e548df7ba7e7782ab081f08c4f4ad32b", + "rawBytes": 24706, + "rawSHA256": "6A435EFF7E3CD2A2DFEA248B3A8ABEBABAF10FF643927C5C3FCAE52E666E7CB5" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-010.json", + "mode": "100644", + "gitBlob": "8a1ad87378cf6f88bf51b120f1bd0448e6d461e4", + "rawBytes": 1224, + "rawSHA256": "A4C33CA61D0BA0573296A47BCD281483F868B197A4EC85530C8379E4DF0463A1" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-010.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-010.stdout.bin", + "mode": "100644", + "gitBlob": "4c9314d23730f318c1a4f99ca13e2156912f277b", + "rawBytes": 9090, + "rawSHA256": "0D4F03AC19F890B67894B74042FF7559ADD574A8D160539AD3565A48289BA0AE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-011.json", + "mode": "100644", + "gitBlob": "8fb5111e11eed8c7c2108eaa4368c23305e78261", + "rawBytes": 1497, + "rawSHA256": "791384894174F65ADB6425DD87FFEE3883A9CA510C3F8DD65CBA4C2530C18DDA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-011.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-011.stdout.bin", + "mode": "100644", + "gitBlob": "303c58c52a6738e98ec4ed2d676d1c3cc498c786", + "rawBytes": 113807, + "rawSHA256": "11C14EEFC05A6FFE6F644B10DD031A04B8AE0376844F675A9ADCC1609A267411" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-012.json", + "mode": "100644", + "gitBlob": "4996431bc212b97974d8adba7907baad4c7df9da", + "rawBytes": 1230, + "rawSHA256": "2D96D9F52F0798D1BD8D7F07C6DBF1E10E08B8A3D1D72A55F31E255392E7F422" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-012.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-012.stdout.bin", + "mode": "100644", + "gitBlob": "bd5d0eb38fd4a301eb89b027fcc434fc18dbee75", + "rawBytes": 35633, + "rawSHA256": "486420760DD5C43312DD0A0E9432771B55ADDE1953088B70597269E057A06051" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-013.json", + "mode": "100644", + "gitBlob": "c09972f808a928ac81fe5612586a6543618fc39f", + "rawBytes": 1240, + "rawSHA256": "1C2B7096FB3E206EA194441560A9D9292D19D2B54973145264C2E7824DB63F64" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-013.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-013.stdout.bin", + "mode": "100644", + "gitBlob": "9fd9cace09ceba1058f83765405762c0fa5e1d2f", + "rawBytes": 64577, + "rawSHA256": "690D9FF348D86C2AFDB93016D2626E837721BA1B633A7916DDA55284672B4561" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-014.json", + "mode": "100644", + "gitBlob": "70c9a9e00d1e4047217793d60faddb53e1d7dffb", + "rawBytes": 1237, + "rawSHA256": "B3618116483A66DDF3A5206A867A05D03565C3808FBA7D719BDDAF08ACC9C7D5" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-014.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-014.stdout.bin", + "mode": "100644", + "gitBlob": "81708677bf85742da2e43a4811507aabded1bf9d", + "rawBytes": 37806, + "rawSHA256": "719C068F469729787700FBA2B6C9BC90F9798C0D8E8FBA944B7DACC1A68B91DA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-015.json", + "mode": "100644", + "gitBlob": "91c2d239537f53c6aa601e65c64a638add29e0ec", + "rawBytes": 1521, + "rawSHA256": "A7F0CF8FE9D5B012729DE35157367481A0DA7BA41975DEC8C661E399314194FF" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-015.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-015.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-016.json", + "mode": "100644", + "gitBlob": "e9a44bdb4669aed9435b9de4d9349528a3a95cd0", + "rawBytes": 1481, + "rawSHA256": "175A13A24FEBFEE41A54205EFA5EED7C6B8DCE8DBE17210DD37CDD5F09FA5563" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-016.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-016.stdout.bin", + "mode": "100644", + "gitBlob": "8fc2e260632e387b58a5d07cb77701b22c68ff55", + "rawBytes": 4611, + "rawSHA256": "3111DB4DFD9DD148AB70F4D78E762F78C9994F0B5C9D805A36B5D4AD3D623204" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-017.json", + "mode": "100644", + "gitBlob": "dd0a10300e9a09622a046f25760323cc9b986750", + "rawBytes": 1455, + "rawSHA256": "F807D40C6310A4F7A0BC96074106F1B7FA3923440264AC8CD9376DCC4B3A4AD4" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-017.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-017.stdout.bin", + "mode": "100644", + "gitBlob": "91a242f75d835a0c123040f5cb2b67c2ccea051a", + "rawBytes": 111272, + "rawSHA256": "324A4B9D41064758DEDFD3E46936FC54B8107FD1B903F24A20BC2CCBFC663826" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-018.json", + "mode": "100644", + "gitBlob": "f72753927cbf9066240513ea70f5a7b35e48fd20", + "rawBytes": 1455, + "rawSHA256": "22CD1B7D1F60566ADA3911E334AC0E7E7DEFBDD04AEAB53A3C7611792097D9FA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-018.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-018.stdout.bin", + "mode": "100644", + "gitBlob": "91a242f75d835a0c123040f5cb2b67c2ccea051a", + "rawBytes": 111272, + "rawSHA256": "324A4B9D41064758DEDFD3E46936FC54B8107FD1B903F24A20BC2CCBFC663826" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/process.json", + "mode": "100644", + "gitBlob": "3359b1da30ba271964a0b8a27a2e839c821e63b6", + "rawBytes": 1046, + "rawSHA256": "04DCFEE265CFEDB81DF514644803CE7B57F73CB6070107C624A3B912A10313DD" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/result.json", + "mode": "100644", + "gitBlob": "8c730b33eca2fd5f709d6cdaef29398a78728dbb", + "rawBytes": 543691, + "rawSHA256": "D180C5EC6281F297DCE3091687F6DA136D83784650B3B0846C4B789E06510313" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/IDENTITY.json", + "mode": "100644", + "gitBlob": "44d0539a706634d98e7137447f9b2a7d828843e3", + "rawBytes": 396, + "rawSHA256": "69FAE4175530C7A65D7B1737D445741B5A8634B074F46CDAE90CFD019C4A9C2F" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/RESULT.json", + "mode": "100644", + "gitBlob": "bce6c611783d246464de4c46237a94e72ac96616", + "rawBytes": 11880, + "rawSHA256": "0AB69A10BB6CAF5453AD0BA7DCFE4B49BA5D6824F2A887C6BE16C091AE23EC9C" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/SPECIFICATION.json", + "mode": "100644", + "gitBlob": "b0539e0eeae181a576a1d73a8f847dec0a81908a", + "rawBytes": 2123, + "rawSHA256": "F407ACCE0CF2F8664B22B71B977C4A274DAC95CCCCC5B68A8C6DA18D2FF1CA5E" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/C09-MIDDLE-OMITTED-restoration.json", + "mode": "100644", + "gitBlob": "dc95d574cf148d394078905e98414030461978ca", + "rawBytes": 525, + "rawSHA256": "905B1886BC406D72411C6182C691219ABF225D8C99E18D974BA348B7FD6A8FD9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/C10-MIDDLE-DUPLICATE-restoration.json", + "mode": "100644", + "gitBlob": "dc95d574cf148d394078905e98414030461978ca", + "rawBytes": 525, + "rawSHA256": "905B1886BC406D72411C6182C691219ABF225D8C99E18D974BA348B7FD6A8FD9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P05-SOURCE-TOKEN-restoration.json", + "mode": "100644", + "gitBlob": "80144e73576e92bc5d66cd474a97919170b04b57", + "rawBytes": 486, + "rawSHA256": "4147F09C50BEF089668D2C89D99BBBC94510F0C0CDCB9E95D7CE7575EEB3FBFA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P06-ARTIFACT-TOKEN-restoration.json", + "mode": "100644", + "gitBlob": "326943a101becbb2ee7f0076a0d8c7f271518705", + "rawBytes": 508, + "rawSHA256": "E7131480510326D9939B7F6EA32CC20C6108B641F1C12FA765E872F457793E65" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P07-ARTIFACT-MISSING-nested-failure.json", + "mode": "100644", + "gitBlob": "3c1c3477a3d04788e09e803d6e0098ff1e28ff02", + "rawBytes": 1146, + "rawSHA256": "F306DCD75B2D986189008FA3C5F517FE475846055D9545D8198B14D6BB545CA6" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P07-ARTIFACT-MISSING-restoration.json", + "mode": "100644", + "gitBlob": "326943a101becbb2ee7f0076a0d8c7f271518705", + "rawBytes": 508, + "rawSHA256": "E7131480510326D9939B7F6EA32CC20C6108B641F1C12FA765E872F457793E65" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P08-ARTIFACT-STALE-nested-failure.json", + "mode": "100644", + "gitBlob": "963df18de15ef61334e8038af8782fb28dc49fac", + "rawBytes": 1013, + "rawSHA256": "E73E5863F62D1E014F03F3365576A9A8A560B588D21E6DB83507E43E4A308A63" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P08-ARTIFACT-STALE-restoration.json", + "mode": "100644", + "gitBlob": "326943a101becbb2ee7f0076a0d8c7f271518705", + "rawBytes": 508, + "rawSHA256": "E7131480510326D9939B7F6EA32CC20C6108B641F1C12FA765E872F457793E65" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P09-SOURCE-PROFILE-restoration.json", + "mode": "100644", + "gitBlob": "43a29200eac0dcfd625651c2ef1487b06cb7665f", + "rawBytes": 532, + "rawSHA256": "9D8814F36E7B1549D39839F9ABA6C84DEAA0F54134AFD7EB97C19C01900B209C" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P10-BUILD-RECEIPT-restoration.json", + "mode": "100644", + "gitBlob": "82520ad5e28736c34f7a3da73af78e26ce0ed386", + "rawBytes": 531, + "rawSHA256": "4F4193F5F46CCEB04D87E3630D58D7D0D266FE981A88BEC8842D9DB76FF79CB9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P11-TOOLCHAIN-TEXT-restoration.json", + "mode": "100644", + "gitBlob": "ddb5676811a933360e51a08e250faf1eca8f8361", + "rawBytes": 479, + "rawSHA256": "544DFB38111AB496F9A9D668548715B1080B6029AB86F80C7CBDD73907C4DF12" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P12-IMPORT-OMITTED-restoration.json", + "mode": "100644", + "gitBlob": "148c552dddde65ba0bfcfda684c9967cc2c130b9", + "rawBytes": 501, + "rawSHA256": "B67F77A048FDD21908B1420AF6E36D01D5A8A5962A7E3B3FA3365237A0C88D74" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P13-IMPORT-DUPLICATE-restoration.json", + "mode": "100644", + "gitBlob": "148c552dddde65ba0bfcfda684c9967cc2c130b9", + "rawBytes": 501, + "rawSHA256": "B67F77A048FDD21908B1420AF6E36D01D5A8A5962A7E3B3FA3365237A0C88D74" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P14-SOURCE-SPACE-restoration.json", + "mode": "100644", + "gitBlob": "80144e73576e92bc5d66cd474a97919170b04b57", + "rawBytes": 486, + "rawSHA256": "4147F09C50BEF089668D2C89D99BBBC94510F0C0CDCB9E95D7CE7575EEB3FBFA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P15-SOURCE-UTF8-nested-failure.json", + "mode": "100644", + "gitBlob": "16d19c4c2aa007e8b51cfe386d83c5c09d1b0c9f", + "rawBytes": 1092, + "rawSHA256": "E6EE064E7CF6ED416A887A65D8ACBDF44071BC7DED58B830F42FB23F18AB8126" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P15-SOURCE-UTF8-restoration.json", + "mode": "100644", + "gitBlob": "80144e73576e92bc5d66cd474a97919170b04b57", + "rawBytes": 486, + "rawSHA256": "4147F09C50BEF089668D2C89D99BBBC94510F0C0CDCB9E95D7CE7575EEB3FBFA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P16-SOURCE-BOM-restoration.json", + "mode": "100644", + "gitBlob": "80144e73576e92bc5d66cd474a97919170b04b57", + "rawBytes": 486, + "rawSHA256": "4147F09C50BEF089668D2C89D99BBBC94510F0C0CDCB9E95D7CE7575EEB3FBFA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P17-SOURCE-BARE-CR-restoration.json", + "mode": "100644", + "gitBlob": "80144e73576e92bc5d66cd474a97919170b04b57", + "rawBytes": 486, + "rawSHA256": "4147F09C50BEF089668D2C89D99BBBC94510F0C0CDCB9E95D7CE7575EEB3FBFA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P19-EXTRA-ARTIFACT-restoration.json", + "mode": "100644", + "gitBlob": "23b71374f17e7f22ee7673b89f45703c8b35f19a", + "rawBytes": 70768, + "rawSHA256": "AEC31169A8011E973C4DF074973B9BDF8125696FDD1E31216D7B79E3AD26F6B0" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P20-SHADOW-DIRECTORY-restoration.json", + "mode": "100644", + "gitBlob": "b178bf3844f94a373b6f2e5c2a6371d6a23c436c", + "rawBytes": 70762, + "rawSHA256": "6419EEF8696BA7A59D016F1B6C05BE1DB0D7615D29A779B5C318E23D7EE9D043" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P21-ARTIFACT-SIDECAR-restoration.json", + "mode": "100644", + "gitBlob": "23740fb7bc4da4c31e7e9ae0894f9d2144160d88", + "rawBytes": 70787, + "rawSHA256": "9B816C60DCAB454D197C0A53B9AC24C6A392CB2652D94A6D19C29005A52970AA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/R08-MIDDLE-OMITTED-restoration.json", + "mode": "100644", + "gitBlob": "d999e3af2b0a0024ed0325214bf9d12555df28b8", + "rawBytes": 518, + "rawSHA256": "28F6F6AE31540DD82A7397317598CCD369A0D00F4B5A97137BFB628DF61C08D1" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/R09-MIDDLE-DUPLICATE-restoration.json", + "mode": "100644", + "gitBlob": "d999e3af2b0a0024ed0325214bf9d12555df28b8", + "rawBytes": 518, + "rawSHA256": "28F6F6AE31540DD82A7397317598CCD369A0D00F4B5A97137BFB628DF61C08D1" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/RESULT.json", + "mode": "100644", + "gitBlob": "8469a93815a4292767126418b4f1d203ca528344", + "rawBytes": 113872, + "rawSHA256": "246F53054F8DD081EDFEC90874534FEA2E133489872DABD9CA01664F01156192" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/V01-SOLE-SETUP-verdict.json", + "mode": "100644", + "gitBlob": "21729a397a3e422a76960d46526bedd1713452b0", + "rawBytes": 175, + "rawSHA256": "E9D7DBB1B3AE1D490C30D805D8E66C9013F121D342006F1CEE8B0848D9FBAAE6" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/V02-MIXED-STDOUT-verdict.json", + "mode": "100644", + "gitBlob": "3dfeb4266c5e56de81f66708721d7a095137a4f4", + "rawBytes": 228, + "rawSHA256": "8BF7693E8B6C45BDE24C64DF5441A59F779B3FDB60CFAA3CE0736DCD3DC4A028" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/V03-SUCCESS-STDOUT-verdict.json", + "mode": "100644", + "gitBlob": "0629cd35dfd04333ac9bf09c870b8be8204d76b1", + "rawBytes": 230, + "rawSHA256": "B94A644278506B55D89133F3AEDB2BC784501A39B84CB79EE1AB044FDCF19882" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/V04-WRONG-STDERR-verdict.json", + "mode": "100644", + "gitBlob": "3fb8583ecc248afe4b3b72bc33d74ec5f712cbe5", + "rawBytes": 231, + "rawSHA256": "31417EBE11CD21E031EEF8B8773E0459DE1CC902F1CE4D4639D323BFAA9035E5" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/V05-ALLOWED-PROGRESS-verdict.json", + "mode": "100644", + "gitBlob": "71b2c4051dbe3920f48dcb2e66775195056da9cc", + "rawBytes": 181, + "rawSHA256": "F421487D1A9A0EFBEADCAA6DD6624FA9815DD16BA4B8B0DFB37590CBC4719B56" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/V06-DUPLICATE-PROGRESS-verdict.json", + "mode": "100644", + "gitBlob": "f037ffa28c1d294f5eadc5dd295957ef55c1e764", + "rawBytes": 237, + "rawSHA256": "BECF65636AC794285E33A32C8201374657942F451406F15035AD7DDC0A5D58D6" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/V07-REORDERED-PROGRESS-verdict.json", + "mode": "100644", + "gitBlob": "9dae2e436d6c7f73327535b575f01a6e127d900c", + "rawBytes": 237, + "rawSHA256": "D11C552242C5A1C6216CCC5801ED31834BA8FA08102E6FDEA0AFBEE8AE382006" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/V08-EXTRA-STDERR-verdict.json", + "mode": "100644", + "gitBlob": "a41ff19b841d05a49676f3ca8b8571ebb409a266", + "rawBytes": 231, + "rawSHA256": "F8F905A829C23C214A187762A9CD214AAF15A662B296E2B7196BC2E706F63B8C" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/V09-PREFIX-HOLDOUT-verdict.json", + "mode": "100644", + "gitBlob": "5548db51189b55071111ebe24cee7c7333a85879", + "rawBytes": 230, + "rawSHA256": "FF15C97A7590EC0CF0EB1DAED2AE935A178580D917B1DE15B5D21A91264F73BE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/identity.json", + "mode": "100644", + "gitBlob": "4686ecce5457d1b35a9877ecde209e69bf14310d", + "rawBytes": 441, + "rawSHA256": "DDE0EE7CBB6098F9A762F6F1615E8A67562762A4A12DBEC126C589EF0FE7F7EE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/stderr.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/stdout.log", + "mode": "100644", + "gitBlob": "ed2cfdbebfad9904c63305126019212837db2189", + "rawBytes": 1912, + "rawSHA256": "9E1D31CC96F4AE09D6A8AD08EF069BA180E9CB550D30F0736BEDDC5E8DCB0EFB" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/runtime-27/IDENTITY.json", + "mode": "100644", + "gitBlob": "fca3f78b81f7800de01bdf8318bc2bbdfab230f8", + "rawBytes": 393, + "rawSHA256": "6032D42915B2CB8CBA8DC24245758F2ED0F3CFCB0AC3EEB2C6D414FD2F329F00" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/runtime-27/RESULT.json", + "mode": "100644", + "gitBlob": "19c59af2365d6fdb1aca636e3450dfdc2d7ce056", + "rawBytes": 11348, + "rawSHA256": "AA3D8D9CE004E0736E0AA0A9BA004E736236C03E388F96F522C886E42666D97A" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/runtime-27/SPECIFICATION.json", + "mode": "100644", + "gitBlob": "ceb23f7621537bfa90f5904503da6c1365f746be", + "rawBytes": 1701, + "rawSHA256": "F1D68FA8AA2B83ED96D90B1BFC9C5A897211E01E98E36E38459F6A70C5DAF02B" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/runtime-27/stderr.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/runtime-27/stdout.log", + "mode": "100644", + "gitBlob": "6a718e97da0812a68704c6260471dd998c1bc46a", + "rawBytes": 2106, + "rawSHA256": "E5CD7B9CBF20996B6A7877FF3A1093AC99E4556BA1E6918B9439F6603C80691D" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/runtime-53/RESULT.json", + "mode": "100644", + "gitBlob": "510e58b1a6623e799cc12686db90e804998ebfa8", + "rawBytes": 87799, + "rawSHA256": "AA71E8D2E2C411BFFE031E2FB7B0AB86F0B87AB5429A414C795D0522F937EB00" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/lf-A01-UNCHANGED/executed.json", + "mode": "100644", + "gitBlob": "38e81e50f77df3c1504a1647e455fecb926f5579", + "rawBytes": 844, + "rawSHA256": "D754F489C164E09FA9D291AB5E25E69C8C7FCC2306406A49AB126E0671C1B30B" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/lf-A01-UNCHANGED/summary.json", + "mode": "100644", + "gitBlob": "f57a8b0d5f039aff5400bf3fca1d3ce3e614dc4d", + "rawBytes": 7926, + "rawSHA256": "B8227E7E58140FFE6619B43948524CB704E94658E0B251ACA67604941F647F74" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/lf-W28-stepBound/W28-stepBound-Consumers.stdout.log", + "mode": "100644", + "gitBlob": "49aea9adf781c314f08baf8c07845f5a90b179ae", + "rawBytes": 343, + "rawSHA256": "46EC0F12821201B4D9A0ECC3CB3BC2AF7B48F81E2CC6D1F32787DB14FD15763E" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/lf-W28-stepBound/executed.json", + "mode": "100644", + "gitBlob": "1c94fe568ce30979d9cf432fd880bb78c7e481f3", + "rawBytes": 844, + "rawSHA256": "D1BFEBE109E78526821C069E1CA79771C29C639209272B3B0645C5D5B8C33434" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/lf-W28-stepBound/summary.json", + "mode": "100644", + "gitBlob": "fee4f4d0fe84d300c02ca573af3002800a57cf90", + "rawBytes": 8838, + "rawSHA256": "35D8AE0A5891D0B3891D36DB05F393E477264328B69D3149EAA9B9BE711C7ED8" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/lf-library-selftest/library-control.json", + "mode": "100644", + "gitBlob": "e1c3f7292ae9ebb1fd0bcc28236dfbf965b31bd0", + "rawBytes": 843, + "rawSHA256": "D02EE2854553246B89EC25A67EE4CC7C472E0843A35DDB345ABA6B643E1A7D16" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/lf-library-selftest/summary.json", + "mode": "100644", + "gitBlob": "e7345e41850ae8b66250fe19f8667a4b74bd058b", + "rawBytes": 4429, + "rawSHA256": "0748D02D5EB35D25D9FC48191353E0B38F414E51119AB833D0A31AE3A39F72A4" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/lf-runtime-startup-only/summary.json", + "mode": "100644", + "gitBlob": "a4ff8a08772e26e66e40c5477bee22cb4d8a27c7", + "rawBytes": 98299, + "rawSHA256": "742DED8E73F07AB695F900ACE06CBDC537FFCDCBC05CC203580F5E21D55BFD78" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/windows-library-selftest-powershell51/library-control.json", + "mode": "100644", + "gitBlob": "2920fb44daf3b14e3db794531cd649e957ecf077", + "rawBytes": 1060, + "rawSHA256": "F2CAA3AA69905B872F55AF47ABB3D4F32A40768C67EEFF150D2BFCD339B8EDB4" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/windows-library-selftest-powershell51/summary.json", + "mode": "100644", + "gitBlob": "e68fc70a9b64ca6de04f6922bdf249990079c16f", + "rawBytes": 8122, + "rawSHA256": "38D9BC35B047C93C08DBAFB992FF1FD1781E8A51246EE8BFA9F68A0B5AF2D03C" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/windows-library-selftest/library-control.json", + "mode": "100644", + "gitBlob": "52ad6b59ce0eea9f470b62db860e742fb0afb64d", + "rawBytes": 843, + "rawSHA256": "537D3D7BAD4CE6E358480E94373A8F542A5983CDBBAD2E5B2010085730150623" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/windows-library-selftest/summary.json", + "mode": "100644", + "gitBlob": "365bcef53b5272fa774026bdd967afb2e68e3531", + "rawBytes": 4458, + "rawSHA256": "25CBE297A780F14FBEE045613A7D80B6F44B47B8DF0D7C2B009ECD58D3A10AA7" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/freeze-integrity.json", + "mode": "100644", + "gitBlob": "d94d141d3a1d603af05a499e4cc1647ad233d126", + "rawBytes": 3588, + "rawSHA256": "D7563A985B954F139FE3DF81AA45FCE1336F749E031EBA95B6DEC4A758C857E1" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/prepare-checkouts.ps1", + "mode": "100644", + "gitBlob": "d4ab9dcc14d358cf851094dfa6079f02ff306bf3", + "rawBytes": 4570, + "rawSHA256": "04DF708AF450D374C2029C3D2356C649DD7AFC897207D27A25951AD6DAE46408" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/.gitattributes", + "mode": "100644", + "gitBlob": "dec65d7ad94b973c87a547099e442f3e124538a4", + "rawBytes": 11884, + "rawSHA256": "7BEA47E94099D26BBE5D16009717D9066D00C59EBA6FAB9814BBC42714B78CB2" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/DEVELOPMENT.md", + "mode": "100644", + "gitBlob": "1e8f4f310a5418b7e1dc77c4c17213abdd844ca6", + "rawBytes": 2976, + "rawSHA256": "42C8CA60B99C3A27040B1780DD2FFB66B50E558E284B1C9BE98A6CE3FBD79155" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/README.md", + "mode": "100644", + "gitBlob": "fa7e57a8aee4437efe5d0fef4653cf108ec6c894", + "rawBytes": 2930, + "rawSHA256": "B0973CBCF11011F52126F0E122EDF86245E8CA9AACCDE57FE38719DCDC6507D4" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/check.ps1", + "mode": "100644", + "gitBlob": "e606c4c606978351480e52fec04c96d9eb41f9d7", + "rawBytes": 2398, + "rawSHA256": "288B8DEF19720BD53F448EC80598CD658CDCD3C287178D0677C8515F5D5FB496" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/check.py", + "mode": "100644", + "gitBlob": "b9371490047ccd2b4d16329be4d6a499cb449410", + "rawBytes": 26009, + "rawSHA256": "AB47AF51D7074C00B1A3A8C73CA5321EC5447B284C0EDEBA04CE2A5D8954A38A" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/registry.json", + "mode": "100644", + "gitBlob": "18c902e9a1ba9b6bfcc8b2639e96eccf489e3179", + "rawBytes": 1401, + "rawSHA256": "ADD660412125551A7F73CDC1693E953EFF5CC6CCC9582DBF09F8B21EF2E032A1" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-001.json", + "mode": "100644", + "gitBlob": "fabe38e01835dd2746f7217a5e18d6c508957de2", + "rawBytes": 1196, + "rawSHA256": "437736C6CEB992E04BCA72116535469B0E48690E6314837A390C3FDC50548E15" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-001.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-001.stdout.bin", + "mode": "100644", + "gitBlob": "10ad37bc51367b2668d4db62d9742137bf808bf6", + "rawBytes": 41, + "rawSHA256": "45AC888455EA4AEF7C2599CE38E52991800E604D3735FD45881D8D5076E41D2F" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-002.json", + "mode": "100644", + "gitBlob": "c807cc1224d160d56ce8b1e515d2d74208488eee", + "rawBytes": 1241, + "rawSHA256": "5394F7E4F5A1D46C27C17EE614DF88A1D11BF26D0F146659ADF9A1648809F8AF" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-002.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-002.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-003.json", + "mode": "100644", + "gitBlob": "f2d796683347e486320eaab9ea53a7c2f9638fac", + "rawBytes": 1240, + "rawSHA256": "3FEB84472415A73120917549B997E703DAE9358C837EE20EAE65B11B9E699BCC" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-003.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-003.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-004.json", + "mode": "100644", + "gitBlob": "b1ea73ae64931a4001ef243bb1f6dd0ff33f88df", + "rawBytes": 1502, + "rawSHA256": "327F07167F5ED5375E55C625AE25D58A33543312C0FC380304744205D44B7C32" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-004.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-004.stdout.bin", + "mode": "100644", + "gitBlob": "539328d7c4bf06ca53176deec58e39608dc48900", + "rawBytes": 68359, + "rawSHA256": "954F4354774E6571FC392A678B8CFF302A7C2F361166558BC2D5607CB400AB20" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-005.json", + "mode": "100644", + "gitBlob": "3bf9e57d67ed151b68e9dbd65fc7354acc511c98", + "rawBytes": 1236, + "rawSHA256": "234FADD2A6E97D307CF31323140CA103248AC65E393E4F0554338781DCEF1CE7" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-005.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-005.stdout.bin", + "mode": "100644", + "gitBlob": "96d856ad8ad44f4bd84f862ee5275fb3b57015a9", + "rawBytes": 24783, + "rawSHA256": "BDD50082D978815E9005EDE9C34A9757F83693806307EE766E4CCD3C8472AAEA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-006.json", + "mode": "100644", + "gitBlob": "f70587215e9239dd3e26517d07fb826e148cca9c", + "rawBytes": 1235, + "rawSHA256": "498B9A03892A1F36CC75E6DBEBEF460ED4C82C3C0FE7AFF8BFF459232CEDC431" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-006.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-006.stdout.bin", + "mode": "100644", + "gitBlob": "bd5d0eb38fd4a301eb89b027fcc434fc18dbee75", + "rawBytes": 35633, + "rawSHA256": "486420760DD5C43312DD0A0E9432771B55ADDE1953088B70597269E057A06051" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-007.json", + "mode": "100644", + "gitBlob": "fadb74d3ec95e7f56ba709a17d5f7189fbf1e441", + "rawBytes": 1245, + "rawSHA256": "7154CA8079C8403448A7B6EFE8406776CB59ACBD490D5042BEE57D033CBBE32D" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-007.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-007.stdout.bin", + "mode": "100644", + "gitBlob": "3760470717560aafc5ae4652522eff1953d001e7", + "rawBytes": 11640, + "rawSHA256": "0D1529C98D35B6FF2AC53D58D107F0A47EC8F5D263F51819C085827C055A63BB" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-008.json", + "mode": "100644", + "gitBlob": "fb526d0f2bcd6e3b39bc2dd080db88a750f09662", + "rawBytes": 1230, + "rawSHA256": "BEDFCCF8BA300D172F4D8B7DD1C2AB896E9242EA3549F5103ED567CE917EE651" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-008.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-008.stdout.bin", + "mode": "100644", + "gitBlob": "7a78c403e548df7ba7e7782ab081f08c4f4ad32b", + "rawBytes": 24706, + "rawSHA256": "6A435EFF7E3CD2A2DFEA248B3A8ABEBABAF10FF643927C5C3FCAE52E666E7CB5" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-009.json", + "mode": "100644", + "gitBlob": "6e47bd62944b951aad7a64e5eb075c70de72a0fd", + "rawBytes": 1230, + "rawSHA256": "2CD0B483698E4F475CD4B4295F6F7FE9CA694C32C69B1175888E6E5276944FA7" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-009.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-009.stdout.bin", + "mode": "100644", + "gitBlob": "4c9314d23730f318c1a4f99ca13e2156912f277b", + "rawBytes": 9090, + "rawSHA256": "0D4F03AC19F890B67894B74042FF7559ADD574A8D160539AD3565A48289BA0AE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/process.json", + "mode": "100644", + "gitBlob": "4bc6ee76be1257761e8cd6e3e340a50f28495e09", + "rawBytes": 1474, + "rawSHA256": "5CCA6C004D2FED7261FF7C53F888F07EF5E6479A77DD923C1DFE0A9FD001B36A" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/result.json", + "mode": "100644", + "gitBlob": "a644cbb5a2187a9f85aacc9690a974a412028f14", + "rawBytes": 258011, + "rawSHA256": "73163B98D940CC59DD5458A781BFEB2A47B04C1C8CCE1F2BE52CB39498A63B63" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-001.json", + "mode": "100644", + "gitBlob": "fe6da93a5c5718a1e4ef835a25b7d1afab9942b4", + "rawBytes": 1196, + "rawSHA256": "F263D627648AC4DE38976DAFBEFDE1B2B7C70E558E2DBFE915EBBE2614221EBD" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-001.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-001.stdout.bin", + "mode": "100644", + "gitBlob": "10ad37bc51367b2668d4db62d9742137bf808bf6", + "rawBytes": 41, + "rawSHA256": "45AC888455EA4AEF7C2599CE38E52991800E604D3735FD45881D8D5076E41D2F" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-002.json", + "mode": "100644", + "gitBlob": "038eca6c7025dcfb0d22c285ba074d52650cd98b", + "rawBytes": 1241, + "rawSHA256": "0FE3639B92409F748170BE0C15D143788F5F73D64FEF55DF3A3D2BAB93415D17" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-002.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-002.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-003.json", + "mode": "100644", + "gitBlob": "7c7d2953e478fc99809a25f97e3a1271ae71e044", + "rawBytes": 1241, + "rawSHA256": "0A8647ECB60F767BC30B7218E1E8656DBCBE8AB142C354DEF5ED9D3F7A805344" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-003.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-003.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-004.json", + "mode": "100644", + "gitBlob": "d4f9554aff2cee1ec249a2c99f007cdbf80dfff1", + "rawBytes": 1503, + "rawSHA256": "26220B11D8E7BE113FB02D8663BD1AC99D1D019482F12BA93DBAD7A8D776B29A" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-004.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-004.stdout.bin", + "mode": "100644", + "gitBlob": "539328d7c4bf06ca53176deec58e39608dc48900", + "rawBytes": 68359, + "rawSHA256": "954F4354774E6571FC392A678B8CFF302A7C2F361166558BC2D5607CB400AB20" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/process.json", + "mode": "100644", + "gitBlob": "97b4e44cdbba7508e7427cb61963742559e62ec3", + "rawBytes": 1759, + "rawSHA256": "900ACFC74743C61FA34EC94FCFB43D5296B06F268E3F19BAEFFA573EE4730161" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/result.json", + "mode": "100644", + "gitBlob": "d486100c8324e453c59e7cf599712528fdd7c776", + "rawBytes": 216984, + "rawSHA256": "EF852B6C574A9A6E114FEA1538D65D8E8012B1BFFEEAA8380AB1485ACD19A4AB" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-001.json", + "mode": "100644", + "gitBlob": "03180e938a23801ed2138d15b6ebde74dcd40256", + "rawBytes": 1196, + "rawSHA256": "05058DD47572C0CCE48B88E92F202C42F0069C9B2693A899C5F5EA588D819871" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-001.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-001.stdout.bin", + "mode": "100644", + "gitBlob": "10ad37bc51367b2668d4db62d9742137bf808bf6", + "rawBytes": 41, + "rawSHA256": "45AC888455EA4AEF7C2599CE38E52991800E604D3735FD45881D8D5076E41D2F" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-002.json", + "mode": "100644", + "gitBlob": "de538c568117a8ef73170f5c799013b8c545fb53", + "rawBytes": 1241, + "rawSHA256": "96AAC2C0187F3B72D3944D3303ED80128DDF67DDB0673363C020358458670D68" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-002.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-002.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-003.json", + "mode": "100644", + "gitBlob": "3092fde7ae5f7a62d9bd9b133f275c4fd356daf7", + "rawBytes": 1241, + "rawSHA256": "970BDB76CEB298D35F4D9012915AADD51C907F61DD9E0DC65C172586FE63FEA2" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-003.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-003.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-004.json", + "mode": "100644", + "gitBlob": "ce90f25e2d703979538ffb46fe1a095b21c168cd", + "rawBytes": 1502, + "rawSHA256": "5ABDA3E84133B9E13079679830B65A679DB6B2F58369CBA0B15B13605891CFF9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-004.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-004.stdout.bin", + "mode": "100644", + "gitBlob": "539328d7c4bf06ca53176deec58e39608dc48900", + "rawBytes": 68359, + "rawSHA256": "954F4354774E6571FC392A678B8CFF302A7C2F361166558BC2D5607CB400AB20" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-005.json", + "mode": "100644", + "gitBlob": "a5d30a5cb73eab77bed5d6e94e0daabc1edeb5b5", + "rawBytes": 1459, + "rawSHA256": "7EE6BEFEB85403AFF151A9F5AF706BBC9044956F1F04AD4CC63647296E6C74BD" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-005.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-005.stdout.bin", + "mode": "100644", + "gitBlob": "b135a0846eb41af84fb599df0524fc61eec6c962", + "rawBytes": 66829, + "rawSHA256": "B0D9DF27CF51042A17F4BE283545C7C19B330E25FD0FA7E2971977B483FA2F5A" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-006.json", + "mode": "100644", + "gitBlob": "03c9a522e44b3141a7bd78a66937c0e66a4ab567", + "rawBytes": 1236, + "rawSHA256": "1EE487F543901AA6E4AE0CFBFEB43908122A72B319ED61FA4BB108B233FFAA5B" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-006.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-006.stdout.bin", + "mode": "100644", + "gitBlob": "96d856ad8ad44f4bd84f862ee5275fb3b57015a9", + "rawBytes": 24783, + "rawSHA256": "BDD50082D978815E9005EDE9C34A9757F83693806307EE766E4CCD3C8472AAEA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-007.json", + "mode": "100644", + "gitBlob": "7a9ff74fd8e360585aa4119854a8ea4e9909db38", + "rawBytes": 1236, + "rawSHA256": "9FB44D74744E314E6496DA84C486D0417BA24CBD80A44CA1A2E9AD7A1933E292" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-007.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-007.stdout.bin", + "mode": "100644", + "gitBlob": "bd5d0eb38fd4a301eb89b027fcc434fc18dbee75", + "rawBytes": 35633, + "rawSHA256": "486420760DD5C43312DD0A0E9432771B55ADDE1953088B70597269E057A06051" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-008.json", + "mode": "100644", + "gitBlob": "ee3251eb690b7c907e1483d2b1c7d593d48b581a", + "rawBytes": 1246, + "rawSHA256": "F23E6A2FB34D07712EC35EA0D658ABE0F8EAD7A923A288ECB750C8A11E368980" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-008.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-008.stdout.bin", + "mode": "100644", + "gitBlob": "3760470717560aafc5ae4652522eff1953d001e7", + "rawBytes": 11640, + "rawSHA256": "0D1529C98D35B6FF2AC53D58D107F0A47EC8F5D263F51819C085827C055A63BB" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-009.json", + "mode": "100644", + "gitBlob": "94278895900c80dcb0fcc1d44aaf553e5b1cb5c2", + "rawBytes": 1230, + "rawSHA256": "4D1B21EE33DF720F5D039457F6E07A09375827017083E619C056A671C582CCBE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-009.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-009.stdout.bin", + "mode": "100644", + "gitBlob": "7a78c403e548df7ba7e7782ab081f08c4f4ad32b", + "rawBytes": 24706, + "rawSHA256": "6A435EFF7E3CD2A2DFEA248B3A8ABEBABAF10FF643927C5C3FCAE52E666E7CB5" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-010.json", + "mode": "100644", + "gitBlob": "a3110083a3bad98be3c5fc0faea6c6ec5519399f", + "rawBytes": 1228, + "rawSHA256": "70D528593521988187564ED7E1197E3C4929C48D5FF326DFB0D968707DC4BD6D" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-010.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-010.stdout.bin", + "mode": "100644", + "gitBlob": "4c9314d23730f318c1a4f99ca13e2156912f277b", + "rawBytes": 9090, + "rawSHA256": "0D4F03AC19F890B67894B74042FF7559ADD574A8D160539AD3565A48289BA0AE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-011.json", + "mode": "100644", + "gitBlob": "baa3a06251817a16f0137c0a62b82a9179058226", + "rawBytes": 1460, + "rawSHA256": "4A244FA7231A10DBD75CC11A36B75797FD96F24CF93F68800A3CDDB1BD1D2F53" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-011.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-011.stdout.bin", + "mode": "100644", + "gitBlob": "b135a0846eb41af84fb599df0524fc61eec6c962", + "rawBytes": 66829, + "rawSHA256": "B0D9DF27CF51042A17F4BE283545C7C19B330E25FD0FA7E2971977B483FA2F5A" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/process.json", + "mode": "100644", + "gitBlob": "b15e6eb932d96f9c315d8466c1c5ba24388a2f2e", + "rawBytes": 1473, + "rawSHA256": "DE01D42569F10ADA97405D0BE370CB81B14CD899CEC1D58436E4767DAF57A213" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/result.json", + "mode": "100644", + "gitBlob": "259f4b7541eed219aa31fa65385db3c7b6c2d8ca", + "rawBytes": 261488, + "rawSHA256": "CFD79D9E0CC7E4166BB9419B2CF3CD54CA3DD9767C6174BF97E084E2FD06B03E" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-001.json", + "mode": "100644", + "gitBlob": "2dbae161b1adc43134a9f69365e92425a7ec69a8", + "rawBytes": 1194, + "rawSHA256": "CA9C09ED96A4FA701B680A83E13B35681D0BFE89E400B5D38DFE508BF4CB327F" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-001.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-001.stdout.bin", + "mode": "100644", + "gitBlob": "10ad37bc51367b2668d4db62d9742137bf808bf6", + "rawBytes": 41, + "rawSHA256": "45AC888455EA4AEF7C2599CE38E52991800E604D3735FD45881D8D5076E41D2F" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-002.json", + "mode": "100644", + "gitBlob": "4bff5ebff4751d6d02e5f423332d6b94d322b338", + "rawBytes": 1241, + "rawSHA256": "B934433543CDDA36C676C3724D5053ABBA2A91324F6AFF8B8F81E301C1C7143B" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-002.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-002.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-003.json", + "mode": "100644", + "gitBlob": "726d7c940b7562dd016ee421fe58d6880649d64b", + "rawBytes": 1241, + "rawSHA256": "5DA6AB1CBA939653D41B45392A502E0A58798DCF169C98638428BFD17C264224" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-003.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-003.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-004.json", + "mode": "100644", + "gitBlob": "f63cc03e78ca6352cd9c9e11ce0b79f7836fe9b7", + "rawBytes": 1503, + "rawSHA256": "BF85F4BC78EC77F406BB6F8481E9187CAE76F6D03405B43D6E4606257DEE85C7" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-004.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-004.stdout.bin", + "mode": "100644", + "gitBlob": "539328d7c4bf06ca53176deec58e39608dc48900", + "rawBytes": 68359, + "rawSHA256": "954F4354774E6571FC392A678B8CFF302A7C2F361166558BC2D5607CB400AB20" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-005.json", + "mode": "100644", + "gitBlob": "71096ff3aafab13e8e59359ae89e8e299a35e531", + "rawBytes": 1460, + "rawSHA256": "8017AEF38B8447CB3BDA4A3C7D8CDB2D9B409FDD1338F7F0E6095B8442AC25AA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-005.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-005.stdout.bin", + "mode": "100644", + "gitBlob": "b135a0846eb41af84fb599df0524fc61eec6c962", + "rawBytes": 66829, + "rawSHA256": "B0D9DF27CF51042A17F4BE283545C7C19B330E25FD0FA7E2971977B483FA2F5A" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-006.json", + "mode": "100644", + "gitBlob": "9bd3e44ce9f5b6f829da80880603937f6feae84b", + "rawBytes": 1235, + "rawSHA256": "B8311242D14F1B40701E9DFB7907DD913ADE2D6FBFA1CC912AEB536B7738FD55" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-006.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-006.stdout.bin", + "mode": "100644", + "gitBlob": "96d856ad8ad44f4bd84f862ee5275fb3b57015a9", + "rawBytes": 24783, + "rawSHA256": "BDD50082D978815E9005EDE9C34A9757F83693806307EE766E4CCD3C8472AAEA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-007.json", + "mode": "100644", + "gitBlob": "a77c7d0260111ca3e5c3be855440cf43759f396b", + "rawBytes": 1236, + "rawSHA256": "D4414939ECFE2562919FB2546D46BEE2B0A17DBC6CD24D87EE7D48394E652D7B" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-007.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-007.stdout.bin", + "mode": "100644", + "gitBlob": "bd5d0eb38fd4a301eb89b027fcc434fc18dbee75", + "rawBytes": 35633, + "rawSHA256": "486420760DD5C43312DD0A0E9432771B55ADDE1953088B70597269E057A06051" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-008.json", + "mode": "100644", + "gitBlob": "2cc5fbd86b243ac84e2770f9798ff8103423d07f", + "rawBytes": 1246, + "rawSHA256": "945A0A9E4AA65C9C33C2234BC7CD2BA00F041BE5617E97CA60F1007087C21F7E" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-008.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-008.stdout.bin", + "mode": "100644", + "gitBlob": "3760470717560aafc5ae4652522eff1953d001e7", + "rawBytes": 11640, + "rawSHA256": "0D1529C98D35B6FF2AC53D58D107F0A47EC8F5D263F51819C085827C055A63BB" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-009.json", + "mode": "100644", + "gitBlob": "2337c5f4c2fdd0aaf1f07ac9a7d1d0edbc71f7a8", + "rawBytes": 1230, + "rawSHA256": "75512231B3F6432B8E3C1CE58196C068623E16AC7A9B764BF7244DC516CDE1E2" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-009.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-009.stdout.bin", + "mode": "100644", + "gitBlob": "7a78c403e548df7ba7e7782ab081f08c4f4ad32b", + "rawBytes": 24706, + "rawSHA256": "6A435EFF7E3CD2A2DFEA248B3A8ABEBABAF10FF643927C5C3FCAE52E666E7CB5" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-010.json", + "mode": "100644", + "gitBlob": "b89bdd93866d587bd882f11ef801d2640c64c925", + "rawBytes": 1231, + "rawSHA256": "4B894F7C03530853795F9FD6BE5156497B4390D2C36930D6857B7320D6F2EFC8" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-010.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-010.stdout.bin", + "mode": "100644", + "gitBlob": "4c9314d23730f318c1a4f99ca13e2156912f277b", + "rawBytes": 9090, + "rawSHA256": "0D4F03AC19F890B67894B74042FF7559ADD574A8D160539AD3565A48289BA0AE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-011.json", + "mode": "100644", + "gitBlob": "ab56e5d5aadb535acd1c26a1a079311c6543da3b", + "rawBytes": 1460, + "rawSHA256": "4C49720764FADFFEBB8D167F05A536429F2F6ECA2248CEEB3E7920EE6533DEDD" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-011.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-011.stdout.bin", + "mode": "100644", + "gitBlob": "b135a0846eb41af84fb599df0524fc61eec6c962", + "rawBytes": 66829, + "rawSHA256": "B0D9DF27CF51042A17F4BE283545C7C19B330E25FD0FA7E2971977B483FA2F5A" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/process.json", + "mode": "100644", + "gitBlob": "96230bc9722a4766c750e6e527272e76228effb0", + "rawBytes": 1473, + "rawSHA256": "8E4995C80EB575CA904A128BFD965AE9DE85114A4EA7F6F845A4BB04D5CD0E31" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/result.json", + "mode": "100644", + "gitBlob": "9fbf8d15b4edef2c7e0d8b750a7ca962b9e71876", + "rawBytes": 261490, + "rawSHA256": "8872D99690A49F2C3BD059DC71023A42977028E2343D564A3F5AF51CC9939485" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/profile/.gitattributes", + "mode": "100644", + "gitBlob": "9c1a2ed32bb8ec1191c5dc332ea9700fa0af5943", + "rawBytes": 561, + "rawSHA256": "6042504A00DCAA30BFEC535D61686CFE22B98065CDE695B80ECA0FC572A3CD75" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/profile/BUILD_DRIVER.ps1", + "mode": "100644", + "gitBlob": "29f3b5d558cbf037791c4a0d47bc86ac8645e215", + "rawBytes": 17548, + "rawSHA256": "A14F1205C57AC4D475C38E3D73179FC1645EAF1D5BC4962DAD9F3C42655588A9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/profile/BUILD_RECEIPT.json", + "mode": "100644", + "gitBlob": "4e79ef322c0bbd75814d28600f84f3e73a4153dd", + "rawBytes": 734327, + "rawSHA256": "EED1ECEE4A031A9C3CFCADEA445307D8E15E70E732E6FFDD5B166D135292B64E" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/profile/README.md", + "mode": "100644", + "gitBlob": "516ccfbe9dd7384e28faa97019392fc5a8ce8db4", + "rawBytes": 9888, + "rawSHA256": "30A5DEB7F03013A51B495A5D30DAC2596FC5D1FD2E94AF928506134837B3D926" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/profile/SOURCE_IDENTITY_CHECK.json", + "mode": "100644", + "gitBlob": "fd9303a2eb8162392c362688dc433f120c8164b4", + "rawBytes": 314, + "rawSHA256": "E9D16D471E46497586658D52BA6B346A5BC92AEDD306CB032DAB8B5020C7EF18" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/profile/SOURCE_PROFILE.json", + "mode": "100644", + "gitBlob": "534850c886539b9334c5d9f18fc27c257c333660", + "rawBytes": 1039454, + "rawSHA256": "B83ADA3BAA438D812DA076B48422C0A92F88CE686CD48EF982F39DE7701699C9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/profile/TOOLCHAIN_VERSION.json", + "mode": "100644", + "gitBlob": "50bb8de202db60474638d4b75ff9c78ede1eaa59", + "rawBytes": 886, + "rawSHA256": "5ECAF07FB8A1B0F081A4321DD4CBA3133E63728FDB86AA217A664118C91577A7" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/profile/TOOLCHAIN_VERSION_CHECK.json", + "mode": "100644", + "gitBlob": "ef0fd251048ef2d504afc98272f22416ab708feb", + "rawBytes": 707, + "rawSHA256": "BC0D11B70E3FA7593FFFF29195C5A17037CDFE63DF153C64733B979C79FF805C" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/provenance-reproduction/checkout.json", + "mode": "100644", + "gitBlob": "2cc14c6b87f66620819b087deb05ed357b4e9a99", + "rawBytes": 491, + "rawSHA256": "AC677628EECE057C583F55D417F317AB391FC8B6500CD19DACAF788C5B7C4FE9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/provenance-reproduction/fetch.json", + "mode": "100644", + "gitBlob": "81c39e82ccaefd9632ad91de3357a8fd73e193bc", + "rawBytes": 572, + "rawSHA256": "F2AA7C343D3AD3E3E45D7B00E06D886427CAAF07BD809F21601F637CCCE22334" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/provenance-reproduction/init.json", + "mode": "100644", + "gitBlob": "0fce03eb91321b2c00dd181da264f832dd8bee9d", + "rawBytes": 491, + "rawSHA256": "DEE455B1F90954840C3BE3EC2131B37B18005E90D22E2E6330473D92C4947FDE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/provenance-reproduction/lf-profile.json", + "mode": "100644", + "gitBlob": "9c2391ce6bc7cccb4ebebc0b97872f2aa29f28a6", + "rawBytes": 285, + "rawSHA256": "E410DC3BD06794B8180FE9E5632181BD983DB090D8EEBB4F2B40014EC42F7C7D" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/provenance-reproduction/raw-library.json", + "mode": "100644", + "gitBlob": "be321df155fa52e964f12c0712b5febace21d644", + "rawBytes": 1430, + "rawSHA256": "569FC9CF918FA6A60DE36833BC2176D8A71821FE42C1DA12716425BB76F0794F" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/provenance-reproduction/restored-status.json", + "mode": "100644", + "gitBlob": "213b3bcc02ef6fdbf876fe45bdf35ee6102245d5", + "rawBytes": 290, + "rawSHA256": "489F9B6F20997E320B1051E3F4578B3890BC2BFFED155E9880CFD448FDE6C182" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/provenance-reproduction/source-artifact-pins.json", + "mode": "100644", + "gitBlob": "f38ef492a422ae143705175071a868f1422fcc86", + "rawBytes": 118279, + "rawSHA256": "3A3110C60B0906257A170EE6BC550A6A3E0F4CD5BD38D414F64ECDB7DFF9EF30" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/provenance-reproduction/summary.json", + "mode": "100644", + "gitBlob": "9b2b8590f7b32086138f8a40a104007b571e5ee8", + "rawBytes": 482, + "rawSHA256": "3D03746CFB268606C17E1B825F1F3C2404037F9D7D749C82870EB8A0EC5E41FA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/run-command.ps1", + "mode": "100644", + "gitBlob": "f5bfabd18940cc46407f603ea039be670cb0dfd2", + "rawBytes": 6015, + "rawSHA256": "4E9CEFA6709720F672D0C0337297B83FC33E1FFCD9963A62CE72202322AEE0A4" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/.gitattributes", + "mode": "100644", + "gitBlob": "3ca7a684bfd3f7e00ec198867b1dc20668667b44", + "rawBytes": 1093, + "rawSHA256": "CB6F85C6781E7980C8F5C74AAA713F1ED5B5E69A58AA49C75AC2ACE88B7CB623" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/README.md", + "mode": "100644", + "gitBlob": "1e462cdfd300b5acff35bed3fbbda9f71e1763e9", + "rawBytes": 6183, + "rawSHA256": "630C124E87DDA7FB7A7AEA54CABF4C7C20EE50261553618EFF4F9297242CE564" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/REGISTRY.json", + "mode": "100644", + "gitBlob": "4621407c3ba15dc31ca86da6768c8d421b3f7442", + "rawBytes": 12444, + "rawSHA256": "35DEE68D8EFBB972FB35276BC03B1EC18071048D83E0BFAC0334DAA9364ADE4D" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/RESULTS.md", + "mode": "100644", + "gitBlob": "bdb7379bd2cbde3fb342aa3e796e5dfba2ccd8d0", + "rawBytes": 7535, + "rawSHA256": "A32D6A4EAC4ECE606A873B48A7D5D5072526104391089326411430FEBD03BD19" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/evidence/development-full-1.json", + "mode": "100644", + "gitBlob": "d49f4a0c97394c9f9dc17f6bbbb8140f75702bf9", + "rawBytes": 60410, + "rawSHA256": "42758D526392FD5EA923807FF9CC4561A07F82A860E25A491A4ED963DD3B2AF9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/evidence/development-overflow-failure.json", + "mode": "100644", + "gitBlob": "be46acc610c59fa2c89d08f58de833e0f62d7759", + "rawBytes": 1777, + "rawSHA256": "DCF039BC5EAEFA0FB00BD453D41FC83B415E8841A3F32D9F1BA2A03917EB1292" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/evidence/final-runtime-repair.json", + "mode": "100644", + "gitBlob": "040568c918d866c9da0fd07b2d270a766d4a4fa3", + "rawBytes": 88913, + "rawSHA256": "D53853E373DFD04500BC4F1842C3AEFEB92ADADBAF74FA4161D648A4406594AD" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/evidence/final-runtime-wrapper.json", + "mode": "100644", + "gitBlob": "27a3669982b2f201d0657d96e12d642a039e4c40", + "rawBytes": 7981, + "rawSHA256": "EBE14AE1CA6979D897B90CB1EC3C47ED51F2F89F2A4F0011696B5626BCA77F8C" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/evidence/frozen-raw-reproduction.json", + "mode": "100644", + "gitBlob": "bca6df58c4364d6558eec1433245d2e9e267a872", + "rawBytes": 3291, + "rawSHA256": "B132C2A76400AA98C723C9962D9CCD020F43C1C1A3FF9D5B1E5437B85EA1DAFF" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/frozen-reproduction/RESULT.json", + "mode": "100644", + "gitBlob": "f8d5d8528b873b5502c57051ac6a143ead8bea70", + "rawBytes": 2685, + "rawSHA256": "739CED2CBE0A8EED869B7EF941E55CD42D315A7BB416D03789FA5C201D9F9458" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/frozen-reproduction/mixed-streams.ps1", + "mode": "100644", + "gitBlob": "fed74d73245fce35619ba4780f76eb81ef8a2572", + "rawBytes": 180, + "rawSHA256": "4EC6115EB4F44000A09C073E697FBE3A106FD125C1E94CF2EBEDE24152063574" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/frozen-reproduction/sole-expected.ps1", + "mode": "100644", + "gitBlob": "90977fdd0d84c21b00ed4cd7bf8c7738bb44e5e6", + "rawBytes": 97, + "rawSHA256": "4A4FD004E3979A1F2D05E0B0C3C33BCA0AF2E9C00DCAA24020E59A805476FAFA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/frozen-reproduction/unrelated-only.ps1", + "mode": "100644", + "gitBlob": "118f8c5a1bb19e2eb3c4acf13b57d5a95b6a2ab4", + "rawBytes": 91, + "rawSHA256": "957CF83AD76BFD0CE34D86090F3D8704B353A81023A7691CC8F93D01CC1ABB39" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/replay.ps1", + "mode": "100644", + "gitBlob": "14868ae0d9ea940db1af11edaddfaa3d92f59066", + "rawBytes": 19726, + "rawSHA256": "77511FC8F0013CD839599E80AC192CCBADB2733DC925286FA788956B191A1077" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/reproduce-frozen.ps1", + "mode": "100644", + "gitBlob": "31f765d6ba6be396196274617f1b091245112f07", + "rawBytes": 4677, + "rawSHA256": "85353A39ED6353E571076A66A41DE9471F285D3725B4F0C0D9B741BF46C3A857" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/review/PARENT_SCRIPT_BEFORE.ps1", + "mode": "100644", + "gitBlob": "6aa6f7536e0e23b505673f8c175f4ba5fe39261c", + "rawBytes": 16561, + "rawSHA256": "9F52C599FEE4B7BEE683BA9A87156A028959E37339AFA7AD8E430D04517C71FD" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/review/README.md", + "mode": "100644", + "gitBlob": "bf136b7080919af995047d57a1e7447c43170337", + "rawBytes": 4499, + "rawSHA256": "AA8A040BC344F542769C34A6C38EB7E76304113AD2D0D63573A586D5C42887B9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/review/RESULT.json", + "mode": "100644", + "gitBlob": "be6f67caad2f986a0866f223832baaf6c6e2cd0e", + "rawBytes": 2738, + "rawSHA256": "6B94BC821130EADDEA08C8818A0A0B485B6610AC6E9E799397DDB346BD555231" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/review/fixed-controls.json", + "mode": "100644", + "gitBlob": "36d3e2c6794517acdfe67b0d79eb07648335c6ff", + "rawBytes": 27889, + "rawSHA256": "3EB4611C50E28C0708986C2ABA87679CFEEC20BCAB4B1E00CB4921648BB41FFF" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/review/mixed-success-stdout.ps1", + "mode": "100644", + "gitBlob": "3414697777ef5b6a5ed141231a1d5f606bf22542", + "rawBytes": 239, + "rawSHA256": "0A30A82FDD1D7FCFF0D2A7E14F5D2C1CE1EA09FF25277FDC607F394DB779CE5B" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/review/mixed-unrelated-stdout.ps1", + "mode": "100644", + "gitBlob": "e67db033990296be5b418e10035c5fed50b4a5ce", + "rawBytes": 211, + "rawSHA256": "75FA54CFBA3824C3E2063A70C777BE87B097F47C8A243F8EFD587CF7D4288608" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/review/replay.ps1", + "mode": "100644", + "gitBlob": "7ffd775d5460c15f149853b845484a195f8d2c74", + "rawBytes": 2664, + "rawSHA256": "EA33E00E5C1D83C615DFBE98553D39997EA3492B0A3F8EEB2D320647732E7F79" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/review/run-fixed-controls.ps1", + "mode": "100644", + "gitBlob": "d1634201f68a62db6b8f03a204f52bd2da131ac3", + "rawBytes": 3313, + "rawSHA256": "288951C138DF0B5D44836BE09F42976586AC2102DC55D2C7C82B47C1BD6F82D7" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/review/sole-expected.ps1", + "mode": "100644", + "gitBlob": "d0c293d1099a538e3a7487df3df3523b9f9793f9", + "rawBytes": 128, + "rawSHA256": "1D479AAE3FA4775CB3CEB928FEDCD4F3A8AD5CF9B43D8A2807BEC7DB1CBB8265" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/run-bounded.ps1", + "mode": "100644", + "gitBlob": "89f07d3640a4c3259645430bff26e6172dc80b09", + "rawBytes": 2424, + "rawSHA256": "1CC0A634394749CB56000A03C15C805D3A209EF8AE9D4284E6A0295871B111CC" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/.gitattributes", + "mode": "100644", + "gitBlob": "40ffcb2e7b5576390e868bc926fd7b2d90f8fe06", + "rawBytes": 718, + "rawSHA256": "CB9ED8254A683519B59A24842AA1F928677CB4BC790A0B21CB0961011D6324FA" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "a291d46d5ad592ec1b215dc31d59d38883a05a10", + "rawBytes": 33574, + "rawSHA256": "A1C1912126AB17D2B11B6A900F445CCB5832F815529756D5BCA89B4CE1397DCF" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/RECEIPT_ARCHIVES.json", + "mode": "100644", + "gitBlob": "341989ae42a368d142ffe83c70e4b8f7112ff7f4", + "rawBytes": 9954, + "rawSHA256": "BB808AB761F6136215B361AB93E7405843040ADB8D6BCBBAE963CDC6B0F15492" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/REPORT.md", + "mode": "100644", + "gitBlob": "0e5bdc9b6fae2ac7c3d5f0e610ca616b0e9c27a7", + "rawBytes": 46596, + "rawSHA256": "6934D5AE549A055954D4D7038FC34228810742B5A54B0C39B4847888E8431032" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/preservation/check_relocated.ps1", + "mode": "100644", + "gitBlob": "85be19e39057c10b88146e0d234422064534a1a0", + "rawBytes": 7097, + "rawSHA256": "8F3E53880AF81CF6AF3B3F325043F924632923ECD969B8EDD309C53B419D891F" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/preservation/check_relocated.py", + "mode": "100644", + "gitBlob": "258d37c02a4105c29fade62d9f45f18be182d562", + "rawBytes": 29354, + "rawSHA256": "DA0DC413F1AF56727F5E009A79DF115D4933272854DC17967F15879020D2060C" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/preservation/relocation_controls.json", + "mode": "100644", + "gitBlob": "ab9776919c6579a556a08fcd4d93a4482520f4f3", + "rawBytes": 978, + "rawSHA256": "D0DE6D0B68CC7334054210432AB0B40A6E3995DDA5400A8D2423E4DA64C2DB6E" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/receipt_archive_control_helper.py", + "mode": "100644", + "gitBlob": "5b81f42c7f92ac99f2454f44991b35a7a31634d3", + "rawBytes": 6180, + "rawSHA256": "EFC3775D6B8C55E85F7AC4CE52865B6AAB5B50A79FFCF52A66CCC39D2A301CEE" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/receipt_archive_controls.json", + "mode": "100644", + "gitBlob": "058f480d94432b649731b6e0c147b45d86922698", + "rawBytes": 3790, + "rawSHA256": "69FF8EB23D710A0134C408D2029A177CA6D73E64E1EA9F63895EF3566BDFA447" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/receipts/checks-3b82967.json", + "mode": "100644", + "gitBlob": "4527767b88522e949fe54bccec74076f3fd25b95", + "rawBytes": 24593, + "rawSHA256": "17376CCF3323C3BA18811E4A409C0A694EF16CC8C2F727523931152A7429C77E" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/receipts/controls-3b82967.json", + "mode": "100644", + "gitBlob": "9599082670bc8b3e82854aec89d4fbf2c31db71b", + "rawBytes": 30154, + "rawSHA256": "4B75CBA83529F84DE99C01CEE166AE9D76D9C0476D5BB9B34D94FD7872D3823A" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/receipts/preservation-3b82967.json", + "mode": "100644", + "gitBlob": "8576e46804b57889fa160252fcd70ff3050f8796", + "rawBytes": 51499, + "rawSHA256": "85986D1BAF47272D971E2658C0F7A5ED84664F5AAAF4DB16D3C04C72DC85532D" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/receipts/scan-base-4cc9501.json", + "mode": "100644", + "gitBlob": "682f8b3eb7eb5ab66f03c3b6e63511f033eb725a", + "rawBytes": 20267, + "rawSHA256": "C288B9DF8342F77D141637B48E0CF93E88AAD716D4F535BBBA9BB929AC2AADDF" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/receipts/scan-repaired-3b82967.json", + "mode": "100644", + "gitBlob": "3f82b3a5ec424418a2bc55c880dbf6fd1b5512f1", + "rawBytes": 6099, + "rawSHA256": "E09229DAF12E45186BDA4659D3AB18E838A1086CB1694F05833E53ADA190B782" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/run_receipt_archive_controls.ps1", + "mode": "100644", + "gitBlob": "d2328ae593630279aeb142a9c5dcaaa2baf81818", + "rawBytes": 17574, + "rawSHA256": "1C247F13FEC0EA2C1CEAACC3B57E76039F1EFD747000FA520CED2E0DBDF067AF" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/verify_receipt_archives.py", + "mode": "100644", + "gitBlob": "5507db6f73d57b7eafd1a8468762e3077ea329b3", + "rawBytes": 27132, + "rawSHA256": "01C91E8FCDD25B57430369420A1C359132D06D6F484522B4E3CBA70DBD63E367" + }, + { + "path": "docs/internal/extensions/opt1/replay-source-manifest.json", + "mode": "100644", + "gitBlob": "241c66d5fe7fec1b8391c0c52653b24616d8d744", + "rawBytes": 4649, + "rawSHA256": "ABF64C86D32412386978AA788CA92D9D1B0FE36418C626E4F05BACAC0542B22C" + }, + { + "path": "docs/internal/extensions/opt1/root-composition-plan.json", + "mode": "100644", + "gitBlob": "529a00fc1a24439189d1ba1d1faf4277715ed9ba", + "rawBytes": 239, + "rawSHA256": "1D5D04AEDF782FC9412FDFE7955816C11DEBD8595541469D3465EBE9A3EC9F3D" + }, + { + "path": "docs/internal/extensions/opt1/runtime-prerequisites-plan.json", + "mode": "100644", + "gitBlob": "5aab8ad094734756b0c3b4bd086c500a4ab665aa", + "rawBytes": 44, + "rawSHA256": "11230E0E01FAA36D958A9C5B85A373F24DFBE290A804BB395A73E766C1D0EC81" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/REGISTRY.md", + "mode": "100644", + "gitBlob": "7c38145bbed1a4e12c7c4758d6f1898129e9dec4", + "rawBytes": 4943, + "rawSHA256": "94FBB20F078EEAF8C199B85F74B34E9C0293AAD7DECF1AE7F5E9FCF36B940AF5" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/REPORT.md", + "mode": "100644", + "gitBlob": "a6fcc6987c8c61141236fc8a46399d4e45644c13", + "rawBytes": 19773, + "rawSHA256": "92ADB83CED48B409325BB472A0A3C61FE9506B3F6B8285DE65ACED408A2A7CD6" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/checked-source-hashes.json", + "mode": "100644", + "gitBlob": "95345551dd393c7a69ef8f05e264d81df2366e9d", + "rawBytes": 600, + "rawSHA256": "C14708FC3FA9D661CF0B597B722082225E0C8AE9FF0E72EB669B4957792A916F" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/continuation-source-hashes.json", + "mode": "100644", + "gitBlob": "91b4c0c3eaf36b3b58076ea62cd78f2ebf904924", + "rawBytes": 621, + "rawSHA256": "066A84597BF6348C7C0A9E52A4EDD98CA79B3B16B2CD0010A537E63A0035CDE0" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/deadline-covered.json", + "mode": "100644", + "gitBlob": "e54ef17c1ad3abb0e4b80c79a9f3b9c58960e0ef", + "rawBytes": 3927, + "rawSHA256": "AF19867B3CC67C3E7890501DF9C2494938231CE0FE77EA1B6BB04472025991FE" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/deadline-first-uncovered.json", + "mode": "100644", + "gitBlob": "a66c0ea8c7e6da6e762bfb4c773dfb12a155c7ae", + "rawBytes": 3788, + "rawSHA256": "9401B78D769A2639E621A1C42E1782D7512741635037B97D803B62292EEBB73D" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/deadline-host-coverage.json", + "mode": "100644", + "gitBlob": "1a459a445c0dbf300d17c6179e346249be15c0d2", + "rawBytes": 182, + "rawSHA256": "AE2927746B6835BD0E721E29F11676CA807DC52F65228987AB1A6214AC43A0F8" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/full-runtime.json", + "mode": "100644", + "gitBlob": "67dad1cc6085f41f481068284641cb7c0ef627a7", + "rawBytes": 510115, + "rawSHA256": "A7EB5831A88A7431607D5FE1D7189318D41978391E0A10BE3ED336C014563661" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/interrupted-before-full.json", + "mode": "100644", + "gitBlob": "af87864beaaa33e6d72adb19794db618ea63c55a", + "rawBytes": 1784, + "rawSHA256": "D76BD74773B5B40518C57B5B611CD13D2CB0581DA38E70BD588561A39B100C6E" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/powershell7-selector.json", + "mode": "100644", + "gitBlob": "6c74400005a50aaf606d8006f26da98712012d9b", + "rawBytes": 23413, + "rawSHA256": "B399B5193D9E0F6D828BA55FDD9ECA15322A116D1066F7557C3DFD25D272930A" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/startup-checked.json", + "mode": "100644", + "gitBlob": "2211f10a0ff7401ceab0b01b6d56de83977adb32", + "rawBytes": 173188, + "rawSHA256": "AE128EFA28AB54EFFA1B9381C3E04B9F17F11081716675169B5474959E759DDC" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/windows-powershell-selector.json", + "mode": "100644", + "gitBlob": "63910c48bf30f005f34ecbd38ea1fb54a6c706dd", + "rawBytes": 44302, + "rawSHA256": "0946A0FE7E5B8B2DFCA5CA76F31863A43EE55694B6A771C90B3B4EF4B9A3DD15" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/kernel-attempt-1/RMQ.Validation.PackedOptimized.20260912T0911577149359Z.json", + "mode": "100644", + "gitBlob": "b9951a6dbf679edc3b9fe24354189bf4bc395005", + "rawBytes": 7143, + "rawSHA256": "C618620A957F8DE205A5A90B8F9C6727A6060982C491AC2F276B2F2118AE99FF" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/kernel-attempt-1/RMQ.Validation.PackedOptimized.json", + "mode": "100644", + "gitBlob": "b9951a6dbf679edc3b9fe24354189bf4bc395005", + "rawBytes": 7143, + "rawSHA256": "C618620A957F8DE205A5A90B8F9C6727A6060982C491AC2F276B2F2118AE99FF" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/kernel-attempt-2/RMQ.Validation.PackedOptimized.20260912T0913380735403Z.json", + "mode": "100644", + "gitBlob": "d0924b767ab8560b3d1a536b05323bfd70ffcd43", + "rawBytes": 1388, + "rawSHA256": "90C4C951DC62E99661F255AFF1CA71F359290F5E14384D045ED20B42FEC4CE2E" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/kernel-attempt-2/RMQ.Validation.PackedOptimized.json", + "mode": "100644", + "gitBlob": "d0924b767ab8560b3d1a536b05323bfd70ffcd43", + "rawBytes": 1388, + "rawSHA256": "90C4C951DC62E99661F255AFF1CA71F359290F5E14384D045ED20B42FEC4CE2E" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/validator-plan.json", + "mode": "100644", + "gitBlob": "406737c81b76ae41769f20c86e4dae990d8314bb", + "rawBytes": 36, + "rawSHA256": "2BABC5547271A4A23A78A8186CD80A68FD8E4B4962FD5346E5C27C2582134AB1" + }, + { + "path": "docs/internal/extensions/pre1/.gitattributes", + "mode": "100644", + "gitBlob": "9bd69dd96a4e84d257b6d97cc197fa0215573443", + "rawBytes": 129, + "rawSHA256": "CA36DC03D28B9591E3D97BD76E0EF1F8A3A3584A04CEDA79B27CDB55AB571607" + }, + { + "path": "docs/internal/extensions/pre1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "166a048000d4f5de9d19b7a3bd9f1a3f270efae1", + "rawBytes": 126306, + "rawSHA256": "7B0488CAF93553AD801B5F801D6E9E61871BF5D224E8CBF906D413844D3BA057" + }, + { + "path": "docs/internal/extensions/pre1/AMENDMENTS.md", + "mode": "100644", + "gitBlob": "f459e88d92950b240864495184ce9e1a6ebc83ab", + "rawBytes": 34078, + "rawSHA256": "5875B3C6B8F243321BB0A8F3FD9ABBF3E75F6387F1EEBFDB6936DC04B3882D7C" + }, + { + "path": "docs/internal/extensions/pre1/ATTACK_TABLE.md", + "mode": "100644", + "gitBlob": "7b840ab8964a67ef026cd8150cd68c8e330bce22", + "rawBytes": 8212, + "rawSHA256": "1B8BCCD323C6E80B4A6F15B18305C357435B8C83BFAAE5DA1ABDB2BE915DC3E7" + }, + { + "path": "docs/internal/extensions/pre1/BUILDER_PLAN.md", + "mode": "100644", + "gitBlob": "1bbde52be65889ef6b59cd3a4b0745521152ea89", + "rawBytes": 69280, + "rawSHA256": "5DDEA33280CA08DB590BA847F5210D0317425CDC8EF191836EB28F255D8C0ECA" + }, + { + "path": "docs/internal/extensions/pre1/BUILDER_REPLAY_DESIGN.md", + "mode": "100644", + "gitBlob": "0dc145c0768dc0ea19d63f6aea06997da096066b", + "rawBytes": 33478, + "rawSHA256": "2D335C81AF45E7FD207D07B22FDF2C50E0FE0933FA471DC6ED2977E6FBBC62C3" + }, + { + "path": "docs/internal/extensions/pre1/BUILDER_STAGE_LOG.md", + "mode": "100644", + "gitBlob": "4b140e76af38d4ad665a7670347bb4856940b315", + "rawBytes": 127416, + "rawSHA256": "FCAE86DCAD1FCBAFE0153251926D8B4608C4B30575E00999AED4BD2737ABB132" + }, + { + "path": "docs/internal/extensions/pre1/CONTRACT.md", + "mode": "100644", + "gitBlob": "58c2c69883a45a5f6ea81346ed1121e46a8d13a7", + "rawBytes": 50947, + "rawSHA256": "3DBE6E8C3DA5191C12D193113A8A2303CB2285D393EDCA95613D968E3FAF1F94" + }, + { + "path": "docs/internal/extensions/pre1/REPLAY_DESIGN.md", + "mode": "100644", + "gitBlob": "8af8542a322febda78710e424dc231f666da4463", + "rawBytes": 10951, + "rawSHA256": "6021056C4D80F73A8FAC162CBAF5C3FD307D4F9486274B5AF17394A463B86EB2" + }, + { + "path": "docs/internal/extensions/pre1/REPORT.md", + "mode": "100644", + "gitBlob": "a4f0104aabdd452b9459d3baeff64542c976930c", + "rawBytes": 150971, + "rawSHA256": "663F25A0637187A49EF1F2E9AA50713ECB5B9894AD50E8C0E7A9F47153397A49" + }, + { + "path": "docs/internal/extensions/pre1/SOURCE_FACTS.md", + "mode": "100644", + "gitBlob": "c4191dc06dd86b4571809bd0cbf30f34233707dc", + "rawBytes": 6006, + "rawSHA256": "49F6589F23D197D443780152A45498310A87D2B7E04A166F2D6F3E683F988473" + }, + { + "path": "docs/internal/extensions/pre1/builder_cases.json", + "mode": "100644", + "gitBlob": "45778d8177bd746d85a7ef93d75e4b22281573c4", + "rawBytes": 87144, + "rawSHA256": "911ED51BC30F2260508000D6C6E892C840D80AFBBA0233610559289861E1C931" + }, + { + "path": "docs/internal/extensions/pre1/builder_manifest.json", + "mode": "100644", + "gitBlob": "cdb685ca943f38b9a727559677290b8794e4b2fe", + "rawBytes": 3016, + "rawSHA256": "2D860BF6B6DD4CBDD6E1147B3A66C738926B17FB01C833C8E754118AB641FBEF" + }, + { + "path": "docs/internal/extensions/pre1/contract_cases.json", + "mode": "100644", + "gitBlob": "8c95728686e569aaec1f0cfeb7d94c66b3208f6a", + "rawBytes": 19219, + "rawSHA256": "85EAFFCD86E95C0F8468A76596C1153BB0A6B986F5B3A977B40926E1776E6C97" + }, + { + "path": "docs/internal/extensions/pre1/evidence/Input-check-r2.json", + "mode": "100644", + "gitBlob": "1ce8161e1180f97ceaadfcf6bfe5050024b9d0f4", + "rawBytes": 3580, + "rawSHA256": "385D256E603DC4523CE54760B940237FFA831613104B7EA92A4CA2722A657D5C" + }, + { + "path": "docs/internal/extensions/pre1/evidence/Primitive-check-r2.json", + "mode": "100644", + "gitBlob": "145f5347cae99d2b89426200d17a455835f9d916", + "rawBytes": 505, + "rawSHA256": "947223783505D60BEC7460D42AFF9870BFF6426C568879825CD39BBAAEB24994" + }, + { + "path": "docs/internal/extensions/pre1/evidence/Primitive-check.json", + "mode": "100644", + "gitBlob": "61268f60c97cbab020db7d3efdddd95246693c13", + "rawBytes": 5381, + "rawSHA256": "0EF34FD60E6C9789F985EB6D46662571CF3425334D21845903C5E7196DDC3ECA" + }, + { + "path": "docs/internal/extensions/pre1/evidence/REPLAY_INDEX.json", + "mode": "100644", + "gitBlob": "f3311e1f8a5dec9c948c51990eac93af253699f1", + "rawBytes": 6022, + "rawSHA256": "DF45ABB5B7DA9C40A5FBF644629635BA9C47E5DCDDAB82046038B81744D454F2" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.Shape-check-r5.json", + "mode": "100644", + "gitBlob": "fd07d65ee4232dff9e8f0427feabce86e6edc647", + "rawBytes": 1032, + "rawSHA256": "F07E6B06D4EAF8FB26B22F3C804B2C48356E6B286C6D906CEF61D1F8D69561C1" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Conservative-check-r7.json", + "mode": "100644", + "gitBlob": "921fecb764dc00d75be5ad329086c971d91aed00", + "rawBytes": 23787, + "rawSHA256": "3F59B240F66B9CFF9B5BBF1C2FF8D909DA621F3D42E5F248B9FEFD34C2D04275" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Conservative-check-r8.json", + "mode": "100644", + "gitBlob": "c4c410542a5019fd38a6272de21ac3db313c2dcb", + "rawBytes": 543, + "rawSHA256": "E600FC324D19772FEE89191D172B1722782E2102A1FD87BD870FE943A57A58DC" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Contract-check-r7.json", + "mode": "100644", + "gitBlob": "409bfd8ae07316e6c2ea09fea82c48046faec24c", + "rawBytes": 535, + "rawSHA256": "7981F8035FB3C9C17E28A72CC817328BF8DBEAEBBF72559D4A2AEE185C315EAA" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Contract-check-r8.json", + "mode": "100644", + "gitBlob": "3833a903877b8765fb3d925ba1f7e252eea7d038", + "rawBytes": 535, + "rawSHA256": "BD46CA11D154BF1972AA106223826D67ACA2F6432E0F0642057E451855476B41" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Controls-check-r5.json", + "mode": "100644", + "gitBlob": "e694c4b4abbb080b3584ff6153d8d7a335fb4d19", + "rawBytes": 7322, + "rawSHA256": "E994AF2080EE1B338ED8EFC77FE2BE471C72196CEF398602370C84661FD2DF1A" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Controls-check-r6.json", + "mode": "100644", + "gitBlob": "8a24e611f4c1aa94c4158e918b4c4a814954acd0", + "rawBytes": 5869, + "rawSHA256": "83A1F1C000119AFDEC2BC18BBE82D5368B887AD1395306BAECCEA1EBB4CE706B" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Controls-check-r7.json", + "mode": "100644", + "gitBlob": "310d9b0595c2a4b17e6099c0cd7b245d0ca94658", + "rawBytes": 535, + "rawSHA256": "344F3720E08B8FC7680FC3DABCA5F9126EDAEDD109D8C55023889265DCFA6451" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Controls-check-r8.json", + "mode": "100644", + "gitBlob": "05936c9748bccaa41e286eafbd90957570c54f4c", + "rawBytes": 535, + "rawSHA256": "957F992257F990286C0FFFBC8AAC708A130C8BE6AF937E726059B66CC9948A11" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Input-check-r3.json", + "mode": "100644", + "gitBlob": "c7960fda818a7aa9d6ea8bec2ac3ef73eff87168", + "rawBytes": 522, + "rawSHA256": "F7C7CC2F0253D6AA6284FC3008E595159FC91EFEF845D1823119FEDB40D24617" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Model-check-r3.json", + "mode": "100644", + "gitBlob": "eb2952ab38f7936824b0e8d2aa5686c76d8b0310", + "rawBytes": 3999, + "rawSHA256": "212EF834BD2C34F18493531AFB1EDB20A49C7A9967E0BF987B7F413DAFA935B2" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Model-check-r4.json", + "mode": "100644", + "gitBlob": "47e7faad6a5ee35186c45bc8e9e62c42a9eafa97", + "rawBytes": 2911, + "rawSHA256": "7E3AE7F940AB52D5DCE2399FC26CFF44E52896AEF15D39F8E1708DCA25F68BC1" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Model-check-r5.json", + "mode": "100644", + "gitBlob": "11c125cce63e05a4788cb6e25a99946f99586472", + "rawBytes": 523, + "rawSHA256": "5191770DF1A5C982F7961BDC0C2AB3F7B07E2F0B3CAA0D76098E21E7441B3955" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Model-check-r8.json", + "mode": "100644", + "gitBlob": "fd84d6013dd8eda8d3be159e8d96bf35bebdebb3", + "rawBytes": 522, + "rawSHA256": "8F84CCC5915B9B4FE36836006B68C1DC4E4A9D24E0CE9FEA09608ADCD5A808E0" + }, + { + "path": "docs/internal/extensions/pre1/evidence/aggregate-gate.zip", + "mode": "100644", + "gitBlob": "9e82dbabd5ac1a28d0dd4f862f11346a25165bf6", + "rawBytes": 2488373, + "rawSHA256": "E701983375FB3D632A01FFAD26DAE2BE3E38CB9BD990EE9791F05D924269192B" + }, + { + "path": "docs/internal/extensions/pre1/evidence/aggregate-summary.json", + "mode": "100644", + "gitBlob": "57a201ba96ee1dc8fca83487ebd6f12cad0f7446", + "rawBytes": 5123, + "rawSHA256": "6BB95BC989398EC71E403DF4F06E94A0FCA6A74126A1C25864CD62D80490491A" + }, + { + "path": "docs/internal/extensions/pre1/evidence/archive-integrity.json", + "mode": "100644", + "gitBlob": "2febfd154e47ad41a7999b36669222439554bdb8", + "rawBytes": 5873, + "rawSHA256": "C92CE6C0578C96CCAA9D47166D11FBC30D8F6C36049078B595073C7974E46037" + }, + { + "path": "docs/internal/extensions/pre1/evidence/audit-archive/2026-09-12_PRE1_contract_fresh_blind.md.gz", + "mode": "100644", + "gitBlob": "066ab81ff6387a8cf342e7799a729aee4d5ec1bb", + "rawBytes": 33919, + "rawSHA256": "E8F77103CE5AB4E15734AF6E09564D3FE8A6BDA8C2463C2776471E8A02D0FDBD" + }, + { + "path": "docs/internal/extensions/pre1/evidence/author-final-checks-summary.json.gz", + "mode": "100644", + "gitBlob": "8cf2fa3e8dbc7b784ec1a974a0a3162cfc535041", + "rawBytes": 1199, + "rawSHA256": "DB44F7AC0D2DBFE58CAB93CCF20B0BF1ABD14B71625C458AC72F66822FD45E39" + }, + { + "path": "docs/internal/extensions/pre1/evidence/author-final-checks.zip", + "mode": "100644", + "gitBlob": "ef7e51eb73cfbb60e14543b690c3b2ae42415fe4", + "rawBytes": 2332193, + "rawSHA256": "34D9F499033F67EB0373537B372AE63F6A5116FBE27B0A7547D40ACEBBF1424C" + }, + { + "path": "docs/internal/extensions/pre1/evidence/deadline-margin-check.zip", + "mode": "100644", + "gitBlob": "22caa734160e214ee78da049b330bb6a3ca5ba1a", + "rawBytes": 3398, + "rawSHA256": "58564BF8B345A85E942BF0F3F6744F697EEA934B354CF22E4ADA0E8040D50084" + }, + { + "path": "docs/internal/extensions/pre1/evidence/final-evidence-summary.json", + "mode": "100644", + "gitBlob": "346ad868efdf8c01a5350e3a1a53e35c493eed24", + "rawBytes": 11588, + "rawSHA256": "629D98184381F0D538A92DC7B8C28B6168D7BC79E01519464262F19A941D1BD8" + }, + { + "path": "docs/internal/extensions/pre1/evidence/focused-C01.zip", + "mode": "100644", + "gitBlob": "d3920cd184c1a5e320b614be5ddb115a6a323731", + "rawBytes": 51920, + "rawSHA256": "4A57AA1F63F36ACD9DAFCB4C843CA8D468AA9270939D8C3CD0ACEA6A7E04BD71" + }, + { + "path": "docs/internal/extensions/pre1/evidence/gate-failure-diagnostics.zip", + "mode": "100644", + "gitBlob": "b04dcf140b4edaccbe11f4e1a8abeb593660a46e", + "rawBytes": 5240, + "rawSHA256": "A709586842FA18AE57F3CD87999E677DBB1AA90DCAD7CB5B47CD2AA0B5C09D58" + }, + { + "path": "docs/internal/extensions/pre1/evidence/initial-build.json", + "mode": "100644", + "gitBlob": "9aa00707d027f76c92bf9edaa11cea811b3bdb24", + "rawBytes": 671, + "rawSHA256": "B26C8250CB2B0B2DC8A33DB12C15BE7BAFEA6A6B9B2537D889D0A4D447505E46" + }, + { + "path": "docs/internal/extensions/pre1/evidence/postgate-final-checks.zip", + "mode": "100644", + "gitBlob": "1a9b9e4f1a096359667053fe5123b8821ee6ff61", + "rawBytes": 1172050, + "rawSHA256": "890D595F45D2FF98D4D478DC03D3CB644735BE71AD3C08843CCC7B4EB8F0F486" + }, + { + "path": "docs/internal/extensions/pre1/evidence/primitive-build.json", + "mode": "100644", + "gitBlob": "7740441cda96a67900823dd81f1ef5cec4c6fb6e", + "rawBytes": 2560, + "rawSHA256": "7367026A8773FB9F89C7354D6DFAAC0BB33179BF2EB948D84129EB2AC54BBA8F" + }, + { + "path": "docs/internal/extensions/pre1/evidence/ps5-registry-matcher.zip", + "mode": "100644", + "gitBlob": "86b094dca031b94d1c1632532963e25ce0061965", + "rawBytes": 1008, + "rawSHA256": "4D8418A4AFF2CB02FB4DDFD31C30E1C131A3545CA34B8F34C231D3F4C473877C" + }, + { + "path": "docs/internal/extensions/pre1/evidence/ps5-selectors.zip", + "mode": "100644", + "gitBlob": "aca6c790dea6968833ad7b8d5b0c7f029db6f844", + "rawBytes": 9813, + "rawSHA256": "278E2095F846D88236F6B67F75B0938C0E11E9BA8CA1E6262471A27D3E8F2CC9" + }, + { + "path": "docs/internal/extensions/pre1/evidence/ps7-deadline.zip", + "mode": "100644", + "gitBlob": "c7208b6b90e838a115c1a31ad4eb711466061d13", + "rawBytes": 3406, + "rawSHA256": "0DFE2785591C500414070524A714786A6F8DD423FC105473C3868B995B9CBE90" + }, + { + "path": "docs/internal/extensions/pre1/evidence/ps7-registry-matcher.zip", + "mode": "100644", + "gitBlob": "0710b3ed9879eefec666ef4817545b67c6cc91e3", + "rawBytes": 943, + "rawSHA256": "FC01A94307AD981BD5763967839BE836C98E826997F677DD1EB0B00A4A09BE14" + }, + { + "path": "docs/internal/extensions/pre1/evidence/ps7-selectors.zip", + "mode": "100644", + "gitBlob": "83c06faca43eca0733c888b7b0f44ac68bb0c331", + "rawBytes": 9186, + "rawSHA256": "4D518769461B29DAF0B5EA21A7F281EF62B44C3F59718CCE2006F0B4FEA93E3E" + }, + { + "path": "docs/internal/extensions/pre1/evidence/replay-full-summary.json", + "mode": "100644", + "gitBlob": "4299f4b51921aac54dbbad2dd30a227e477908d6", + "rawBytes": 14500, + "rawSHA256": "47AC250E4E306617B9BA05941BE20C7417EF760ECD4B397FD7EDCD7073C87036" + }, + { + "path": "docs/internal/extensions/pre1/evidence/replay-full.zip", + "mode": "100644", + "gitBlob": "eadd16208862614d571e15c74eda07409000f432", + "rawBytes": 394230, + "rawSHA256": "2C27A21720206014042DDB7B1EE57B4322AC665BF1B4D2C999AD6CE7705C6A12" + }, + { + "path": "docs/internal/extensions/pre1/evidence/replay-inconclusive-startup.zip", + "mode": "100644", + "gitBlob": "ceeb1df311c3c8c1785277666741349475416177", + "rawBytes": 28326, + "rawSHA256": "F611F107C1FEA26241505A3DD6EB0E7725E1D7D42290985C5B01657B3F5BC2D6" + }, + { + "path": "docs/internal/extensions/pre1/evidence/startup.zip", + "mode": "100644", + "gitBlob": "6d49aac4eb31a056ab29eafd0c650817ac2056a0", + "rawBytes": 31912, + "rawSHA256": "CF0251628B1AA2D2408768ADDCA688D37145F885F877712D73BCD7B478EA6662" + }, + { + "path": "docs/internal/extensions/pre1/evidence/typed-consumer-final.json", + "mode": "100644", + "gitBlob": "a4cccb195bf4b3f5274139ea4e241aebadd49a6c", + "rawBytes": 2403, + "rawSHA256": "65D2051211837334368ECC17E8DF7C9277DFDF50A83C4E8AA908A7A61156BFF1" + }, + { + "path": "docs/internal/extensions/pre1/evidence/typed-consumer.json", + "mode": "100644", + "gitBlob": "4109f54442bd2417661c9bde4e4f160e672cbb17", + "rawBytes": 2873, + "rawSHA256": "964283BB8A0FF2A5D7F72DDB07C4A6F570CA965217BB793015EFC2C86877B4B0" + }, + { + "path": "docs/internal/extensions/pre1/primitive_manifest.json", + "mode": "100644", + "gitBlob": "88443b4a8bc49e89e2a01b8b4d144ca2d461ff5a", + "rawBytes": 627, + "rawSHA256": "308D30D13B89117FA5D75A7CDAE561BC1132DFF33AA9740C06233CAB034EE409" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/.gitattributes", + "mode": "100644", + "gitBlob": "a4d7d77d1297e414a4e7481b04371ac472f77365", + "rawBytes": 174, + "rawSHA256": "1EEF15FB19FA9A9AB5C368C3417D3502E61782FF0BEF1BCDC77A65EA6DC7371B" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "8afedb2a3cfbb6d8ae159d0aef4b57827cf13ca4", + "rawBytes": 40623, + "rawSHA256": "305A35019DF93CDECB13E1D2F8AB252DBBFE40F2CD06A4E78DC6317A5D77630E" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/RECEIPT_ARCHIVES.json", + "mode": "100644", + "gitBlob": "699f96c6c0f53c72f02479ef6fd4214116c79551", + "rawBytes": 5095, + "rawSHA256": "8351A360960132F8F37FF15189FB6BFB84422FD83DB3DBB725F0DE98C3F0885B" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/REPORT.md", + "mode": "100644", + "gitBlob": "b98e2b68a2baa2485257cb050aa2c1067f524315", + "rawBytes": 44353, + "rawSHA256": "8E39B60ECD3FACFD86749326734916962CC3670CDA57430712BCEE3292063C5F" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/REWORDS.json", + "mode": "100644", + "gitBlob": "57d61db39e5a8d737bb7b536abff69d53ed9f037", + "rawBytes": 5108, + "rawSHA256": "8FCEA55E77C01C13FC1EA8137875F62065E6513A5833B9989C88B7DB3A772E23" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/build_repair.py", + "mode": "100644", + "gitBlob": "1dba9c1f97d6a2d28e2144182f6195f3c85cf096", + "rawBytes": 12869, + "rawSHA256": "9E8741F82762DA06683FD023C479984234B407A0E0641B8B79957673268FEA4E" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/check_preservation.py", + "mode": "100644", + "gitBlob": "a0e863a41a8b906b6147788aeebdcc9b5313620c", + "rawBytes": 16282, + "rawSHA256": "345048E430E98E9185C3A409AC6165644077FD8AB4C2D5B28ED39ABE25D14C42" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/claim_scan_detector.py", + "mode": "100644", + "gitBlob": "4efcd5df2aed1e5d3deee0bff48c761e2aa5fe11", + "rawBytes": 13995, + "rawSHA256": "CDBCBC8816E094A9BA20D49410EB78F9C724F40153267D36697615AD087C8C76" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/checker-modes-84ae12f.json", + "mode": "100644", + "gitBlob": "46e3ab3f9213ac645c0051b78ff4f76aba67689a", + "rawBytes": 30970, + "rawSHA256": "EEA3CD642AB7C5D94EBCE92F27EB44016BCACCE638F7FB19450A16AD6034EA0E" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/checker-modes-e977053.json", + "mode": "100644", + "gitBlob": "732fb0e1e696a6d76fe5d8c86c7c4a516af83972", + "rawBytes": 30971, + "rawSHA256": "7D61361A3BFDFE4B98A93ED848AE150759C87832261B688E0B599561F622E9A0" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/checks-e977053.json", + "mode": "100644", + "gitBlob": "ea5e395d7dd334d1efba62791866cb29ebbfb91f", + "rawBytes": 2692, + "rawSHA256": "7BCCE381F2A937E95AF16AB99061B960FCA0C21B64EB0C4AAC6AE7A105BD8804" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/controls-e977053-incomplete-attempts.json", + "mode": "100644", + "gitBlob": "b423f901cdaa1ecc450e7931d63d499b69e3f386", + "rawBytes": 91573, + "rawSHA256": "FBD98BD4B582791B66AE9FD197E8B195A2BE8B2423A9E0D5F40D534345D03690" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/controls-ece8ae5-ps51.json", + "mode": "100644", + "gitBlob": "659aa5b9f943d29e8819b55712ddd4e0444defde", + "rawBytes": 79009, + "rawSHA256": "6E1252B420B5D658998B2143062E57E839A9020A6B0513373E9681034DB82252" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/controls-ece8ae5-pwsh.json", + "mode": "100644", + "gitBlob": "1fa56a1fb0bb63e4b6fce6e476bab3ffa00a73c9", + "rawBytes": 78752, + "rawSHA256": "5F4568CFF8057367522F3B07D828AE070B47D82A7CBFA633E9B20B5345D98A87" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/controls-focused-runner-fix.json", + "mode": "100644", + "gitBlob": "2c90fa2f5e72c91568cc0441905932ec69b719f8", + "rawBytes": 8962, + "rawSHA256": "8A30F9DCC95005DB66E45B299F329F13820C409AFC56D7BBEEF28B3FC6D5E7FA" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/hit-accounting-84ae12f-e977053.json", + "mode": "100644", + "gitBlob": "340f013745ef348a735fd75864ad75fa2beb511e", + "rawBytes": 2172, + "rawSHA256": "C85644E02EAB7318EF22DB072038460BEE9663D07B90BAAA11DB094B30D29C0F" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/preservation-e977053.json", + "mode": "100644", + "gitBlob": "502b4ff21125879a7e271c07f4ab89b1c3776c1d", + "rawBytes": 13833, + "rawSHA256": "C11BB96D3372EB2103A8879AA191BA86A4001B6A8C1EEC0DA04E4A076840EF4C" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/reproduction-84ae12f.json", + "mode": "100644", + "gitBlob": "aa9ac87d3ce304705ded23ebb23b7bd0f8dd3a69", + "rawBytes": 24839, + "rawSHA256": "B095113C73381BD1AA5A3E351CDBB24493C7BB9A312807ECE10F509F178502CB" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/scans-e977053.json", + "mode": "100644", + "gitBlob": "150c3b247644d90bcfb763824c0b7f7ec5028556", + "rawBytes": 12144, + "rawSHA256": "BF2FD2CA2B0B94832E35B9CC46F097C0E644EC5D243E14450ABA8EE31F9AD2AC" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/verifiers-e977053.json", + "mode": "100644", + "gitBlob": "579f292748126db4427b6a462e5fe944a2943ec4", + "rawBytes": 5066, + "rawSHA256": "0B8372DB5FE35B3503075126E28509AA5786B1965B470C32C967A34B4A9884F3" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/verifiers-ece8ae5.json", + "mode": "100644", + "gitBlob": "05ed2ad2310040b772cf101de75f7b22231e41ec", + "rawBytes": 20160, + "rawSHA256": "2CC4ECC7CBC679534A2407DAA9B42A5EA76E13CF27C690D1D24AA0168AE98562" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/repair_control_helper.py", + "mode": "100644", + "gitBlob": "15ecfc0b00d74627a9817284bc61ae7dab0f93ce", + "rawBytes": 11198, + "rawSHA256": "7D4ED15EDDFF0E6358D1973E782240CFC215EA9CB393DA8B3B82EC45C246A476" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/repair_controls.json", + "mode": "100644", + "gitBlob": "1e227e13d4486fca59377ee7d4c0f2e179ea4af1", + "rawBytes": 7582, + "rawSHA256": "3B44C6BC3693B1017D4451BDC5DF1E372AF97AFEE1B7183366C7C349C5EB7ED7" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/run_checker_modes.ps1", + "mode": "100644", + "gitBlob": "ed3a9977b88b7c198adf4be26c26920afb1294d2", + "rawBytes": 11820, + "rawSHA256": "578E9779BFFBF7BCF65EB7886E8379E702B7E3AD05A78540FC2AB8C9398B3DB5" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/run_claim_scans.ps1", + "mode": "100644", + "gitBlob": "9b18c6564d452421d13776677df72fecaa08627b", + "rawBytes": 10015, + "rawSHA256": "0A3CE98812903458B103008FD519DE3A8CE72D2F87F3D5CD9646AD14C7B97AF8" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/run_repair_controls.ps1", + "mode": "100644", + "gitBlob": "3cb1d35aa64d4d60dd8bc8f7d249f377ee02e6dc", + "rawBytes": 23099, + "rawSHA256": "3C7AE3B0AEF6FBB4A83EA027C528AD4AC8EF16E5FAE8C6EDC337FF4E683B1B87" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/verify_receipt_archives.py", + "mode": "100644", + "gitBlob": "4352d77640533519caf97a01bfdabf7581dddd80", + "rawBytes": 32791, + "rawSHA256": "76AFAACBA4D788856F4F023872019CF999C63B2AF41AD9FBCC6DA5D2D278A3D3" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/verify_rewords.py", + "mode": "100644", + "gitBlob": "79fb096c0e9379cb3a8d22410343ec6fd4500d62", + "rawBytes": 21504, + "rawSHA256": "B980778487D495B2BC7434EDF26D03C758A5A81FFD975C3DE5F93A7F0F65DF85" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "ca1a2c086cdc47f5d0cb6fd29fcfd2937e1c5e0f", + "rawBytes": 51944, + "rawSHA256": "5056D888AC2C79A7B1F011206E8B32AE78D078A8A0DB3F812345635A9FDC1027" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/REPORT.md", + "mode": "100644", + "gitBlob": "5f85e2b1e9ca96b6b34e636a6cce6f995364e3d1", + "rawBytes": 28219, + "rawSHA256": "66EAFCF92D325AB3D90B7444CB101CA34773DD10B7C94BF68CB1239F97C2E42C" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/marker_controls.json", + "mode": "100644", + "gitBlob": "a941723cd42205f1b9151c271d53479607249f68", + "rawBytes": 25912, + "rawSHA256": "554072EC7FFD20DE73A74EF78528A6B7902B100A4B13B0BCE6B7C86FB4678310" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q1-build-consumers-341bc28.json", + "mode": "100644", + "gitBlob": "f0304059d93be6584b94b67fb22a8d343f8f206a", + "rawBytes": 14869, + "rawSHA256": "C873D58D3BD17C29DDEA4D4A0B2766B4A4FF4D5B712F2B54FE2CEE3EC0981074" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q2-focused-replays-c33f2a8.digest.json", + "mode": "100644", + "gitBlob": "7ddcb20a896c990f456a3d2cd13b3bbe3160e744", + "rawBytes": 37466, + "rawSHA256": "3A689E197A2236CBDB57650FA245DA202ED23D7F07A5830415F304EAFCB9ECEB" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q2-focused-replays-c33f2a8.json", + "mode": "100644", + "gitBlob": "ad2e7305c5107df919adb546d821be67afa09409", + "rawBytes": 8293, + "rawSHA256": "27E170E7AC997A972FA7F04B764C658214D40F36EE5FE3D3C11B5C431C563C3B" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q3-marker-controls-26b175e-ps51.json", + "mode": "100644", + "gitBlob": "1d7bd325421dbd432274bb6397e97a449df88d16", + "rawBytes": 112308, + "rawSHA256": "147F2E34E546DD509ECDF22EA829E453FBC4F9A6E5ADCA2ED106AA5D8C15FAA6" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q3-marker-controls-26b175e-pwsh.json", + "mode": "100644", + "gitBlob": "1db92f1d9c50b54254e6cc9d0471be9b9e0db827", + "rawBytes": 13891, + "rawSHA256": "D43C613E31B260AF8C4ECB69CF3A850ADA59FFEA4FCACE0BB5B63AE50F349375" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q3-marker-controls-26b175e.json", + "mode": "100644", + "gitBlob": "d58fe48cf1e973c50b79097b4af12d52926bc7a0", + "rawBytes": 5920, + "rawSHA256": "63A267D75D204AE47E87648EBAC9915EFCD5BA60797C197C57666DBB91AC08F4" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q3-marker-controls-e935f84-attempt1-ps51.json", + "mode": "100644", + "gitBlob": "e51a2b6e56268c89035035a8322724daccabe823", + "rawBytes": 112325, + "rawSHA256": "6210FD56F661987BE039663E6370558199E41EA0425E8477D4A8777BD396B450" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q3-marker-controls-e935f84-attempt1-pwsh.json", + "mode": "100644", + "gitBlob": "8535506f3f786dd6fa8fb00274a311985325a496", + "rawBytes": 13997, + "rawSHA256": "0E4A6552CC5D982CB636E8B1C71C5FF13613D7DFD32C2E39A8CE603FB464A70C" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q3-marker-controls-e935f84-attempt1.json", + "mode": "100644", + "gitBlob": "6743adb933405e1787fa7ed9af7898a57c804d0e", + "rawBytes": 7005, + "rawSHA256": "F191E8082C6FC9E64E252CE6D6726657E752DE13FD79B660E1B68D754E383038" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q4-builder-replay-full-f5d6128.digest.json", + "mode": "100644", + "gitBlob": "e29c716674f951b1158e254a4788e825f98821e4", + "rawBytes": 276464, + "rawSHA256": "9E26D05C041690E8CC8C73A2C86A38F9308301AEEF20D22D5B718B71343372AB" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q4-builder-replay-full-f5d6128.json", + "mode": "100644", + "gitBlob": "fdb8f6b8d70f7c44f29de7b022cc79fc6e10faf4", + "rawBytes": 4137, + "rawSHA256": "B205D5C09EC98B7AED38E92335AFDD27104B94C5936E815402FFBA6D63A6DE37" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q5-contract-replay-and-selftests-f7bdf20.digest.json", + "mode": "100644", + "gitBlob": "82852aa6f833861aa3faf0907f0fab89487a0cae", + "rawBytes": 102729, + "rawSHA256": "8997264344C6FA8680C09C41FF7B74EF0FE0ABE857CEAEEA54398D599930ED96" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q5-contract-validator-selftests-f7bdf20.json", + "mode": "100644", + "gitBlob": "1509c128b6d215b7e33632271d24c0fb7f6d5752", + "rawBytes": 20230, + "rawSHA256": "7FA0C101BEBB0899852C9E118875554E59787A96AD9F51BAE35637918C532B8B" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q6-claim-scans-9598f72.json", + "mode": "100644", + "gitBlob": "353d58e005e1fd59f34a8f869f3069e780bb340f", + "rawBytes": 6424, + "rawSHA256": "30EBA9677921448179B0B8DC692CAC3739F38B58FF43B0F97FD2FF357573AE7F" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q6-static-checks-9598f72.json", + "mode": "100644", + "gitBlob": "4eed9c3127ba7439c5cad3907a58f55256a179f0", + "rawBytes": 21467, + "rawSHA256": "7B7C8F4650DD262185A26482736AEAA7981047E3133E82482D3E547BB159FC81" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/run_marker_controls.ps1", + "mode": "100644", + "gitBlob": "33e336860111a7eb7d1d2eb875b42f5d96458cc0", + "rawBytes": 25996, + "rawSHA256": "763AF78EA72149FF92D080EA04B39BCBBB8371F35120DB7CED39F62EBA4504AB" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/apply_consumer_edits.py", + "mode": "100644", + "gitBlob": "aa0ebf9538ca395ccb8ecfe9fb7877c2eaab464a", + "rawBytes": 9826, + "rawSHA256": "8C0B7E702B288280B377D7A4D91F9C8B7F744FF6E6C93835D40DF343CE0C05C5" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/cab_probe.ps1", + "mode": "100644", + "gitBlob": "dd1f23e247ca3d7571e18d5d921a9aaf96d3901f", + "rawBytes": 4734, + "rawSHA256": "65975106ACB5F0A7365F08CE71D2D6BA53ED991A64BE56D491FE0337915059F3" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/clone_cases.json", + "mode": "100644", + "gitBlob": "2239e2292978aa240f239bf846968595964bef87", + "rawBytes": 34934, + "rawSHA256": "FC706E3811651949B11BB6B48363B3AEA97190D7A9D0235EE5D3D90B016124CA" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/clone_mutant_probe.ps1", + "mode": "100644", + "gitBlob": "b778fd024784ccc04cbe898125a8ed62828df726", + "rawBytes": 4250, + "rawSHA256": "55B33FC42C69CD4822D2FF311619D3DC4C0EB1DB807481A05A318C71AAD30BE7" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/make_marker_registry.py", + "mode": "100644", + "gitBlob": "4d3faa3df71bbdcdf1fed56ef928c024e3340212", + "rawBytes": 7335, + "rawSHA256": "B9022B920B314F6CCB677D83EAF27656A9159499F6192DA841D549AD639945D4" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/make_registry_v2.py", + "mode": "100644", + "gitBlob": "1f826cf31fcb4afcfedddd5cbe167b4b4576bb58", + "rawBytes": 5300, + "rawSHA256": "763997C57836DE44FACB2E16E07927FB4014AFB8D9A48C9D28C525147F1B0E12" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/marker_block.py", + "mode": "100644", + "gitBlob": "e303f0af86ecbe21deea23013ad09e05ff7f2fc2", + "rawBytes": 3085, + "rawSHA256": "7899AF501D6427D0A6572007DE22EC2EA770B264943E429E42848037E3F95A75" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/mechanism_toy.lean", + "mode": "100644", + "gitBlob": "ff4949ee91f6e29dc6ab52ae27ec1258120c0095", + "rawBytes": 2047, + "rawSHA256": "88399FBEB37F4766DC3925AEEA0108F78A3F714ACB0746B5789A6F22ED72FD61" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/mechanism_toy_variants.py", + "mode": "100644", + "gitBlob": "d5f7ce8db5bc258b6538deae6063156dfe463906", + "rawBytes": 1693, + "rawSHA256": "ED7C7D6667D11401295D7110311AE2B9AD2B024D65ABC99128C98D26E50BF6F4" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/p2_2_work_probe.lean", + "mode": "100644", + "gitBlob": "92247bfe7792b106670150183517ee18cca6daae", + "rawBytes": 1818, + "rawSHA256": "95F002099B86F8F77882C38BDFE9C03F7CB4D2DD76197FFBB9C64C93DFF3C205" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/queue.ps1", + "mode": "100644", + "gitBlob": "c4f8b8c33861f9cd9a308602021d49b53fe3f10b", + "rawBytes": 2554, + "rawSHA256": "3A65D5EFCA05CE8E48F110FB6C4B9883CFDE319DCF4C5B20982399EBF858B9B5" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/runsafe_mutant_trial.lean", + "mode": "100644", + "gitBlob": "0aa55521e295be888b0a5396287b32b3d46a228c", + "rawBytes": 3577, + "rawSHA256": "7A100040C52C211B059E1651E46A13C0AD70099E3846C535D51C87F9FD9AB3AF" + }, + { + "path": "docs/internal/f03_evidence/F03_COORDINATOR_FINDINGS.md", + "mode": "100644", + "gitBlob": "222efcede6e4f73af780d125041c84440ec76754", + "rawBytes": 9846, + "rawSHA256": "D0474352835FBBEB2D7639177B2974BC4C34E9472537563E35DFAD61F68D448F" + }, + { + "path": "docs/internal/f03_evidence/README.md", + "mode": "100644", + "gitBlob": "86288c8a12ad7b2a82511f6c5130171db39e892f", + "rawBytes": 2838, + "rawSHA256": "7211AFD058AC8C49A29C7E71B718E967DBD0B0EB9868A506DD7188243AFDF820" + }, + { + "path": "docs/internal/f03_evidence/T1_COORDINATOR_FINDINGS.md", + "mode": "100644", + "gitBlob": "c43d7f076c0e27b82cb76c87a21cecf54806a4fa", + "rawBytes": 3267, + "rawSHA256": "3428203FBBB459E8ED682DBA0EE824BBB5007C5E463990DEA8E26E413DDF773B" + }, + { + "path": "docs/internal/f03_evidence/adv6_L1_big.lean", + "mode": "100644", + "gitBlob": "5b00f3abfc14571ab35a55378e71c8837c8c17b7", + "rawBytes": 4829, + "rawSHA256": "2296F855F37754F6BEE4EBCD559E3EC0D3BC031B97ABA2BE7200BF57CF372661" + }, + { + "path": "docs/internal/f03_evidence/adv6_L1_cross.lean", + "mode": "100644", + "gitBlob": "18beaa24784b467ba4639e9d600164ec7dd6507a", + "rawBytes": 4349, + "rawSHA256": "4E2B66AD2B7ABFD035ACAEC63C778ED56F46872DBC2D211F2013A996B5C2D8CD" + }, + { + "path": "docs/internal/f03_evidence/adv6_L1_degen.lean", + "mode": "100644", + "gitBlob": "717516493b62f1f9eff846b427c45d3a7fb9c416", + "rawBytes": 7122, + "rawSHA256": "1F662CC299653B365EA1B3F231ED9829FC15C1D836E0711AC14F72DF990B88FF" + }, + { + "path": "docs/internal/f03_evidence/adv6_L1_forced.lean", + "mode": "100644", + "gitBlob": "4d213a6cb6c1933c348270e2eefb920b05346076", + "rawBytes": 4911, + "rawSHA256": "58302C766DF60226A0FBD574B902E440E25F74F1403C5593851E842574F53B9E" + }, + { + "path": "docs/internal/f03_evidence/adv6_L1_forced_out.txt", + "mode": "100644", + "gitBlob": "2d944985193025bdbd8ef1e66e5aa861c77fd519", + "rawBytes": 917, + "rawSHA256": "C237126F01017FBE06CCAD9D6D492FFB60556AC356C922D3005B78BE13E37AE4" + }, + { + "path": "docs/internal/f03_evidence/adv6_L1_real.lean", + "mode": "100644", + "gitBlob": "09676973ed603d386abc94afebf51a61c366a657", + "rawBytes": 4993, + "rawSHA256": "B086DB935B42728A772DADF111B28CCFE4F73784F61F85B1D264031AD2126DB1" + }, + { + "path": "docs/internal/f03_evidence/adv6_L1_refute.lean", + "mode": "100644", + "gitBlob": "54987d83a27def1b1bb9c132d83a9b898d76bf6e", + "rawBytes": 8567, + "rawSHA256": "EF835AE1CA55B62361096EF563E51413B4CD924A6E7BB0865D3E07B80530DAF3" + }, + { + "path": "docs/internal/f03_evidence/advF1_attack.lean", + "mode": "100644", + "gitBlob": "16e2e24c4ca3fda75a018fd2f7bc12d03a595daf", + "rawBytes": 7694, + "rawSHA256": "91A9269F28D97B426F522AD3C8F8E70CF61353B7524F58145259CF40A98A7E10" + }, + { + "path": "docs/internal/f03_evidence/advF1_attack2.lean", + "mode": "100644", + "gitBlob": "688496c7b8d445e5403d31b4b5a1d9e476c12826", + "rawBytes": 6559, + "rawSHA256": "48A95206C8FCC5B33B0A091DF326E6744AEE58A708F5FF6D761938268BCA0AC1" + }, + { + "path": "docs/internal/f03_evidence/advF1_attack3.lean", + "mode": "100644", + "gitBlob": "c96f4ab804b314c7876f02cd56f13ccc1ef58f2f", + "rawBytes": 4931, + "rawSHA256": "75D7DDCB305732A350A1D34BF222EAD10A97386ED036772D8EC996BB0A365EB4" + }, + { + "path": "docs/internal/f03_evidence/advF1_reach.lean", + "mode": "100644", + "gitBlob": "6df91d76d18f966f7f9309a6db0b483b8737b770", + "rawBytes": 6551, + "rawSHA256": "42B2E60349E3785CF2009B0E5DADA2AF615F5906A705C3628EEA9E734130757A" + }, + { + "path": "docs/internal/f03_evidence/advF1_refute.lean", + "mode": "100644", + "gitBlob": "c69bf86bc4ad050012f6ca7629fcdca80f9c24b6", + "rawBytes": 8233, + "rawSHA256": "10385A7C8BAFB73793D4ABD79A43693C8BCDEAF47A2C48FCB1B92BB7D9B7BDD9" + }, + { + "path": "docs/internal/f03_evidence/advF1_refute2.lean", + "mode": "100644", + "gitBlob": "94f1ad811137f30c17d6dac4f3d5b6ef6f9e025d", + "rawBytes": 6372, + "rawSHA256": "63747A41E13265337783EDAB0F7320E0E3B1FD1655A36EA2766269E46B20BE9E" + }, + { + "path": "docs/internal/f03_evidence/advF5_antivac.lean", + "mode": "100644", + "gitBlob": "ec2dcbb5412ff8d2175999380f920e4d775d1049", + "rawBytes": 4071, + "rawSHA256": "841ECCB20C1D4F07997010CB0AAE8B0EED1F39453332F67FF88A00DE2DF33642" + }, + { + "path": "docs/internal/f03_evidence/advF5_antivac_out.txt", + "mode": "100644", + "gitBlob": "29b1ddf845353b72e53558730c8ed69ca5084a10", + "rawBytes": 4423, + "rawSHA256": "AAC7213F6B329D3738B4C07CDB40BDBAB64AAD6F563AE79994A747CCFA11F403" + }, + { + "path": "docs/internal/f03_evidence/advF5_live.lean", + "mode": "100644", + "gitBlob": "e413938829553fdb343e12c7dc158d214fa2064b", + "rawBytes": 4492, + "rawSHA256": "638DE48FC052F46AF0300045E842F76D8C1197BFA7D7C8108C6C6301D7255CF8" + }, + { + "path": "docs/internal/f03_evidence/advF5_live_av.lean", + "mode": "100644", + "gitBlob": "7d3bd53c2d5d82fa16cbdebc0e47286689618360", + "rawBytes": 3727, + "rawSHA256": "DB32698BAA1379B638D30C3E37A573EFD80FA431231AE552A52F5E4F63946C56" + }, + { + "path": "docs/internal/f03_evidence/advF5_live_av_out.txt", + "mode": "100644", + "gitBlob": "cca181778bb455e320d3ab3fc3d9428ff76b7361", + "rawBytes": 1140, + "rawSHA256": "0884572FB34A95DACC16535126074395AD095C7EE20B807084D7CEE2ECC0EB98" + }, + { + "path": "docs/internal/f03_evidence/advF5_live_log.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/advF5_live_out.txt", + "mode": "100644", + "gitBlob": "30de603098d62e2214ccb9914d57401be8445546", + "rawBytes": 272, + "rawSHA256": "0F0392944F536416DAA5F8294215093C575702ED2F594DBAF0E57CCBF8DC4C64" + }, + { + "path": "docs/internal/f03_evidence/advF5_rand.lean", + "mode": "100644", + "gitBlob": "6569408b0fdb2c42cef03b88651431edfc0fbf79", + "rawBytes": 6505, + "rawSHA256": "DF977646DEDFA3C83D0E2F759D10E31BEC5ECD1DD5B1D6D932F8A72CF02D8CEA" + }, + { + "path": "docs/internal/f03_evidence/advF5_rand_out.txt", + "mode": "100644", + "gitBlob": "47735f142da34fd9c881a992841c1f8c2609e0ee", + "rawBytes": 2118, + "rawSHA256": "AEFF543853D475E19726D65C3D2DD64BB5F6F63FEE4058ABC59B1222C24B4893" + }, + { + "path": "docs/internal/f03_evidence/advF5_realstore.lean", + "mode": "100644", + "gitBlob": "0eebe26dc937a6b94b3162194ae1faea9f89d40d", + "rawBytes": 4057, + "rawSHA256": "DAFD050AE29D9A641934B1619CDAD9FFC9E8687858162E330141BA883AC6EF46" + }, + { + "path": "docs/internal/f03_evidence/advF5_realstore_out.txt", + "mode": "100644", + "gitBlob": "4da2132dff19ae82e499c214453843a80fea4697", + "rawBytes": 461, + "rawSHA256": "063234C228D26205D7BD1FBB825FBC3221C2C75EE8EBADA1EE4BB7638D9F5D31" + }, + { + "path": "docs/internal/f03_evidence/advF5_seg20.lean", + "mode": "100644", + "gitBlob": "9825c8e266d976ec70baa70729decc0d2e79169a", + "rawBytes": 2778, + "rawSHA256": "F21D8A537F3B43C285C9BF2BAE368C09C3613D200894304959C836A3713D98E4" + }, + { + "path": "docs/internal/f03_evidence/advF5_seg20_out.txt", + "mode": "100644", + "gitBlob": "20ebe9c2277bf833426813c059b21864c1a0fcfb", + "rawBytes": 205, + "rawSHA256": "9AA375FD682949671F3EC490E3B0D8AC013CDB7A456A4E2A02787B00DE7CACA3" + }, + { + "path": "docs/internal/f03_evidence/advF5_seg20b.lean", + "mode": "100644", + "gitBlob": "133d7bbf2ce487a28643fad64a8f7fb7259b956f", + "rawBytes": 1840, + "rawSHA256": "45B21637A8AC8F59C6696569F008ECC71ED6C550527B99DF3B5CF13D08DE6BB0" + }, + { + "path": "docs/internal/f03_evidence/advF5_seg20b_log.txt", + "mode": "100644", + "gitBlob": "5a6a98bdf28057616afd7b55a920f4440fc59a77", + "rawBytes": 1444, + "rawSHA256": "E8EFCC30699AFD6179BF5ACDDA67BED3679BDA810C96967C16586B57202D6428" + }, + { + "path": "docs/internal/f03_evidence/advF5_seg20b_out.txt", + "mode": "100644", + "gitBlob": "5c93fe57e9d1fccb757b64a9677a53bcb05331f4", + "rawBytes": 1442, + "rawSHA256": "0F693EFA05E9733678FA6FF1ECF4FB66C51DDCB84E99B89100DFFE41E0B2C7CC" + }, + { + "path": "docs/internal/f03_evidence/advF5_top.lean", + "mode": "100644", + "gitBlob": "72a8dcc75bbdb63ca4e50524cbee659201222b27", + "rawBytes": 4292, + "rawSHA256": "487E7B46431406FF249CBF24DB38E49382C372CFC52720338A437D97341C37AF" + }, + { + "path": "docs/internal/f03_evidence/advF5_top_out.txt", + "mode": "100644", + "gitBlob": "4d10ad510bd3c141f3f97998884c69437a6be421", + "rawBytes": 729, + "rawSHA256": "CFCC838EB98D35F361214E04B9695824092A38590C023A92B57D47C66A5A6D20" + }, + { + "path": "docs/internal/f03_evidence/advQ_f1_core.lean", + "mode": "100644", + "gitBlob": "f811ed5264b8f2ddb4e07edaec714b054ad3ffc9", + "rawBytes": 6363, + "rawSHA256": "61AB1F4A9B110A2D9A04C4A6411C02597AFF9A108AE23AE69B38698308B4574A" + }, + { + "path": "docs/internal/f03_evidence/advQ_f1_quant.lean", + "mode": "100644", + "gitBlob": "6a7e63c7156207fad102398931834e1fe964997d", + "rawBytes": 11570, + "rawSHA256": "45747A4F6184060BAC11480D4434F178621407E6CB919F94A35647E01DF10992" + }, + { + "path": "docs/internal/f03_evidence/advQ_f1_sweep.lean", + "mode": "100644", + "gitBlob": "2a3b075eb1ea1f1a36dc333451a62d504e02a026", + "rawBytes": 5534, + "rawSHA256": "960412AA54FE7152A903F46B80DAFE1B9312442AAF15DBED889629A571A69DB5" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_forced.lean", + "mode": "100644", + "gitBlob": "0b625228f0cb3eae2ba5ae5272c4ef35962283d7", + "rawBytes": 3991, + "rawSHA256": "0B8FA153FDFC8FFBFA0FBBA791D14A62AF1DDE3FCB1470C1C0B8EA37CE64E3A3" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_forced_out.txt", + "mode": "100644", + "gitBlob": "f73a87b739aeadac47f6cd93a171a01b7fcbf84d", + "rawBytes": 3272, + "rawSHA256": "E05E82F70D038384D23F7850DDE0641A9B0AC5C082833A2576D4A18354E538D2" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_global.lean", + "mode": "100644", + "gitBlob": "e38263eb6d38eb08826d91d66776f618bd0c02c8", + "rawBytes": 6190, + "rawSHA256": "0F1E01696AF991AF5C1B36135B6B8197C2690DD91E298E299D4D046FA7BF1EF8" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_global_out.txt", + "mode": "100644", + "gitBlob": "49f75996e8777e96d8097e684c47a0176764e011", + "rawBytes": 459, + "rawSHA256": "5CBADCB2904D83D414185435EAB83C37A790E8538763B10371057D8BAC87E98C" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_offsets_thm.lean", + "mode": "100644", + "gitBlob": "b361406c2c18f68538acdafa48d596aa263f3b4b", + "rawBytes": 4815, + "rawSHA256": "7DECB57A627866E946C7578B0DFA6335CD40F6834B495312584CC9F6DEAC35CC" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_regime.lean", + "mode": "100644", + "gitBlob": "c664cfc8ee37563a9c149a86d3b050d63c39cdf2", + "rawBytes": 5040, + "rawSHA256": "2458D558DAD5DFD9F62B9064B05949EAAAFCEB3672020EB1E3424551E4978D04" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_regime2.lean", + "mode": "100644", + "gitBlob": "8667296960bcf61fb04c0251b2f8ad0a7326dfc5", + "rawBytes": 4806, + "rawSHA256": "5AE86F40E93D2AB344A441DE868D9345FE9E0C04A9C9EBB3CCBE2C2A7460C98E" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_regime_out.txt", + "mode": "100644", + "gitBlob": "8056689c3cce7839d11b799aeaca398b5c68df38", + "rawBytes": 4083, + "rawSHA256": "F505717258D3EF5108BE34CA658A2FBEB85F5583E353EC0044EF5A73F70F588C" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_uncovered.lean", + "mode": "100644", + "gitBlob": "421b69f6d19d9fb93e0e47bf8517650e6166a760", + "rawBytes": 5289, + "rawSHA256": "3D87D3362A56AA0A3AE759D2646249222AA5324C539DCB45C02E7F3B8BCBD2CF" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_uncovered_out.txt", + "mode": "100644", + "gitBlob": "467ab1ad59b880c9f1f5b8abce5fdf9e14b60057", + "rawBytes": 3185, + "rawSHA256": "31D1B50BA11DB7E90E21A519B159DFACAAC5B21FFF3645E621F262E02486FE5A" + }, + { + "path": "docs/internal/f03_evidence/advQ_f6_big.lean", + "mode": "100644", + "gitBlob": "2debecdcde893031994576270329d8802faa5243", + "rawBytes": 6596, + "rawSHA256": "4DCC601D51F5339E5929CA91EA688985C758D74DF6B07D6AE3FC6D9A77124E2C" + }, + { + "path": "docs/internal/f03_evidence/advQ_f6_big_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/advQ_f6_kernel.lean", + "mode": "100644", + "gitBlob": "a59b280a8c99d56e3ff461de4ef9806b330edc7b", + "rawBytes": 4837, + "rawSHA256": "7BE21820D2483D7B75F459677099707442B060785091E170928EACBAD4E4D0FA" + }, + { + "path": "docs/internal/f03_evidence/advQ_f6_raw.lean", + "mode": "100644", + "gitBlob": "c38707ce61f21fe83d707507fb80ac77bce4af3c", + "rawBytes": 6464, + "rawSHA256": "E565576531BCED3A0A9E1FDCF2931C527B1CD57E9BD851DEFF51A633DA431340" + }, + { + "path": "docs/internal/f03_evidence/advQ_f6_raw2.lean", + "mode": "100644", + "gitBlob": "0e596d955a76cf82964c65790e39f4859eb52cc6", + "rawBytes": 5929, + "rawSHA256": "B4BA1AD0AB3A74CDE1EED6B982CB1E2BFF429C87131E5F2B91ABF63449DB703F" + }, + { + "path": "docs/internal/f03_evidence/advQ_f6_raw_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/advQ_f6_thresh.lean", + "mode": "100644", + "gitBlob": "7972ff5e98acfb9c7bceeac63fe82ba972dc7e9f", + "rawBytes": 2116, + "rawSHA256": "3D4357C219271EC21C19DB4B7B25CC34D159338DB00122FB54C22D4B9D8141F7" + }, + { + "path": "docs/internal/f03_evidence/advR_f5_addr.lean", + "mode": "100644", + "gitBlob": "73f5b7b97de436e1a9db0850587de7b823b648df", + "rawBytes": 3238, + "rawSHA256": "69D3D1B255B255158C6AC0C9FF848401D86993428994AAED6C18586F7853671C" + }, + { + "path": "docs/internal/f03_evidence/advR_f5_cut.lean", + "mode": "100644", + "gitBlob": "3f46f1cd63e0e555bed66c964d29db2bb2974e05", + "rawBytes": 7478, + "rawSHA256": "DC651FB6E64D5E3F4B005E0036B6EDA1AC919A0C4B5F8805077A3938BFA1EF1A" + }, + { + "path": "docs/internal/f03_evidence/advR_f5_cut_out.txt", + "mode": "100644", + "gitBlob": "d145bdcb9a2dae21439f9c608b761d4466dcbd9b", + "rawBytes": 5201, + "rawSHA256": "AFFFD96E20C852404A847866774C32F05EFB1D163BB4630F0FE125ADAD312026" + }, + { + "path": "docs/internal/f03_evidence/advR_f5_root.lean", + "mode": "100644", + "gitBlob": "1fef6d2c53949e0c93bd8697924c76bde67426bf", + "rawBytes": 3938, + "rawSHA256": "62E0DC3FF361937800FCAF38278D99A5E7F7D6592601D8540B8742DEE0A648CC" + }, + { + "path": "docs/internal/f03_evidence/advR_f5_root_out.txt", + "mode": "100644", + "gitBlob": "23891c08a675dfb5331ec29475071d84636d8bb2", + "rawBytes": 1308, + "rawSHA256": "52979171305096FD4E93E6A4455FFD2BF97B12EAA6C278D57AD65530576725AF" + }, + { + "path": "docs/internal/f03_evidence/advR_f5_vac.lean", + "mode": "100644", + "gitBlob": "9fe3a02cc20c3cb1c0f2273e4467036bf4d98ab4", + "rawBytes": 2642, + "rawSHA256": "A70CCD6266E84C543E763F8966A2B5188E163DFCFED86CC98474C9FD562383F4" + }, + { + "path": "docs/internal/f03_evidence/advSZ_axioms.lean", + "mode": "100644", + "gitBlob": "11fd9c54ea0e05083c52ebec3192d127cf851901", + "rawBytes": 3344, + "rawSHA256": "3D5D9FB2C3D4CDD9DB6272AC8461B824A5FB412B14A634B7EAD754287F0B6AFE" + }, + { + "path": "docs/internal/f03_evidence/advSZ_big.lean", + "mode": "100644", + "gitBlob": "06f1dd062fc3cddda08eeafa9e612c4a62783b96", + "rawBytes": 7205, + "rawSHA256": "BEDE7F4A12E2E1B6F723110AF755AE6B730361998B0FACD1C66D32A036D6D786" + }, + { + "path": "docs/internal/f03_evidence/advSZ_chk_rank.lean", + "mode": "100644", + "gitBlob": "52f6541e19a13fc5e6d6281e118b61230b4cca30", + "rawBytes": 3206, + "rawSHA256": "BEE74772A7B66255EB93360ED1B57B27057544DEC535819ACE6685B679C24DC5" + }, + { + "path": "docs/internal/f03_evidence/advSZ_chk_size.lean", + "mode": "100644", + "gitBlob": "59c5228b77235e4db6bb17ae8684c0f6ffda136a", + "rawBytes": 9503, + "rawSHA256": "B27B0E8F4FE02D983FCBF17E93B9DA4309111E7D14B4D206855D0FFE2549EDD9" + }, + { + "path": "docs/internal/f03_evidence/advSZ_ctrl.lean", + "mode": "100644", + "gitBlob": "4491f9aad117d87266730dd69c346d7617534806", + "rawBytes": 3172, + "rawSHA256": "C84D2A1D30EF36C2C3CC3123106E8DC008706FE995DEE80C8849E00F2F106BD2" + }, + { + "path": "docs/internal/f03_evidence/advSZ_decide.lean", + "mode": "100644", + "gitBlob": "ff921260c68b763e38a9b3dc5f7f9255bbc3721e", + "rawBytes": 2927, + "rawSHA256": "230471E703A359AA798B3497D72F94D984B16C8006DBA12A9F320FC245FB4286" + }, + { + "path": "docs/internal/f03_evidence/advSZ_decide2.lean", + "mode": "100644", + "gitBlob": "0932787e4989c02452026081cde1259dab03325e", + "rawBytes": 2699, + "rawSHA256": "6109040B4CF2333057D5A1614BF4B03EE07580829B0DAD92EDBA748FFFB8AD81" + }, + { + "path": "docs/internal/f03_evidence/advSZ_decide3.lean", + "mode": "100644", + "gitBlob": "87eced826ecdcae9fdc864ad807f71722816fdf2", + "rawBytes": 2678, + "rawSHA256": "5B89AF0BC36A649777345CB7ECD171214A7599231B48A49A54170FC4B2C6DD80" + }, + { + "path": "docs/internal/f03_evidence/advSZ_exh8.lean", + "mode": "100644", + "gitBlob": "6a44c3596aa658fde7464e27735ba22d4e998306", + "rawBytes": 2189, + "rawSHA256": "E363351BB9FEDFE975F968549C733754DB0CBE0D9EB5384509818B43A2EC6024" + }, + { + "path": "docs/internal/f03_evidence/advSZ_huge.lean", + "mode": "100644", + "gitBlob": "4091faba89139b01b7fb3e30c32dc626222ba30d", + "rawBytes": 5813, + "rawSHA256": "53EA79EAE41CAF88D773744BECC8FAA9ECDB4CA4F39D27F0D1111735DA9655E4" + }, + { + "path": "docs/internal/f03_evidence/advSZ_layout.lean", + "mode": "100644", + "gitBlob": "400a2dd3852d725dd37940e2e2d1286971c43278", + "rawBytes": 6025, + "rawSHA256": "B6B76F44132CB583ADDD4E44D1AB011E725801C46E58AA2AF328C9A9FE2C0492" + }, + { + "path": "docs/internal/f03_evidence/advSZ_layout2.lean", + "mode": "100644", + "gitBlob": "4ad3086766fb97f6b7a8a47c085324d60f465a17", + "rawBytes": 5616, + "rawSHA256": "A712D57ABB8F47A6FA5E2A8429F6765B4AC5909A5798F3498CBC1FCE46E3D45D" + }, + { + "path": "docs/internal/f03_evidence/advSZ_probe.lean", + "mode": "100644", + "gitBlob": "fbf03d252cddfdd8922215f971c61107541b7f89", + "rawBytes": 2243, + "rawSHA256": "031D5386CDAFEA6A95F7A842190C951871052CAC03A3880D8ECCDBBE30D46363" + }, + { + "path": "docs/internal/f03_evidence/advSZ_sparse.lean", + "mode": "100644", + "gitBlob": "6d3f752812018adeb95546be10109a63e745cadb", + "rawBytes": 3621, + "rawSHA256": "BB053A952E8B58AC8A1423FDE25C13B62AE1C68C081F9BED4AF9F57299D7FAE5" + }, + { + "path": "docs/internal/f03_evidence/advSZ_sparse2.lean", + "mode": "100644", + "gitBlob": "297b4498c8d83f51eabff472645c6fcff5c3d7d6", + "rawBytes": 3617, + "rawSHA256": "6DE1F9F073A641EF531E46582F3DDA08F85B8373AF45E9E4D14CA745881E2F41" + }, + { + "path": "docs/internal/f03_evidence/advSZ_store.lean", + "mode": "100644", + "gitBlob": "bd303471f038211d90251e51bb8b91d78633572c", + "rawBytes": 3472, + "rawSHA256": "B7B85FB6CDB30882A72C8C98F03D3F3E08519DFC59630AF6601E768E6F4DC1AE" + }, + { + "path": "docs/internal/f03_evidence/advSZ_strides.lean", + "mode": "100644", + "gitBlob": "8ee9290ba9e454760c113332e6084ed958853594", + "rawBytes": 6107, + "rawSHA256": "BABC1C02A3BE69BAA67D0337B3AE3DEAC78538354399729719E041A5143507CD" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack.lean", + "mode": "100644", + "gitBlob": "ef03dc2e5265d857b7722c429e9d80e8b446b0c4", + "rawBytes": 8008, + "rawSHA256": "AFE1B805FE3DB50000A5B220F016825D882199E51D8EDA2F1418EF4E0B375880" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack2.lean", + "mode": "100644", + "gitBlob": "5a71be7ec0c107c481983915ee7fc9108c721e67", + "rawBytes": 6826, + "rawSHA256": "F01039D1D32283706DC3C860A8A53C6BB63EC6E034EF32F2082E5FCEF9C2CEB9" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack2_log.txt", + "mode": "100644", + "gitBlob": "28409735729251605cc1007c9d97c6145c2327c7", + "rawBytes": 154, + "rawSHA256": "1B523FE252A7A813DED19E5751628F769328C3DF4AAC868C09C763FC57C9F427" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack3.lean", + "mode": "100644", + "gitBlob": "5289bbae06043bea216ededbe9e8281fe3e29418", + "rawBytes": 8449, + "rawSHA256": "35F5B3CEACC4E89C65C58BBDB062E6F137C04DE7E806C978B761B83D827F411A" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack3_log.txt", + "mode": "100644", + "gitBlob": "eec3b9f201b9914b2409148951f5ab415b699995", + "rawBytes": 1756, + "rawSHA256": "C78BF65B7D6567A0C7E2E809FE8CF511120C2E231EA98E9B5EED7A6FFE6FA689" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack4.lean", + "mode": "100644", + "gitBlob": "f4d0f8f2432408173e780ded73389e409b108fd0", + "rawBytes": 10925, + "rawSHA256": "ACD00DAE304613FF05DC1DB415331FC5A9E0ED7CC39FE358E2319F405C0E1723" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack4_log.txt", + "mode": "100644", + "gitBlob": "0adcc14e557e451fa554713f1fbee4fe2f5867d2", + "rawBytes": 2032, + "rawSHA256": "4FAB92B64F781B45951DE881C9C1D929072D89F6360866532039B9DFE582F29E" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack5.lean", + "mode": "100644", + "gitBlob": "5f4ee86ff53c694c2dccc6486741ae2b94b252fc", + "rawBytes": 10880, + "rawSHA256": "1C4C45986A09ACA8B0048C6455FC8D26E8AE867D098F33DAEBA022648926BA8E" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack5_log.txt", + "mode": "100644", + "gitBlob": "0776b5bee5940c375d35bc98e89d698c9413f51e", + "rawBytes": 1876, + "rawSHA256": "C200B23D7E9AC23516FE4A06B336BD37E88A8962D8AE732D560CF87D358C7B6D" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack6.lean", + "mode": "100644", + "gitBlob": "893edfa680993ef27dcbb09208159c30e07742bc", + "rawBytes": 7305, + "rawSHA256": "3BCBCB3D465FEC21BEC45C598E563D4C87E067418586D014D2FB2C29EC375F6A" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack6_log.txt", + "mode": "100644", + "gitBlob": "0e0a40dcdf63ea6cde5e35767972f0df99d1c26f", + "rawBytes": 1858, + "rawSHA256": "F5CD1251FA50C3D9E171B86C9FD23B14F71AD31F5B9E622F90033F63A69FA1D1" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_cost.lean", + "mode": "100644", + "gitBlob": "7065e8ebceeb983b31f33037509ce517863dbefb", + "rawBytes": 3461, + "rawSHA256": "119E12052AE6DB2EA29B48F91BBAAAF53D186E690A8DA626800F80BABBCABACF" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_cost2.lean", + "mode": "100644", + "gitBlob": "d6c37db3e0499679e4ec1b9334cfe925d3867d35", + "rawBytes": 3082, + "rawSHA256": "5AB2D4175CDD58D4D03E6574A3E88147042D5C58AC2C3A3C5B6840A6C6BEF8AD" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_cost2_log.txt", + "mode": "100644", + "gitBlob": "4936f417a793effa6e2b439f1ed0073990c6adca", + "rawBytes": 848, + "rawSHA256": "9FFD0C739C8E4C62E71B326C1650447D79EE7386202AF2C9054FA95334447B52" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_cost3.lean", + "mode": "100644", + "gitBlob": "469ddc342689ea3712dd82552319cc031d75da55", + "rawBytes": 2309, + "rawSHA256": "719087894B25538525416479E36470294965789DB02315FA437366B287BD72DA" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_cost3_log.txt", + "mode": "100644", + "gitBlob": "4cae1deacca584b633289fe9a73ec72887ea4b26", + "rawBytes": 818, + "rawSHA256": "18904F5683AA4498F2F15933A3DC5795C3F3E1EE52062176A903418320A30262" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_cost_log.txt", + "mode": "100644", + "gitBlob": "090c111c5323c1231366a9f52ab765521da07b44", + "rawBytes": 1423, + "rawSHA256": "C2E7AE10F25CA4D55F80EDA510C58B93F2C8DBFC6B9EAA24F06C55968699B763" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_diag.lean", + "mode": "100644", + "gitBlob": "c720d7d98c00b8da12c38d72a54099d8dfcadb5e", + "rawBytes": 1365, + "rawSHA256": "4B33FBB409CBA895D77F3BCBD7D1C18A259C2B8F214E9FF1891C42A9445D8980" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_probe.lean", + "mode": "100644", + "gitBlob": "afc0226aefd0c5f7df48e26f8a39f3f8bd340b4a", + "rawBytes": 2606, + "rawSHA256": "9E2F7132F6938D86D6E5DCDDB2C6C80752EB5E28F976729ED58C9BBD5BD42D3F" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_probe_log.txt", + "mode": "100644", + "gitBlob": "87d643f0ae0a4d836a154c666814f69e115fbe41", + "rawBytes": 497, + "rawSHA256": "9503178276B9A55ACAF054F957A1C9A597AEB1FCE359F88158F30D0F8D86C03B" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_time.lean", + "mode": "100644", + "gitBlob": "5692578e457e7231676cc20b97c715bda15f3205", + "rawBytes": 2522, + "rawSHA256": "E0AAA845F678834F1D8BAFBA9A52E59D261585C66797A96C083B4D5C13ADBA5D" + }, + { + "path": "docs/internal/f03_evidence/adv_f2_bridge.lean", + "mode": "100644", + "gitBlob": "ce3f026d15e5bb973dea1aeadb73ae51e90debe7", + "rawBytes": 5250, + "rawSHA256": "50E52EC28270573FBFD975879414BF33F8F8262425029E257687B0348FC25326" + }, + { + "path": "docs/internal/f03_evidence/adv_f2_nonstore.lean", + "mode": "100644", + "gitBlob": "d806cc2ed59e15e3014390a0b36e2a2eae089614", + "rawBytes": 4732, + "rawSHA256": "9927255460E4554F48BF483B466FCE7E329F446977015CD39D31C21CB73D0B39" + }, + { + "path": "docs/internal/f03_evidence/adv_f2_reach.lean", + "mode": "100644", + "gitBlob": "7468b985be07efa2347431285c21c33d0ca49436", + "rawBytes": 5647, + "rawSHA256": "F2514A5F08A05F691EA27B9F45630732DEBF8621521EDD2CCC1CE17335185037" + }, + { + "path": "docs/internal/f03_evidence/adv_f34_attack.lean", + "mode": "100644", + "gitBlob": "b7ee196406f9e23a8ec4f39e5f1f8280d4864791", + "rawBytes": 6936, + "rawSHA256": "EE417757DCD423AF0981E4316C4A3E3BE7E7BD47D23369AF794764BB75CFCB7F" + }, + { + "path": "docs/internal/f03_evidence/adv_f34_attack2.lean", + "mode": "100644", + "gitBlob": "5d3fe92753e2ac740e2344e17fe03465b3473bc4", + "rawBytes": 5172, + "rawSHA256": "20757C750C71EEBEC51A09EAFA78836AF13BF779184B9B0E19C0B466DB9F5DE2" + }, + { + "path": "docs/internal/f03_evidence/adv_f34_density.lean", + "mode": "100644", + "gitBlob": "9ee50adae44e409dfbd40963172aa84f06717b48", + "rawBytes": 5446, + "rawSHA256": "3CA82F2168389671A5C948D0614CDB9DB4B70CA9AD6400BFDC4472D85CA58CFE" + }, + { + "path": "docs/internal/f03_evidence/adv_f34_density_out.txt", + "mode": "100644", + "gitBlob": "cae228e346251d73adca25d6311c696f1b01bf91", + "rawBytes": 1275, + "rawSHA256": "869536B3A43BD6D0B1C71D02206EAD28DC4685981AB07BBB192F84B0B4CD7E0A" + }, + { + "path": "docs/internal/f03_evidence/adv_f34_out.txt", + "mode": "100644", + "gitBlob": "93ffe88d303e0b47b86bf8a46fe9d3a58dbe8bc0", + "rawBytes": 3274, + "rawSHA256": "8C600EC1F2DB13AC4E296026C9046C33F4DFCECFD139074D968264ED72A9311C" + }, + { + "path": "docs/internal/f03_evidence/adv_f34_reach.lean", + "mode": "100644", + "gitBlob": "31eb630c6517b8ad50ac7918a7eefa47f5396c0c", + "rawBytes": 2828, + "rawSHA256": "2DF6CB7BEB3EE14C4F666C235F83A3EAB4B97248E0B0C6EC7066F8F1AD4625AF" + }, + { + "path": "docs/internal/f03_evidence/adv_f34_refute.lean", + "mode": "100644", + "gitBlob": "c80408018f5616825b5cd00243b9b85bfc1b714f", + "rawBytes": 7257, + "rawSHA256": "D79B11F3F883BBC73EABAD102BCD05DCCB09281E7D25DDED59DE4E242A4ECC55" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_bign.lean", + "mode": "100644", + "gitBlob": "cc8df582f712480e9a720ecd70d40ad5ec5017a9", + "rawBytes": 5279, + "rawSHA256": "D73855ACF47E9824BCB7EDD9954B8F6A8F6EBBBAB5BFA54ABABDD2B33FE42A69" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_bign2.lean", + "mode": "100644", + "gitBlob": "562510a4f4e84d2b8524274938db6faed42e1e25", + "rawBytes": 5292, + "rawSHA256": "525BD12787316583B2E81C00A0246FCD10952D7CA927C052D0EFFA3F6A217B68" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_fulltrace.lean", + "mode": "100644", + "gitBlob": "fa3fd8108015f3b9dc84d60666687f1992bfbe3a", + "rawBytes": 6097, + "rawSHA256": "35136691B981601D49E721CB3ABAA03CB5FD80F63A65F17E878C8D37DA661F49" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_fulltrace_s.lean", + "mode": "100644", + "gitBlob": "c759d0fe400750f44d4350f07e04f9f650c6dc7c", + "rawBytes": 6090, + "rawSHA256": "2753620A7A2AF10EF52EFDD79D2727BC595C03D07C01C5AD23197E88A60C72E4" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_leafvac.lean", + "mode": "100644", + "gitBlob": "e2ca9442e955844ae3756da9765540748f1b6779", + "rawBytes": 6662, + "rawSHA256": "C4E081289AFB2CBF45CD6440CE4BCB731193B5C05B939A8B373C40A427C8A427" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_leafvac_out.txt", + "mode": "100644", + "gitBlob": "e7bfe7f6ad5c936a963b5680ba6d73c42f091d6f", + "rawBytes": 8800, + "rawSHA256": "77BD455E13B16E310B5185CD16B52B6FF0D6FE97B2685FE74BCC61F3BE9D366F" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_off512.lean", + "mode": "100644", + "gitBlob": "c47494d36f0b80b448f885b4087e46ae2d393f6c", + "rawBytes": 2166, + "rawSHA256": "CBFA26D6C0198544AE27C8695FF9E3990F6D92839FBFB9372EDCCAE1BA629519" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_offsets.lean", + "mode": "100644", + "gitBlob": "dde1c1693ff694c5760ce59bed02f5aa87cc68e2", + "rawBytes": 6403, + "rawSHA256": "09276AF3393F2F958DB3BEDFDFD38D825255C5C8E5628DF90BCB3DB073C4711E" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_offsets_big.lean", + "mode": "100644", + "gitBlob": "5cfe77bb262f39deff282ed4ea1cb4a450c204ff", + "rawBytes": 6411, + "rawSHA256": "200332316AB3C364F897578950F9ABA3D4C7232E7F8D72FF219E9C151C1CB65F" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_sweep.lean", + "mode": "100644", + "gitBlob": "468501e354f740fac5707daded0094a497a9f5bc", + "rawBytes": 4967, + "rawSHA256": "6709633E705AA539189CA7275C26445F05059EAADA75C2EE05260466DEEA7622" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_sweep_s.lean", + "mode": "100644", + "gitBlob": "a3da65ed76ceadde09615e2745e538cd20ab1995", + "rawBytes": 4941, + "rawSHA256": "9A5F7837FDFE19BAED5745A955492074ACE5F6B5017FF62353DF365F14144958" + }, + { + "path": "docs/internal/f03_evidence/atk_crossshape_big.lean", + "mode": "100644", + "gitBlob": "a2e4af929807b383a30cf22ec0cf6c0db1763209", + "rawBytes": 2575, + "rawSHA256": "5EA5EFB7CCF4503EB6ABCD83A6434EAFDE38B709D74CE3F841C5C7395CDDF5E6" + }, + { + "path": "docs/internal/f03_evidence/atk_crossshape_lite.lean", + "mode": "100644", + "gitBlob": "f27d423126edbd06a3d262f3febb246d6c91a84a", + "rawBytes": 1268, + "rawSHA256": "F574EF8A142D5E144FF6AC585A07BD599CFA9A524DF69ED818BFA54B5E37B2AA" + }, + { + "path": "docs/internal/f03_evidence/atk_frontier.lean", + "mode": "100644", + "gitBlob": "d6d3fcdbb0841fa9e861d430ccb59e9c49ea9b48", + "rawBytes": 6516, + "rawSHA256": "C8BC01583CB6E42030F05B4C6EDC62AAC8F12426906906E8BB27E023B7AE32C0" + }, + { + "path": "docs/internal/f03_evidence/atk_frontier_out.txt", + "mode": "100644", + "gitBlob": "ff4796c75fd34868d2c1414697d6f2c6b903f881", + "rawBytes": 8615, + "rawSHA256": "55B1227A8027D7902ADF5EF92575F972F31524E9AFF94164227701D72E800B72" + }, + { + "path": "docs/internal/f03_evidence/atk_guard.lean", + "mode": "100644", + "gitBlob": "58c350e22d246bc7216fb7aee6af6e9ff900ba87", + "rawBytes": 1095, + "rawSHA256": "8333E3DF8C169D83D80D15D275C0981EB629B82CE1FD53F1D6AEE8006372242C" + }, + { + "path": "docs/internal/f03_evidence/atk_lengthonly.lean", + "mode": "100644", + "gitBlob": "c25b1479720b1d899268da2189ae22949bb72c46", + "rawBytes": 2896, + "rawSHA256": "2C3107FD1DFF8C383B79388112D664A029DD913021A186F0CCB0A014E45111CB" + }, + { + "path": "docs/internal/f03_evidence/atk_linchpin.lean", + "mode": "100644", + "gitBlob": "fdaeca8c6b6dbe798a79172aa7220dddbe909e45", + "rawBytes": 8771, + "rawSHA256": "2A71020C34E62B369225C997CBA34BAFD713CA1A61917EB666E290ADCDAF5046" + }, + { + "path": "docs/internal/f03_evidence/atk_linchpin_out.txt", + "mode": "100644", + "gitBlob": "e59677e40021e324c8807e5fa1507ea7281dc290", + "rawBytes": 5870, + "rawSHA256": "E1C52D2378792F9AFE4220EA81A2C8962936E81013B31FFDE53C79F9F8F14F53" + }, + { + "path": "docs/internal/f03_evidence/atk_paths.lean", + "mode": "100644", + "gitBlob": "64dde886a22309b6aa5787c8fd1593b5e11fb8dc", + "rawBytes": 5578, + "rawSHA256": "269218005EFB0467CAC80E56A3FE4AD62066DB623881E1FA1F43E79C74278F3B" + }, + { + "path": "docs/internal/f03_evidence/atk_paths_out.txt", + "mode": "100644", + "gitBlob": "4847fad7938024eb1845042418b9e11b44ed64b8", + "rawBytes": 16931, + "rawSHA256": "3E22F9058195FC1203DD9D5CA706B395BE310955957DCBB2CFBF37485D20F8AC" + }, + { + "path": "docs/internal/f03_evidence/atk_sizeonly_eval.lean", + "mode": "100644", + "gitBlob": "e7428fe7e3c087bc21424aa80eb209a28ce483c9", + "rawBytes": 2669, + "rawSHA256": "03AD661C712E20D03BAA5381949D3AED6C6CFD138385F69F0A2990D6028B1AD6" + }, + { + "path": "docs/internal/f03_evidence/atk_taint.lean", + "mode": "100644", + "gitBlob": "44fdf1b596615d3dbad8952bfba4655248d18538", + "rawBytes": 6960, + "rawSHA256": "1E5F7047CBDE50615B372D07E138CC4FA713823CC5258C7D0AA1168A941BFC01" + }, + { + "path": "docs/internal/f03_evidence/atk_taint_out.txt", + "mode": "100644", + "gitBlob": "598102a099c916b944845993c7c86ca4e6f845ca", + "rawBytes": 3540, + "rawSHA256": "14E8FA27B8AB71462064A8BAC599FEF2BFCA93DDDD3A2AD00C7DA3408698AAD2" + }, + { + "path": "docs/internal/f03_evidence/c06_comp_antivac.lean", + "mode": "100644", + "gitBlob": "2f97fcfb8f38f24e64d78c5c57c8b23031f5d0d3", + "rawBytes": 2313, + "rawSHA256": "0A1B36E6F54014C0F48DD31507C4BCBE5D5B53614667AC13D04A8B92C2E7952D" + }, + { + "path": "docs/internal/f03_evidence/c06_composition.lean", + "mode": "100644", + "gitBlob": "348134a02687f616ba2643900887f253f39d4694", + "rawBytes": 2501, + "rawSHA256": "7562D98D3A17F6C7D3F38D90B2A0504540B01F83BE01077374F3BF32D36C13B7" + }, + { + "path": "docs/internal/f03_evidence/c06_f03_final_check.lean", + "mode": "100644", + "gitBlob": "034321cc0fd222658d34ad102a7ad0afbdb40ecf", + "rawBytes": 4036, + "rawSHA256": "FCF978516EBA22ED0563AEF720D30AB2354BE18455EFD182F7ACD2AC2FCB82C0" + }, + { + "path": "docs/internal/f03_evidence/c06_sourceinventory_check.lean", + "mode": "100644", + "gitBlob": "eda401aea5c91bdfda2801c66042087f321b9a4b", + "rawBytes": 1471, + "rawSHA256": "21725F258A614369613052F0DC472B30E5C4030C065DDB7D3E51C7D2A57C3805" + }, + { + "path": "docs/internal/f03_evidence/dpR9_f34_attack.lean", + "mode": "100644", + "gitBlob": "dbdee3e0ba4ad3880071da0e486bb626e5d454f1", + "rawBytes": 7402, + "rawSHA256": "6FE38F8BF3264838E475D4AADA116B88A82D93040E1C6F7FD0950C19628EBDF4" + }, + { + "path": "docs/internal/f03_evidence/dpR9_f34_regimes.lean", + "mode": "100644", + "gitBlob": "1266b9e1c0879378aabbda28209ccb968973f978", + "rawBytes": 2391, + "rawSHA256": "CC941A4DBB8CF9065194847A4754B782F308E57FAF5165A94F2E3B6963FDF122" + }, + { + "path": "docs/internal/f03_evidence/dp_cross_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_branch.lean", + "mode": "100644", + "gitBlob": "7220b65503936692061aa131eed911eba2e38eb7", + "rawBytes": 15399, + "rawSHA256": "E3676DB775BF5C4ED007FB071B656988C26B0895A3B4655D03EA98E86BACFBD2" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_branch2.lean", + "mode": "100644", + "gitBlob": "f8a5061654ee226d903079eda97be37743edef20", + "rawBytes": 12946, + "rawSHA256": "4B73DCF6934DCF8F918C1960BC13445E315C18ED09E65F856D9ED2BF8CB59B2B" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_branch2_out.txt", + "mode": "100644", + "gitBlob": "9d0d1fc9931dd78984e8d67bc627fdeac1b606f7", + "rawBytes": 22614, + "rawSHA256": "7637F1BD959813CA9217E5FE660EE603D345F59EACABA72DD30626B7BE0A44EF" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_branch_out.txt", + "mode": "100644", + "gitBlob": "12e06a862cd7caa3ebc8e49488d1ff13ab44a503", + "rawBytes": 12335, + "rawSHA256": "7EEAE522AEB9E55A47DC9C6615463D20DFCE7188D1FDA9D974D6686FB70B3204" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_cross.lean", + "mode": "100644", + "gitBlob": "1552e98131b1c0d3a06c81fdaf54d32a21bd52b3", + "rawBytes": 4673, + "rawSHA256": "24AFE12DFE1CDF881C3F53A803308D76621A9CB2ECDAF1363EAABA616DEE9590" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_cross2.lean", + "mode": "100644", + "gitBlob": "811409c44a1b63f3457748256a67e16db9059c68", + "rawBytes": 3947, + "rawSHA256": "16D75CB57208CB4381E732EA228F668968D43B2360B71A4F78CB7B3F00E9A2F3" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_cross7.lean", + "mode": "100644", + "gitBlob": "afdeb218825eb427e72f0df2f5a0a293ed00d89d", + "rawBytes": 2010, + "rawSHA256": "62B14CB14B45942744032E54218D29552EE755C07CE1FED57DCD6231BBB12139" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_cross_small.lean", + "mode": "100644", + "gitBlob": "56d69c962521cec866a30f2b68ed882c4fce58dd", + "rawBytes": 2238, + "rawSHA256": "52DB3D4660D9B1B389A887CD3295BB35CA5C43B9290EE9B025E5735F4C93641B" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_div.lean", + "mode": "100644", + "gitBlob": "3c785e707e976d6d3ce332b0b468f2fceef02075", + "rawBytes": 12292, + "rawSHA256": "9A87571C206083C495961798E4D3616AF3B4241C34EDA5B63951C0020322CDA9" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_div_out.txt", + "mode": "100644", + "gitBlob": "f3bcb53b5c2857526566ba8a49590e33fa920971", + "rawBytes": 23143, + "rawSHA256": "344FF32991D9ECB2A1553454488A2A2E66F176AC8306A8E730340733A6CC8CA2" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_path.lean", + "mode": "100644", + "gitBlob": "bd227cbd4aacfb635eee3a57e4c45b558b83c918", + "rawBytes": 3202, + "rawSHA256": "EEB04F999A9AFFD8E89337CB070B277D5A330B14B3B56A9325D73D1DEA353E82" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_path_out.txt", + "mode": "100644", + "gitBlob": "c455a263894c2bb5ff68a81a2aff32d44759e5e3", + "rawBytes": 11821, + "rawSHA256": "ADEFEC0ECCB0564B977E26680F4BB13B6D8F0D2F42F0511927ACEEF1FE20E947" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_rankfields.lean", + "mode": "100644", + "gitBlob": "ea62f45de157913b4e5abeb59c3642895bb7d67a", + "rawBytes": 2885, + "rawSHA256": "F2CB4DE4A8BE830308ECEA8AF21791B4E0210E4F14453BA8144A3D152D2C260B" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_size.lean", + "mode": "100644", + "gitBlob": "8feca10a722aae6c6dd168714202beaeb5ef165d", + "rawBytes": 8706, + "rawSHA256": "667322712B50A6F5728E9552BC24A029B47C79FB18E1B3700AA1BE7A31D54870" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_A.lean", + "mode": "100644", + "gitBlob": "7b8eeef3b13060b3a8e9fecd1704287b924048ae", + "rawBytes": 4423, + "rawSHA256": "BE1A9179BE11F57AC33E709D1FD0C514370ACE66252C7778E385A41E2C79B735" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_A_out.txt", + "mode": "100644", + "gitBlob": "5175afdc0e54f2ee4c3b62f3aa39dfbba9460a94", + "rawBytes": 627, + "rawSHA256": "066AFF6CB1CC35105E83C4EEC97D6CF7F09DA39BE565DB3E55E83F683B309C46" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_B.lean", + "mode": "100644", + "gitBlob": "c21fa704517e1d098f9b6c51f8d7d660ccd576e6", + "rawBytes": 3763, + "rawSHA256": "10D971DEEE48DABAFFA54924E3DF70A66B572224312D08C90BE6960E6840C2F5" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_B_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_C.lean", + "mode": "100644", + "gitBlob": "e448fbd2f4da3c9238f736909030d5722ed75501", + "rawBytes": 4009, + "rawSHA256": "9B9AC6D036CC9E9FFAEF2CD8512BDC5574786435263A464FB462E47A1CC7C70C" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_C_out.txt", + "mode": "100644", + "gitBlob": "8a531b130c650c9aa117412c8371c83abe06cf06", + "rawBytes": 5379, + "rawSHA256": "BABB25927D442DB2609995AD73AFA4BCEE0F7A78967EE2649299516BBA04BA24" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_D.lean", + "mode": "100644", + "gitBlob": "f82da2852577b4ab389edc53ca5fb795e15c8cfb", + "rawBytes": 4440, + "rawSHA256": "34A73593037E0DD184F45B4B0FB65041AEEB476407B186FC60365FD13AFFFD79" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_D_out.txt", + "mode": "100644", + "gitBlob": "44f84f6f85b0d82fbd1b9ae9954f28f85bddb9a1", + "rawBytes": 5186, + "rawSHA256": "688EE8A5A5F5CEF088C77A63F0112FCDFF5F4F9510356D59C78056B0E78E44E8" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_E.lean", + "mode": "100644", + "gitBlob": "d83d4414bb176462f528c3241e1a11e037871e19", + "rawBytes": 3864, + "rawSHA256": "B1F43DC1DD3C8ECFD57C23C9094351E81DE065C509A2FEE45A707E0BB913A29C" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_E_out.txt", + "mode": "100644", + "gitBlob": "77a43175d4be4d32e746aa2c161d0868d35518c0", + "rawBytes": 3338, + "rawSHA256": "E80519DCD3EE1457F32623F220F7726339270F714EBBE917BCD2EF9B09E5BABE" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_F.lean", + "mode": "100644", + "gitBlob": "2979430ea3033b5bfd0b4f49f11df5d6394282f4", + "rawBytes": 3381, + "rawSHA256": "1315D7FF8CACD60D494C734A87888D4D71552B4FDEA27E1A78E21E66D13EAD1A" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_F_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_G.lean", + "mode": "100644", + "gitBlob": "d91d0c2099dad6f253c786be9d2a4b0f89b070bb", + "rawBytes": 4108, + "rawSHA256": "4C6E970429F82FBC05201D8F118DC5F85F19A559D8BFB06CBC3B0B9FCA0ABD52" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_G_out.txt", + "mode": "100644", + "gitBlob": "c0d5b944d21325f0d059eb90f4b21dffbdbf47dd", + "rawBytes": 85, + "rawSHA256": "C3F33A8FD37784904EA1D7584B8F911520A3C7522FD7D34BE134A513EABCAE7F" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_smoke.lean", + "mode": "100644", + "gitBlob": "de38926d0df08a6b633adc6d2751908cbc8e9420", + "rawBytes": 1424, + "rawSHA256": "084FE3008E9C7C954201C9BA4EDE36F4EF2A882F37ABB98FBD052652F8BEA985" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_sweep.lean", + "mode": "100644", + "gitBlob": "42239a927db37d998c97c50f274462e24f33078a", + "rawBytes": 7022, + "rawSHA256": "2D24D94AEF9B456FD894A00DCB71EDF3FCAEE34AD41B59447384C1002061C445" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_sweep_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/dpx_a3_out.txt", + "mode": "100644", + "gitBlob": "a2e34e9e65f9afe3bb9789afe4e23a303f3fd5e6", + "rawBytes": 255, + "rawSHA256": "7BE6A7EDE7C0882317216D26EB0264F301C2837304532F2882707F937AD48110" + }, + { + "path": "docs/internal/f03_evidence/dpx_a4_out.txt", + "mode": "100644", + "gitBlob": "781126d79d4c919e8a0463cb1e425a8ff80e0515", + "rawBytes": 176, + "rawSHA256": "A756DB83B4865ECC2E0CEAE93D90C1BE205F5C579A8E6CD1F7FEFBAE269ED583" + }, + { + "path": "docs/internal/f03_evidence/dpx_f2_attack1.lean", + "mode": "100644", + "gitBlob": "80b6b8bf9afd7a921c20ff5eb079f2cc0b805110", + "rawBytes": 4731, + "rawSHA256": "B608353BAAA3DD577B33A6E81816B121883E2E78CFD3565A73757D5A9A1402CE" + }, + { + "path": "docs/internal/f03_evidence/dpx_f2_attack2.lean", + "mode": "100644", + "gitBlob": "973a4dad3922541f2ad624169b55442da78fe0ed", + "rawBytes": 5940, + "rawSHA256": "E218A0E43CC0D5ACFA7385FDE6A0407E99BC1EA92ADEF35E472B33C5C867D15F" + }, + { + "path": "docs/internal/f03_evidence/dpx_f2_attack3.lean", + "mode": "100644", + "gitBlob": "9d8e741d66840318b4eb006588a15896c46d8f85", + "rawBytes": 3717, + "rawSHA256": "7819DFB47CC9B60E1B1C1572A4FE2837E07560449C5AA63EEA9668C1DD382E85" + }, + { + "path": "docs/internal/f03_evidence/dpx_f2_attack4.lean", + "mode": "100644", + "gitBlob": "5469b47074ee4a9cfc94c325e592fb9ff98b6da2", + "rawBytes": 3301, + "rawSHA256": "F5909F163270669E0143BD4115D50077AC86B0FDD85BFC2547472E6E261ED776" + }, + { + "path": "docs/internal/f03_evidence/f03_F1_addr.lean", + "mode": "100644", + "gitBlob": "fe95008406fd8c717300af406f4991540049b27d", + "rawBytes": 1623, + "rawSHA256": "B2BBEE3870CFFD11A8B806395325150366990F5DAEDDD1F689BFD3C288E2695D" + }, + { + "path": "docs/internal/f03_evidence/f03_F1_exp.lean", + "mode": "100644", + "gitBlob": "c858176729826a7f86e27808ab2ee6c77106085d", + "rawBytes": 4963, + "rawSHA256": "467411CDCAA0AB0AA18648AE000CBAFF9E60B5825A847D4EBDF677E7A2A031F9" + }, + { + "path": "docs/internal/f03_evidence/f03_F1_exp2.lean", + "mode": "100644", + "gitBlob": "e02cc128d8dafe4e80300a7a25d1acbe72235361", + "rawBytes": 3670, + "rawSHA256": "9A76EA26952635C6FD9F6E3058B90E309AE62C7A8B3753BA572E45C71395E04D" + }, + { + "path": "docs/internal/f03_evidence/f03_F1_exp3.lean", + "mode": "100644", + "gitBlob": "5ac47b2615857dd898aa715091c953afc50ee6e4", + "rawBytes": 4156, + "rawSHA256": "4AC29311D71D30DAE497BD8430E787363547AAB99D3C494B5365E9296E74393B" + }, + { + "path": "docs/internal/f03_evidence/f03_F1_out.txt", + "mode": "100644", + "gitBlob": "665c0b498e86eedcd33480a0c933a8ffa2d5fe37", + "rawBytes": 763, + "rawSHA256": "24FDCD4D940624FD07717F69BF1295A4E1D9A25EB91BE3923CE7F1EEB98CBB97" + }, + { + "path": "docs/internal/f03_evidence/f03_F1_rankleaf.lean", + "mode": "100644", + "gitBlob": "042dd31f38cc540b1eef33834f40792424cc4738", + "rawBytes": 3547, + "rawSHA256": "4ED355EF4760220681BC962ACE60DFD5B8AFC80C6CD5BB2521961DE408BFD2D2" + }, + { + "path": "docs/internal/f03_evidence/f03_F1_thm.lean", + "mode": "100644", + "gitBlob": "09b68dc798d6966c22163270676f26746a6728de", + "rawBytes": 4159, + "rawSHA256": "6C71CAD4F9970E64E5008690F1ABD9F7364FCD6AB24472A6FC043C7A7298486C" + }, + { + "path": "docs/internal/f03_evidence/f03_F1_tiny.lean", + "mode": "100644", + "gitBlob": "099fede6238d5a6577c03b71fd0f5cca51f3f62c", + "rawBytes": 1123, + "rawSHA256": "06A0A4770B7109F7572B28302F71745C6BF960B7F829FAD9A5588372E31C3716" + }, + { + "path": "docs/internal/f03_evidence/f03_active_regime.lean", + "mode": "100644", + "gitBlob": "4b3dd02584af7008b31f3115dba6010a75f862e8", + "rawBytes": 3999, + "rawSHA256": "6B6FE026376A699C71C5CE09DD6CC4CB82DBBCF1C45D82C388782F2C984CDF8F" + }, + { + "path": "docs/internal/f03_evidence/f03_channels.lean", + "mode": "100644", + "gitBlob": "e5adebe754a27016f8771b5d4912848b3a4de59c", + "rawBytes": 4500, + "rawSHA256": "2AF4F79114AC6BCF303F780F10B9D989CBFED69A5518F4518081ED0A65FB59EF" + }, + { + "path": "docs/internal/f03_evidence/f03_channels_out.txt", + "mode": "100644", + "gitBlob": "6c36a456dc19315e32eeeb2f790097a55578154e", + "rawBytes": 1275, + "rawSHA256": "84F8270B146980FF5449407E83BDFF3912C8132072C3C9901262DEA156F17E2F" + }, + { + "path": "docs/internal/f03_evidence/f03_crossshape.lean", + "mode": "100644", + "gitBlob": "eb75f88b15e2d50e5265f62a55de00283fe87370", + "rawBytes": 2553, + "rawSHA256": "FB252ED629102963EECE560B3C0C3A34B6A6D28E2B1C0B5C9FD6DA2CFAB95327" + }, + { + "path": "docs/internal/f03_evidence/f03_crossshape2.lean", + "mode": "100644", + "gitBlob": "33f1bef50891549ddddf7ee22585b60d1b1ec6ca", + "rawBytes": 4420, + "rawSHA256": "4D7A42DCAF2B6A5CCDA439DA1CF73876DECB2DEFBA5D03617A58BB73A3C93418" + }, + { + "path": "docs/internal/f03_evidence/f03_f2_antivac.lean", + "mode": "100644", + "gitBlob": "7de89bebbed5180d65aa0179d6dbdcd1693d459d", + "rawBytes": 4155, + "rawSHA256": "2120BAC991A75C52D4389BF8B9D4A95DDBC0484FDD98CEEC76E000780D3CD5E8" + }, + { + "path": "docs/internal/f03_evidence/f03_f2_axioms.lean", + "mode": "100644", + "gitBlob": "97e131b0f97049da6305ec78a385342f53984f8d", + "rawBytes": 7325, + "rawSHA256": "3BF69A5E58DA9869673963AF233DC889C546AA8E8A3B93084407F9E9F9348F4B" + }, + { + "path": "docs/internal/f03_evidence/f03_f2_parents.lean", + "mode": "100644", + "gitBlob": "db8f52eebbab986e1ccb8d0649e388251f981da8", + "rawBytes": 1861, + "rawSHA256": "61EB1EE480148299CD6F8D294A6A78703D22EA881AE41A5EFD536204FAF2248B" + }, + { + "path": "docs/internal/f03_evidence/f03_f2_path.lean", + "mode": "100644", + "gitBlob": "03ea09fc507dd6fcb57a87a0af67bf4aac7edc77", + "rawBytes": 2164, + "rawSHA256": "8FF5B98BF88BC682594EC92E15A1D46272AF9584B98EE9694A890AC218B94CBF" + }, + { + "path": "docs/internal/f03_evidence/f03_f2_rankgeom.lean", + "mode": "100644", + "gitBlob": "65d4b6b88ba6be0a9b45317406183396ef93ba56", + "rawBytes": 6932, + "rawSHA256": "9CE9C2F0910C51BD24E6098884EB39F21A1DE6E57C9A87B2FC13FEF4A0EF0424" + }, + { + "path": "docs/internal/f03_evidence/f03_f2_segments.lean", + "mode": "100644", + "gitBlob": "0449a72bc695623267bee384af310856f09cfb1d", + "rawBytes": 2920, + "rawSHA256": "156CA2DBD8A0F05D7B532377771ED4D03D4B85395ABFB4B9A978AC929208E408" + }, + { + "path": "docs/internal/f03_evidence/f03_f34_binders.lean", + "mode": "100644", + "gitBlob": "9489b1fb7aa4790215fc38c09547d6b525026c8d", + "rawBytes": 1901, + "rawSHA256": "EDBEFC26C92467A5E4D45F5574EF5D091E450B793CB7E11E522A5EB8D303016B" + }, + { + "path": "docs/internal/f03_evidence/f03_f34_ir.lean", + "mode": "100644", + "gitBlob": "4a0274ad4bee6f5dadaff710691bc90dc7d46b17", + "rawBytes": 1444, + "rawSHA256": "8790411CC51CBA2B7DC3BF1AC6955E43089EEF3DC00F54990FBF1D2EA1D2A12E" + }, + { + "path": "docs/internal/f03_evidence/f03_f34_overhead.lean", + "mode": "100644", + "gitBlob": "4c6e7fa6bb74dbb2a90d2f9d74f207ec6c941c10", + "rawBytes": 4523, + "rawSHA256": "812190DD2E343E1261DF21CA1C2FA7450EA72FEE8564504C67CEEC0B4165F97A" + }, + { + "path": "docs/internal/f03_evidence/f03_f34_reach.lean", + "mode": "100644", + "gitBlob": "5d4bd56cce3c0bca06eb008becf0b5ce30ccd3bb", + "rawBytes": 3642, + "rawSHA256": "E086ECC745815754F5E109C41A167D191177F390EC3563EDA67E00B9C5BF6B99" + }, + { + "path": "docs/internal/f03_evidence/f03_interior_geom.lean", + "mode": "100644", + "gitBlob": "bbbc40c93d2ee4efbcca8fca1f57b62907e6ab32", + "rawBytes": 4487, + "rawSHA256": "0783D8EE32AEA6522F7175EFAD08419A471268038B451FD9F20400ED67BCC374" + }, + { + "path": "docs/internal/f03_evidence/f03_inventory.lean", + "mode": "100644", + "gitBlob": "783a3928c07ee4f069196d863f0db3ac0e69875a", + "rawBytes": 5418, + "rawSHA256": "9DEEAF33D994FD1DC74A5DB8D4A1C0613ABC5175E3D0456EB258CF3B9753652E" + }, + { + "path": "docs/internal/f03_evidence/f03_inventory2.lean", + "mode": "100644", + "gitBlob": "ec44b986b684c2ba1e72111140b0175d3e4e0403", + "rawBytes": 7292, + "rawSHA256": "089622DCBA16FFBA40600EC79F8F20DB988E51B34D17776DC0B9F2453BBC6800" + }, + { + "path": "docs/internal/f03_evidence/f03_inventory2_out.txt", + "mode": "100644", + "gitBlob": "f6c6dcbeac2767ddb228b31047834ad285fd0744", + "rawBytes": 4884, + "rawSHA256": "B7853677D2D0BC40420BEDE0ED3255A15A21B3FD5059E5AA4F2DFD37942ED950" + }, + { + "path": "docs/internal/f03_evidence/f03_inventory_out.txt", + "mode": "100644", + "gitBlob": "a6fae513c50cf3f369c91ad0a2aa04d18b16c878", + "rawBytes": 13069, + "rawSHA256": "24940C9D7D405D7605DC4BC8ABA41384FD21DA63C6B12A4B6065613177BC3AD4" + }, + { + "path": "docs/internal/f03_evidence/f03_lca_leaf.lean", + "mode": "100644", + "gitBlob": "a42e2d4e526580a24b76205f770d606b292beb4c", + "rawBytes": 3393, + "rawSHA256": "7A5607FCE727ACFBF5FCC862519EF2A9AD9A580B9718E46D6D1DDB925D2612F2" + }, + { + "path": "docs/internal/f03_evidence/f03_lca_min.lean", + "mode": "100644", + "gitBlob": "47a15334946e6e35551c57ecf9bf4cdde1e82093", + "rawBytes": 2651, + "rawSHA256": "FD261ABDBEB58BDC55B579343087B818FB3DE1A21C5E0C5AA57CCCA317E62445" + }, + { + "path": "docs/internal/f03_evidence/f03_lca_min_128.lean", + "mode": "100644", + "gitBlob": "47a15334946e6e35551c57ecf9bf4cdde1e82093", + "rawBytes": 2651, + "rawSHA256": "FD261ABDBEB58BDC55B579343087B818FB3DE1A21C5E0C5AA57CCCA317E62445" + }, + { + "path": "docs/internal/f03_evidence/f03_lca_min_256.lean", + "mode": "100644", + "gitBlob": "6eedfcbeacfa503d07c1e803b844dafea6051647", + "rawBytes": 2651, + "rawSHA256": "D6FA4D50F083C572FE32C50EC8BCC6C201B59A2706BF05BF1AE34F2EB39EA878" + }, + { + "path": "docs/internal/f03_evidence/f03_lca_small.lean", + "mode": "100644", + "gitBlob": "27b5b63e006b34ebfc7aa25013245d66b34316c6", + "rawBytes": 3385, + "rawSHA256": "7CF60BC044344BD1FDA6497FB4AB81E5E0550650C7BBE5312FC161175E798C14" + }, + { + "path": "docs/internal/f03_evidence/f03_longflag.lean", + "mode": "100644", + "gitBlob": "36e5677773418bdffaccf5346afb686107c38a1c", + "rawBytes": 4431, + "rawSHA256": "3C72F2C3C8E6279D99EEE4593EDC0D5C34540C607CA37D9F91460B0D8D76E9CC" + }, + { + "path": "docs/internal/f03_evidence/f03_probe.lean", + "mode": "100644", + "gitBlob": "5e08bbe10c33e807533a3f86506a8c9a0ee2e03d", + "rawBytes": 454, + "rawSHA256": "07BB8CFDD6C17D901735C9C00F484EB2A5142DCC547E58893F2EBC46DD7FC8EC" + }, + { + "path": "docs/internal/f03_evidence/f03_regimes.lean", + "mode": "100644", + "gitBlob": "38b85bba93964ff7280ff90cabfe99d2f85d426b", + "rawBytes": 3928, + "rawSHA256": "EABF83B15B44F8632B96C0DE7A4C75FB1A8277E812F255243BB3D9C23CFEFE50" + }, + { + "path": "docs/internal/f03_evidence/f03_sel_n128.lean", + "mode": "100644", + "gitBlob": "30fca7bbbf98422021821312656c1fa1564bfa8a", + "rawBytes": 5138, + "rawSHA256": "9A5A5BE37C438B10C400333EFFF52E97FA604DC451A762B7F23DB441D08C81FD" + }, + { + "path": "docs/internal/f03_evidence/f03_sel_n256.lean", + "mode": "100644", + "gitBlob": "7ae7cdf9d3446020818d51ead1ac499f216ead6b", + "rawBytes": 5138, + "rawSHA256": "6F6E8ECF80EA3541A5D9B3B6EEE5C229B509085C8279DD4C391F9B54597AB8A2" + }, + { + "path": "docs/internal/f03_evidence/f03_sel_n512.lean", + "mode": "100644", + "gitBlob": "cf4e16759c4e9211d6a7465e959ea4b8038308f5", + "rawBytes": 5138, + "rawSHA256": "346DE79677AA63E6AE5C66CF3E0F37E7D839A360C13EEFB14B03F007D930C23A" + }, + { + "path": "docs/internal/f03_evidence/f03_sel_n64.lean", + "mode": "100644", + "gitBlob": "5371b6a8a539d651914b941bd98b81d16616e8b2", + "rawBytes": 5137, + "rawSHA256": "9CE2AA8B1430A1FDAB315E44253F1971F9E0BFD4B253E9AAC6409316B97433D7" + }, + { + "path": "docs/internal/f03_evidence/f03_select_leaf.lean", + "mode": "100644", + "gitBlob": "332e818a483c3c4c647117e64040103086cc563f", + "rawBytes": 5145, + "rawSHA256": "AB974A1ED7C7433B5291B30A2A1CCC34455DABA3D98CB24564A0B2C7CE735FD2" + }, + { + "path": "docs/internal/f03_evidence/f03_select_leaf_n8.lean", + "mode": "100644", + "gitBlob": "1926fe2339d94da67c9ab5fd603c5105ed3f2029", + "rawBytes": 5136, + "rawSHA256": "527D203149A86C13CD1012B3504355426B7252FD2443F61D90173CC89D124F37" + }, + { + "path": "docs/internal/f03_evidence/f03_superlong.lean", + "mode": "100644", + "gitBlob": "33078301253b2114dde1d46402ab02524deb2081", + "rawBytes": 6095, + "rawSHA256": "84C5D3614BF005FD5E39D2624C7674EE0A071E02131EB9BF534A50054BEF22A2" + }, + { + "path": "docs/internal/f03_evidence/f03_theorem_probe.lean", + "mode": "100644", + "gitBlob": "a40b95b2d71715c239aa559c5cddff51d6b85c31", + "rawBytes": 5483, + "rawSHA256": "E6854514164FA743F37529760F52EEC7CBB7974D27FE9086B6918FE1D910A3A7" + }, + { + "path": "docs/internal/f03_evidence/f5_big.lean", + "mode": "100644", + "gitBlob": "0497bc80351badd31e79b2f6323482e682a21dc0", + "rawBytes": 4394, + "rawSHA256": "6A70C05D49A97CDAEE6AD98D1B07E5CDF12BCA535FB06C92096746E0A5A569E8" + }, + { + "path": "docs/internal/f03_evidence/f5_big_out.txt", + "mode": "100644", + "gitBlob": "ba01b9dc8b276e8a93f411cdf80689b4ac7f7d3c", + "rawBytes": 2208, + "rawSHA256": "540C082AAE24F5CFFE326D1FC913CA69E9A3808D9B3ED91EC30BB629D9B275C7" + }, + { + "path": "docs/internal/f03_evidence/f5_callers.lean", + "mode": "100644", + "gitBlob": "5e33d2175ebe11156f7c079953a982e8b2c4aa59", + "rawBytes": 4289, + "rawSHA256": "9B76A8EB662BAC79D6E16C30290077FD9B96C6BE6556EF947DD8AC7B5407B1DD" + }, + { + "path": "docs/internal/f03_evidence/f5_callers_out.txt", + "mode": "100644", + "gitBlob": "4d7345fb66a280a6e6154addb9bea4c920dd0a19", + "rawBytes": 17460, + "rawSHA256": "4C8B8E4938FFD567A9C59F214A3C1FF31ABE3ADCABD785AB5E9FEB2F8847F85B" + }, + { + "path": "docs/internal/f03_evidence/f5_exec.lean", + "mode": "100644", + "gitBlob": "bfa31907bd1d9b921ba6b420afe08fbfa97ba70a", + "rawBytes": 4210, + "rawSHA256": "317675D693B55A28BBA97E18A28851E81365398C7EF592F12810F8A77CBEB4CF" + }, + { + "path": "docs/internal/f03_evidence/f5_exec2.lean", + "mode": "100644", + "gitBlob": "7d08b1d97db34699fd49f5c1994e88b8fc9918cc", + "rawBytes": 3429, + "rawSHA256": "07C92D730E1AB45FC5CB89786ABF0E845439D0BD20E4797BCF05D2B75D4BEE87" + }, + { + "path": "docs/internal/f03_evidence/f5_exec2_out.txt", + "mode": "100644", + "gitBlob": "20194e78b5b81f9f3beb7dc54f3f1b06831405b6", + "rawBytes": 1892, + "rawSHA256": "D1425FFE7C3B699FC5EC709B7792F8539CB9928A5CF3D854F4104CFC9AB4DA17" + }, + { + "path": "docs/internal/f03_evidence/f5_ir.lean", + "mode": "100644", + "gitBlob": "30c1a460fb58e66fc44ba3ae698fc2d197394e5b", + "rawBytes": 3485, + "rawSHA256": "F02C499EBA77BDF2C8B49133914322C681107649AE2BB9237D5686B8D2D30A0D" + }, + { + "path": "docs/internal/f03_evidence/f5_ir_out.txt", + "mode": "100644", + "gitBlob": "e15b7435d9a722d70c90e3daecf4d34567f49520", + "rawBytes": 1383, + "rawSHA256": "47DE9E5862FC60913939B78694B963A1320E64BD7ED7DF93DB654E091B514DB8" + }, + { + "path": "docs/internal/f03_evidence/f5_irdump.lean", + "mode": "100644", + "gitBlob": "6785d35fe058b51a25dc01aebdf49b81d3f99235", + "rawBytes": 1469, + "rawSHA256": "FC930F6F46C87B6377264645F455CE2E17DA0C6224BCEBDBBCB48D8C9C909A90" + }, + { + "path": "docs/internal/f03_evidence/f5_irdump2_out.txt", + "mode": "100644", + "gitBlob": "163e2ed966a04181124298bb1e910739de6d7a0f", + "rawBytes": 11490, + "rawSHA256": "05522143B255326C82F74B73CDFCCEDF00A80BEF8D206E14D7FBA02D050EBBB7" + }, + { + "path": "docs/internal/f03_evidence/f5_irdump_out.txt", + "mode": "100644", + "gitBlob": "67787ae9fa3412120eababd75db80416ca05d43a", + "rawBytes": 9393, + "rawSHA256": "7978DB838C50AD9DDCC6A33042AEE99FF2691B293464BFE267D4940C31D3771A" + }, + { + "path": "docs/internal/f03_evidence/f5_irpath.lean", + "mode": "100644", + "gitBlob": "73a3d1ef6bd977f1ace93e94f601b83cf793dbbe", + "rawBytes": 3530, + "rawSHA256": "3A90C0A59480C275FC19AC6B909AA67B5C7C2029919470568FE6FDF4373D78F0" + }, + { + "path": "docs/internal/f03_evidence/f5_irpath2_out.txt", + "mode": "100644", + "gitBlob": "93106df0732ca5c5cb52baac5c7d8a04bdb7ed4f", + "rawBytes": 15806, + "rawSHA256": "102626723D15C2A38B802E3FED38A28AEDE36BC08F731C717B673B3F3D5E2032" + }, + { + "path": "docs/internal/f03_evidence/f5_irpath_out.txt", + "mode": "100644", + "gitBlob": "74b1754797e56dbc388b92584826028967ee9272", + "rawBytes": 6022, + "rawSHA256": "B9F8E9875EBA9EE3A4FB4618E453279B008565F01B0B2865EB3B3B7E574A2B2C" + }, + { + "path": "docs/internal/f03_evidence/f5_lemma.lean", + "mode": "100644", + "gitBlob": "80124f4651a810c6d5e4312cd2fcb70dd8b59952", + "rawBytes": 5008, + "rawSHA256": "5F0F2ABD47EB14E69E4A7534738E02BD5BFF169214848FB02E4720885E360072" + }, + { + "path": "docs/internal/f03_evidence/f5_probe_api.lean", + "mode": "100644", + "gitBlob": "ec80405988a4491d58a13a7de7a6fde25754593f", + "rawBytes": 482, + "rawSHA256": "D6E0E6DCA6591BE76AFEA526017B65D0EA0EE0D04955FD034ABB5CED09AD9168" + }, + { + "path": "docs/internal/f03_evidence/f5_probe_api2.lean", + "mode": "100644", + "gitBlob": "d909f7ed95447f006f33f3421e1c7d7e04bd6875", + "rawBytes": 173, + "rawSHA256": "B1557D922083C2F7B5BD6A9471ED5528504F01A2D8AAAF39CD1F872B9BBF8CCE" + }, + { + "path": "docs/internal/f03_evidence/f5_probe_api3.lean", + "mode": "100644", + "gitBlob": "ed55b160447844d334d004606a69920a62458b78", + "rawBytes": 86, + "rawSHA256": "ABE18C884DB8B73A7039F9E3488FA185DA43D0532A8580C7E4C63A594E7CE979" + }, + { + "path": "docs/internal/f03_evidence/f5_subgraph.lean", + "mode": "100644", + "gitBlob": "d4290a61be01c8a96485eb686adfcffde6546334", + "rawBytes": 3226, + "rawSHA256": "B942B1A2116605858F9F138CBD8018E0F3002E96A5AA7ED1BC45EFB6436813F2" + }, + { + "path": "docs/internal/f03_evidence/f5_subgraph_out.txt", + "mode": "100644", + "gitBlob": "1f73429cec2046ddf711e228354e4f4b2a411c41", + "rawBytes": 13185, + "rawSHA256": "1C4B62DEE61AE6735C71284137B55071CD4BF69AAD337F7BEB4A4EC51CA86645" + }, + { + "path": "docs/internal/f03_evidence/f6_bits.lean", + "mode": "100644", + "gitBlob": "c2d68ed0efb2fd549428d231b0cce9fd10d9ee67", + "rawBytes": 5230, + "rawSHA256": "813F4E832E343A0BCB08B566D769CEB1281696398762B24A69EBC763E1DDEE3A" + }, + { + "path": "docs/internal/f03_evidence/f6_bits_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/f6_leafL1.lean", + "mode": "100644", + "gitBlob": "8671df42044ffbacb365c86963b4c275bcf6090e", + "rawBytes": 7097, + "rawSHA256": "330B31B3BC95DA93D03BF511D8B1427D711A37430AF4A8FFEC6375A97F012D11" + }, + { + "path": "docs/internal/f03_evidence/f6_leafL1_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/f6_proj.lean", + "mode": "100644", + "gitBlob": "3717dfca5e83ebe3b229fb4d95d1912a76a33dd1", + "rawBytes": 3205, + "rawSHA256": "290C1663501829EEC6D5DA38CA8DED67D1F4ED0921C54848C0450275DD302D59" + }, + { + "path": "docs/internal/f03_evidence/f6_regimes.lean", + "mode": "100644", + "gitBlob": "fdd6dd93b2843b05f57142abf2ff7bdba222b365", + "rawBytes": 4873, + "rawSHA256": "13085CF745918220641A4D26EBCB3E7C94AA32BF1A31B7720E5B8B4FB80451C5" + }, + { + "path": "docs/internal/f03_evidence/f6_rfl.lean", + "mode": "100644", + "gitBlob": "c22f5c8a8bc9f7db571b239ec7c47a44cca12fe8", + "rawBytes": 2185, + "rawSHA256": "A1343E4871B1206BF49C538961244A4E2EA3C75B5D230D133355E44FF23FCF18" + }, + { + "path": "docs/internal/f03_evidence/f6_rfl2.lean", + "mode": "100644", + "gitBlob": "70184be4f0f248776c39e53053e2e44a352abc57", + "rawBytes": 1247, + "rawSHA256": "C69F62DD8F0DC5854D425DEEA8B12F6CCFD89DD35E68717FA8F536E04E3B380F" + }, + { + "path": "docs/internal/f03_evidence/f6_rfl_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/hdr_f34_ax.lean", + "mode": "100644", + "gitBlob": "9bf2309ed6e32cefb04b0613d0bfeebb44a6dbf5", + "rawBytes": 3873, + "rawSHA256": "41AA69E1ADC1EA1FCE304190F054C9815819709355A807F0C1263A8A8C7A494E" + }, + { + "path": "docs/internal/f03_evidence/hdr_f34_thm.lean", + "mode": "100644", + "gitBlob": "c4c9f4d2716d0b5852fe19a2b1141e07c5a67005", + "rawBytes": 3683, + "rawSHA256": "DEDC76ADB09CFEE0E59333E8B6DDA34FC7FC043EBC0C0E7ADE69D0585527BE56" + }, + { + "path": "docs/internal/f03_evidence/hdr_offsets.lean", + "mode": "100644", + "gitBlob": "772b563dbf86cd2a7b039673b63fcd371f386cb7", + "rawBytes": 1319, + "rawSHA256": "D524C6FD0C6B65A033222F34E2CA9B95EA36E05E30A9CB9D66817BF7F386D655" + }, + { + "path": "docs/internal/f03_evidence/hdr_scalars.lean", + "mode": "100644", + "gitBlob": "e59d99ee50c2e11b8c17d0136d69683b67d97cca", + "rawBytes": 3252, + "rawSHA256": "4EF456FFD923B83C1116DF75F43649D3896FFA4ED86DE4BFD95BD4A9579EE229" + }, + { + "path": "docs/internal/f03_evidence/hdr_scalars_out.txt", + "mode": "100644", + "gitBlob": "5f3eb5a09adb65cdda6c7e4376c786340b3f3f6d", + "rawBytes": 2951, + "rawSHA256": "4890EE0AE3938D0295286D82B17F4B89FA1DB0AEF16C70623F1121560A30B8CB" + }, + { + "path": "docs/internal/f03_evidence/hdr_schema.lean", + "mode": "100644", + "gitBlob": "805b61fd500ea4901c226dc14bcadc5438ef95d8", + "rawBytes": 4421, + "rawSHA256": "D54AAFCD32A0F0A08CC613567C084B035359427DAD9CBE21C7B5CFD42ADB45FD" + }, + { + "path": "docs/internal/f03_evidence/hdr_schema_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/hdr_seglen.lean", + "mode": "100644", + "gitBlob": "dae0b5dfe5ac59951e432167fe86c2464e69ac5e", + "rawBytes": 3727, + "rawSHA256": "0DE7625F56D03D997D8FDB4D91EDF3FD19D0680C062E23F835C88B89E44152BB" + }, + { + "path": "docs/internal/f03_evidence/hdr_seglen2.lean", + "mode": "100644", + "gitBlob": "1fd2b2e52ffcd96a7150bc68314d978d6135e140", + "rawBytes": 3425, + "rawSHA256": "252C1A8DBECB1355EC5CEBDF292F9A0478DE57EC7F6E188FE2E58B96DF81D2E8" + }, + { + "path": "docs/internal/f03_evidence/hdr_seglen3.lean", + "mode": "100644", + "gitBlob": "c58539bb5b291777c377fde1a237c1a41792f105", + "rawBytes": 3452, + "rawSHA256": "896D31245CA12CE438EFE3DF409DCBE1354728E553FBF2EE593437A4120A7591" + }, + { + "path": "docs/internal/f03_evidence/l2x_l2_crossblock.lean", + "mode": "100644", + "gitBlob": "b4413cf9afdd28aa1100ba33af9098eb880495e9", + "rawBytes": 37772, + "rawSHA256": "2F6794C883C636D715F92C9541BDB1AA88C87AAE116BD29C11AF7B92561724F0" + }, + { + "path": "docs/internal/f03_evidence/l2x_t4_capstone.lean", + "mode": "100644", + "gitBlob": "9853ce2593e9b5229606ca8c20e22bd493375b89", + "rawBytes": 63283, + "rawSHA256": "CB046722A7492DC69C1EC4ACF8D43A93E440255C46D1D0C9248DA9F3241EDE84" + }, + { + "path": "docs/internal/f03_evidence/qz_int2.lean", + "mode": "100644", + "gitBlob": "8d5d27cd93e1c6f3fe3eeb7b5368c1f1c50bd558", + "rawBytes": 3269, + "rawSHA256": "58D0B95673C711FDC4AA8AEBC8B85378121F9678F9AA357438455D304F501E44" + }, + { + "path": "docs/internal/f03_evidence/qz_int2_out.txt", + "mode": "100644", + "gitBlob": "7fd17bb50da1cdaf9d8486481d4341a5c4cc77cc", + "rawBytes": 1419, + "rawSHA256": "A5325F98D2EB5C0B166DD1FC5BFBD568C1990F2F921DA4CB59E1E9A60C84D7B1" + }, + { + "path": "docs/internal/f03_evidence/qz_interior.lean", + "mode": "100644", + "gitBlob": "357bf73daa9de5f1c568cfd0b386725277b6db82", + "rawBytes": 5953, + "rawSHA256": "1F11D08F9E6DF252B475EE65F45336AA105F9BFA982804714FD5120BFADD2A63" + }, + { + "path": "docs/internal/f03_evidence/qz_interior_out.txt", + "mode": "100644", + "gitBlob": "31196019932a80cf35393f245e25bd901646c846", + "rawBytes": 318, + "rawSHA256": "A357DCFF5D8D24A42D99DF7F953D386E7162FFA77F4D33686A9E22F6A6BE00F0" + }, + { + "path": "docs/internal/f03_evidence/qz_mech.lean", + "mode": "100644", + "gitBlob": "0893b968ac272932af2970ed4104776f6a479523", + "rawBytes": 8325, + "rawSHA256": "A1513D0B146BFDFE5A4F67106C98B74D840FDA151449511886E0ADF51396455C" + }, + { + "path": "docs/internal/f03_evidence/qz_offsets.lean", + "mode": "100644", + "gitBlob": "f4c2930ce4e7b877ab28bac9136ad4c30b9d1a3e", + "rawBytes": 6013, + "rawSHA256": "DA4A9D7D17D32820530259ACF60087C94C4C1FB54657DE80A4ED8183DFD96397" + }, + { + "path": "docs/internal/f03_evidence/qz_popcount.lean", + "mode": "100644", + "gitBlob": "cd3be9c108bebb6003adca644cc8c206273e983e", + "rawBytes": 2249, + "rawSHA256": "FEC09D8422664441C1762E181384FB41224171B8A7E7D24DD409F91F09CC4F2E" + }, + { + "path": "docs/internal/f03_evidence/t1_c06_verify2.lean", + "mode": "100644", + "gitBlob": "84304e4d585f2549eb6e1712054f8a246bdad6d0", + "rawBytes": 14160, + "rawSHA256": "FF5C6486B74A4633D61AD8120F1DF04ACA0D6BAE33764D4807A9EBC98B2F8446" + }, + { + "path": "docs/internal/f03_evidence/t1_readprogram_core.lean", + "mode": "100644", + "gitBlob": "7e5e1851eb13c9a1854fc037d57bfeaabd69cea2", + "rawBytes": 2572, + "rawSHA256": "72DD83DEF761F62F0CD6FDB8BC27887D4BB79A3A22278DB87DC6584076887F53" + }, + { + "path": "docs/internal/f03_evidence/t1map_layer2.lean", + "mode": "100644", + "gitBlob": "5f873a222883ccd63aad70cad11fca8e4224cf52", + "rawBytes": 11131, + "rawSHA256": "A0DD737A57CE39218B2DF4BCD3DE87125ECB6DA9095B41EFD9B1B82FDFC1E3F9" + }, + { + "path": "docs/internal/f03_evidence/t1map_obligations.lean", + "mode": "100644", + "gitBlob": "8056c5290f89d73830111c9aca683cb150c8c6f5", + "rawBytes": 7826, + "rawSHA256": "7FC0CB5C4E37AD602555505B60E7F1545D49D112D182434845F82D553A970518" + }, + { + "path": "docs/internal/f03_evidence/t1map_route.lean", + "mode": "100644", + "gitBlob": "09bd3e69dbdc6c7254f3c0c5f04ce11d372b6572", + "rawBytes": 4141, + "rawSHA256": "9EA9C2AD2D43A9EDF775A8B5B3FA5AAA0A22AAE15B7D611DDE7ABF56CA67B0F9" + }, + { + "path": "docs/internal/f03_evidence/t2_l2_selector_sameblock.lean", + "mode": "100644", + "gitBlob": "d08c8d26c33644d10eb3f1c7f8d5e162934b4459", + "rawBytes": 24660, + "rawSHA256": "05D87090ABE7B05A3327384F4A53BC7A22CB2D66B0CE3B4BCF5E5DB029F59160" + }, + { + "path": "docs/internal/f03_evidence/t4pub_audit.lean", + "mode": "100644", + "gitBlob": "e5793847f92b1f2789aecab22523516c9e7ed090", + "rawBytes": 83344, + "rawSHA256": "E6B61FD59CD36369F05A884E1E9280979B15132D4184A5D1FE0DD23BEF2503CE" + }, + { + "path": "docs/internal/f03_evidence/t4pub_public_entry.lean", + "mode": "100644", + "gitBlob": "a37e36481d35e44e985b319b5ed5ae0228ad4019", + "rawBytes": 77302, + "rawSHA256": "64B9A67209449F6CA0921FC74713AC12A776943058E3CE9C6619308C49F59C90" + }, + { + "path": "docs/internal/f03_evidence/w2_l2_l3_interior.lean", + "mode": "100644", + "gitBlob": "56545e891420ab77683e01cf43ec9d7deb18cc46", + "rawBytes": 47927, + "rawSHA256": "631D9D5FE11A515DE500C4BF0FCD4BEA09FC16809F8EEEAA7B7767966004AB9D" + }, + { + "path": "docs/internal/f03_evidence/wq_branches.lean", + "mode": "100644", + "gitBlob": "a462d271c3a74b24a266199079f7fe6a179364f8", + "rawBytes": 4531, + "rawSHA256": "9832F911566E06191FCE1F7381760928312C51193F69CC621442B17C99171120" + }, + { + "path": "docs/internal/f03_evidence/wq_branches_out.txt", + "mode": "100644", + "gitBlob": "d123b254e7edef8fccbc4bfeb037e656e724a223", + "rawBytes": 2795, + "rawSHA256": "224646A2E624F7448486CBB14CAEE72ECCFA755DD6CF56F4FF88140D3F7BC5B6" + }, + { + "path": "docs/internal/f03_evidence/wq_checked.lean", + "mode": "100644", + "gitBlob": "f8f1567aab48bd05beac97dfc7c87338222b47f5", + "rawBytes": 4720, + "rawSHA256": "67AE1E9655F3B5F550E8D7208C11D3618BFFB8A038C5C85D0E4F283FA5D07681" + }, + { + "path": "docs/internal/f03_evidence/wq_checked2.lean", + "mode": "100644", + "gitBlob": "71188940371a4f662b56312130b33d6c66ea6ce3", + "rawBytes": 5591, + "rawSHA256": "F095B01B77EB28DBF70E3252BCBBC48FAD1688AE083E7B69AFF96C2CC8A6D183" + }, + { + "path": "docs/internal/f03_evidence/wq_checked2_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/wq_checked3.lean", + "mode": "100644", + "gitBlob": "d39bb0a960ab2a53c6c8f3cf18772e6997d2687f", + "rawBytes": 2602, + "rawSHA256": "17B5A551BAC25C43E866C73A332F8E74C148FCC4A3FCAC7E49FC2324B387DF2A" + }, + { + "path": "docs/internal/f03_evidence/wq_collapse.lean", + "mode": "100644", + "gitBlob": "3cff617de194f3726122079ed60b791cbb178141", + "rawBytes": 5844, + "rawSHA256": "A4D5586FE84E4703714FEAB6B7D524753D352CCEFAE26ECF39A5F60406CA1C14" + }, + { + "path": "docs/internal/f03_evidence/wq_collapse_log.txt", + "mode": "100644", + "gitBlob": "0fb4f17846405abae42e640476cd0743ce51d3dc", + "rawBytes": 1443, + "rawSHA256": "5D9543C8C0490E79E5D7E4D614EF5A9E09B95E6D598592DB3300A7C1F6EFA086" + }, + { + "path": "docs/internal/f03_evidence/wq_collapse_out.txt", + "mode": "100644", + "gitBlob": "0fb4f17846405abae42e640476cd0743ce51d3dc", + "rawBytes": 1443, + "rawSHA256": "5D9543C8C0490E79E5D7E4D614EF5A9E09B95E6D598592DB3300A7C1F6EFA086" + }, + { + "path": "docs/internal/f03_evidence/wq_extrap.lean", + "mode": "100644", + "gitBlob": "4e1a8f81f7cf0bb1ebeeccdcd311cdeeddbb03df", + "rawBytes": 2469, + "rawSHA256": "F427A2B28415ED299A5B86F855655141BEACC75B67F1335EC14A1DE587167C08" + }, + { + "path": "docs/internal/f03_evidence/wq_extrap_log.txt", + "mode": "100644", + "gitBlob": "0cd66bc2dc647588151825dde6a3e98e362d5497", + "rawBytes": 1240, + "rawSHA256": "7EE572D596211234D260452AC67695E72CFA585A65904FC7D587D3295456572B" + }, + { + "path": "docs/internal/f03_evidence/wq_extrap_out.txt", + "mode": "100644", + "gitBlob": "0cd66bc2dc647588151825dde6a3e98e362d5497", + "rawBytes": 1240, + "rawSHA256": "7EE572D596211234D260452AC67695E72CFA585A65904FC7D587D3295456572B" + }, + { + "path": "docs/internal/f03_evidence/wq_longfront.lean", + "mode": "100644", + "gitBlob": "715737df3df482e603c320b08133b20a6ba83967", + "rawBytes": 7122, + "rawSHA256": "F244273C60F92A2D826B6A42738F619556BF8CB7746A4476A79641AEE4405C17" + }, + { + "path": "docs/internal/f03_evidence/wq_longfront_log.txt", + "mode": "100644", + "gitBlob": "42eb5b8133f13fe8e06b4ec2e3f0dffea71cd3ac", + "rawBytes": 8462, + "rawSHA256": "DEC58C8C7F66109663DE0CAD2E339F1B704B3E7F47304586FFFC59F06B9E1B83" + }, + { + "path": "docs/internal/f03_evidence/wq_longfront_out.txt", + "mode": "100644", + "gitBlob": "42eb5b8133f13fe8e06b4ec2e3f0dffea71cd3ac", + "rawBytes": 8462, + "rawSHA256": "DEC58C8C7F66109663DE0CAD2E339F1B704B3E7F47304586FFFC59F06B9E1B83" + }, + { + "path": "docs/internal/f03_evidence/wq_mismatch.lean", + "mode": "100644", + "gitBlob": "0aa0c089b80c62f6929969aef66097321f1f57e6", + "rawBytes": 5680, + "rawSHA256": "00838213F9EAB6DC51BD98CA6F8A15199565D019F21B1289ECA1155119422291" + }, + { + "path": "docs/internal/f03_evidence/wq_mismatch_log.txt", + "mode": "100644", + "gitBlob": "b2e43246214b29336f78c7df3165c65dd62b340f", + "rawBytes": 424, + "rawSHA256": "B750B6858C0CA552647FEF31E6F89932C6E908B999BA6176C310E744DEE55E5C" + }, + { + "path": "docs/internal/f03_evidence/wq_mismatch_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/wq_regimemember.lean", + "mode": "100644", + "gitBlob": "4535f5df9f0448a8b907c788fc33571a6b3b28dc", + "rawBytes": 5280, + "rawSHA256": "059333FE2D9EEF1D906991ABDF5CC3F0565573308FAA5D1A586E70BF1AFDDFF6" + }, + { + "path": "docs/internal/f03_evidence/wq_regimemember_out.txt", + "mode": "100644", + "gitBlob": "f6a1b783eb4c357ed1d9841448ad7bc9c7367a7d", + "rawBytes": 2177, + "rawSHA256": "2BEE1FEA839F1F50FF218641A286A90C247AE5BEE6811117A63F0BC9D1148F56" + }, + { + "path": "docs/internal/f03_evidence/wq_sens.lean", + "mode": "100644", + "gitBlob": "6e4143d4fa343f9a4856b75c8176a3402ec68b92", + "rawBytes": 2935, + "rawSHA256": "F4F0273F22676C6799DCCE30616ADEF75229E465205CE63F8CC318C31FA327FC" + }, + { + "path": "docs/internal/f03_evidence/wq_smoke.lean", + "mode": "100644", + "gitBlob": "3265600418e221b59cbe5e3fed563595a88ff605", + "rawBytes": 1459, + "rawSHA256": "6ACFF6A4DFFC7E05C95F2C4B143F13A0D31ECE267D0D8F127BE53437E1D70D0A" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_a.lean", + "mode": "100644", + "gitBlob": "156af0058260edf382e8735c4a211bf11f574713", + "rawBytes": 7123, + "rawSHA256": "1ECE28BC27659F94E89D659919498F465A659E071957F2BAB9A7E5FC35D629C5" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_a2.lean", + "mode": "100644", + "gitBlob": "ff5e0c5cb303041e136b0726da99035cb5297772", + "rawBytes": 6581, + "rawSHA256": "F93A8F51C794C447966BB867D64AB4714158F417C4E46CB0125737DB0570E3E2" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_a2_log.txt", + "mode": "100644", + "gitBlob": "8c0b068c596cedb7691bdc2115012ed738ae10ed", + "rawBytes": 1568, + "rawSHA256": "D286701517FEBEEF11A1793146098C1988A74F44156C5009F8FB66301B44371F" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_a2_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_a_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_b.lean", + "mode": "100644", + "gitBlob": "db4df154bac5195905e33d61e136cf539439cb99", + "rawBytes": 4505, + "rawSHA256": "B854AF791E6A3502E9EF0AC6CC7A586F515DE4347A5DD85F422A406ACBA5A625" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_b_log.txt", + "mode": "100644", + "gitBlob": "ac95899c085c5f1e74e81dd09518e37c3aec55c0", + "rawBytes": 110, + "rawSHA256": "4F0B9AFDE1DD8EF28A97106418D093891B2DD456600185AD07A26B75EFEE53DF" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_b_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_big.lean", + "mode": "100644", + "gitBlob": "799596eadc4bdf80176777ea1764ecd880c073f3", + "rawBytes": 4517, + "rawSHA256": "38F8CB62BC35111CF3EDB9AD36EA09429D605D3E42968635BFA85BC0D942ED14" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_big_log.txt", + "mode": "100644", + "gitBlob": "67b38de33dbc11f0df0daaab99983e9ddbd2f2f5", + "rawBytes": 47, + "rawSHA256": "CD431BD6EAB1AFC189996103EB8618BC63BD0011CF10D73B2C9A14662F03A120" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_big_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" + }, + { + "path": "docs/internal/f03_evidence/wq_thresh.lean", + "mode": "100644", + "gitBlob": "31711fe4452df471ffa21014e32d0375f2537de1", + "rawBytes": 5393, + "rawSHA256": "52E0095B21B5D4E0F4335AD1C720CCFCBF2CBE717033454709E3A79504B98D80" + }, + { + "path": "docs/internal/f03_evidence/wq_thresh2.lean", + "mode": "100644", + "gitBlob": "09a6aadeb60a8640dd77ba206e4e7a7071a0881e", + "rawBytes": 2336, + "rawSHA256": "29B0B34760FEA04B957596C2D2DFBB9944067511507751E984274EF599F44095" + }, + { + "path": "docs/internal/f03_evidence/wq_time.lean", + "mode": "100644", + "gitBlob": "3adea40fea9430f513db739c554841fc24249fb1", + "rawBytes": 961, + "rawSHA256": "CA5DDEBADD082318A6A5C3D5E56FC7DA45D1D363F19A428861DDDA2DD5CED30C" + }, + { + "path": "docs/internal/f03_evidence/zz_blind_diff.lean", + "mode": "100644", + "gitBlob": "b5d90987a13c90a2b2f45656c1d5cba911b8efe0", + "rawBytes": 2277, + "rawSHA256": "C10520EA13913CB583840A6C1C814429366FCB6B0C9B79F7F23C6814BC203659" + }, + { + "path": "docs/internal/f03_evidence/zz_blind_elim.lean", + "mode": "100644", + "gitBlob": "dfbccf01062c03244099186fb73d5d98d984017d", + "rawBytes": 7111, + "rawSHA256": "560C5B8ADF710C4BF453867D1A4229378D15A531B499DE87E5E80D7703639D96" + }, + { + "path": "docs/internal/f03_evidence/zz_blind_elim_out.txt", + "mode": "100644", + "gitBlob": "ae5b87cfb1999fa8175ff9f354065c3a099f0709", + "rawBytes": 22198, + "rawSHA256": "17F3EA3FB57FBABEE3676304BD0C5F58E4409D0FB6853CDCD36758FE2231C0C5" + }, + { + "path": "docs/internal/f03_evidence/zz_blind_invisible.lean", + "mode": "100644", + "gitBlob": "c342506905e21c51315fbf28b95ea84c8995edff", + "rawBytes": 4339, + "rawSHA256": "0E519A145FBBE318A05080CFDD2F116CA0110ADAAF4C08E36480E63475644D6F" + }, + { + "path": "docs/internal/f03_evidence/zz_blind_invisible_out.txt", + "mode": "100644", + "gitBlob": "2558921679801824c8e3d60e97f415ce3836d2fc", + "rawBytes": 5666, + "rawSHA256": "2ABA2832A7378EB42FFA1105E8E78E44EF43E0CE2ADBFFBDD7C1461A6003E86A" + }, + { + "path": "docs/internal/f03_evidence/zz_blind_modes.lean", + "mode": "100644", + "gitBlob": "abddb928b720d2fc1f02dd54a4253c36a27df7f9", + "rawBytes": 6662, + "rawSHA256": "E69C1A28202794B6E6C28D217A9585DD91D903551F50D81B8785A1B1CCD4C921" + }, + { + "path": "docs/internal/f03_evidence/zz_blind_modes_out.txt", + "mode": "100644", + "gitBlob": "1f9aa1ce5c41ad176f1c1aef8f01225021c13b51", + "rawBytes": 1132, + "rawSHA256": "45E751DA968F7A4A92EB124311EF3770A46616E6325D14EEEA556B6C178AAD13" + }, + { + "path": "docs/internal/f03_evidence/zz_blind_rev.lean", + "mode": "100644", + "gitBlob": "66fd0ed69c81b5a92a42c4d7659a13c75b6fd7a8", + "rawBytes": 6624, + "rawSHA256": "1326B9233CD7B439D78EE8A7D9D44CBB662F16D58985E2908C62733E2E62C6A9" + }, + { + "path": "docs/internal/f03_evidence/zz_blind_rev_out.txt", + "mode": "100644", + "gitBlob": "bf8ecb27cc308791dad4088e1860c2de7c9a682b", + "rawBytes": 6744, + "rawSHA256": "1D7F93E5FA1C03B5FB8EF2D3DE92A1DA8DAC2FAC2E846CE720DBB6364E97A063" + }, + { + "path": "docs/internal/packed_query/PQ1_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "d49e00a7c4838ba66d9ac9685abef7ec25598d04", + "rawBytes": 47712, + "rawSHA256": "E9045CBBE821ECC10187FD06BFFA024E69BCA9DC76C93578F271A33D47D55C48" + }, + { + "path": "docs/internal/packed_query/PQ1_CALCULUS_MATRIX.md", + "mode": "100644", + "gitBlob": "7499ee1923d5447d61a5d562816be1dc4f834d15", + "rawBytes": 10206, + "rawSHA256": "28270074AFD2964440C24B5A70C36656949D561A61201C212E319E40DF304A40" + }, + { + "path": "docs/internal/packed_query/PQ1_CALCULUS_PROMPT.md", + "mode": "100644", + "gitBlob": "d65f1754227c5ceb2e4c9bc3a30ecef9765d0b9e", + "rawBytes": 6946, + "rawSHA256": "3660477F7B9CA7B25BAD6C50626B9915CBED798ED81C0A9C532AEFE8D46912BB" + }, + { + "path": "docs/internal/packed_query/PQ1_CALCULUS_REPORT.md", + "mode": "100644", + "gitBlob": "7f213c2e8a8df16b13d354fb5396f67071f19cd2", + "rawBytes": 16173, + "rawSHA256": "2E6311896FD3DE13A687A3B43D4853642AC04A2179D8EB5D05F99DAF8057D943" + }, + { + "path": "docs/internal/packed_query/PQ1_COMPILER_MATRIX.md", + "mode": "100644", + "gitBlob": "ca6341967dde11922e43b89673e58acbbf65e0a8", + "rawBytes": 12970, + "rawSHA256": "0DB706AE9C0BD18E51C1BD83E2FAB6425D696CD81EC9A11E60A696FA66C210C8" + }, + { + "path": "docs/internal/packed_query/PQ1_COMPILER_PROMPT.md", + "mode": "100644", + "gitBlob": "9ff8cda9170d7e94bd7c070c69193548fd57b56f", + "rawBytes": 7174, + "rawSHA256": "7333C26E9D2E6979B63F3B63085CD910D705DC239D82046FDE9F6EF3A6EF443C" + }, + { + "path": "docs/internal/packed_query/PQ1_COMPILER_REPORT.md", + "mode": "100644", + "gitBlob": "9ce167073696a052118107c3bfa3b58ff4281127", + "rawBytes": 18792, + "rawSHA256": "9C325166B6645726F9C76325580DA55AEFC2274766FA5F5E2D3C25966D517B7F" + }, + { + "path": "docs/internal/packed_query/PQ1_CONTINUATION_AUDIT_20260911.md", + "mode": "100644", + "gitBlob": "7dfa53241b60d4517e93ab49d42bac0f2a75c5d1", + "rawBytes": 18939, + "rawSHA256": "4CBB80DFFF4BDF33FC857004DFDD94ECD1D62814FE1268F6BD0A08509B808D5E" + }, + { + "path": "docs/internal/packed_query/PQ1_COORDINATOR_ACCEPTANCE.md", + "mode": "100644", + "gitBlob": "9bb5d43e7bb67d8a447ebe683f31860f380c87c7", + "rawBytes": 14134, + "rawSHA256": "C1FD55B51457E89F8F46F8EA13424F3D2B26C8CD95FE45362A22CFA368C9390D" + }, + { + "path": "docs/internal/packed_query/PQ1_FRINGE_SAFETY_MATRIX.md", + "mode": "100644", + "gitBlob": "c1a481c9026907c9488d274d66742be8ea3237d0", + "rawBytes": 13359, + "rawSHA256": "08E5F53F226840D68BA243EFB013A65ACF0DD9FC5B22C5150A3FD78F070B9006" + }, + { + "path": "docs/internal/packed_query/PQ1_FRINGE_SAFETY_PROMPT.md", + "mode": "100644", + "gitBlob": "5e1836b2b16f3d3da0c4dd8dc48eac44c1f033ac", + "rawBytes": 7434, + "rawSHA256": "8F5482648C701350AE2D38B5C8C38FBFDD054BE4ED7CCCA2F3EE0E789AF8B3A9" + }, + { + "path": "docs/internal/packed_query/PQ1_FRINGE_SAFETY_REPORT.md", + "mode": "100644", + "gitBlob": "ebb751059b9f144ea22f34ebc71b6935cf525159", + "rawBytes": 26960, + "rawSHA256": "ADD862CC9A746E4DD4FCDC9D6CBE9BACEFEF598BC9D15F485AB648083A3A9656" + }, + { + "path": "docs/internal/packed_query/PQ1_INTERIOR_CANDIDATE_MATRIX.md", + "mode": "100644", + "gitBlob": "bf5833efa949b8b2fbe9e19bce18647709d16147", + "rawBytes": 21548, + "rawSHA256": "C04900132448055926F4AC21EFE96A6F68A0D7AC5C6437EB9CFCAF4290C38A05" + }, + { + "path": "docs/internal/packed_query/PQ1_INTERIOR_CANDIDATE_PROMPT.md", + "mode": "100644", + "gitBlob": "7a32b274722ba7ae1d64bf26c16c5ec3b9269cbb", + "rawBytes": 9322, + "rawSHA256": "58762A10341FE9251721D3EF49349C854F37340D868C7B34FB5A729F947924B7" + }, + { + "path": "docs/internal/packed_query/PQ1_INTERIOR_CANDIDATE_REPORT.md", + "mode": "100644", + "gitBlob": "0dfdebbd3d8fa2612fcb86cad6dc722336c0e931", + "rawBytes": 17883, + "rawSHA256": "A93310A7DD3AB42154A47620A91E130F50C21CE0029E18D1512DBF2DBADA4AD5" + }, + { + "path": "docs/internal/packed_query/PQ1_INTERIOR_SAFETY_MATRIX.md", + "mode": "100644", + "gitBlob": "55985de18b41d8f3faa1dfc2fe26d5eb1a5c3e03", + "rawBytes": 14258, + "rawSHA256": "FF1D6698A3825E270B29478BB85E0E355D36330A07F5F25AB004F0CD1287831A" + }, + { + "path": "docs/internal/packed_query/PQ1_INTERIOR_SAFETY_PROMPT.md", + "mode": "100644", + "gitBlob": "20ab5873f389eda7f17ba2f07e609222edafe4b4", + "rawBytes": 7417, + "rawSHA256": "9852763D4D2DD75D50F8E245E78314FF1DA4EC3252EB53D00BEED80CBB456E28" + }, + { + "path": "docs/internal/packed_query/PQ1_LOAD_SAFETY_MATRIX.md", + "mode": "100644", + "gitBlob": "f7d1db209f9d6881becb829282d07f8e5c267662", + "rawBytes": 14193, + "rawSHA256": "5D065A6ECD97EB4F5314C3BCD6EE71A4FE560A4979383F50C1C9AC0F25D5062C" + }, + { + "path": "docs/internal/packed_query/PQ1_LOAD_SAFETY_PROMPT.md", + "mode": "100644", + "gitBlob": "64ebc2996a01f3d364f78ff9bcb41244d8860e68", + "rawBytes": 6822, + "rawSHA256": "651E99C38D12F1CE0E4AE4168BD939368B5584B7459926BDC9433B5F88962A40" + }, + { + "path": "docs/internal/packed_query/PQ1_LOAD_SAFETY_REPORT.md", + "mode": "100644", + "gitBlob": "0b40cc7ee506c574414b57a0c29a2771822ccd73", + "rawBytes": 18443, + "rawSHA256": "EEC357153E0C787B52DFFBABFAC4B7D790415A75D6611A17AB309B9816A52B49" + }, + { + "path": "docs/internal/packed_query/PQ1_LOCATE_MATRIX.md", + "mode": "100644", + "gitBlob": "d5f92c16a43a73216f953f4c52e879e021702bf2", + "rawBytes": 12658, + "rawSHA256": "241979F668395E7D970F21BDC2F6204617DD9A7471A733E1D7BDAE0229AE38CC" + }, + { + "path": "docs/internal/packed_query/PQ1_LOCATE_PROMPT.md", + "mode": "100644", + "gitBlob": "21af554a383e9a860da359ee7e81252852089ca2", + "rawBytes": 7430, + "rawSHA256": "8FF76786C878D9C98D32A9EC0F4B53A1747F264372C74A0C8DB0BAE67DAE9395" + }, + { + "path": "docs/internal/packed_query/PQ1_LOCATE_REPORT.md", + "mode": "100644", + "gitBlob": "650c00512242e125e3909d46f47302830d598d12", + "rawBytes": 13885, + "rawSHA256": "F8B8926F322D2BD0D4A8A2B749026631FB386431A328DFA3934B8E33163680F5" + }, + { + "path": "docs/internal/packed_query/PQ1_LOGICAL_SPAN_MATRIX.md", + "mode": "100644", + "gitBlob": "11f2c86fd20d6601b98a11499e6865caf6c1f642", + "rawBytes": 16343, + "rawSHA256": "8AFC390E2E932A5C759FA9909F9CE1905D14A9492736949F1DD4DF069704F3C7" + }, + { + "path": "docs/internal/packed_query/PQ1_LOGICAL_SPAN_PROMPT.md", + "mode": "100644", + "gitBlob": "e736aea7770042f4912bc95eba769f013dc7266b", + "rawBytes": 7443, + "rawSHA256": "D6DF64EE82819B246918C0E9515FCC2A59B417FF2B7973CC72D7D8E5459843FE" + }, + { + "path": "docs/internal/packed_query/PQ1_LOGICAL_SPAN_REPORT.md", + "mode": "100644", + "gitBlob": "f7301043413cd355d2ba4161eb51151ef20e463e", + "rawBytes": 12880, + "rawSHA256": "68215D91FB55C69EAEFC0BFE2307CE71CF21E23B3FAB00088CE558E1CBF7890B" + }, + { + "path": "docs/internal/packed_query/PQ1_MODEL_AND_PROOF_DAG.md", + "mode": "100644", + "gitBlob": "c2529c547e9f3d40f36131b18b61c769ba1afe2e", + "rawBytes": 8139, + "rawSHA256": "0D484A3520831346C9C71822A3C378D4B1A0A2B4E7796332B7849A9FE6C9B655" + }, + { + "path": "docs/internal/packed_query/PQ1_QUERY_SAFETY_MATRIX.md", + "mode": "100644", + "gitBlob": "4be2096b3246af25351767af95abad5b41bc2569", + "rawBytes": 11702, + "rawSHA256": "DE0310EF3D2E918F6BF3405BC033A5F54AF478B34E50B043A1E738791B0A65E0" + }, + { + "path": "docs/internal/packed_query/PQ1_QUERY_SAFETY_PROMPT.md", + "mode": "100644", + "gitBlob": "b7f8ee3b36b0f5737922579d2155e8df0d739e2c", + "rawBytes": 8511, + "rawSHA256": "E6367A8E0F9F5771AF38A0DDA2BB730DAB5EEF9BF57F04C30671B6C165F0BB31" + }, + { + "path": "docs/internal/packed_query/PQ1_RANK_PROOF_MATRIX.md", + "mode": "100644", + "gitBlob": "cd5b24afe9f035664f45075fea158ca1a822843d", + "rawBytes": 17006, + "rawSHA256": "BE669EEA3534F49557EB7E884E1D12BAB15DF204F6834EF18FE8DE30D47031D7" + }, + { + "path": "docs/internal/packed_query/PQ1_RANK_PROOF_PROMPT.md", + "mode": "100644", + "gitBlob": "8d50811ba44e49e37d8d51eba8a55567c032e816", + "rawBytes": 8311, + "rawSHA256": "6F2A2F67FC6C9A484DF5454AA4829C695D9A57759EA3C3C091970CC5EA23D4CA" + }, + { + "path": "docs/internal/packed_query/PQ1_RANK_PROOF_REPORT.md", + "mode": "100644", + "gitBlob": "59c6a465c4c3c8879bc83123f04403e6d15766f5", + "rawBytes": 11905, + "rawSHA256": "8CA7FA347A9408023DDB50D0812F933BF53088001AA3C8BB16E69CF70C6D3F8B" + }, + { + "path": "docs/internal/packed_query/PQ1_RANK_SAFETY_MATRIX.md", + "mode": "100644", + "gitBlob": "865adf10e226b5a8e89d212d42ce8d92b301cf23", + "rawBytes": 13659, + "rawSHA256": "3717C1552A1E815912D359C1DBB0E2E82DB129D56866F9B9A581D2BF1AB68FE5" + }, + { + "path": "docs/internal/packed_query/PQ1_RANK_SAFETY_PROMPT.md", + "mode": "100644", + "gitBlob": "019f4b2f5466a9d23b2e8efcb9cf35db076c610b", + "rawBytes": 6694, + "rawSHA256": "4D3260A3A206D665E4EC9A26DFEED2D20035F07E8758D31F2B2365B9F1DFBD77" + }, + { + "path": "docs/internal/packed_query/PQ1_RANK_SAFETY_REPORT.md", + "mode": "100644", + "gitBlob": "162d6b05ca77522b4ef3f33e3f0de6794bdc3471", + "rawBytes": 34791, + "rawSHA256": "D8A04B76F040366BA52DC18982872FB2D0076C54AF0D7CA0451F418319A9A20A" + }, + { + "path": "docs/internal/packed_query/PQ1_READER_SAFETY_MATRIX.md", + "mode": "100644", + "gitBlob": "13d6f93a3bdfc1001bfafea03d78976e4475fe07", + "rawBytes": 14991, + "rawSHA256": "EF7EBD2EDF9DE2AC7E19ED24D6E125862EAEA3FD9D73B336FDB4EF64099ADCC4" + }, + { + "path": "docs/internal/packed_query/PQ1_READER_SAFETY_PROMPT.md", + "mode": "100644", + "gitBlob": "8c92eac6024cc6b1b069a6e52eec263f20d478ba", + "rawBytes": 8348, + "rawSHA256": "E05457E0485A08CC233CFF160F2BF35C0AC9ECE7F75FD32A2ADA811613F6A16E" + }, + { + "path": "docs/internal/packed_query/PQ1_READER_SAFETY_REPORT.md", + "mode": "100644", + "gitBlob": "6fb4f29022244e8d8618d71e6e939e358b18725b", + "rawBytes": 16403, + "rawSHA256": "5DA7013165D2E8FA768E4E8B720A7911F48B85EEEBD37FCAED4B0281DCFB511A" + }, + { + "path": "docs/internal/packed_query/PQ1_SAFETY_MATRIX.md", + "mode": "100644", + "gitBlob": "5e9020c691c78b8e1874124c1596ebe96b3132f4", + "rawBytes": 13788, + "rawSHA256": "2F3E9AAFB9BA4BB768A1F2D5922867A9574861B4EEB3C60D9B6DFEC0D6C5D2A9" + }, + { + "path": "docs/internal/packed_query/PQ1_SAFETY_PROMPT.md", + "mode": "100644", + "gitBlob": "a7f7c4428f9b29f044a9f9b925cb2f77b8d14ecb", + "rawBytes": 6776, + "rawSHA256": "0A811DAE7269A0DC850F1CA504EA1E5DC982FCAC7D565806270A60967B6A853B" + }, + { + "path": "docs/internal/packed_query/PQ1_SAFETY_REPORT.md", + "mode": "100644", + "gitBlob": "f1a77d387d1d1d8c6153de08c8844f3e5f31f745", + "rawBytes": 19959, + "rawSHA256": "E48166421AF238635E31E86445EEA5CE7A07B4A7C153F5C4D18F6DD7D2E91AE4" + }, + { + "path": "docs/internal/packed_query/PQ1_SCOUT_CONTROL_PROMPT.md", + "mode": "100644", + "gitBlob": "117e3b4deea78463604ab5d87172e7f8d5f26665", + "rawBytes": 4752, + "rawSHA256": "DA6366BD7A35E4AC956CDA221CB5954B796D144D3B2FB1A9A5F3C60141CD702D" + }, + { + "path": "docs/internal/packed_query/PQ1_SCOUT_MEMORY_PROMPT.md", + "mode": "100644", + "gitBlob": "af706c9efd3c056cde15d388882f8c8863f9d47b", + "rawBytes": 4471, + "rawSHA256": "86C2690EBD7C6E54971A2A80175034B708E6FA6453EE1CAB3E2B61FA279DD555" + }, + { + "path": "docs/internal/packed_query/PQ1_SELECT_PROOF_MATRIX.md", + "mode": "100644", + "gitBlob": "b319481fa6e815287d758cea2c68e69c53d420f9", + "rawBytes": 20822, + "rawSHA256": "384094C13DA955A6D9FE7776A57E9C09A98DD0263A2127543F26C0FAC398073F" + }, + { + "path": "docs/internal/packed_query/PQ1_SELECT_PROOF_PROMPT.md", + "mode": "100644", + "gitBlob": "d363a1eb11a9c2a6cc48cb92f7e48af1e2da38de", + "rawBytes": 8311, + "rawSHA256": "A6F262915C579E5DA632200138AD5239373B395BD82E4F91165479D6AFD1B6EF" + }, + { + "path": "docs/internal/packed_query/PQ1_SELECT_PROOF_REPORT.md", + "mode": "100644", + "gitBlob": "d13d929fb066c7cc1fe4d4e06e44250a5b793598", + "rawBytes": 13634, + "rawSHA256": "B357BD67BF7420233C4C2FDF68A1D6A24991020BA048500660B0AB9CAA0A3278" + }, + { + "path": "docs/internal/packed_query/PQ1_SELECT_SAFETY_MATRIX.md", + "mode": "100644", + "gitBlob": "c2977a1e49b80f43f7ef4080af21405d706da20a", + "rawBytes": 27631, + "rawSHA256": "1D376AFEB2FBADE82B58F67C15C8DD2D95E3AC840884C09D1D0FD6CEA9E6EA37" + }, + { + "path": "docs/internal/packed_query/PQ1_SELECT_SAFETY_PROMPT.md", + "mode": "100644", + "gitBlob": "5fb75dfae88a292ae40da193438307090e01e0c4", + "rawBytes": 6967, + "rawSHA256": "DDB29AB58E22AE76EB966D6983504B5197F03DCDC3CFA867A51962A1F2E1FC50" + }, + { + "path": "docs/internal/packed_query/PQ1_SELECT_SAFETY_REPORT.md", + "mode": "100644", + "gitBlob": "0b28955ca38ad7a963307ed669c168b8465403fc", + "rawBytes": 10974, + "rawSHA256": "125BEA3E2589CB556DAADDADE31F4B909D593DBB0C373E756411BA74160CC8B6" + }, + { + "path": "docs/internal/packed_query/PQ1_SETUP_MATRIX.md", + "mode": "100644", + "gitBlob": "51cc65369f443d5594f3e8d25989bd4e506595b9", + "rawBytes": 15160, + "rawSHA256": "5DABAFF48F2E952FF42D31E9BE0E9654FA905E8CFF0EE7D1F49F88818B0FAF89" + }, + { + "path": "docs/internal/packed_query/PQ1_SETUP_PROMPT.md", + "mode": "100644", + "gitBlob": "0103507552f7c5fa6f05b0aac1b354cf36321fb9", + "rawBytes": 6238, + "rawSHA256": "F9E0304B95219AE40EAF839B1C98CF9C9C1A0E9B16649B73B4E9C2754481248D" + }, + { + "path": "docs/internal/packed_query/PQ1_SETUP_REPORT.md", + "mode": "100644", + "gitBlob": "378699114923e5c02b9d2fc00be6a5e21da1901c", + "rawBytes": 8323, + "rawSHA256": "03BB82397A6D6A5917FACAC71BB00E051CEFE1CA2298989AB758254F5B1A0DF6" + }, + { + "path": "docs/internal/packed_query/PQ1_SOURCE_INVENTORY.md", + "mode": "100644", + "gitBlob": "02fe5c84bbd50e78e00ac52e2a717fe985ebeece", + "rawBytes": 7143, + "rawSHA256": "5B07395933DE75678BCA9F2FABE42F63949E27994AA9FF6F3973A66F35FCD6B7" + }, + { + "path": "docs/internal/packed_query/PQ1_SPAN_ASSEMBLY_MATRIX.md", + "mode": "100644", + "gitBlob": "ce6b994a0310d634745b4b0c3987531191583486", + "rawBytes": 17581, + "rawSHA256": "8DE87DEC805A31AB7815968A1E4EBDA0AF76AAA4F19CEBA5551E55D8F1E3E32C" + }, + { + "path": "docs/internal/packed_query/PQ1_SPAN_ASSEMBLY_PROMPT.md", + "mode": "100644", + "gitBlob": "bf687762c4c2125a6470a5906501e29e67482bdb", + "rawBytes": 7392, + "rawSHA256": "44A8A6F58BF4CF5282AC89B80D46B28DBFD12EBC4108DFA5BC251973E01493FD" + }, + { + "path": "docs/internal/packed_query/PQ1_SPAN_ASSEMBLY_REPORT.md", + "mode": "100644", + "gitBlob": "bb463938cd6a6a8d827a0949448783c42161e546", + "rawBytes": 13371, + "rawSHA256": "FFF6A3F404E506D2F7AFE1C29DF7FDF331A63CFDD720850E70FA29287FC864A7" + }, + { + "path": "docs/internal/packed_query/PQ1_SPAN_MATRIX.md", + "mode": "100644", + "gitBlob": "863a43610bc481325a398e1f416a162c903507ca", + "rawBytes": 15781, + "rawSHA256": "F7CC8E7FA8AFB6C4A2EA067F888F318D6FC93D666744D1F28C5234EEC9915D0E" + }, + { + "path": "docs/internal/packed_query/PQ1_SPAN_PROMPT.md", + "mode": "100644", + "gitBlob": "b57550c81e534c29e8c456e4c7e4b2b186201eb2", + "rawBytes": 6941, + "rawSHA256": "E77950A68BAB1D572B1171DD4950AD243DDEBEF5B87429F9F90DF2AEF0171E5A" + }, + { + "path": "docs/internal/packed_query/PQ1_SPAN_REPORT.md", + "mode": "100644", + "gitBlob": "2ccddc96cebbd3380297457f5b976fa42ef82ac8", + "rawBytes": 11489, + "rawSHA256": "3B7327C6F3ECE0F16909099B6D978B0ED10E0E0753B6A3BDF60C1FD7826ADE13" + }, + { + "path": "docs/internal/packed_query/PQ1_VALIDATION_PLAN.md", + "mode": "100644", + "gitBlob": "b14a64c1bd8a595bdec301768fabb807f67c76c9", + "rawBytes": 21486, + "rawSHA256": "19E58D6FFE48EBEFAF4A80E7A3EA9C56B53429B0839CC71B667013C01F8CB3A2" + }, + { + "path": "docs/internal/packed_query/PQ1_WIDTH_MATRIX.md", + "mode": "100644", + "gitBlob": "402dd21d065be5bd0d570038066d4fb42b5cfbb5", + "rawBytes": 12742, + "rawSHA256": "0BC62713892B85337359E33B9CD138CBD642EAC5C3CCA522BC8C310DC142FAE6" + }, + { + "path": "docs/internal/packed_query/PQ1_WIDTH_PROMPT.md", + "mode": "100644", + "gitBlob": "6a497241f03f7e8e6b689c5e469236acdec612df", + "rawBytes": 6376, + "rawSHA256": "6174BBFA2DE26E83F3584B9F20182F9A37178570A6EC35ECF1048534CF6196C8" + }, + { + "path": "docs/internal/packed_query/PQ1_WIDTH_REPORT.md", + "mode": "100644", + "gitBlob": "881e14b2a7063ad103a26bc6dbfb784bef864a63", + "rawBytes": 8189, + "rawSHA256": "6313FFF421F5AB80EB27DF92488445A26391C9F376693D6BF22751A54F82C111" + }, + { + "path": "docs/internal/packed_query/RC6_SOURCE_SYNTHESIS.md", + "mode": "100644", + "gitBlob": "ff522886495a8a000691fef69201a7af4ed60efb", + "rawBytes": 8121, + "rawSHA256": "CA924475DA674923EF364684FFD712D3D55ACE726C70CADDF7140D8DD8C151CF" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/.gitattributes", + "mode": "100644", + "gitBlob": "41378e904c4e2223772820f0bd21d409c48a53e3", + "rawBytes": 229, + "rawSHA256": "1914CB5D7D14A932FA54941A9AA497F6059361E5C4011A18E1E52DB94D2B4FD5" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/ASSESSMENT.md", + "mode": "100644", + "gitBlob": "57f6c8b014617cec4194848588d5a36ecbd08195", + "rawBytes": 13392, + "rawSHA256": "BF8F4BB30728365412C70563FD3BF9F3646267FA71D12286E9E9F80EE8CFD287" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/CONTRACT.md", + "mode": "100644", + "gitBlob": "09f16c2aa95093874c4083a8ed53de13341866b7", + "rawBytes": 4924, + "rawSHA256": "16DD79CF147AD1CD871D748FB6961FF72F2136A473DD15133BF5251CCBC4D105" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/CheckMachine.lean", + "mode": "100644", + "gitBlob": "1df3778afc40208e34e5763593918c7772efdc7c", + "rawBytes": 5870, + "rawSHA256": "207D314AFF59552C725AB54F9E20573C62E17696C4A4FFB9C368EF682DABD6E5" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/ExportFixture.lean", + "mode": "100644", + "gitBlob": "097d348bc0a070c0553d7125e64e1008263f5203", + "rawBytes": 15764, + "rawSHA256": "FEAE2CCF257629A89BB0567D7F2CF8143BF3366CDA0AD84B12DC239A19E013E7" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/README.md", + "mode": "100644", + "gitBlob": "e77ed169f020cc5cc33aabe28599e20ddcceae70", + "rawBytes": 1259, + "rawSHA256": "29BB54823BF6168908DE2943A19069C5FF61348095FFC32F30880F79BA0E1364" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/compiler_checks.py", + "mode": "100644", + "gitBlob": "b0224c35f879abf79a3d4fe548eb8a773ba56089", + "rawBytes": 838, + "rawSHA256": "286504CFB9D199AE70B7BB3E14763CE6DB05C0ADDF94AC35C62B86A51D2ABFA6" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n15-comb-vm.json", + "mode": "100644", + "gitBlob": "b4927d1dbde70bf221d0359c44aaf57c447d7d1b", + "rawBytes": 41372, + "rawSHA256": "1F5C36CA27753655F06A91D3C0F8A4DEC10E285536690A1984F30FF1F7D10BFF" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n15-comb.json", + "mode": "100644", + "gitBlob": "13a1d094a587553e5ffaa5bcf782fb02a424de7b", + "rawBytes": 84059, + "rawSHA256": "A5EA4B84C31832F8F2303882E2668A016787B6B46E2362C52F08C310FABD5361" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n15-zigzag-vm.json", + "mode": "100644", + "gitBlob": "96136bac482e8e401e4edd82b01918dd59fece59", + "rawBytes": 43930, + "rawSHA256": "2EF8BD8B76F6C5A50740890E0F74293DBA02F5742DCEE10DC0A7F8BA1784AB2B" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n15-zigzag.json", + "mode": "100644", + "gitBlob": "72b885b6c4e8251b5fbd6f9d1ad8e85b26eedcae", + "rawBytes": 89986, + "rawSHA256": "2DB0A1EEC22EB2C3ED5C0A1C44117FFC4138A4474844542E500CC252EA0E2173" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n16-balanced-vm.json", + "mode": "100644", + "gitBlob": "6bc956f7b3f2199588556233e196939da09a5422", + "rawBytes": 42736, + "rawSHA256": "A215C657BA75F04DB4EA95173858C233DEA1D7B8D963CF61D6DF1141FC84BED0" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n16-balanced.json", + "mode": "100644", + "gitBlob": "4713f39ae6c8344a622652812eac069cccdd0f8d", + "rawBytes": 88013, + "rawSHA256": "9C18600312F9C0C2ABF95DE57B935518257FB0A222CF4C0CB2DC088C2DC18C0A" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n29-zigzag-vm.json", + "mode": "100644", + "gitBlob": "aa8f3b502eb0437d94457cd2f93533df85840a39", + "rawBytes": 45389, + "rawSHA256": "959455F0D722993E7920EE789A059DF7CDDB3A67962FFF3BC74907750256742A" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n29-zigzag.json", + "mode": "100644", + "gitBlob": "96c6566a0fb05e60104cc9c3a9db1652fa71112d", + "rawBytes": 94411, + "rawSHA256": "D56FB364F993F90240D32470E76FF1D4BFD97162F89C424F35621BB66F49926F" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-ascending-vm.json", + "mode": "100644", + "gitBlob": "f14a9e5a3c333700b025ef763b790ae0db2d6eef", + "rawBytes": 36788, + "rawSHA256": "826407F5B41E4B28A4A367B46805D174182FB0F4EC6B5426E3323783C3D5F5ED" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-ascending.json", + "mode": "100644", + "gitBlob": "74a101ccb72cf8d49908942381f092b5b8fb3995", + "rawBytes": 73036, + "rawSHA256": "79A3F29ACDE6BE9432C9BD9913A80213B33695CDEA33956AC52F1EACF0C54C5A" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-balanced-vm.json", + "mode": "100644", + "gitBlob": "454967f733d16a0cb0bfb79ddb98b3d409f1caf5", + "rawBytes": 38132, + "rawSHA256": "76D8C34BE4EEEF22409DE10FC65E06E6CFECD8B22A810A2FDF245CF0C0511BCE" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-balanced.json", + "mode": "100644", + "gitBlob": "280e991c92e2ec84e860010dddab4d55bd565871", + "rawBytes": 75738, + "rawSHA256": "437D9512D3452AA753791CBC1FEB5F6850C0162729B932327B8D57C8D68CB697" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-descending-vm.json", + "mode": "100644", + "gitBlob": "845867277bf3864d2e3664166c78c80ec1f3c3ce", + "rawBytes": 29344, + "rawSHA256": "328DFED4A208734E0F8C3F84D858B58A54A1DDAFA9CFD2028E0E12438D940DCC" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-descending.json", + "mode": "100644", + "gitBlob": "ac136cd74146687a1ff910541d466b539657cc3c", + "rawBytes": 65253, + "rawSHA256": "F9E6F7D9156FF62FC43D22983BA44128780987863C232EA8449A40404A0DDCC7" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-invalid-vm.json", + "mode": "100644", + "gitBlob": "2cc6f558e44b83ed38ec903c98a96d43482441ae", + "rawBytes": 830, + "rawSHA256": "B681CF928040B6A7615186842B2949E9CF7A1095E96422212429A875A06EEFAB" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-invalid.json", + "mode": "100644", + "gitBlob": "da97512696bcbb14a1ac1c1c93aa1d05f2769766", + "rawBytes": 7279, + "rawSHA256": "613B3C9FAB261B1DB929F0C8C3821562309143F3B5129800DE91CC828A019CBD" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-ties-vm.json", + "mode": "100644", + "gitBlob": "243d3be0d57a69487740bd9de0a543a0f33c12be", + "rawBytes": 36783, + "rawSHA256": "C395D330C116B63D206652C5A88349DFCC2AB31845D45A061D0C0850A03455C4" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-ties.json", + "mode": "100644", + "gitBlob": "08f5a983b2d8f7fe75b55f7fba38269f8f1523ef", + "rawBytes": 73031, + "rawSHA256": "A14E1B5353FE132EB435D2AFA06DC82FD7B6468D4AD6522B6CF65FAD93234AF9" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-notes.md", + "mode": "100644", + "gitBlob": "07c6d573c1dda8f7b769f553c9923e85904b0264", + "rawBytes": 7091, + "rawSHA256": "C9FC8654209725E1F8CA34A6C37202A69A6C23BE8B5BDF8DC719B2454A03F8CD" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/lca-interior-spec.md", + "mode": "100644", + "gitBlob": "621b43bfefe90cc473a56022d5f95ba8890ec4f6", + "rawBytes": 16013, + "rawSHA256": "EDB7599808C25B8A5CF603CBF7A5145B3851495DD18F90307D30185D541B6A3F" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/lca_interior_program.py", + "mode": "100644", + "gitBlob": "25334ca80c2e1c36e177d98669f1fcb7722d7b7b", + "rawBytes": 9390, + "rawSHA256": "8030779301E802313A7E7FD5EE6E7DB8BF8267C811FC1E6B07B02E634F4EFA7B" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/machine.py", + "mode": "100644", + "gitBlob": "5522c467fd54f4be69abe5aaa2157a3089503a97", + "rawBytes": 15425, + "rawSHA256": "730EF56FD1E8365A41C954FBA46881EB450E1BAB6918C2E831C6545E860979BF" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/manifest.json", + "mode": "100644", + "gitBlob": "14faf12bf2b9720039031c1fa75332e392d8a309", + "rawBytes": 6198, + "rawSHA256": "83D296A47D365E6710B6C8CB6253BFD9A32C185A3E778F4C194B6F492D28F073" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/package.py", + "mode": "100644", + "gitBlob": "d8c7413f7bfd38725f4eaffe2ad43f4f3a95d76c", + "rawBytes": 957, + "rawSHA256": "85D37ECBD2BAA282ABD1F9F99BAF52C1C673A3E71018B10F41FE893E9AA850C9" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/physical_program.py", + "mode": "100644", + "gitBlob": "5b8814d628e1db14abf95aeeb5a6f6da6454fae0", + "rawBytes": 1599, + "rawSHA256": "9015D68AFDF3DBE03245734B554B6155502D626E9C3224791AB7A52622782D19" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/program-n15-source.py", + "mode": "100644", + "gitBlob": "ef1cca46d3c4547fe385e20b8201eb713cabda90", + "rawBytes": 24964, + "rawSHA256": "74AFDFBA8C4E549A3BC0A0F9C2231DD6CA5811552DE0B56D5DFCEF6B16D16540" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/program-n15.json", + "mode": "100644", + "gitBlob": "920c3085d0838e685672ccfc30dc4eb67f8035cf", + "rawBytes": 154507, + "rawSHA256": "77AD0F860FBA8D04BB3B6A4DAA595A5F05C974407087B8691E6AA04B9DAF5249" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/program-n16-source.py", + "mode": "100644", + "gitBlob": "6486930abe79985096b578a41963553294709148", + "rawBytes": 24965, + "rawSHA256": "3B671EAB457DC3ACC4E8E1A8F94A7AED0F19CF24F5835DC8B2672AA913F5F8CF" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/program-n16.json", + "mode": "100644", + "gitBlob": "9f896d976449a8036dd49e78bef5726ea5b448df", + "rawBytes": 154520, + "rawSHA256": "AFA03B191E9FF6BFC5C60BB1E343A57E9F5E9FD1DB7BA2D785D7112B6E63FB32" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/program-n29-source.py", + "mode": "100644", + "gitBlob": "0fd47ac45d09b4b2503796a52c5e474dce312795", + "rawBytes": 24973, + "rawSHA256": "00C1885BA71646AEDA265B28F70C781F786E41BDF8A98F5D5648A97D9B96D1F5" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/program-n29.json", + "mode": "100644", + "gitBlob": "df1eeffc0037293600fcab33d713b6ffaf56e8f9", + "rawBytes": 154529, + "rawSHA256": "A2DC5E9764B4B39911C8474CE7FF709027191B82B4A23567C0F370AB7E9B529B" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/program-n9-source.py", + "mode": "100644", + "gitBlob": "cf5dc3aaba827860b0e2f58ac6b7aadbbf4849a6", + "rawBytes": 24958, + "rawSHA256": "95B95A22F63BC06157A9E3CCAE93B6148B352A04CD03591E213827B39062EB1A" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/program-n9.json", + "mode": "100644", + "gitBlob": "2b0f4bc1894092fe5ad5f9f909da09db3865017e", + "rawBytes": 154489, + "rawSHA256": "9EE640E68601B47BE82417621C557C688A4BBAA0B1BC061A9E43FA2DA0309AB6" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/rank-select-spec.md", + "mode": "100644", + "gitBlob": "49d1c45d9b7ba099e14729defabefd6bded8e986", + "rawBytes": 17432, + "rawSHA256": "2EA0AF303B6FD3FCB8A2BF69783EC2F39D952D4A07B80572645A2A93BE024C1C" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/rank_select_program.py", + "mode": "100644", + "gitBlob": "5e6c77604a1d3921bf6338375627df33c438b825", + "rawBytes": 5473, + "rawSHA256": "346CBA19724CF066E79E2A45A722C465DBA8A7AFE97432EEA0653DE2970C8166" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/reproduce.ps1", + "mode": "100644", + "gitBlob": "be869496aa4854c3bb3cce54f83fda7504e3a770", + "rawBytes": 2197, + "rawSHA256": "BAF93F3486F80AF5D2F41BA406DDB897D65A2755748410ED019B2BDD4AAC8859" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/reproduction.log", + "mode": "100644", + "gitBlob": "532a3c8409f61357e8933f8850295a78af4396c0", + "rawBytes": 3735, + "rawSHA256": "E4F48B76BD4736CB8548CD710A5924FADA593AF7872DAC34DB1FBCE1457713B0" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/run_experiment.py", + "mode": "100644", + "gitBlob": "4ac681a72a72878860db797990c0e54c0686c1d8", + "rawBytes": 6952, + "rawSHA256": "7F057D55DA6B3678D8195EA0923858BDA6A2DD03B7C58C5392CA28818A3AF61F" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/validate.py", + "mode": "100644", + "gitBlob": "d6f86885f09568f6265c67c731e1e2b5014e08de", + "rawBytes": 3818, + "rawSHA256": "F1EC1CD52ED7CB4F836F8DBFE7547AC3304D93524665D5C660F582FE27DD264F" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/validation-results.json", + "mode": "100644", + "gitBlob": "ea24b62d6fe4cef99d47386d3061f1ce37e21e11", + "rawBytes": 7441, + "rawSHA256": "DD1079A76552172AA9546539E577983B1701553C5997371590D98FB5671A2BEA" + }, + { + "path": "docs/internal/templates/AUDIT_PROMPT.md", + "mode": "100644", + "gitBlob": "91631d91a01a21027654855bbb3a8699154df7ef", + "rawBytes": 6422, + "rawSHA256": "ABAC66980E1B9B93A86A64DCAEA851448ED3EECF19CAF23CD683DEBD2CF79375" + }, + { + "path": "docs/internal/templates/COORDINATOR_HANDOFF_PACKET.md", + "mode": "100644", + "gitBlob": "a3c5e31e1a42f727a9f675a12b7cc00a9372e1c9", + "rawBytes": 1806, + "rawSHA256": "E5148D09DA3465530BB143E69A2CEC623B49C70D48D3D8ED3B9577A0390EE736" + }, + { + "path": "docs/internal/templates/COORDINATOR_REENTRY_PROMPT.md", + "mode": "100644", + "gitBlob": "2b9038c3be299a3aacde24f8021ff7d50cbe48a1", + "rawBytes": 3262, + "rawSHA256": "1FDB73903A8E70C206EFAB2CB669435BF758A2A1D76ADC336C802A82E96BAE38" + }, + { + "path": "docs/internal/templates/PROOF_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "6571abf14bebe279b8f1fdfe17b669d07f98a999", + "rawBytes": 6141, + "rawSHA256": "774909BA0467EEC29303BE6F160123828AF02329EAB2ADC5663719166C016671" + }, + { + "path": "docs/internal/templates/WORKER_PROMPT.md", + "mode": "100644", + "gitBlob": "d77902361cf2931f97053fcf734cf1e0d1a4f877", + "rawBytes": 19040, + "rawSHA256": "AB4B8B3391A45420BAB6E92CC60D00D1164B50769F527F5D77E755A61B966256" + }, + { + "path": "docs/internal/wf3_attack.json", + "mode": "100644", + "gitBlob": "91bfeafaf704b1875be745242e73ca5dd1389b11", + "rawBytes": 36004, + "rawSHA256": "F26087549E6AB0B5A8A43423474F42509CCA2720DE93ED761840DD02660B44E6" + }, + { + "path": "lake-manifest.json", + "mode": "100644", + "gitBlob": "c84e20fca6ea6816a0b342ef8cabf5aa2b203c35", + "rawBytes": 114, + "rawSHA256": "779633B5A9F128F713A68C5A788A50C6B86D558551215B5D046647E692AD046F" + }, + { + "path": "lakefile.toml", + "mode": "100644", + "gitBlob": "b0e72516918125c22272b36c360db7f91182ade5", + "rawBytes": 1176, + "rawSHA256": "B47C7ABE3955D1A2E9BA51A4C71FC2E7961423D2BF5F3856F79A24BEBC8BDD50" + }, + { + "path": "lean-toolchain", + "mode": "100644", + "gitBlob": "b9994064fbbb081ca94a50384ff5951b50ea5b42", + "rawBytes": 28, + "rawSHA256": "AD3E6363C78908C80953282BAF57162702F1134173A5247AAD3DBFEA108A525F" + }, + { + "path": "native/packed-rmq/.gitattributes", + "mode": "100644", + "gitBlob": "ec999e9d630559366ebf50cd5fa969bcdd39a652", + "rawBytes": 326, + "rawSHA256": "1A8252F52CC8EAAFFD8E07ECFC651E5A4DD81B8CBC1F4E3CAB030A0B48809778" + }, + { + "path": "native/packed-rmq/.gitignore", + "mode": "100644", + "gitBlob": "99d2bb15a12368587abd95bf1db11297137741fb", + "rawBytes": 17, + "rawSHA256": "6192C78B3A190E1DEAE3B9235FBA123041714EBBB86B43CCB858BA34B26994D5" + }, + { + "path": "native/packed-rmq/Cargo.lock", + "mode": "100644", + "gitBlob": "583bd4fdf5e8f8c35d88a25c04587ed34eca6fb2", + "rawBytes": 154, + "rawSHA256": "5A59DA0864CAB8E739DC408245DF7BF5ED4BC7AD3A11FAF2962C3DECFF1C8AAC" + }, + { + "path": "native/packed-rmq/Cargo.toml", + "mode": "100644", + "gitBlob": "b7e787faaed137e63b87613b78d5d765f179d86a", + "rawBytes": 381, + "rawSHA256": "3F6DB12831D88D60F418F8AB93D943487A6346C29E6475BAE50CD4A0953A7930" + }, + { + "path": "native/packed-rmq/README.md", + "mode": "100644", + "gitBlob": "9fc8d90f186e2068a639fafe8267da8ab345a2b4", + "rawBytes": 10013, + "rawSHA256": "5CFB39FE2A33D4A9F6F95FED9A012DBC8E47D3B437908495080B6CBF74A6151A" + }, + { + "path": "native/packed-rmq/examples/lifecycle.cpp", + "mode": "100644", + "gitBlob": "cdafcd82a1eb825730a201c65d868bfe843f400b", + "rawBytes": 7661, + "rawSHA256": "D0C35278DE1A959D8058AB9D3AAEBF7BA15BAAB8313A263B6303655C2E864F07" + }, + { + "path": "native/packed-rmq/examples/native.cpp", + "mode": "100644", + "gitBlob": "1ef6703ddca42866c500502c0eb97e150cdfc354", + "rawBytes": 7428, + "rawSHA256": "A5BFE471012D24A68BF743F2EC76F141F5B7731E66F7002A6F2127485FBA3FAB" + }, + { + "path": "native/packed-rmq/examples/route.cpp", + "mode": "100644", + "gitBlob": "c33afca71427dbc6d3974469aac56a0109cd5b4d", + "rawBytes": 1207, + "rawSHA256": "5A83460269C79D8288982D747A0020F0CC7F47C9C1230759708E14041D5EFC1C" + }, + { + "path": "native/packed-rmq/fixtures/canonical-cross-cell.fixture", + "mode": "100644", + "gitBlob": "ec6fff340ddacb7469351611c7890d05d249fb5d", + "rawBytes": 14859, + "rawSHA256": "DE8CB638266AD0D5FDF3F62F511990E9D4A4D6C5311E10A79BD70F1A949A960A" + }, + { + "path": "native/packed-rmq/fixtures/canonical-interior.fixture", + "mode": "100644", + "gitBlob": "aea1778195914584f82491739c67ffb8bd845f9d", + "rawBytes": 13223, + "rawSHA256": "4DA0FC04DFA2E12C70D109BEF89B973F2D82225B1CAAC01F47FE969D5F3EEB66" + }, + { + "path": "native/packed-rmq/fixtures/canonical-left-fringe.fixture", + "mode": "100644", + "gitBlob": "3d1acc9848dd0f3c4c06805d4ac8a03561e05ade", + "rawBytes": 13226, + "rawSHA256": "E947CA28C98A87953B31E7D1F95DD8A1808BE1BAE2EA7AA67CD7186266D1D7ED" + }, + { + "path": "native/packed-rmq/fixtures/canonical-rank-final.fixture", + "mode": "100644", + "gitBlob": "799d3941237ce7363f52cc4e1157b361dc4d3f03", + "rawBytes": 13218, + "rawSHA256": "53781774F1B5438C2593FA960858197927AB746C137F672DE972C96DAE916CF9" + }, + { + "path": "native/packed-rmq/fixtures/canonical-right-fringe.fixture", + "mode": "100644", + "gitBlob": "381022decc3c27a41f268d5f9e95de790d2f1342", + "rawBytes": 13228, + "rawSHA256": "A30BB0C905F87D3BB4FB0008B4BC894358F4782023D412DB24ABBD16FA87937A" + }, + { + "path": "native/packed-rmq/fixtures/canonical-select-left.fixture", + "mode": "100644", + "gitBlob": "7e84cc59736508cf331b4e9ceaf542cff7916cd7", + "rawBytes": 13211, + "rawSHA256": "03DDD5A11F37D1DB2A1562FB03CB2DF8DD7CB392654E01CD3F4839A15090FE6F" + }, + { + "path": "native/packed-rmq/fixtures/canonical-select-right.fixture", + "mode": "100644", + "gitBlob": "0213cae9330c9617e1ea32c1be06da1d70a3e621", + "rawBytes": 13217, + "rawSHA256": "9A518E610469A3B05BE1D91D628EC64E8553692C070BDA77283137B96346208E" + }, + { + "path": "native/packed-rmq/fixtures/manifest.json", + "mode": "100644", + "gitBlob": "300c5ac9d05e9b9a5d092eb0db5e980ca62edb83", + "rawBytes": 3112, + "rawSHA256": "B744C146C889896DD14BADB77BBEE53CCF4ECFE6764AB338811853347AE341B0" + }, + { + "path": "native/packed-rmq/fixtures/n12-adjacent.expected", + "mode": "100644", + "gitBlob": "4da0aed54809c29c1e1e91cb900ebad1d752b86f", + "rawBytes": 3884, + "rawSHA256": "E2834D14FF9BA5977CD31869623B91D2E573D8B6117889D2E0F768F21BBCE34D" + }, + { + "path": "native/packed-rmq/fixtures/n12-adjacent.fixture", + "mode": "100644", + "gitBlob": "c781c859d0b49eee8797c76e7480b5f690b87a50", + "rawBytes": 774, + "rawSHA256": "159719FFDE2DEC626239D410671AE0CD4F91833AC5E8214DC7CB9C7633B0A50E" + }, + { + "path": "native/packed-rmq/fixtures/n12-interior.expected", + "mode": "100644", + "gitBlob": "8d9d893c6e992890608244e59b8ab14a605dfc23", + "rawBytes": 4737, + "rawSHA256": "380E25EC977E4234A02184451F9F96E462431BE4262F8EF3F3358F7061E65A95" + }, + { + "path": "native/packed-rmq/fixtures/n12-interior.fixture", + "mode": "100644", + "gitBlob": "5a87b6aad2091d277c31aae86d2829437d4311ff", + "rawBytes": 775, + "rawSHA256": "26C204304B119A98EFDB099AE830440127FCFF8E5AD36422A7ABA6B7583A4234" + }, + { + "path": "native/packed-rmq/fixtures/n12-same.expected", + "mode": "100644", + "gitBlob": "f818662c6209284f12895ead51ae2b81f2ea859b", + "rawBytes": 3324, + "rawSHA256": "A3FFCF6BF9FB995BD765A902EEE65FB1DE70EF52BA5CF9BBB3A032F3C1E1C2D8" + }, + { + "path": "native/packed-rmq/fixtures/n12-same.fixture", + "mode": "100644", + "gitBlob": "56968c9c6cf2f64a77521f388083493cf474dc45", + "rawBytes": 775, + "rawSHA256": "254604DEEE28105717BC31744D14B9442D1AF3A34828BEDA2756AF0D8BFE9930" + }, + { + "path": "native/packed-rmq/fixtures/n9-corrupt.expected", + "mode": "100644", + "gitBlob": "50d2bca892cd47813918b23cd3af35b8aad2c5a4", + "rawBytes": 1059, + "rawSHA256": "237CCC8507B3AB49891946D6129E46EEC1D4C98B74D5C19033D10F2ECD17370F" + }, + { + "path": "native/packed-rmq/fixtures/n9-corrupt.fixture", + "mode": "100644", + "gitBlob": "384116849c9c24deba70d1021efb596bc49971b6", + "rawBytes": 720, + "rawSHA256": "C4BCA82BBE201FBD8319B1DD24A0582633600D8C8F6E1B4DB57D8AC425F1CF76" + }, + { + "path": "native/packed-rmq/fixtures/n9-empty.expected", + "mode": "100644", + "gitBlob": "0af2b219746cbf7556f1b20517705beb04e68d68", + "rawBytes": 17, + "rawSHA256": "3F59B43485A5E120ACBA4A6C65BD9BF938601835359C6E8DF83F311E17273FA1" + }, + { + "path": "native/packed-rmq/fixtures/n9-empty.fixture", + "mode": "100644", + "gitBlob": "efe7705885f1abf3a0e1f9ad612668c2dffc8ecb", + "rawBytes": 720, + "rawSHA256": "63E4B303AC9D518F2672B187BE9F3AF9E51C65E1EC4E03F8A9E342A78A685785" + }, + { + "path": "native/packed-rmq/fixtures/n9-full.expected", + "mode": "100644", + "gitBlob": "c958c4a1eccd095386f03a5300190e1df62767f9", + "rawBytes": 4516, + "rawSHA256": "FC25F556CD4C4E5804AB580A3FB8B184D98F72CEE207F4C4829EDD412F418A56" + }, + { + "path": "native/packed-rmq/fixtures/n9-full.fixture", + "mode": "100644", + "gitBlob": "6374a623f176ff84fe3830e4021a68bad94750b9", + "rawBytes": 720, + "rawSHA256": "70216D5E6F5CA5769EBB8D7269DA9B74ED867D7B4B7F9B2C4AD7603AA513DDC1" + }, + { + "path": "native/packed-rmq/fixtures/n9-missing.expected", + "mode": "100644", + "gitBlob": "2f6fe97da1271f08c387699644a859d73789c226", + "rawBytes": 26, + "rawSHA256": "D658EFEEED82848B94A085B2F3CDE29FE5E649449694A422FD6CEB9CF26366EC" + }, + { + "path": "native/packed-rmq/fixtures/n9-missing.fixture", + "mode": "100644", + "gitBlob": "1266c004970a521f3435400330656ce554731715", + "rawBytes": 18, + "rawSHA256": "08637CDED478315C117052EEF8A3D2FD8A37E972A202A68AE033B168ECA3E6C4" + }, + { + "path": "native/packed-rmq/fixtures/n9-range.expected", + "mode": "100644", + "gitBlob": "5ba4ab99feebe0bfdfe4490a0986a0aa9fbe2aea", + "rawBytes": 17, + "rawSHA256": "DB477A96C823BCF48B468FD1BCC4CA95804504EADC69991F4E39DF56D05A8E54" + }, + { + "path": "native/packed-rmq/fixtures/n9-range.fixture", + "mode": "100644", + "gitBlob": "9aee57b4585b027343402c31b859e6e13b778150", + "rawBytes": 721, + "rawSHA256": "5FB5C9F9B1785A5F873248F7BA1AB7E11048757C0BF3B88BBD97ABB47329409C" + }, + { + "path": "native/packed-rmq/fixtures/program.txt.gz", + "mode": "100644", + "gitBlob": "fc36d7beb7bd7fb9f75e762163999d8bd34e1687", + "rawBytes": 1008972, + "rawSHA256": "13EE9E81E17DD25D5F25546B72762A038886AE7545031FAF51DC2757E666C011" + }, + { + "path": "native/packed-rmq/include/packed_rmq.h", + "mode": "100644", + "gitBlob": "c69c5a5072646271e455ede3863cbc68fa47508d", + "rawBytes": 2936, + "rawSHA256": "E2DDB51D62B2CBAB79E0A64803F38343F4E73D66C91327E55D708CF47A3C993E" + }, + { + "path": "native/packed-rmq/include/packed_rmq_lifecycle.h", + "mode": "100644", + "gitBlob": "b88d89ed5abb950f473e00495eb415e34a606aec", + "rawBytes": 11394, + "rawSHA256": "791910DE0CDE090ADD04B2D144E5A2E12081CF4CAED81E8AB98FEBC7E76C499F" + }, + { + "path": "native/packed-rmq/include/packed_rmq_route.h", + "mode": "100644", + "gitBlob": "b92bdd54ca70913bee97167909d8118e6429c595", + "rawBytes": 1061, + "rawSHA256": "57B8D5524BE0B479AB65706E0D009DFA9F47DCB5CBAFD90FEFA27833539A6E13" + }, + { + "path": "native/packed-rmq/lifecycle_shim.c", + "mode": "100644", + "gitBlob": "34e2d53fb3f795139c0df38fc7efc9ee06df5382", + "rawBytes": 41735, + "rawSHA256": "3B3ECA3FE1E789034E1B0C1A0CB881E15CE6443363E7E397D1313FEF909ACDE1" + }, + { + "path": "native/packed-rmq/native_shim.c", + "mode": "100644", + "gitBlob": "db1e22fdf3b50763f95f699fbb521f1ac0b824ae", + "rawBytes": 3692, + "rawSHA256": "0D395279A803AB9FB796BB1176F5376F59CBF887E0414F09AF4D376A78F89780" + }, + { + "path": "native/packed-rmq/packed_rmq.def", + "mode": "100644", + "gitBlob": "cbf10b820efc18352d419ffbabdad6afc84309d8", + "rawBytes": 256, + "rawSHA256": "1FDE85FF9210ABD57407803250A4348B6F919187D387B0368E76BFA2B4CFB1B9" + }, + { + "path": "native/packed-rmq/packed_rmq_lifecycle.def", + "mode": "100644", + "gitBlob": "a170df0d1148daac3caade4e6b3d8d8318ccb914", + "rawBytes": 654, + "rawSHA256": "6F9CB164758FA15552739E498FA34779137F11CF380298ED508232482C2EEFE3" + }, + { + "path": "native/packed-rmq/packed_route.def", + "mode": "100644", + "gitBlob": "36b303757a541f05bf30142c38170ceaa3ca0c9b", + "rawBytes": 117, + "rawSHA256": "AB40183B646A3AD96727F41555EED46C8E381EFF9293FB922FA9264F310845E5" + }, + { + "path": "native/packed-rmq/route-registry.json", + "mode": "100644", + "gitBlob": "ae692b2bf1ad61f7897677ca482b3fb5b9299753", + "rawBytes": 4324, + "rawSHA256": "33609A968052FB37894CACD9721BE12AD1FBAFF0BF332A0287CD1AA38622F539" + }, + { + "path": "native/packed-rmq/route_shim.c", + "mode": "100644", + "gitBlob": "e54b29b4f8a3df6654df0d34df13a87ea86e573c", + "rawBytes": 1580, + "rawSHA256": "24FFA6075DFE6D0C1AFCD89096A60306B794A7CF29C1D98A85D49B4E9B66149D" + }, + { + "path": "native/packed-rmq/src/lib.rs", + "mode": "100644", + "gitBlob": "0811bfde8b13442e4932623c004446ecfadbdd25", + "rawBytes": 2702, + "rawSHA256": "755DB6898E9FD6D843C290AA48FA19591B1BEC6B4BCE966103E121B7DF21E573" + }, + { + "path": "native/packed-rmq/src/lifecycle.rs", + "mode": "100644", + "gitBlob": "8a9fcfea775ee186436006cdf74e6defad94cc40", + "rawBytes": 18498, + "rawSHA256": "19EF29EF8A6A4DC49276F1E0587819CC9317CB1AA778AED194BD13006F0AD2E1" + }, + { + "path": "native/packed-rmq/src/lifecycle_main.rs", + "mode": "100644", + "gitBlob": "9e7d25ddf1a87385e8d15e1454a997c14cd57607", + "rawBytes": 3926, + "rawSHA256": "576FC2EE813ABA8779B276182AE431DED2F111A49C3E7031149BF42A99715033" + }, + { + "path": "native/packed-rmq/src/main.rs", + "mode": "100644", + "gitBlob": "5d6477d1c053b7d825a962a90c09740b6c8182fa", + "rawBytes": 782, + "rawSHA256": "09D2A564311B22309DC0D9E972043124485C47BEA302FCFE8D34373AF7388BED" + }, + { + "path": "native/packed-rmq/src/native.rs", + "mode": "100644", + "gitBlob": "2274667fdbc986a76091c2469fa37b99afe64d28", + "rawBytes": 5211, + "rawSHA256": "82E7DEF4F6F67FBC52D0829FF82BA67082D7E68FC8B7A6938EDA41802AA1BDE7" + }, + { + "path": "native/packed-rmq/src/native_main.rs", + "mode": "100644", + "gitBlob": "bb457d349d8ae70dfa4d1441c7fa431d1407b582", + "rawBytes": 2910, + "rawSHA256": "3251E67EA8339FF7E5339B78A025308B0D031348BA844BDCBACA9C56CFAF1E22" + }, + { + "path": "native/packed-rmq/tests/lifecycle_owner.c", + "mode": "100644", + "gitBlob": "d621e1b20700adfc718258dde392f1a3597ead8a", + "rawBytes": 48070, + "rawSHA256": "0CD522806030BDDB51BE7F55B4B8C006612C59A3D168815ACCFA34B9AD635DED" + }, + { + "path": "native/packed-rmq/tests/lifecycle_rust.rs", + "mode": "100644", + "gitBlob": "dcdf5e5f3e4a26b0b5620b88df5899432e597a00", + "rawBytes": 5436, + "rawSHA256": "D825DE27E65CA7C0BA872B1B3100D6DF9D98DC895F85A0CC2B7B81E7C50C850E" + }, + { + "path": "native/packed-rmq/tests/lifecycle_storage_probe.c", + "mode": "100644", + "gitBlob": "1dbf0fa0b34b77f7aa6e2af120d6a3f816c3edc4", + "rawBytes": 14720, + "rawSHA256": "5F32F4A91B21697F86B4F2FEA855CD050E59E330CE6C6FFDA28898353B66D7B1" + }, + { + "path": "paper/.gitignore", + "mode": "100644", + "gitBlob": "5303101f1cf6c4745bafdd80e1261823420ecddd", + "rawBytes": 150, + "rawSHA256": "448507AF277485B91566F6098AF6079E1854D56AE00D3F3E1952FA31C3A517EB" + }, + { + "path": "paper/EVIDENCE_MATRIX.md", + "mode": "100644", + "gitBlob": "bff00359697fa4895fdd9086a086226dd5bf5fea", + "rawBytes": 23874, + "rawSHA256": "C55119C91F4481688F83ABF8133470A753BA497DFA14F9D026DE6D3E6D0B56D7" + }, + { + "path": "paper/NOVELTY_LOG.md", + "mode": "100644", + "gitBlob": "b8a17d33c984b6a311f2af7da988c28d2f32d261", + "rawBytes": 101342, + "rawSHA256": "3CA0111F985E15FFFFBDEA6304EF13D46B4818B05C490AC361DD531E7D7BD509" + }, + { + "path": "paper/README.md", + "mode": "100644", + "gitBlob": "5197d6ee8425962a8be7360096401a918287edec", + "rawBytes": 15433, + "rawSHA256": "B318A0087D82514E71938B04282F407357F43198D8D0F3AE379CC1B238E09A9A" + }, + { + "path": "paper/RELATED_WORK_LEDGER.md", + "mode": "100644", + "gitBlob": "74c56d2bb1dc3be0ce924ec4a521f44b17ab4a10", + "rawBytes": 21862, + "rawSHA256": "5A901CCEF1EE753FD7882254F056488A2F322BB25F15750789E1CDF75882BE71" + }, + { + "path": "paper/THEOREM_LEDGER.md", + "mode": "100644", + "gitBlob": "2173cff1fe884f3f2d6bfccce0e96d3efdf1d4c9", + "rawBytes": 43742, + "rawSHA256": "32A299E6094F7CDE4E65AF5E23F17A50146DD83BB3B505D11DB95F89164C206F" + }, + { + "path": "paper/WORKLOG.md", + "mode": "100644", + "gitBlob": "845f9621da12e9c4f19da7a407366e1a95c482f4", + "rawBytes": 18045, + "rawSHA256": "C2D3E7EDD1097047E2D318359AA00F3ACFD206DC2D9280484DF2348D544D7C8F" + }, + { + "path": "paper/check_citations.ps1", + "mode": "100644", + "gitBlob": "8517110484e0a11edeb0a1ee8523c68005b07061", + "rawBytes": 30833, + "rawSHA256": "7A7A4A3C4C62E826A77E954E1BC4D97207BD4364B950B5F58032D906D1A9624F" + }, + { + "path": "paper/check_paper.ps1", + "mode": "100644", + "gitBlob": "6d728f1d58747b02a659281f6e6df48d5a97459a", + "rawBytes": 39497, + "rawSHA256": "C7EFA32146415426E691AC673963E36D35E96D8DCBDBF04DC01A262B0861B26F" + }, + { + "path": "paper/references.bib", + "mode": "100644", + "gitBlob": "2b70ba3c49f42ca53e8a257792103a4781dbefe1", + "rawBytes": 12993, + "rawSHA256": "DA043B74A42C7B05F4DE31EDF2EF9297677642EC7089489216894D43ACD8C248" + }, + { + "path": "paper/rmq.tex", + "mode": "100644", + "gitBlob": "5e8b9d2f6b4f533332d52748338e2eeb4fb15828", + "rawBytes": 67318, + "rawSHA256": "3D46820F764594E34703A4C546B20867013A127AF96FA91C679DF627D855BFFB" + }, + { + "path": "scripts/.gitattributes", + "mode": "100644", + "gitBlob": "0a5b864e5c92c10da85b2f61f939cc1d50b460de", + "rawBytes": 748, + "rawSHA256": "7C4B1F2664E8E60ECB8C7FA4E0663F58C240891B96A9EDBCB69D41E26B62BE33" + }, + { + "path": "scripts/archive_axiom_check.lean", + "mode": "100644", + "gitBlob": "ec6adbb7aea3d241c5dc864a6911602b06bba0c6", + "rawBytes": 945, + "rawSHA256": "2CA5126392155285E8236B3BC0316DA0609CCE711B3647D500D046910B0D13AB" + }, + { + "path": "scripts/axiom_check.lean", + "mode": "100644", + "gitBlob": "5efb115e73bc90c11bfb39eef5493dd64e2e1213", + "rawBytes": 112880, + "rawSHA256": "EC45BA8EB324FE514D5919B0295C295FF7C8B8906117E6B9F96CA48BFBA0D4C2" + }, + { + "path": "scripts/bp_navigation_axiom_check.lean", + "mode": "100644", + "gitBlob": "4e8a2da0dc129314d5eca7761a623c8d4d18e7be", + "rawBytes": 3660, + "rawSHA256": "51036FC6B7C924283865D5DA7E76F2E29869685AD83025060B6E7554D270F637" + }, + { + "path": "scripts/claim_drift_policy_regression.ps1", + "mode": "100644", + "gitBlob": "6fd6dc4d2463851666b49f2c7e4a00ea1e4fe3bb", + "rawBytes": 68061, + "rawSHA256": "6746AAAA408194889D451DEEE348072CF53BDA5920318CD228AA7A45835DFC77" + }, + { + "path": "scripts/claim_drift_scan.ps1", + "mode": "100644", + "gitBlob": "62badf7e071447a3f3a3f8db0d47a3970b918ad5", + "rawBytes": 19319, + "rawSHA256": "5310DBA1242B3ED4A0B054A15B1B6911C056C228B2711F3D958EAB539BB3F6F7" + }, + { + "path": "scripts/constant_sync_check.ps1", + "mode": "100644", + "gitBlob": "85a6d18537eb3fd96edb00c29b413be2490120c1", + "rawBytes": 23256, + "rawSHA256": "78273ED1D7EAFCF991882804C761E458C53090EDA2AFE1A9CC25970EDF1A4506" + }, + { + "path": "scripts/design_decision_check.ps1", + "mode": "100644", + "gitBlob": "f3352f2312b746a698b411436d3f126b970b9781", + "rawBytes": 17247, + "rawSHA256": "1099C55F3112CF3D7B93033E5A666A3E9E1C707BA09ADB1F71EE69B8039EC4AD" + }, + { + "path": "scripts/design_decision_check_regression.ps1", + "mode": "100644", + "gitBlob": "fcb65d9709e2cfe15389788a9fc1bdf73e2abee0", + "rawBytes": 70080, + "rawSHA256": "BC866C3CEBE236FA304ADB1DCF4DD2DDBF9A9708C83D60A16EF274C93E7393F8" + }, + { + "path": "scripts/eg_cp_final_falsification_replay.ps1", + "mode": "100644", + "gitBlob": "2e30e5870acec557766a8223b97d9f106e265d84", + "rawBytes": 40608, + "rawSHA256": "0A1CC091C304238C24D5AE1F955511C19440B40E443612B47094230B95C488D3" + }, + { + "path": "scripts/eg_cp_stagea_replay.ps1", + "mode": "100644", + "gitBlob": "a5744329b0bbdfb1e599d24d9a36b92a3fb5c045", + "rawBytes": 45432, + "rawSHA256": "ADEEBA662C1FB668862DEE64653F35DAF9FBF1553262A0BFB9734D1C73F52A1E" + }, + { + "path": "scripts/gate.ps1", + "mode": "100644", + "gitBlob": "3bf1baa224b2507cda8bddb3206de89d7265c073", + "rawBytes": 37829, + "rawSHA256": "CED6ED7DD975FFBADE7211B8F82DE1AFC78F3DA69A0E2EC706EC5A545A41DD95" + }, + { + "path": "scripts/headline_axiom_check.lean", + "mode": "100644", + "gitBlob": "1b4b1c780289f7a381d803aa1b64f0a871ed614f", + "rawBytes": 41098, + "rawSHA256": "9DB73B697645B7C92F460AF642A61E9D19DDA97225960D8E7A7FC548BD6B9A49" + }, + { + "path": "scripts/headline_check.ps1", + "mode": "100644", + "gitBlob": "145b9c5d0517fa690fd272739638296a112a73c9", + "rawBytes": 1394, + "rawSHA256": "D3A19639864A95AD842AED6D94EF4D1AD1F36C8A83577F2FCE2B78969C853C7C" + }, + { + "path": "scripts/host_shell_path.ps1", + "mode": "100644", + "gitBlob": "4beb65a1cdde891603cb6842df269ef6d26dcee6", + "rawBytes": 3467, + "rawSHA256": "47D2F37A0CDE2920D08608702F22BEEE7C1340AC8548368E9289BC08A410AA56" + }, + { + "path": "scripts/hub_axiom_check.lean", + "mode": "100644", + "gitBlob": "829bf6e09aca9566bb6c803e9f35c52d8dc446ef", + "rawBytes": 2521, + "rawSHA256": "BB36646C35B4118FA5284D933DE154836718CBAAC95E80A2BA1D66592AEF96EA" + }, + { + "path": "scripts/hub_closure_lint.ps1", + "mode": "100644", + "gitBlob": "d08d6467b30ad88630a45f1f892db4b93fb2723e", + "rawBytes": 8495, + "rawSHA256": "241FDF677E4CE5AEE12CBA99D940A6F1C06E08A32B80C86454278F54A9DAF200" + }, + { + "path": "scripts/independence_check.lean", + "mode": "100644", + "gitBlob": "adb72eeb5cd46a8027b4a2f305dc7a691321034d", + "rawBytes": 10685, + "rawSHA256": "290BCB30D4284E3D132B2CF6FAD04B3FE0C32795C44F9A1C5015B538A9686033" + }, + { + "path": "scripts/ledger_decl_check.lean", + "mode": "100644", + "gitBlob": "704ae9825822e0f2e0b21fb9932e7a6fbc655d65", + "rawBytes": 8133, + "rawSHA256": "50DB7F0F27CFBADE83B6CE8ABE46206F540AE67890CA56497CCBA8095B72916A" + }, + { + "path": "scripts/lifecycle_contract_integrity.ps1", + "mode": "100644", + "gitBlob": "a75884897c856177f180e90c359c9d2d2ba0ed5f", + "rawBytes": 8781, + "rawSHA256": "F582FDC21665307B946B41F17EEB95C9BBE96DB7B025FDE6CC0D7141F5C4A9DF" + }, + { + "path": "scripts/lifecycle_dependency_README.md", + "mode": "100644", + "gitBlob": "76cb916bb762b33c16433e84c081f23205cac5f4", + "rawBytes": 5500, + "rawSHA256": "E5A65E69E7D337B11906CF1A5F1A91C15E53D7BC0C1707757AEAA1A01C4A8105" + }, + { + "path": "scripts/lifecycle_dependency_cases.json", + "mode": "100644", + "gitBlob": "57f1d4427f09299814542172b93fe164c098fbea", + "rawBytes": 38490, + "rawSHA256": "003343871E23C93DF874A960A8AF60AE7A8A2E615ADB05B6E581DC4407A1C84B" + }, + { + "path": "scripts/lifecycle_dependency_replay.ps1", + "mode": "100644", + "gitBlob": "2218a00913f0dd8865cd298d81279b0f41b1e998", + "rawBytes": 20989, + "rawSHA256": "4BF287CF5E0715DBE2413DE0E842E21781A38D51A94DA5873E1CF8A8972003FB" + }, + { + "path": "scripts/lifecycle_inventory.lean", + "mode": "100644", + "gitBlob": "aede16830f7cfcf79c8121fc354f31e2ebf0686d", + "rawBytes": 3790, + "rawSHA256": "A6D2C6B8AFA097BA21A5BBB11F529F375E4B1CC5A087F58AB0B143B924790001" + }, + { + "path": "scripts/lifecycle_native_build.ps1", + "mode": "100644", + "gitBlob": "6999611765409cf8dae62193da18f736dd606cab", + "rawBytes": 25307, + "rawSHA256": "2ECE2CEC3489A9AD2293D2E2B8B8F3950FF880DB346308EC87B918C8261083DF" + }, + { + "path": "scripts/lifecycle_native_cases.json", + "mode": "100644", + "gitBlob": "8acb56da0b992dc90b71070763428a6a064201fe", + "rawBytes": 22091, + "rawSHA256": "9DC72366B51592F18DC50E52D2B799C736DC047E6166538A0A880192062985FD" + }, + { + "path": "scripts/lifecycle_native_identity.ps1", + "mode": "100644", + "gitBlob": "9bcc52579d4b5c757784c8c4c8f7597f7bfb8e60", + "rawBytes": 9233, + "rawSHA256": "1D9F30EF1844EA0B48204B8417013A1661FE7B9488BA3985D81776596AFEC873" + }, + { + "path": "scripts/lifecycle_native_replay.ps1", + "mode": "100644", + "gitBlob": "58727f3b01e8bd84a77882903b4060ef5d9557d1", + "rawBytes": 19646, + "rawSHA256": "159CE88D97381E7B02C3CE4A27005C440156A5385222A0BD94A6FD746F4A7E2D" + }, + { + "path": "scripts/lifecycle_provenance_contract.lean", + "mode": "100644", + "gitBlob": "f7962d23c57e778daf937a7280e48c5ce5518b64", + "rawBytes": 5660, + "rawSHA256": "767743A4DD79B34377F5F5550BAB88693DF4A966826B02DE7AEDDA78043FD020" + }, + { + "path": "scripts/lifecycle_validator.ps1", + "mode": "100644", + "gitBlob": "6034e73e8214d0701a6429a4cbde0df9b2ecbc68", + "rawBytes": 8079, + "rawSHA256": "60655B5ECC0AA79E4FB11871C6FD802B57B29AB81491D577F7828F5052CABF63" + }, + { + "path": "scripts/lifecycle_validator_environment.ps1", + "mode": "100644", + "gitBlob": "6204df919a21f2c40d8c3d9f213e675d152a88c3", + "rawBytes": 2071, + "rawSHA256": "2FB2C4D95EAF3F6633FFAA60413D3D798B26E5BF8B4E712E6A254E293E4F9F19" + }, + { + "path": "scripts/m1_certificate_mutation_regression.ps1", + "mode": "100644", + "gitBlob": "2404417ed8dd5790b0b75a7952d906d8644e215b", + "rawBytes": 69107, + "rawSHA256": "9B8FF36330DD2D3C87B24A50196ACEF6303DEF9D71723ACD6140C8D7A69FB811" + }, + { + "path": "scripts/make_audit_packet.ps1", + "mode": "100644", + "gitBlob": "2bdfc822c43061f49f10793035150eb6d075d763", + "rawBytes": 3398, + "rawSHA256": "1E3FF7BC49ACCC5016F750C36F5B32B5E0257F9C34685822A809E833B3363753" + }, + { + "path": "scripts/owned_process_tree.ps1", + "mode": "100644", + "gitBlob": "71b2704e9b77af3b55d4b97c626207013938b5b0", + "rawBytes": 47060, + "rawSHA256": "6690AD4F9E3AEE9596E53E89D3D242E4BE59C0A04733BC50184AE35B292FF90E" + }, + { + "path": "scripts/packed_bitvector_allocation_consumers.lean", + "mode": "100644", + "gitBlob": "2e31e7c41041a53a62634361d940209d3005adc2", + "rawBytes": 2349, + "rawSHA256": "11625C223A9EA1952FE664DFEE7D8DC9C2C3CE798A6C74A39CCD24ACC42D08DE" + }, + { + "path": "scripts/packed_bitvector_axioms.lean", + "mode": "100644", + "gitBlob": "92d7736811aab1c75e7417cb5b88dc721a53218f", + "rawBytes": 955, + "rawSHA256": "505072CA4722C123F65C7184855813AD75C4208763F696222B9127C955C0C145" + }, + { + "path": "scripts/packed_bitvector_crossing.lean", + "mode": "100644", + "gitBlob": "6227be6e6866f6ce75d3a3f9ab5cfa694482f7e1", + "rawBytes": 3638, + "rawSHA256": "33FFD328EBC0F80EEBEA279B4904F804D5A54E1FE5CBC2C4A017A75807FE279D" + }, + { + "path": "scripts/packed_bitvector_exceptions.lean", + "mode": "100644", + "gitBlob": "931ed6a7e4261c29b278b62652d5df81f9a59903", + "rawBytes": 14618, + "rawSHA256": "DC3A964CDE6DE9AC1222761BFFB89B3D6D783708D3661DE20EF9EF77134E136F" + }, + { + "path": "scripts/packed_bitvector_exceptions.ps1", + "mode": "100644", + "gitBlob": "8dda71bd5763e9e2c9f741e83d2e46d52638e8df", + "rawBytes": 11128, + "rawSHA256": "F16EDBFC6578043DBAD17BEE9F97FD2B1A569E2BBBBA622958F1F65195A7BD64" + }, + { + "path": "scripts/packed_bitvector_machine_controls.lean", + "mode": "100644", + "gitBlob": "b44cf08967fccc4a4a457f91aa74130c554dc2de", + "rawBytes": 9929, + "rawSHA256": "F8F7ECBB3C6AF7023B9F5FD69E9034EFB48C1EF29449A288C2395B7B363C2DC5" + }, + { + "path": "scripts/packed_bitvector_machine_controls.ps1", + "mode": "100644", + "gitBlob": "8a32f2afed7f1f181f8e64006379fc5929d40b5e", + "rawBytes": 10320, + "rawSHA256": "19299CD26FDC0050605D8054DD2608723DB95E76682EE8F2DDC4A1347AE71F13" + }, + { + "path": "scripts/packed_bitvector_normalization_consumers.lean", + "mode": "100644", + "gitBlob": "f309cbb54fc9ae6a051bc59eaf51e4c04b328d11", + "rawBytes": 1115, + "rawSHA256": "CF7C09F2CE8DF5D364933FD0BD982BC1835610F5D2B6CCAEBE0EDD6374C529A2" + }, + { + "path": "scripts/packed_bitvector_probe.ps1", + "mode": "100644", + "gitBlob": "865e3d38ff8a19904f9bf1fe23b1a9664c4626eb", + "rawBytes": 2384, + "rawSHA256": "FE126C3906CD65BA3AE65EE773EE1B818CD86564CB7190DB837151BD0D10A06D" + }, + { + "path": "scripts/packed_bitvector_public_controls.ps1", + "mode": "100644", + "gitBlob": "3fdb45ab92074cf1a215212951cf3af6ce2ee671", + "rawBytes": 31987, + "rawSHA256": "CF2D7C080AD7F4ADF42313C693ACF474CF87147DE1FCAF93A31AA164994BA085" + }, + { + "path": "scripts/packed_bitvector_selector_controls.ps1", + "mode": "100644", + "gitBlob": "db6f8cca8452005208bd62b779eaf47e2045c26f", + "rawBytes": 4287, + "rawSHA256": "601BD8289E805E9ABB2B09607C02FD2AA36428F7EA7FB5767B812BC3B578739D" + }, + { + "path": "scripts/packed_bitvector_validation_controls.ps1", + "mode": "100644", + "gitBlob": "94d9831d869ff73950972ac853267a0f5e583432", + "rawBytes": 7561, + "rawSHA256": "FA3E2C3A7F6E329417CB854F8B2B841B543479478B2FB346314F71E84F0818F0" + }, + { + "path": "scripts/packed_native_binary_build.ps1", + "mode": "100644", + "gitBlob": "05f3961aa8e9ad141a5dec2857d2d534c9b14de9", + "rawBytes": 9141, + "rawSHA256": "7FB90CC8AF87AD01FD250E8D9A253852E5A954FEF0E5FD8E7B48F06DBBFDAB87" + }, + { + "path": "scripts/packed_native_binary_cases.json", + "mode": "100644", + "gitBlob": "a5f65a46d14eaf9f39a1c6b6c8bdd31801cf7eb6", + "rawBytes": 133238, + "rawSHA256": "2D38A1002C1E8A72DF5E164144EC4E8F5410511F2C585831AEFBBC0D1BD4C637" + }, + { + "path": "scripts/packed_native_binary_controls.ps1", + "mode": "100644", + "gitBlob": "9d4ff7d086c611efa400879235b6d5961a4149e6", + "rawBytes": 20304, + "rawSHA256": "EDEE71ED973FFF4BC860E1258C6B7FED315FEE43218179C800407998AAD58104" + }, + { + "path": "scripts/packed_native_binary_replay.ps1", + "mode": "100644", + "gitBlob": "fb33e0f29e876a7ab90d57eccc1f69b5cd09b55b", + "rawBytes": 20983, + "rawSHA256": "36774810EB0BA670594D11D11DBD22924032CE8F67554027B5ED5F02CB80DCF6" + }, + { + "path": "scripts/packed_native_build.ps1", + "mode": "100644", + "gitBlob": "8c138c52ba1363bc07b5e5b15b71af882159473a", + "rawBytes": 7888, + "rawSHA256": "4DD02865B2965BECA93E506BB65CA452A867A4DDB047BA9E8A7A4A01B49E751E" + }, + { + "path": "scripts/packed_native_cases.py", + "mode": "100644", + "gitBlob": "ca521d5e9714902f57f0092ce49f36f550155169", + "rawBytes": 54317, + "rawSHA256": "C6AF8167DCE972FF220FA5D61B1D528109737FA9BC9D0A7AB625AB06B0391A4C" + }, + { + "path": "scripts/packed_native_command.ps1", + "mode": "100644", + "gitBlob": "e83f9970bcb1c8cf8d2e63bc66bcc446b39cf22a", + "rawBytes": 1612, + "rawSHA256": "AFB87A955A63408F5E6E4BFAA32A99FA0BE62B16AB81D79EF27654B3B1C31A1E" + }, + { + "path": "scripts/packed_native_contract_cases.json", + "mode": "100644", + "gitBlob": "b4b94a4d978a2eedbcd50c1594858f244ae3c847", + "rawBytes": 64731, + "rawSHA256": "6E0C8E5A73F7DE47D14F7298435E7F72F2AC82A5881AEBF3EFFE0388CBF48E2C" + }, + { + "path": "scripts/packed_native_contract_replay.ps1", + "mode": "100644", + "gitBlob": "f376637c88af8f6786c51ab95124cf5414daff19", + "rawBytes": 20036, + "rawSHA256": "AE8BC171667857E693D58E74626D425AB5C7F8AB43BDA4D6996A6FF92C8C3687" + }, + { + "path": "scripts/packed_native_controls.ps1", + "mode": "100644", + "gitBlob": "229125631b7387950501a9a080e8ff75cd4e80ed", + "rawBytes": 16520, + "rawSHA256": "CB54568CDE80171F868C5D0252EB31C2C5952D1C7EBC586FCA78771C9CADBA9C" + }, + { + "path": "scripts/packed_native_final_types.lean", + "mode": "100644", + "gitBlob": "e71c26b9cdecad4c16713f3b3d2a5017add4e2d1", + "rawBytes": 493, + "rawSHA256": "CF8239C7CE04A72D87843D4BC1D95FAB03B01DA909F747DC65B1EE880FB7B3F3" + }, + { + "path": "scripts/packed_native_hydrate.ps1", + "mode": "100644", + "gitBlob": "8fc2df5271e2d765fc14545a426bc68d43982945", + "rawBytes": 15523, + "rawSHA256": "9E98F0DB4395BDEBE953720140E1BBCC81352EA8A57A649F227CF74D3CD93D83" + }, + { + "path": "scripts/packed_native_identity.ps1", + "mode": "100644", + "gitBlob": "06fec4b50c714cdc473e0fa9167e837c2d0ba295", + "rawBytes": 18289, + "rawSHA256": "A21F67E2EDF49C8E218C657E73967E920EFB85FF025476E01BD04A83CA50B17A" + }, + { + "path": "scripts/packed_native_identity_controls.ps1", + "mode": "100644", + "gitBlob": "e50b0016308af3f6913067f82f5867d2598c1332", + "rawBytes": 5402, + "rawSHA256": "7FAB648DF5CB39FD7EDE63F7E5E4C1D053F2568FF5E55709DF376D4F9E742F91" + }, + { + "path": "scripts/packed_native_identity_v3_controls.ps1", + "mode": "100644", + "gitBlob": "954ea8efbc031540d851a9465cec044cac49b3de", + "rawBytes": 14096, + "rawSHA256": "D8C9C5209D2E4FD738D9F89208A3AEDAB5FC35916A9F8220CCFD94E94422BBD1" + }, + { + "path": "scripts/packed_native_image.py", + "mode": "100644", + "gitBlob": "9c08992a13a23e91694459d0a7e8a0720dea5e16", + "rawBytes": 5140, + "rawSHA256": "29766C6DD5BA76E7BF6FF22AADB6872F7B69AD07C35DDAC79A99B6E5D73ABE98" + }, + { + "path": "scripts/packed_native_lifecycle_integrity_check.ps1", + "mode": "100644", + "gitBlob": "54a46986100f39ff0aaf0f3e02a6bb18e7d76977", + "rawBytes": 7857, + "rawSHA256": "4DBDE3FF1B030829C89DE70EFFD12D959404181A545117ADD11AC869BE0E426A" + }, + { + "path": "scripts/packed_native_lifecycle_storage_replay.ps1", + "mode": "100644", + "gitBlob": "9dbcb0e417544b5044d9d76568d431e5f6003299", + "rawBytes": 44594, + "rawSHA256": "C35BB6D38EB54562CB1E650D437D0914DE72852594DFDB865DB04E24104AD345" + }, + { + "path": "scripts/packed_native_lifecycle_stream_check.ps1", + "mode": "100644", + "gitBlob": "b131230876d9f34cd17fef819aec5f780f4960c1", + "rawBytes": 11222, + "rawSHA256": "71084788A6FE3E5662E187E82F74F078C65FC2F9425ECC9A0C23554BB2E641B7" + }, + { + "path": "scripts/packed_native_route.ps1", + "mode": "100644", + "gitBlob": "9c923afd07d68aa31a36ec875495a8c2b7a31a0a", + "rawBytes": 13622, + "rawSHA256": "8E935824C5A2A01450B7AFFA2E14CE9AA3BAF6C503F1FD423BD249987EB32724" + }, + { + "path": "scripts/packed_native_types.lean", + "mode": "100644", + "gitBlob": "b7e86c11ffbc964b4944fb85a7f6f2f219ab4177", + "rawBytes": 2576, + "rawSHA256": "1E4612ACB570649D8163F684E8F92B7C56056D1A04D1B1AE3592213C08885712" + }, + { + "path": "scripts/packed_native_validator_controls.cases.json", + "mode": "100644", + "gitBlob": "d4024eb6d0e6487cb598cc4c228750e6f13ff4ba", + "rawBytes": 9532, + "rawSHA256": "60D07EC27D7854FEB107CE8A1148F382F17F882CD8F2F18427FBD8BDE8D755EC" + }, + { + "path": "scripts/packed_native_validator_controls.ps1", + "mode": "100644", + "gitBlob": "a7beca1726e99c5d78d4d5e6f4fe71007b6d89e8", + "rawBytes": 13716, + "rawSHA256": "719546F3020562C86DE8169CAA17FB1AB0580255E7E9FAEC4DA3BC70D62BAF9F" + }, + { + "path": "scripts/packed_native_validator_import.lean", + "mode": "100644", + "gitBlob": "1bad2e5002a84aa9a2e9ae1ae0828c3cf67a17e5", + "rawBytes": 327, + "rawSHA256": "1C1B1F8229A2F1B564E9AB5A5A255D9334FEA044E2900D1948E228960B16C6AC" + }, + { + "path": "scripts/packed_native_warm.ps1", + "mode": "100644", + "gitBlob": "845d3ffb5d863e926ab6c67bccd03ab24169da6a", + "rawBytes": 4822, + "rawSHA256": "B891DF9382EDB15BA1CD8E7A513D0E9E7006719771534B6B13DABE3097716ABF" + }, + { + "path": "scripts/packed_optimized_axiom_check.ps1", + "mode": "100644", + "gitBlob": "a7b702b2df4d8c584448076f5d05b0970f8da353", + "rawBytes": 4142, + "rawSHA256": "AFE0FB40ABE0DB38CC002B702A795C3E85096FC448F04AF979FD4B9BA7FA7224" + }, + { + "path": "scripts/packed_optimized_axiom_union.lean", + "mode": "100644", + "gitBlob": "e333a4cd1665817af0ffd2eef7e0f4131d84ca63", + "rawBytes": 10580, + "rawSHA256": "D0A44ECD5F2851661A3036B641FBF42BB6D10F1ACD55A96C3879D86DFB6FC041" + }, + { + "path": "scripts/packed_optimized_axioms.lean", + "mode": "100644", + "gitBlob": "84376e2c104630d0ffbecc4bea354f8f781d9112", + "rawBytes": 9870, + "rawSHA256": "FFDEDB3F171A347E47A84D3064C7F5E146F9E270FD02FBBE719D2D325FFDC908" + }, + { + "path": "scripts/packed_optimized_build.ps1", + "mode": "100644", + "gitBlob": "6f5dcec5d0d49cb0dc280604cf0aab7116e6419f", + "rawBytes": 4701, + "rawSHA256": "56160475202428B1D1FD7A25190743E1EDA3A0FCC2CD98FE568C388E32ACBE6D" + }, + { + "path": "scripts/packed_optimized_certificate_replay.ps1", + "mode": "100644", + "gitBlob": "e1b38040f24b8c227afc486c63c745b2bb61303c", + "rawBytes": 40661, + "rawSHA256": "A37CA628267371275F200C0A0BCE8DB9DEC9663BA1FFDCE76BB9509C259FD33B" + }, + { + "path": "scripts/packed_optimized_replay_profile.ps1", + "mode": "100644", + "gitBlob": "5100f8031169156cc6dfe67e342812b6b26b5556", + "rawBytes": 21746, + "rawSHA256": "AFEBD785F9B38FE08E2652CCF53197180EE4E3BBE088C25545F84663CB573739" + }, + { + "path": "scripts/packed_optimized_replay_regression.ps1", + "mode": "100644", + "gitBlob": "481cb96714d463fedb3b59107b9f2fe3d50e7896", + "rawBytes": 26660, + "rawSHA256": "B88F91393FCDE7395CC1E0B2634C572F8FBBC4AA162F0ADA08F87A7146ED72DD" + }, + { + "path": "scripts/packed_optimized_runtime.ps1", + "mode": "100644", + "gitBlob": "aef90cc789ec25f265d2c645b1d39fcaa4e319b9", + "rawBytes": 25286, + "rawSHA256": "394AA523ADC06D1602CE6F97E7446CDAA2CD36929E96F8D1E80D5564C25A57BB" + }, + { + "path": "scripts/packed_query_inventory_check.lean", + "mode": "100644", + "gitBlob": "6665a12079277057fd63ca483e080ce05e23df2b", + "rawBytes": 2900, + "rawSHA256": "BBDD774E8FFEF0E82857350FC918D2CA11D1BAD2E56E1809E0E2D301BC2D5E2E" + }, + { + "path": "scripts/packed_query_replay.ps1", + "mode": "100644", + "gitBlob": "c006567c7aba8a736eca5e92986224ff5ccebe8f", + "rawBytes": 51332, + "rawSHA256": "9D119A4406057E0A34BC89A2DFCC3FACF98EAFFBE8CB410065FD170C3A3AC1C6" + }, + { + "path": "scripts/paper_topology_lint.ps1", + "mode": "100644", + "gitBlob": "6c2174705132dbb8672cc8feca90fcb38967a64b", + "rawBytes": 39461, + "rawSHA256": "8BB5604311F569334F7EBCF9BDC76BD1115604EFE735BC3C097508283A14D876" + }, + { + "path": "scripts/paper_topology_lint_regression.ps1", + "mode": "100644", + "gitBlob": "f0c6c17858fc09fd29cd5fd31080ec1eafbaf65b", + "rawBytes": 23673, + "rawSHA256": "A51F7025D2F1AC7001605C74B7961724AD770ACD0A64569C03B681BB6FAF7F24" + }, + { + "path": "scripts/preprocessing_builder_check.lean", + "mode": "100644", + "gitBlob": "4f3570cbd8ae3220f784b5c5a2f3abf46c8bc088", + "rawBytes": 34095, + "rawSHA256": "FD38D26CC5E165DCDE1DB860C35892F9BED798277DDB989E7E6251E6CBA4AE49" + }, + { + "path": "scripts/preprocessing_builder_firewall.ps1", + "mode": "100644", + "gitBlob": "27c45086a1ed82531dddb3782624844694e00b3e", + "rawBytes": 10591, + "rawSHA256": "658118E815D994BABAEF68E383A385DFF6B8732100726B27463260B29C73ECC8" + }, + { + "path": "scripts/preprocessing_builder_gate.ps1", + "mode": "100644", + "gitBlob": "79044f143123f7540c9de91a75ced935140f63e3", + "rawBytes": 7676, + "rawSHA256": "DBDBD15332577C6226DC639FF7A79D76B38BC0E3717314EE340198D9C4E6D787" + }, + { + "path": "scripts/preprocessing_builder_replay.ps1", + "mode": "100644", + "gitBlob": "4885ebe233eb6bc3f09a467da74244c2c29a3d68", + "rawBytes": 58256, + "rawSHA256": "A1A1427531BE41317F232CCAF7D73481E4C96B57ACA4D585FF451149E04C4006" + }, + { + "path": "scripts/preprocessing_contract_check.lean", + "mode": "100644", + "gitBlob": "c71b2e6cdf8f6ae58e6cd57a2b470ca63cf78d02", + "rawBytes": 10146, + "rawSHA256": "F2D4D89FC175A0DBB16764A0FFA0B67BEBB413732F20036F590AABF9E2559EE9" + }, + { + "path": "scripts/preprocessing_contract_firewall.ps1", + "mode": "100644", + "gitBlob": "63b8fb96dfcaf7475d47abd8a2a6f02f5b727310", + "rawBytes": 4456, + "rawSHA256": "88255EC83F8F319A909FBB5D98DAF0E8DFDB1A68FC0F15C72FD8A986723B48FE" + }, + { + "path": "scripts/preprocessing_contract_gate.ps1", + "mode": "100644", + "gitBlob": "f83d41824db3d785e65fd83cf9bbf6de9dfd1d70", + "rawBytes": 3783, + "rawSHA256": "707A4D82544AB476D00F103FA780A7B803EECA63B078BF3BF86C97FE27EC1C39" + }, + { + "path": "scripts/preprocessing_contract_replay.ps1", + "mode": "100644", + "gitBlob": "593f4f1a935c4fb8ca8ab31b8c9c772265a9b559", + "rawBytes": 32111, + "rawSHA256": "12BB6E8A802F9A60151B75609E182002EA2D70582168980A7683EFF64DFB6322" + }, + { + "path": "scripts/preprocessing_spec_check.lean", + "mode": "100644", + "gitBlob": "9a74c2b2c7418345c797d40081c0f8c3e8979ea1", + "rawBytes": 42504, + "rawSHA256": "3E4E62DCDC61319B7AE9F33DB691857075FED0DC1C8EF11CC0116990E022129D" + }, + { + "path": "scripts/preprocessing_stage_check.lean", + "mode": "100644", + "gitBlob": "c91f5adb1d18e08b235bf4a1351892a495a01a09", + "rawBytes": 316353, + "rawSHA256": "A312530C7CAD2EC61E2AAB220BDF3D3333C92B80FEAA8E26A6F9CD405C7E0E4B" + }, + { + "path": "scripts/project_skill_preflight.ps1", + "mode": "100644", + "gitBlob": "090b205b5b292b5c1565da86ea27e69fe5b78f0b", + "rawBytes": 7551, + "rawSHA256": "3DD5B60E7C1C08102485F9D25A18647C643BF0CBD4BC00D57A01B8558B7E8FB2" + }, + { + "path": "scripts/project_skill_preflight_regression.ps1", + "mode": "100644", + "gitBlob": "95d142911cdd960f6172c74e33ac0ed79ec27037", + "rawBytes": 8250, + "rawSHA256": "F1F7646BE10E0E20BC05A3F75CDFF9EF04EDA859473319BB6D03735FDDE334C2" + }, + { + "path": "scripts/rank_select_axiom_check.lean", + "mode": "100644", + "gitBlob": "2067eadc2a6898174cb1e5c296bc78542089280d", + "rawBytes": 28465, + "rawSHA256": "5E5A3D0FF05BBBBC07CADEAF63A77E58C0CE98E4F827CC601C47AFEA8F2586BF" + }, + { + "path": "scripts/reproduce_artifact.sh", + "mode": "100755", + "gitBlob": "726f7e7f7790786309c3891263f836eb9025d4a2", + "rawBytes": 3313, + "rawSHA256": "A3A98FFC9F9C096AD3724947DFF96B3E456CF7B553AD8C3951BF850F6C8DFCE4" + }, + { + "path": "scripts/review_wordram.ps1", + "mode": "100644", + "gitBlob": "a290108523bd25b7cf2fb72169c30734743c2441", + "rawBytes": 1588, + "rawSHA256": "6303E50B700F0119BB1E1BC455706C11F17753F51260C4FCDB42D4C3368CB566" + }, + { + "path": "scripts/shim_lint.ps1", + "mode": "100644", + "gitBlob": "e521b5491aca0c310ca7aec8b42be32cf1f3069e", + "rawBytes": 1440, + "rawSHA256": "FB970BF0EA46BCBACE5C6D64314F96F4B64E7817EAD8C0D05883ADE4CF1A7AC5" + }, + { + "path": "scripts/succinct_cost_lint.ps1", + "mode": "100644", + "gitBlob": "f857e99bcd1d58d51dde42f5e5fd715abbd6ed88", + "rawBytes": 1910, + "rawSHA256": "9838CD745B6EAAAFC6F9110827B8815D94A02D76CBB806638942180BB2B30811" + }, + { + "path": "scripts/tag_annotation_check.ps1", + "mode": "100644", + "gitBlob": "d7767fb1330e2545ceae77f8d0f2753f15c6caf1", + "rawBytes": 10420, + "rawSHA256": "D712E33694609F72E64632D58F02A28B8A9BBFB21508C28EBBFCC1292CBF4EC9" + }, + { + "path": "scripts/union_find_axiom_check.lean", + "mode": "100644", + "gitBlob": "ea0f009480c0660d8521925695d88a354b39f0dc", + "rawBytes": 23011, + "rawSHA256": "36B0CCC2A56F344639ABB2EC26948114AFE7E238824CFD544CD119D5DEAD5DF1" + }, + { + "path": "scripts/variable_payload_axioms.lean", + "mode": "100644", + "gitBlob": "75739ba081dc4b7122b8005845c5eb0e7ec3ef76", + "rawBytes": 1877, + "rawSHA256": "6C1A1ACD79D0E218DC27C4B4330CD67C296F022795E3BF567221813CB61C65E6" + }, + { + "path": "scripts/variable_payload_build.ps1", + "mode": "100644", + "gitBlob": "d7e12dd66ecb97e460d53bf06f0c320092d946bd", + "rawBytes": 6712, + "rawSHA256": "B87170FB5780DFE9D503B04E11A2EA31C03C0746ABB278F350949A4061E93ACD" + }, + { + "path": "scripts/variable_payload_contract_check.ps1", + "mode": "100644", + "gitBlob": "bf91c9afbfce0910fce98d874f620925b47d769c", + "rawBytes": 12385, + "rawSHA256": "5504E3E41000F9E91EB12853A34DB02C52B928D65F118A8B699893EA917AA0D2" + }, + { + "path": "scripts/variable_payload_generic_consumer.lean", + "mode": "100644", + "gitBlob": "0bc23412318dc5c0741255f92cb6c0abdbfb3cf0", + "rawBytes": 2648, + "rawSHA256": "ED02747BDBFB75E82782616361C7F3C365362C88B70D3E252FE6ADF05F49D3A5" + }, + { + "path": "scripts/variable_payload_inventory.lean", + "mode": "100644", + "gitBlob": "c946c5fea2cd687d3f60be948c1400686cef795b", + "rawBytes": 5638, + "rawSHA256": "3C6BE8C594634D8B59BC315AB991D934938DF787782403F78C1BC2D43509ED7A" + }, + { + "path": "scripts/variable_payload_replay.ps1", + "mode": "100644", + "gitBlob": "3d56f627e52e25ed56b05a5d119ee725401e0a38", + "rawBytes": 28041, + "rawSHA256": "21278EEB94044B85529A6C28B4F4009800AA50A31DD8371EE71A61E0751A6CD1" + }, + { + "path": "scripts/wordram_axiom_check.lean", + "mode": "100644", + "gitBlob": "130176585c08cbd74c3801077de417efd19228e8", + "rawBytes": 42031, + "rawSHA256": "09439193560121CE14C42666023B8847ACE7643152C179835D5BF063E01558BA" + }, + { + "path": "scripts/worker_prompt_preflight.ps1", + "mode": "100644", + "gitBlob": "e3335a3648ac36cb656366cd7827e1d55c30612e", + "rawBytes": 23117, + "rawSHA256": "C0C68D7D78480D50644AA8C29352E77DFD12F4B0CED3CACAF955A63CCBBF2A40" + }, + { + "path": "scripts/worker_prompt_preflight_regression.ps1", + "mode": "100644", + "gitBlob": "ab6f1709a5303d40a008c5de18a42f81e0ad514c", + "rawBytes": 30419, + "rawSHA256": "B38C72C838D82C8FFCC7B96007CB1FAD4CB6C83D7F313485EFB66A82A2813CAA" + } + ], + "snapshot": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\4935\\RMQ\\.lake\\lifecycle-native1-r1\\restoration\\INITIAL_BASE_IDENTITY.json", + "bytes": 1203941, + "sha256": "eed7ae4880d30fc9a923727487c70ce7933cbee2c76a30386c72d04926d5871f" + } + }, + "restoredMaterialization": { + "approval": { + "path": "C:\\Users\\poin\\Documents\\RMQ\\lifecycle-implementation-20260920\\native1-repair-launch-20260927\\CHECKOUT_DISPOSITION.md", + "bytes": 4839, + "sha256": "8c6d80c15ce32fbe0fd64f2bcae78be3678d0e6cd88ca2ba2b90c9f9c67dd13d" + }, + "manifest": { + "path": "C:\\Users\\poin\\Documents\\RMQ\\lifecycle-implementation-20260920\\native1-repair-launch-20260927\\CHECKOUT_BYTE_REVIEW.json", + "bytes": 1827123, + "sha256": "010717ef74870011c7864235c272b6b404af1a45a883b7752becf519094fd850" + }, + "indexApproval": { + "path": "C:\\Users\\poin\\Documents\\RMQ\\lifecycle-implementation-20260920\\native1-repair-launch-20260927\\INDEX_DISPOSITION.md", + "bytes": 3665, + "sha256": "235a3225b43cf9c6a366baaeffedeba94a46aa6a6200a4a175a5b6382a1c28c9" + }, + "receipt": "C:\\Users\\poin\\.codex\\worktrees\\4935\\RMQ\\.lake\\lifecycle-native1-r1\\restoration-final-authorized\\RESULT.json", + "checked": 3930, + "restored": 64 + } +} diff --git a/docs/internal/extensions/lifecycle-native1-r1/COMMANDS.md b/docs/internal/extensions/lifecycle-native1-r1/COMMANDS.md new file mode 100644 index 00000000..f0fef2d0 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native1-r1/COMMANDS.md @@ -0,0 +1,233 @@ +# LIFE-NATIVE-1-R1 command and evidence ledger + +Status: CANDIDATE_COMPLETE, conditional on the final external delivery binding. Entries below are chronological checkpoints. All paths below are relative to +C:/Users/poin/.codex/worktrees/4935/RMQ unless an original origin is explicit. +This ledger distinguishes actual execution, component controls, cache transfer, +historical applicability and pending verification. It does not certify completion. + +1. Exact governance preflight: scripts/project_skill_preflight.ps1, + governance 7b227c49ef2ec044b702126cc41c9add847eed01, required rmq-coordinator, + actual runtime rmq-coordinator/rmq-proof-sprint/rmq-audit-prompt: exit 0/PASS. + Clean detached c52 was verified, then private branch created. START.json was + written immediately. BASE_IDENTITY initially captured all 3930 tracked files. +2. Immutable audit/launch prompt and complete formal/native/harness reports read. + Actual original mapping callers repeated through retained Python drivers in + .lake/lifecycle-native1-r1/baseline/: twelve ordinary outcomes, six incorrect + invisible-character accepts; no native/compiler child or output mutation. +3. The first H1 driver failed before setup because the fresh checkout had converted + frozen registry bytes. Full raw stderr/stdout remain under baseline/. The driver + then failed while attempting to inspect an absent run directory. This is a + checkout defect reproduction, not H1 evidence. The exact closure helper returned + Codec 3 / Entry 365 / defaults 371 / uncovered 362, with complete rosters in + baseline/BUILD_CLOSURE_REPRO.json. No stale DLL was created. +4. CHECKOUT_IDENTITY_REQUEST.json compared all 3930 original files: exactly 64 + CRLF-only differences. Coordinator approval is recorded in the campaign's + native1-repair-launch-20260927/CHECKOUT_DISPOSITION.md and INDEX_DISPOSITION.md. + restore_checkout.py copied only the approved exact bytes, with original target + bytes retained. Its first finalization failed on 64 Git status flags despite + empty content diff. The first identical-reindex attempt was denied index.lock + write access; the first elevated retry stopped at the existing output directory + before mutation. The corrected distinct-output elevated attempt passed: + restoration-final-authorized/RESULT.json. Staged entries/flags unchanged; raw + originals 3930/3930 equal; no tracked diff. Initial and restored baseline records + remain separate. No original checkout, hash constant or validator was modified. +5. Restored actual H1 baseline: baseline-restored/SELECTOR_SETUP_REPRO.json, ordinary + exit 1, no timeout, missing replay source, disposable remains, no PLAN/RESULT. +6. Four production scripts repaired after reproductions. The first fresh R1 + registry run passed all 74 exact cases: + .lake/lifecycle-native1-r1/controls/20260927T213218683-8830338d/RESULT.json. + Captures bind actual repaired Plan/Validate scripts and exact altered registries. +7. First R1 setup-control driver failed from an incorrectly parenthesized PowerShell + array expression before calling the production runner; the failed receipt is + controls/20260927T214050265-142634d8/RESULT.json. Corrected setup group passed both + cases at controls/20260927T214118298-1806e89b/RESULT.json: ordinary failure retained, + incomplete setup pins labeled, integrity/disposal/receipt independently attempted, + disposable removed and zero downstream invocation. The integrity-fault case uses + a separately retained disposable helper injector; the owning runner is actual. +8. First H3 control group completed five actual closure/phase controls, then its + test driver rejected assigning 600 to a parameter constrained to 120. Receipt: + controls/20260927T214346992-2f36b016/RESULT.json. The corrected driver passes the + long pure pin-check deadline as a separate argument; corrected closure7 passed + controls/20260927T214800052-5d66a654/RESULT.json. + No compiler/native failure or timeout was inferred from that driver error. +9. Lean cache transfer: cache-transfer/RESULT.json PASS. Verified 380 unchanged + source/config/helper pins, 4856 compiler/runtime pins and 742 generated inputs + against the original successful four-root receipt before copying. Also retained + 2226 exact Lake metadata files. Old absolute trace messages remain historical; + no path was rewritten. The changed builder is explicitly excluded from unchanged + source applicability and must execute freshly. This is cache transfer, not a + fresh current-worktree certificate or proof that every module recompiled. +10. Explicit reuse applicability passed for original 34 export cases, 21 axiom + declarations and 17 Rust misuse cases. REUSE_APPLICABILITY.json indexes exact + source mappings and full original tool/generated/capture pins. Checked accessible + occurrences: 6419, 5613 and 275. The 34 removed disposable export artifacts match + exact prior audit path/length/hash records; they are not available executables. + The first collector incorrectly keyed multiple removed mutation artifacts only + by path and stopped; the corrected key includes path, length and hash. No original + file or verdict changed. All actual source/tool/generated checks then passed. + +11. Existing immutable callers freshly passed: + selector33: .lake/lifecycle-native1/selector-controls/20260927T214422271-516ad1d2/RESULT.json; + control-selector18: control-selector-controls/20260927T214714322-376cba32/RESULT.json; + client-selector13: client-selector-controls/20260927T214846350-a79a5793/RESULT.json; + recipe11: native-recipe-controls/20260927T214952150-e95809cd/RESULT.json; + final-stream15: final-stream-controls/20260927T215000996-fd322020/RESULT.json; + final-stream-mapping5: final-stream-mapping/20260927T215056611-1054791b/RESULT.json. + All except the first fully spelled path share .lake/lifecycle-native1/. + Fresh owned root/descendant3 passed owned-controls/20260927T215032469-60182cd7/RESULT.json. + Outer transcripts in existing-controls-20260927/ supplement actual inner raw captures. +12. Fresh four-root Lean passed runs/build-20260927T215238511/RESULT.json under + .lake/lifecycle-native1/. Actual command: pwsh -NoProfile -File + scripts/lifecycle_native_build.ps1 -Phase lean -LeanDeadlineSeconds3600, + with the full nonempty evidence-based rationale retained in PLAN/RESULT. + No claim that all cached modules recompiled. Development R1 scope passed + .lake/lifecycle-native1-r1/scope/20260927T215310189-91ef3c08/RESULT.json (13new files; + the required approved expectation did not yet exist, so not -Complete). +13. Native object transfer native-cache-transfer/RESULT.json copied365 exact + original objects/metadata after source/transformed/generated checks. Fresh DLL + command: pwsh -NoProfile -File scripts/lifecycle_native_build.ps1 -Phase dll + -LeanReceipt . Passed at + .lake/lifecycle-native1/runs/build-20260927T215809530/RESULT.json: selected371/native365, + five actual compile/link stages,7091 final pins,cleanup;318seconds overall. + Toolchain digest matches original. Both full DLL byte identities are new; + all PE section bytes except .buildid match original, without changing raw pins. + Get-CimInstance process inspection lacked permission; ordinary Get-Process, + stage artifacts and subsequent successful completion established progress. + +Fresh clients/consumer campaign is running through retained run_fresh_campaign.py. +Each stage records full argument arrays, outer streams and its actual inner +receipt. Per-stage owned deadlines/captures are the semantic execution evidence. +External expectation approval, full48 Replay, final93 controls, default build and +report-sensitive certification remain pending. No aggregate gate is run locally. + +14. Binding preparation initially asserted equality between Discovery's deliberately + UNREVIEWED verdict label and the old approved accept label. This preparation + assertion failed before publishing any proposal. The helper was corrected to + require the distinct labels and compare the complete healthy projection and + exact ID/control/phase/argument/surface. Production runner/oracles were untouched. + Final immutable packet: binding-review/20260927T221135/REQUEST.json, linked by + BINDING_REVIEW_REQUEST.json. All48 case objects remain exact. Recipe7148 input + occurrences /6013 distinct /1135 consistent duplicates;5995 exact-byte mappings, + 14 fresh artifacts,2 changed harness scripts,1 new client receipt,1 new manifest. + New recipe e6d42db6a53666bbb577c69390240fad0520c8f0c2310940b7e239359ba8059d. + Full recipe/source/artifact bridges retain every pin, not just these counts. + Proposal status PENDING_COORDINATOR_REVIEW; approval has been requested externally. + +15. The R1 matrix writer initially used Windows text newline translation, which + changed embedded original requirement CRLF spans in the new quotation document. + A byte-occurrence check caught only28/55 exact matches. The writer now writes + strict UTF8 bytes without translation and asserts exactly one occurrence of + each of55 complete original requirement strings. All55 pass. No protected + original contract/matrix or source hash was changed. Original proposition and + object-composition cells remain explicitly labeled original evidence. + +16. Source review of the new R1 scope helper found that raw-file checks alone did + not reject protected staged mode/blob changes. The new helper now verifies + all3930 original modes,3925 protected blobs, stage0/unique entries, regular-file + new entries and exact Git changed-path scope. The frozen93 roster is unchanged; + its out-of-scope case adds explicitly test-only metadata holdouts for mode/blob/ + path changes through the actual Git predicate. Actual healthy scope caller + consumes the real Git output. No live index mutation is used in these controls. + +17. Current startup, W-TIES both modes, healthy Discovery, all13 fixtures in both + modes, ABI23 and all10 clients passed. Exact commands/outer streams/inner receipt + pins are in fresh-campaign-20260927T220440/INDEX.json. All142 requests/publications + pass the worker secondary exact capture review at semantic-review/20260927T221910/ + NATIVE_SEMANTIC_REVIEW.json. Preserved predicates independently compute leftmost + answers, compare all non-pointer fields, validate simultaneous live-bank/program + separation, exact capacities, paired owner/memory,10480 later backed reads, + 3288 payload reads and actual interior occurrences. Observed max28613 remains + finite evidence below the formal160257 model-step ceiling. Exact ABI/client + mappings and full streams also match the original. Adaptation records retain + original/current helper hashes and only path/UTF8-output changes. This is a + worker secondary reconstruction, not the coordinator's future blind audit. + Strengthened development scope passed scope/20260927T221817774-ec0f0adb/RESULT.json. + +18. Required fresh untargeted default lake build passed at + .lake/lifecycle-native1/default-build/20260927T221856519/RESULT.json. + Actual owned child219.363954seconds, ordinary exit0; integrity/cleanup passed. + The full fresh producer/consumer orchestration index is PASS. No aggregate + was run; the coordinator owns that subsequent campaign gate. All four new + R1 PowerShell helper/control scripts also passed AST parsing after scope edits. + +19. Coordinator binding decision APPROVE_EXACT_BINDING_FOR_REPLAY received and + full11315-byte DISPOSITION read. External campaign directory: + C:/Users/poin/Documents/RMQ/lifecycle-implementation-20260920/native1-binding-review-20260927/. + APPROVAL.json SHA256 f2742421769bd0cfc70cca740524d5b0f9421ea44ddb8d26298bb6f61f26ca3f. + The approved647054-byte manifest is copied exactly to owned R1 NATIVE_EXPECTATIONS.json, + SHA256723bb8b4422130282aef59f5d94b623f32ee187d6dc7c7a72c6a45ff5fb23d53. + Only proposal top-level status changed; all other proposal bytes and48case objects + are unchanged. APPROVAL_CONSUMED.json retains that identity check. The coordinator + independently rehashed22700 distinct identities/51581 pin occurrences and all365 + derivations. This is binding approval only, not candidate acceptance. + campaignComplete is historically initialized false and never assigned by the + unchanged native-control runner. Actual full coverage is48 ordered selected/ + result/stage IDs plus completeRegistry and successful captures; no false field + is relabeled and no proposal-bound script is edited for that observation. + +20. Complete approved native Replay passed native-controls/20260927T222714986-044d4db1/ + RESULT.json under .lake/lifecycle-native1/. Same approved SHA/path interface, + 300-second per-case deadline with measured fresh under9second process rationale. + All48 ordered selected/result/stage IDs match and completeRegistry=true; + campaignComplete remains false. Worker secondary review at + native-secondary-review/20260927T223237/REVIEW.json passes all48 projections, + verdicts, full recipe/stream/exit/final-pin checks,6500 distinct inputs. +21. Full current93 repair controls passed .lake/lifecycle-native1-r1/controls/20260927T222724916-f98084bc/RESULT.json. + Command: pwsh -NoProfile -File docs/internal/extensions/lifecycle-native1-r1/ + controls.ps1 -Group all -DeadlineSeconds 120. All93 ordered cases, three nested + Git metadata holdouts and actual healthy full scope consumption passed; + integrity/restoration/cleanup passed. No native/compiler semantic child ran. + This records the control-time report snapshot. Final code applicability and + separate final report-sensitive source certification belong to DELIVERY.json. +22. Final report/matrix/guide/plan assembled. All55 requirement byte strings checked + exactly once. Final certification command is pwsh -NoProfile -File + docs/internal/extensions/lifecycle-native1-r1/final_checks.ps1 -Committed. + It binds the final clean private commit, complete cumulative original-base + claim surface, strict design at c52 and3db, protected modes/blobs/raw bytes, + original55rows, append-only ledger, both hygiene scans and all whitespace + ranges. Actual final command/result/source/report identities are recorded in + external delivery/DELIVERY.json after successful certification. No local + aggregate or blind audit is substituted for subsequent coordinator gates. + +23. Private checkpoint commit9f962a7f4b50e0432f6cbeb62128eb0daecb7593 staged only + the exact19 paths and preserved every raw pin; Git metadata write used the + required escalation because the worktree index/object store is outside the + writable checkout. No push or merge. First -Committed final check failed at + final-checks/20260927T224625313/RESULT.json after both production strict design + calls passed:109/26code/80workflow/3neutral at3db;19/0code/18workflow/1neutral + atc52. The inherited Assert-LNFinalDesign consumer demands positive code and + both ledgers; applying it to the frozen WDD-only repair scope was incorrect. + Claims/hygiene were not reached by that failed invocation. +24. Only owned R1 final_checks.ps1 and supplementary docs were corrected. + Assert-R1RepairDesign requires the exact19-path roster and derives zero-code/ + 18workflow/1neutral classification from the unchanged production checker AST + literals/pure functions. Original cumulative result still uses the unchanged + old consumer. No policy/old helper/source/approved recipe changed. Command: + pwsh -NoProfile -File docs/internal/extensions/lifecycle-native1-r1/final_checks.ps1 + -RepairDesignControls. Passed6 direct controls at final-checks/20260927T225142062/ + REPAIR_DESIGN_CONTROLS.json: actual strict checker healthy, missing WDD, + unexpected code ledger, extra stdout, extra stderr and wrong exit. Raw captures, + exact expected failures and source pins retained. The frozen93 registry/driver + and all its executed dependencies remain unchanged. final_checks.ps1 was only + copied scope-file data in that run; final current scope plus these six controls + close its refresh. No Lean/native rerun is justified for this consumer change. +25. Final committed certification is rerun on the follow-up private commit with + final report bytes. Its exact outcome/path/hash and clean HEAD are recorded in + external delivery/DELIVERY.json. The earlier failed certification remains intact. + +26. Checkpoint3cbcaba1b17cadacfc4527f37d605aee371aa758 final certification failed + at final-checks/20260927T225503039/RESULT.json: claims timed out600.12seconds. + Both design checks and exact scope passed. Source integrity passed; the owned + job terminated25344/16560/23184/4700, with no surviving scanner/raw child. + CPU-active rg was running the unchanged attribution paragraph policy over + all109paths; no missing prerequisites, output overflow or build fallback. + Read-only evidence: claim-scan-recovery/ACTIVE_PROCESS.json and + TIMEOUT_DIAGNOSIS.json. Preserved raw stdout256467bytes/stderr0; no fake exit. +27. Changed only the owned final helper deadline to1800seconds and supplementary + recovery documentation. The old178.106-second83path scan and the2.05x raw + baseline line count suggest about4.18x paragraph work, with more than2x + additional margin. This bounded estimate does not guarantee completion. + No scanner, policy, path exclusion, frozen JSON formatting, production repair, + approved binding or native/Lean output changed. Refresh -RepairDesignControls, + commit privately, then rerun -Committed once on the new final source. Exact + current control/final receipt and final HEAD are pinned by external DELIVERY. diff --git a/docs/internal/extensions/lifecycle-native1-r1/GUIDE.md b/docs/internal/extensions/lifecycle-native1-r1/GUIDE.md new file mode 100644 index 00000000..d65beab5 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native1-r1/GUIDE.md @@ -0,0 +1,67 @@ +# LIFE-NATIVE-1-R1 repair guide + +Status: LOCAL_CANDIDATE_COMPLETE, conditional on the final external delivery binding. The original native implementation and its guide remain +immutable in ../lifecycle-native1/. This sibling packet records certification +repairs only. No Lean/C/Rust/C++ algorithm or ownership implementation changed. + +The repaired selector runner owns disposable setup from acquisition through final +reporting. Setup errors retain an ordinary failure while integrity, removal and +receipt persistence are attempted independently. A partial pin inventory remains +explicitly partial. The two native registry callers require exact ordinal strings, +and native build phases reject focused targets that omit actual Entry dependencies +before creating outputs. Focused lean-only compilation remains available. + +Use the four default Lean roots for the native route. Build phases are lean, dll +and clients; the latter two consume the successful new Lean receipt, and clients +consume the fresh DLL manifest. Replay then uses that client-build receipt for +startup, one LN1-W-TIES fixture, all thirteen fixture IDs in both modes, ABI cases, +ten clients and reviewed native controls. Full native-control Replay must receive +the independently approved R1 NATIVE_EXPECTATIONS.json path and exact SHA256 through +the existing interface. A pending binding proposal is not an approved expectation. + +REPAIR_CASES.json freezes the additional 93 controls. controls.ps1 executes +registry, setup, closure and scope-final groups. Source/receipt component fixtures +are explicitly marked test-only; they do not stand in for actual native compilation +or claim an observed stale DLL. scope_check.ps1 and final_checks.ps1 add the exact +R1 branch/base/roster while retaining the original 55-row frozen contract and the +unchanged strict design/claim/stream consumers. + +This fresh checkout required an independently approved exact-byte restoration of +64 line-ending-converted files, followed by an identical-content index metadata +update. BASE_IDENTITY.json preserves both initial and restored identities. Future +audit checkouts must establish equivalent raw bytes before interpreting old pins. +The original 44d6 checkout and all historical captures remain unchanged. + +COMMANDS.md and REUSE_APPLICABILITY.json distinguish new executions from applicable +original formal/Rust evidence. Final DELIVERY.json will pin the committed report +only after its report-sensitive checks. Coordinator review, one final aggregate, +fresh-blind audit and protected integration remain separate campaign gates. + +Native Windows/compiler/runtime and valid foreign-caller assumptions remain live. +The formal retained payload and modeled step bounds are unchanged. This repair +adds no native constant-time, succinct-heap, arbitrary-pointer safety or kernel +proof of the C/runtime implementation. + +The completed local execution index and final exact commit/report certification +are in .lake/lifecycle-native1-r1/delivery/DELIVERY.json. Native48 Replay uses the +externally approved647054-byte manifest SHA256 +723bb8b4422130282aef59f5d94b623f32ee187d6dc7c7a72c6a45ff5fb23d53. +All93 repair cases passed, including actual final receipt consumption and scope +holdouts. The native runner's historical campaignComplete=false is retained; +actual coverage is established by its exact48 ordered selected/result/stage IDs, +completeRegistry and successful captures. Subsequent coordinator gates remain open. + +The repair-base strict-design result has its own exact19-path WDD-only consumer; +the original implementation-base consumer still requires both original ledgers. +Both execute the unchanged production design checker. Six actual checker/parser +controls replay with final_checks.ps1 -RepairDesignControls and passed after the +first final certification exposed the original consumer's narrower domain. The +frozen93 suite remains unchanged; final_checks.ps1 was copied file data there, +so final current scope and the six direct controls refresh its changed bytes. + +The owned final helper allows1800seconds per checker after a preserved600-second +strict claim timeout on the expanded raw evidence inventory. The scanner and +policy still receive every109cumulative path without rewriting the frozen JSON. +TIMEOUT_DIAGNOSIS.json records CPU activity, successful owned cleanup and the +observed-data estimate. The delivery record selects the refreshed six-control +receipt and final clean-commit certificate; earlier attempts remain available. diff --git a/docs/internal/extensions/lifecycle-native1-r1/NATIVE_EXPECTATIONS.json b/docs/internal/extensions/lifecycle-native1-r1/NATIVE_EXPECTATIONS.json new file mode 100644 index 00000000..3be6b966 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native1-r1/NATIVE_EXPECTATIONS.json @@ -0,0 +1,23613 @@ +{ + "status": "FROZEN_ROOT_REVIEWED", + "inputFingerprint": "e6d42db6a53666bbb577c69390240fad0520c8f0c2310940b7e239359ba8059d", + "schema": "lifecycle-native1-native-control-expectations-v1", + "completeRegistry": true, + "cases": [ + { + "verdict": "accept", + "argument": "0", + "oracleExplanation": "Actual status0, canonical answer2 and memory equality, all four exact/exclusive array predicates and no forbidden retained roots; all owned resources released after destruction.", + "surface": "healthy", + "phase": "build", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-NONE-BUILD\\CONTROL.json", + "bytes": 5617, + "sha256": "E256B14942F7F734EFEF6CDECAB1E5DEF7576F7A8E660C28A239157C19B61EB9" + }, + "control": "none", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "none", + "phase": "build", + "argument": 0, + "actualStatus": 0, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": true, + "ownerPresent": true, + "sameOwnerIdentity": false, + "answerPresent": true, + "observationPresent": true, + "liveStrictPredicate": true, + "livePredicateDiagnostic": "", + "memoryEqual": true, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "returnedMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "answerLE": "020000000000000000000000000000000000000000", + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 0, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 3, + "nativeHandlesReleased": 0, + "nativeHandlesLive": 3, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 1, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 181, + "nativeHandlesReleased": 181, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 1, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-NONE-BUILD" + }, + { + "verdict": "accept", + "argument": "0", + "oracleExplanation": "Actual status0, canonical answer2 and memory equality, all four exact/exclusive array predicates and no forbidden retained roots; all owned resources released after destruction.", + "surface": "healthy", + "phase": "query", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-NONE-QUERY\\CONTROL.json", + "bytes": 5619, + "sha256": "AF852AFB5F728E210F7AA4B1BA60454108B3073E313A5F35F70ADF6A92636376" + }, + "control": "none", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "none", + "phase": "query", + "argument": 0, + "actualStatus": 0, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": true, + "ownerPresent": true, + "sameOwnerIdentity": false, + "answerPresent": true, + "observationPresent": true, + "liveStrictPredicate": true, + "livePredicateDiagnostic": "", + "memoryEqual": true, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "returnedMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "answerLE": "020000000000000000000000000000000000000000", + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 0, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 3, + "nativeHandlesReleased": 0, + "nativeHandlesLive": 3, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 1, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 181, + "nativeHandlesReleased": 181, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 1, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-NONE-QUERY" + }, + { + "verdict": "reject-publication", + "argument": "0", + "oracleExplanation": "Skipped build replacement retains excess array capacity; the same strict capacity predicate rejects publication with status10 and outputs empty.", + "surface": "skip-repack", + "phase": "build", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-SKIP-REPACK-BUILD\\CONTROL.json", + "bytes": 5773, + "sha256": "CC2C52BC9E5CB5A7C4CD56FFC4F7F7FB6576D94D5131C614DDC05E9F08F6E4C8" + }, + "control": "skip-repack", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "skip-repack", + "phase": "build", + "argument": 0, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 0, + "valuesEqual": 1, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 0, + "valuesEqual": 1, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": true, + "bank": 0, + "sameIdentity": true, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": true, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": true, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": true, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 0, + "sameIdentity": true, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": true, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": true, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": true, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-SKIP-REPACK-BUILD" + }, + { + "verdict": "nondistinguishing", + "argument": "0", + "oracleExplanation": "The incoming owner already has exact-capacity arrays; the actual query preserves them. Skipping replacement copies zero entries yet the same strict predicate, canonical memory and answer2 pass. This challenge does not distinguish excess capacity on this later-query state.", + "surface": "skip-repack", + "phase": "query", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-SKIP-REPACK-QUERY\\CONTROL.json", + "bytes": 5773, + "sha256": "BBD5D313703E0F46FDB55789FE21B8CD5A01302E952925F197C9807B13E45B5A" + }, + "control": "skip-repack", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "skip-repack", + "phase": "query", + "argument": 0, + "actualStatus": 0, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": true, + "ownerPresent": true, + "sameOwnerIdentity": false, + "answerPresent": true, + "observationPresent": true, + "liveStrictPredicate": true, + "livePredicateDiagnostic": "", + "memoryEqual": true, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 0, + "copiedEntries": 0, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "returnedMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "answerLE": "020000000000000000000000000000000000000000", + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 3, + "nativeHandlesReleased": 0, + "nativeHandlesLive": 3, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 1, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 181, + "nativeHandlesReleased": 181, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 1, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": true, + "bank": 0, + "sameIdentity": true, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": true, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": true, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": true, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 0, + "sameIdentity": true, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": true, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": true, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": true, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-SKIP-REPACK-QUERY" + }, + { + "verdict": "reject-publication", + "argument": "0", + "oracleExplanation": "Actual extra owner root makes ownerExclusive=0; the same strict publication predicate rejects with status10, then releases all roots.", + "surface": "extra-owner-alias", + "phase": "build", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-EXTRA-OWNER-ALIAS-BUILD\\CONTROL.json", + "bytes": 5904, + "sha256": "7C55596C17D1E34E69317CDE8741A52F54D6D432CE1564D1BCD90D87B0CB9153" + }, + "control": "extra-owner-alias", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "extra-owner-alias", + "phase": "build", + "argument": 0, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 1, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 1, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-EXTRA-OWNER-ALIAS-BUILD" + }, + { + "verdict": "reject-publication", + "argument": "0", + "oracleExplanation": "Actual extra owner root makes ownerExclusive=0; the same strict publication predicate rejects with status10, then releases all roots.", + "surface": "extra-owner-alias", + "phase": "query", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-EXTRA-OWNER-ALIAS-QUERY\\CONTROL.json", + "bytes": 5904, + "sha256": "9DC1F1BD0DC7D4F5E2BEC13D22F848022E3A0D813C8F77007BDD4CDB92DFD8DC" + }, + "control": "extra-owner-alias", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "extra-owner-alias", + "phase": "query", + "argument": 0, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 1, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 1, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-EXTRA-OWNER-ALIAS-QUERY" + }, + { + "verdict": "reject-publication", + "argument": "0", + "oracleExplanation": "Actual retainedInputRoots=1 at the transfer boundary violates the same strict root-retirement predicate; status10 and empty outputs, followed by full resource cleanup.", + "surface": "retain-input", + "phase": "build", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-RETAIN-INPUT-BUILD\\CONTROL.json", + "bytes": 5794, + "sha256": "B547D67970BAF586004366D1316CBEBEA21B119003812A8B1843E0CFFD6C60EA" + }, + "control": "retain-input", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "retain-input", + "phase": "build", + "argument": 0, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 1, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 1, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-RETAIN-INPUT-BUILD" + }, + { + "verdict": "reject-publication", + "argument": "0", + "oracleExplanation": "Actual retainedArenaRoots=1 at the transfer boundary violates the same strict root-retirement predicate; status10 and empty outputs, followed by full resource cleanup.", + "surface": "retain-old-arena", + "phase": "build", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-RETAIN-OLD-ARENA-BUILD\\CONTROL.json", + "bytes": 5882, + "sha256": "4777FDE0F039C7C21F48B0C9D60C4010CAE5FB427297E8423581751F20E69B0F" + }, + "control": "retain-old-arena", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "retain-old-arena", + "phase": "build", + "argument": 0, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 1, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 1, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-RETAIN-OLD-ARENA-BUILD" + }, + { + "verdict": "reject-publication", + "argument": "0", + "oracleExplanation": "Actual retainedArenaRoots=1 at the transfer boundary violates the same strict root-retirement predicate; status10 and empty outputs, followed by full resource cleanup.", + "surface": "retain-old-arena", + "phase": "query", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-RETAIN-OLD-ARENA-QUERY\\CONTROL.json", + "bytes": 5883, + "sha256": "54B45939F409900B890695976872BEF9E1BCEAEB979BF722B3DF603C5152B94A" + }, + "control": "retain-old-arena", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "retain-old-arena", + "phase": "query", + "argument": 0, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 1, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 1, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-RETAIN-OLD-ARENA-QUERY" + }, + { + "verdict": "reject-publication", + "argument": "0", + "oracleExplanation": "Actual retainedKeyRoots=1 at the transfer boundary violates the same strict root-retirement predicate; status10 and empty outputs, followed by full resource cleanup.", + "surface": "retain-keys", + "phase": "build", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-RETAIN-KEYS-BUILD\\CONTROL.json", + "bytes": 5773, + "sha256": "94D89D0DA924F0756DB675AF56A483114A6BC52BFBA5ED9048AF791F9FDA5396" + }, + "control": "retain-keys", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "retain-keys", + "phase": "build", + "argument": 0, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 1, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 3, + "sourceCopyCells": 8279, + "sourceCopyCapacityTotal": 8279, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 1, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 3, + "sourceCopyCells": 8279, + "sourceCopyCapacityTotal": 8279, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-RETAIN-KEYS-BUILD" + }, + { + "verdict": "reject-publication", + "argument": "0", + "oracleExplanation": "Actual retainedHistoryRoots=1 at the transfer boundary violates the same strict root-retirement predicate; status10 and empty outputs, followed by full resource cleanup.", + "surface": "retain-history", + "phase": "build", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-RETAIN-HISTORY-BUILD\\CONTROL.json", + "bytes": 5839, + "sha256": "DB6B99F5272BD8AF046B8EC690DB9DCAA3FD021957CF63380B37DE25B6C9473A" + }, + "control": "retain-history", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "retain-history", + "phase": "build", + "argument": 0, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 1, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 1, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-RETAIN-HISTORY-BUILD" + }, + { + "verdict": "reject-publication", + "argument": "0", + "oracleExplanation": "Actual retainedHistoryRoots=1 at the transfer boundary violates the same strict root-retirement predicate; status10 and empty outputs, followed by full resource cleanup.", + "surface": "retain-history", + "phase": "query", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-RETAIN-HISTORY-QUERY\\CONTROL.json", + "bytes": 5839, + "sha256": "18B200EFE9DF8B2B07E1AE363BF272EAA92032027AE845A0700D7C99E795D20C" + }, + "control": "retain-history", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "retain-history", + "phase": "query", + "argument": 0, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 1, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 1, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-RETAIN-HISTORY-QUERY" + }, + { + "verdict": "reject-publication", + "argument": "0", + "oracleExplanation": "Actual memory bank1 differs at index0; the value-preservation check rejects before publication with status10 and all outputs empty. Failure is a state difference, not a log difference.", + "surface": "wrong-copy-value", + "phase": "build", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-WRONG-COPY-VALUE-BUILD-0\\CONTROL.json", + "bytes": 5923, + "sha256": "2E863BAE5AA4FDF9B79106A25ECFDD8571CB0A2284E7DB84191CCAD787C1210D" + }, + "control": "wrong-copy-value", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "wrong-copy-value", + "phase": "build", + "argument": 0, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 1, + "firstMismatchIndex": 0, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 1, + "firstMismatchIndex": 0, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-WRONG-COPY-VALUE-BUILD-0" + }, + { + "verdict": "reject-publication", + "argument": "1", + "oracleExplanation": "Actual memory bank1 differs at index1; the value-preservation check rejects before publication with status10 and all outputs empty. Failure is a state difference, not a log difference.", + "surface": "wrong-copy-value", + "phase": "build", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-WRONG-COPY-VALUE-BUILD-1\\CONTROL.json", + "bytes": 5923, + "sha256": "583A4CA35675D740341E3830607FC1B940C21100637CF9261BB8F04F3DDEAFAA" + }, + "control": "wrong-copy-value", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "wrong-copy-value", + "phase": "build", + "argument": 1, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 1, + "firstMismatchIndex": 1, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 1, + "firstMismatchIndex": 1, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-WRONG-COPY-VALUE-BUILD-1" + }, + { + "verdict": "reject-publication", + "argument": "0", + "oracleExplanation": "Actual memory bank1 differs at index0; the value-preservation check rejects before publication with status10 and all outputs empty. Failure is a state difference, not a log difference.", + "surface": "wrong-copy-value", + "phase": "query", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-WRONG-COPY-VALUE-QUERY-0\\CONTROL.json", + "bytes": 5923, + "sha256": "E261CB60EB49156F7D50A5C05C2DC711460385F4ED39E4FCFB21A22C78E412AF" + }, + "control": "wrong-copy-value", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "wrong-copy-value", + "phase": "query", + "argument": 0, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 1, + "firstMismatchIndex": 0, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 1, + "firstMismatchIndex": 0, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-WRONG-COPY-VALUE-QUERY-0" + }, + { + "verdict": "reject-publication", + "argument": "1", + "oracleExplanation": "Actual memory bank1 differs at index1; the value-preservation check rejects before publication with status10 and all outputs empty. Failure is a state difference, not a log difference.", + "surface": "wrong-copy-value", + "phase": "query", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-WRONG-COPY-VALUE-QUERY-1\\CONTROL.json", + "bytes": 5922, + "sha256": "B5DD4FD3480FEC4340EC5B35ED8E3A5863C899B91E2E5DECFB2BB5478E4DFA48" + }, + "control": "wrong-copy-value", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "wrong-copy-value", + "phase": "query", + "argument": 1, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 1, + "firstMismatchIndex": 1, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 1, + "firstMismatchIndex": 1, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-WRONG-COPY-VALUE-QUERY-1" + }, + { + "verdict": "reject-publication", + "argument": "0", + "oracleExplanation": "Actual memory bank1 differs at index0; the value-preservation check rejects before publication with status10 and all outputs empty. Failure is a state difference, not a log difference.", + "surface": "wrong-copy-offset", + "phase": "build", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-WRONG-COPY-OFFSET-BUILD-0\\CONTROL.json", + "bytes": 5944, + "sha256": "B4E181DE445674E097BBA58F805540BBE6FAA7656922069C24BFA1E634128796" + }, + "control": "wrong-copy-offset", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "wrong-copy-offset", + "phase": "build", + "argument": 0, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 1, + "firstMismatchIndex": 0, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 1, + "firstMismatchIndex": 0, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-WRONG-COPY-OFFSET-BUILD-0" + }, + { + "verdict": "reject-publication", + "argument": "1", + "oracleExplanation": "Actual memory bank1 differs at index1; the value-preservation check rejects before publication with status10 and all outputs empty. Failure is a state difference, not a log difference.", + "surface": "wrong-copy-offset", + "phase": "build", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-WRONG-COPY-OFFSET-BUILD-1\\CONTROL.json", + "bytes": 5945, + "sha256": "D05D4CA19F262F4679DAE9651F1580AA7E80544FC19319F2944ACBE7ADFA79FF" + }, + "control": "wrong-copy-offset", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "wrong-copy-offset", + "phase": "build", + "argument": 1, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 1, + "firstMismatchIndex": 1, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 1, + "firstMismatchIndex": 1, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-WRONG-COPY-OFFSET-BUILD-1" + }, + { + "verdict": "reject-publication", + "argument": "0", + "oracleExplanation": "Actual memory bank1 differs at index0; the value-preservation check rejects before publication with status10 and all outputs empty. Failure is a state difference, not a log difference.", + "surface": "wrong-copy-offset", + "phase": "query", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-WRONG-COPY-OFFSET-QUERY-0\\CONTROL.json", + "bytes": 5945, + "sha256": "B16A952E34112257FB0000E6A15CD47CE9A82894B77A0719AB7170D73D65AEB0" + }, + "control": "wrong-copy-offset", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "wrong-copy-offset", + "phase": "query", + "argument": 0, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 1, + "firstMismatchIndex": 0, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 1, + "firstMismatchIndex": 0, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-WRONG-COPY-OFFSET-QUERY-0" + }, + { + "verdict": "reject-publication", + "argument": "1", + "oracleExplanation": "Actual memory bank1 differs at index1; the value-preservation check rejects before publication with status10 and all outputs empty. Failure is a state difference, not a log difference.", + "surface": "wrong-copy-offset", + "phase": "query", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-WRONG-COPY-OFFSET-QUERY-1\\CONTROL.json", + "bytes": 5945, + "sha256": "610ECFE60017B57EF30E3F9F7F13179B51A99A9B1D92B5D003DA1DB1D1CFD0F9" + }, + "control": "wrong-copy-offset", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "wrong-copy-offset", + "phase": "query", + "argument": 1, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 1, + "firstMismatchIndex": 1, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 1, + "firstMismatchIndex": 1, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-WRONG-COPY-OFFSET-QUERY-1" + }, + { + "verdict": "reject-operation", + "argument": "0", + "oracleExplanation": "Controlled status10 after copying exactly0 entries on the production replacement helper; every initialized entry is released, outputs empty, no live temporary array or native handle.", + "surface": "partial-copy", + "phase": "build", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-PARTIAL-COPY-BUILD-0\\CONTROL.json", + "bytes": 5833, + "sha256": "28A17FA8EE3D465E2523CEDE0E2987441E867A7BBF4AC6589F10F82AA0C14CBB" + }, + "control": "partial-copy", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "partial-copy", + "phase": "build", + "argument": 0, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 1, + "temporaryArraysReleased": 1, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 1, + "temporaryArraysReleased": 1, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-PARTIAL-COPY-BUILD-0" + }, + { + "verdict": "reject-operation", + "argument": "1", + "oracleExplanation": "Controlled status10 after copying exactly1 entries on the production replacement helper; every initialized entry is released, outputs empty, no live temporary array or native handle.", + "surface": "partial-copy", + "phase": "build", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-PARTIAL-COPY-BUILD-1\\CONTROL.json", + "bytes": 5834, + "sha256": "BDB77E28B531D8DB00D1178C8145495847F0CF5FD6DC85E3B608E995FDCD3437" + }, + "control": "partial-copy", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "partial-copy", + "phase": "build", + "argument": 1, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 1, + "initializedEntries": 1, + "releasedEntries": 1, + "temporaryArraysCreated": 1, + "temporaryArraysReleased": 1, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 1, + "initializedEntries": 1, + "releasedEntries": 1, + "temporaryArraysCreated": 1, + "temporaryArraysReleased": 1, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-PARTIAL-COPY-BUILD-1" + }, + { + "verdict": "reject-operation", + "argument": "8272", + "oracleExplanation": "Controlled status10 after copying exactly8272 entries on the production replacement helper; every initialized entry is released, outputs empty, no live temporary array or native handle.", + "surface": "partial-copy", + "phase": "build", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-PARTIAL-COPY-BUILD-8272\\CONTROL.json", + "bytes": 5900, + "sha256": "5567B4CDE9516AF85C83813E7178289B24D51BD0617A39767D130476CB1688FD" + }, + "control": "partial-copy", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "partial-copy", + "phase": "build", + "argument": 8272, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 8272, + "initializedEntries": 8272, + "releasedEntries": 8272, + "temporaryArraysCreated": 1, + "temporaryArraysReleased": 1, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 8272, + "initializedEntries": 8272, + "releasedEntries": 8272, + "temporaryArraysCreated": 1, + "temporaryArraysReleased": 1, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-PARTIAL-COPY-BUILD-8272" + }, + { + "verdict": "reject-operation", + "argument": "8273", + "oracleExplanation": "Controlled status10 after copying exactly8273 entries on the production replacement helper; every initialized entry is released, outputs empty, no live temporary array or native handle.", + "surface": "partial-copy", + "phase": "build", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-PARTIAL-COPY-BUILD-8273\\CONTROL.json", + "bytes": 5901, + "sha256": "51BC4055CC12186F7350EF0113485387FFD9B3B31229D00633B941859A2AB289" + }, + "control": "partial-copy", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "partial-copy", + "phase": "build", + "argument": 8273, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 8273, + "initializedEntries": 8273, + "releasedEntries": 8273, + "temporaryArraysCreated": 2, + "temporaryArraysReleased": 2, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 8273, + "initializedEntries": 8273, + "releasedEntries": 8273, + "temporaryArraysCreated": 2, + "temporaryArraysReleased": 2, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-PARTIAL-COPY-BUILD-8273" + }, + { + "verdict": "reject-operation", + "argument": "8274", + "oracleExplanation": "Controlled status10 after copying exactly8274 entries on the production replacement helper; every initialized entry is released, outputs empty, no live temporary array or native handle.", + "surface": "partial-copy", + "phase": "build", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-PARTIAL-COPY-BUILD-8274\\CONTROL.json", + "bytes": 5901, + "sha256": "A05FC09CD564474B42623979398432BF67B95921441D13F54FD430A9F67BFA61" + }, + "control": "partial-copy", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "partial-copy", + "phase": "build", + "argument": 8274, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 8274, + "initializedEntries": 8274, + "releasedEntries": 8274, + "temporaryArraysCreated": 2, + "temporaryArraysReleased": 2, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 8274, + "initializedEntries": 8274, + "releasedEntries": 8274, + "temporaryArraysCreated": 2, + "temporaryArraysReleased": 2, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-PARTIAL-COPY-BUILD-8274" + }, + { + "verdict": "reject-operation", + "argument": "0", + "oracleExplanation": "Controlled status10 after copying exactly0 entries on the production replacement helper; every initialized entry is released, outputs empty, no live temporary array or native handle.", + "surface": "partial-copy", + "phase": "query", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-PARTIAL-COPY-QUERY-0\\CONTROL.json", + "bytes": 5835, + "sha256": "DFC92262FBF4C132C5AD4947F7AC88DD20E87693DD70BBE765B0892D72DD67CA" + }, + "control": "partial-copy", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "partial-copy", + "phase": "query", + "argument": 0, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 1, + "temporaryArraysReleased": 1, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 1, + "temporaryArraysReleased": 1, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-PARTIAL-COPY-QUERY-0" + }, + { + "verdict": "reject-operation", + "argument": "1", + "oracleExplanation": "Controlled status10 after copying exactly1 entries on the production replacement helper; every initialized entry is released, outputs empty, no live temporary array or native handle.", + "surface": "partial-copy", + "phase": "query", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-PARTIAL-COPY-QUERY-1\\CONTROL.json", + "bytes": 5835, + "sha256": "B280F5D800473E63E19F4D54463375A663833D2132A0F31E5977268513109ECF" + }, + "control": "partial-copy", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "partial-copy", + "phase": "query", + "argument": 1, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 1, + "initializedEntries": 1, + "releasedEntries": 1, + "temporaryArraysCreated": 1, + "temporaryArraysReleased": 1, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 1, + "initializedEntries": 1, + "releasedEntries": 1, + "temporaryArraysCreated": 1, + "temporaryArraysReleased": 1, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-PARTIAL-COPY-QUERY-1" + }, + { + "verdict": "reject-operation", + "argument": "8272", + "oracleExplanation": "Controlled status10 after copying exactly8272 entries on the production replacement helper; every initialized entry is released, outputs empty, no live temporary array or native handle.", + "surface": "partial-copy", + "phase": "query", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-PARTIAL-COPY-QUERY-8272\\CONTROL.json", + "bytes": 5900, + "sha256": "9ADB203E899A830963A056A979DC2CAD360CF2D79E6581BBD7846AF093BEC4BD" + }, + "control": "partial-copy", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "partial-copy", + "phase": "query", + "argument": 8272, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 8272, + "initializedEntries": 8272, + "releasedEntries": 8272, + "temporaryArraysCreated": 1, + "temporaryArraysReleased": 1, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 8272, + "initializedEntries": 8272, + "releasedEntries": 8272, + "temporaryArraysCreated": 1, + "temporaryArraysReleased": 1, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-PARTIAL-COPY-QUERY-8272" + }, + { + "verdict": "reject-operation", + "argument": "8273", + "oracleExplanation": "Controlled status10 after copying exactly8273 entries on the production replacement helper; every initialized entry is released, outputs empty, no live temporary array or native handle.", + "surface": "partial-copy", + "phase": "query", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-PARTIAL-COPY-QUERY-8273\\CONTROL.json", + "bytes": 5901, + "sha256": "331FD92D385E8976D0C53D5337FF6C27318FBF33E530008DE018B8E84F3D9473" + }, + "control": "partial-copy", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "partial-copy", + "phase": "query", + "argument": 8273, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 8273, + "initializedEntries": 8273, + "releasedEntries": 8273, + "temporaryArraysCreated": 2, + "temporaryArraysReleased": 2, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 8273, + "initializedEntries": 8273, + "releasedEntries": 8273, + "temporaryArraysCreated": 2, + "temporaryArraysReleased": 2, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-PARTIAL-COPY-QUERY-8273" + }, + { + "verdict": "reject-operation", + "argument": "8274", + "oracleExplanation": "Controlled status10 after copying exactly8274 entries on the production replacement helper; every initialized entry is released, outputs empty, no live temporary array or native handle.", + "surface": "partial-copy", + "phase": "query", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-PARTIAL-COPY-QUERY-8274\\CONTROL.json", + "bytes": 5901, + "sha256": "2EBF1E7BB053E8864837920FA111520BA977A90DC0D4458EC78B73B1005444E5" + }, + "control": "partial-copy", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "partial-copy", + "phase": "query", + "argument": 8274, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 8274, + "initializedEntries": 8274, + "releasedEntries": 8274, + "temporaryArraysCreated": 2, + "temporaryArraysReleased": 2, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 8274, + "initializedEntries": 8274, + "releasedEntries": 8274, + "temporaryArraysCreated": 2, + "temporaryArraysReleased": 2, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-PARTIAL-COPY-QUERY-8274" + }, + { + "verdict": "reject-operation", + "argument": "0", + "oracleExplanation": "Controlled status10 after irrevocable take; empty/poisoned outputs and balanced resource cleanup.", + "surface": "post-take", + "phase": "query", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-FAIL-AFTER-TAKE-QUERY\\CONTROL.json", + "bytes": 5861, + "sha256": "734A570BDE8A976A85EA0D26439F58749587207D59482A8286D057459A0591B9" + }, + "control": "fail-after-take", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "fail-after-take", + "phase": "query", + "argument": 0, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-FAIL-AFTER-TAKE-QUERY" + }, + { + "verdict": "reject-operation", + "argument": "0", + "oracleExplanation": "Actual runner status7 from initial-owner model-fault probe at argument0, with no healthy baseline construction and empty outputs. This establishes bounded runner/status dependence, not answer divergence from an oracle.", + "surface": "model-fault", + "phase": "build", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-MODEL-FAULT-BUILD\\CONTROL.json", + "bytes": 5772, + "sha256": "E4E982A01FF7903EE10EB8E5C54C249AE1A0B4552EEB2093EB1F8739705E512A" + }, + "control": "model-fault", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "model-fault", + "phase": "build", + "argument": 0, + "actualStatus": 7, + "baselineBuilt": false, + "baselineOwnerIdentity": null, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": null, + "baselineInfo": null, + "baselineMemoryLE": null, + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 3, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 4, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 2, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 3, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 4, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 2, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-MODEL-FAULT-BUILD" + }, + { + "verdict": "reject-operation", + "argument": "0", + "oracleExplanation": "Actual runner status8 from initial-owner fuel probe at argument0, with no healthy baseline construction and empty outputs. This establishes bounded runner/status dependence, not answer divergence from an oracle.", + "surface": "fuel", + "phase": "build", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-EXHAUSTED-BUILD-0\\CONTROL.json", + "bytes": 5769, + "sha256": "AB92038FF268D914AE8CE45091B45B73C7D1C6399C5C547BA124BDC3974BCB10" + }, + "control": "exhausted", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "exhausted", + "phase": "build", + "argument": 0, + "actualStatus": 8, + "baselineBuilt": false, + "baselineOwnerIdentity": null, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": null, + "baselineInfo": null, + "baselineMemoryLE": null, + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 3, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 4, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 2, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 3, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 4, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 2, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-EXHAUSTED-BUILD-0" + }, + { + "verdict": "reject-operation", + "argument": "20", + "oracleExplanation": "Actual runner status8 from initial-owner fuel probe at argument20, with no healthy baseline construction and empty outputs. This establishes bounded runner/status dependence, not answer divergence from an oracle.", + "surface": "fuel", + "phase": "build", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-EXHAUSTED-BUILD-20\\CONTROL.json", + "bytes": 5790, + "sha256": "72F367739677394F89BE4B77FB4DA72613098E2C84B212BF6E5A382E3CAB5AB3" + }, + "control": "exhausted", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "exhausted", + "phase": "build", + "argument": 20, + "actualStatus": 8, + "baselineBuilt": false, + "baselineOwnerIdentity": null, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": null, + "baselineInfo": null, + "baselineMemoryLE": null, + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 3, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 4, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 2, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 1, + "sourceCopyCells": 8273, + "sourceCopyCapacityTotal": 8273, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 3, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 4, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 2, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 1, + "sourceCopyCells": 8273, + "sourceCopyCapacityTotal": 8273, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-EXHAUSTED-BUILD-20" + }, + { + "verdict": "reject-operation", + "argument": "100", + "oracleExplanation": "Actual runner status8 from initial-owner fuel probe at argument100, with no healthy baseline construction and empty outputs. This establishes bounded runner/status dependence, not answer divergence from an oracle.", + "surface": "fuel", + "phase": "build", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-EXHAUSTED-BUILD-100\\CONTROL.json", + "bytes": 5813, + "sha256": "D51ACFE9EDB6CDB0CB03449606A90E92FA8653162C12B522FC08DDC4A6F2BABC" + }, + "control": "exhausted", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "exhausted", + "phase": "build", + "argument": 100, + "actualStatus": 8, + "baselineBuilt": false, + "baselineOwnerIdentity": null, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": null, + "baselineInfo": null, + "baselineMemoryLE": null, + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 3, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 4, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 2, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 1, + "sourceCopyCells": 8273, + "sourceCopyCapacityTotal": 8273, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 3, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 4, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 2, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 1, + "nativeHandlesReleased": 1, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 1, + "sourceCopyCells": 8273, + "sourceCopyCapacityTotal": 8273, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-EXHAUSTED-BUILD-100" + }, + { + "verdict": "reject-before-build", + "argument": "0", + "oracleExplanation": "Actual status9 during native admission or owner-handle allocation, before transfer; all outputs empty and zero initialized replacement entries.", + "surface": "pre-take-allocation", + "phase": "build", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-FAIL-BEFORE-TAKE-ALLOC-BUILD\\CONTROL.json", + "bytes": 6014, + "sha256": "679C6626D28628D87155964CBB0CD6506BF03631B45E2B6E3B35ACF973A857C7" + }, + "control": "fail-before-take-alloc", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "fail-before-take-alloc", + "phase": "build", + "argument": 0, + "actualStatus": 9, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 0, + "nativeHandlesReleased": 0, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 0, + "nativeHandlesReleased": 0, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-FAIL-BEFORE-TAKE-ALLOC-BUILD" + }, + { + "verdict": "reject-before-transfer", + "argument": "0", + "oracleExplanation": "Actual status9 before take; the original owner identity, canonical memory and strict live predicate remain, with empty answer/observation. Generation-local transfer counters are not a census of that preserved owner.", + "surface": "pre-take-allocation", + "phase": "query", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-FAIL-BEFORE-TAKE-ALLOC-QUERY\\CONTROL.json", + "bytes": 6014, + "sha256": "4D8AF32538BF64D6F7D732A88DFA9C51BA8ECA83A53AEC185D3797E239F6F7AC" + }, + "control": "fail-before-take-alloc", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "fail-before-take-alloc", + "phase": "query", + "argument": 0, + "actualStatus": 9, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": true, + "ownerPresent": true, + "sameOwnerIdentity": true, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": true, + "livePredicateDiagnostic": "", + "memoryEqual": true, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "returnedMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 0, + "nativeHandlesReleased": 0, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 178, + "nativeHandlesReleased": 178, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-FAIL-BEFORE-TAKE-ALLOC-QUERY" + }, + { + "verdict": "reject-operation", + "argument": "0", + "oracleExplanation": "Controlled status10 after strictPublication=1 and handle creation, before external publication; all initialized replacement entries and handles released, outputs empty.", + "surface": "pre-publication", + "phase": "build", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-FAIL-BEFORE-PUBLISH-BUILD\\CONTROL.json", + "bytes": 5949, + "sha256": "3C1D4FB828356F311B76654C4E4717BDDC28ED1595D260E7BE081CA52A4E355D" + }, + "control": "fail-before-publish", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "fail-before-publish", + "phase": "build", + "argument": 0, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 3, + "nativeHandlesReleased": 3, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 1, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 3, + "nativeHandlesReleased": 3, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 1, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-FAIL-BEFORE-PUBLISH-BUILD" + }, + { + "verdict": "reject-operation", + "argument": "0", + "oracleExplanation": "Controlled status10 after strictPublication=1 and handle creation, before external publication; all initialized replacement entries and handles released, outputs empty.", + "surface": "pre-publication", + "phase": "query", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-FAIL-BEFORE-PUBLISH-QUERY\\CONTROL.json", + "bytes": 5949, + "sha256": "08A2528F813305EF6E17FE91CD60F577691671C0BB75122B63333F1EF72C77CB" + }, + "control": "fail-before-publish", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "fail-before-publish", + "phase": "query", + "argument": 0, + "actualStatus": 10, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 3, + "nativeHandlesReleased": 3, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 1, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 3, + "nativeHandlesReleased": 3, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 1, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-FAIL-BEFORE-PUBLISH-QUERY" + }, + { + "verdict": "accept", + "argument": "0", + "oracleExplanation": "One actual boxed immutable scalar root remains shared while the same strict owner/array/root/content predicate passes; canonical answer2 and memory unchanged. Scalar sharing is permitted.", + "surface": "shared-scalar", + "phase": "build", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-SHARED-SCALAR-ACCEPT-BUILD\\CONTROL.json", + "bytes": 5971, + "sha256": "7873D51F2AC9EC21786534D085E73D25900AF4368A97624CE76BF5B2AEB29462" + }, + "control": "shared-scalar-accept", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "shared-scalar-accept", + "phase": "build", + "argument": 0, + "actualStatus": 0, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": true, + "ownerPresent": true, + "sameOwnerIdentity": false, + "answerPresent": true, + "observationPresent": true, + "liveStrictPredicate": true, + "livePredicateDiagnostic": "", + "memoryEqual": true, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "returnedMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "answerLE": "020000000000000000000000000000000000000000", + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 0, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 3, + "nativeHandlesReleased": 0, + "nativeHandlesLive": 3, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 1, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 1, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 1534, + "requestedBytes": 12296, + "identity": true + }, + { + "initialized": 0, + "capacity": 4, + "requestedBytes": 56, + "identity": true + }, + { + "initialized": 0, + "capacity": 2, + "requestedBytes": 40, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 181, + "nativeHandlesReleased": 181, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 1, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 2, + "sourceCopyCells": 8275, + "sourceCopyCapacityTotal": 8275, + "sourceCopyCapacityMax": 8273, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 1, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-SHARED-SCALAR-ACCEPT-BUILD" + }, + { + "verdict": "accept", + "argument": "0", + "oracleExplanation": "One actual boxed immutable scalar root remains shared while the same strict owner/array/root/content predicate passes; canonical answer2 and memory unchanged. Scalar sharing is permitted.", + "surface": "shared-scalar", + "phase": "query", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-SHARED-SCALAR-ACCEPT-QUERY\\CONTROL.json", + "bytes": 5971, + "sha256": "763B7312A3806AA768F11647167434AF014EC498BE8574C3A3668405BD1F799A" + }, + "control": "shared-scalar-accept", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "shared-scalar-accept", + "phase": "query", + "argument": 0, + "actualStatus": 0, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": true, + "ownerPresent": true, + "sameOwnerIdentity": false, + "answerPresent": true, + "observationPresent": true, + "liveStrictPredicate": true, + "livePredicateDiagnostic": "", + "memoryEqual": true, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "returnedMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "answerLE": "020000000000000000000000000000000000000000", + "beforeCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 0, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 3, + "nativeHandlesReleased": 0, + "nativeHandlesLive": 3, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 1, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 1, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "replacement": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "copiedEntries": 8451, + "initializedEntries": 8451, + "releasedEntries": 8451, + "temporaryArraysCreated": 4, + "temporaryArraysReleased": 4, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 181, + "nativeHandlesReleased": 181, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 1, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 1, + "arraysExact": 1, + "valuesEqual": 1, + "strictPublication": 1, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "beforeCleanup" + }, + { + "bothPresent": true, + "bank": 0, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 1, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 2, + "sameIdentity": false, + "phase": "afterCleanup" + }, + { + "bothPresent": true, + "bank": 3, + "sameIdentity": false, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-SHARED-SCALAR-ACCEPT-QUERY" + }, + { + "verdict": "reject-before-build", + "argument": "0", + "oracleExplanation": "Actual status1 during native admission or owner-handle allocation, before transfer; all outputs empty and zero initialized replacement entries.", + "surface": "admission", + "phase": "build", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-ENDPOINT-SHORT-BUILD\\CONTROL.json", + "bytes": 5838, + "sha256": "C2399D4D3420164AB813D259F39C4C4BF8FAF5DBFC630E97E8F6B2918DD68397" + }, + "control": "endpoint-short", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "endpoint-short", + "phase": "build", + "argument": 0, + "actualStatus": 1, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 0, + "nativeHandlesReleased": 0, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 0, + "nativeHandlesReleased": 0, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-ENDPOINT-SHORT-BUILD" + }, + { + "verdict": "reject-before-transfer", + "argument": "0", + "oracleExplanation": "Actual status1 before take; the original owner identity, canonical memory and strict live predicate remain, with empty answer/observation. Generation-local transfer counters are not a census of that preserved owner.", + "surface": "admission", + "phase": "query", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-ENDPOINT-SHORT-QUERY\\CONTROL.json", + "bytes": 5839, + "sha256": "E303168D873CBAF8FFE00E05B617A5567F650599347677182F0A0C47B0C6DFA7" + }, + "control": "endpoint-short", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "endpoint-short", + "phase": "query", + "argument": 0, + "actualStatus": 1, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": true, + "ownerPresent": true, + "sameOwnerIdentity": true, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": true, + "livePredicateDiagnostic": "", + "memoryEqual": true, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "returnedMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 0, + "nativeHandlesReleased": 0, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 178, + "nativeHandlesReleased": 178, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-ENDPOINT-SHORT-QUERY" + }, + { + "verdict": "reject-before-build", + "argument": "0", + "oracleExplanation": "Actual status1 during native admission or owner-handle allocation, before transfer; all outputs empty and zero initialized replacement entries.", + "surface": "admission", + "phase": "build", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-ENDPOINT-LONG-BUILD\\CONTROL.json", + "bytes": 5817, + "sha256": "70F28299D4C45359D390E86F90E41213BC2C66F48C5ED5318C1073FCC5EDB406" + }, + "control": "endpoint-long", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "endpoint-long", + "phase": "build", + "argument": 0, + "actualStatus": 1, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 0, + "nativeHandlesReleased": 0, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 0, + "nativeHandlesReleased": 0, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-ENDPOINT-LONG-BUILD" + }, + { + "verdict": "reject-before-transfer", + "argument": "0", + "oracleExplanation": "Actual status1 before take; the original owner identity, canonical memory and strict live predicate remain, with empty answer/observation. Generation-local transfer counters are not a census of that preserved owner.", + "surface": "admission", + "phase": "query", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-ENDPOINT-LONG-QUERY\\CONTROL.json", + "bytes": 5817, + "sha256": "08989AD041E659C2B184ADEF5D3E8383D311F60D0DBF953173F30A93CF6E1DCC" + }, + "control": "endpoint-long", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "endpoint-long", + "phase": "query", + "argument": 0, + "actualStatus": 1, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": true, + "ownerPresent": true, + "sameOwnerIdentity": true, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": true, + "livePredicateDiagnostic": "", + "memoryEqual": true, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "returnedMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 0, + "nativeHandlesReleased": 0, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 178, + "nativeHandlesReleased": 178, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-ENDPOINT-LONG-QUERY" + }, + { + "verdict": "reject-before-build", + "argument": "0", + "oracleExplanation": "Actual status1 during native admission or owner-handle allocation, before transfer; all outputs empty and zero initialized replacement entries.", + "surface": "admission", + "phase": "build", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-NEGATIVE-ZERO-BUILD\\CONTROL.json", + "bytes": 5817, + "sha256": "0E5CF501DB34A196017EA4C730BE79BFA87522625067403E5263379FAB86347C" + }, + "control": "negative-zero", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "negative-zero", + "phase": "build", + "argument": 0, + "actualStatus": 1, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 0, + "nativeHandlesReleased": 0, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 0, + "nativeHandlesReleased": 0, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-NEGATIVE-ZERO-BUILD" + }, + { + "verdict": "reject-before-build", + "argument": "0", + "oracleExplanation": "Actual status1 during native admission or owner-handle allocation, before transfer; all outputs empty and zero initialized replacement entries.", + "surface": "admission", + "phase": "build", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-BAD-SIGN-BUILD\\CONTROL.json", + "bytes": 5707, + "sha256": "FD4B028AACC98244DD7DF04ADC2C604145473C0562E6603A2BD913B676631A71" + }, + "control": "bad-sign", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "bad-sign", + "phase": "build", + "argument": 0, + "actualStatus": 1, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 0, + "nativeHandlesReleased": 0, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 0, + "nativeHandlesReleased": 0, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-BAD-SIGN-BUILD" + }, + { + "verdict": "reject-before-build", + "argument": "0", + "oracleExplanation": "Actual status2 during native admission or owner-handle allocation, before transfer; all outputs empty and zero initialized replacement entries.", + "surface": "admission", + "phase": "build", + "discoveryReceipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\NC-WORD-INPUTFITS-BUILD\\CONTROL.json", + "bytes": 5839, + "sha256": "99EFFCB7E191A9EF81AEAB60A43CC03869FEEE9727CD697CBF0C857056C68287" + }, + "control": "word-inputfits", + "projection": { + "report": { + "schema": "lifecycle-native1-control-discovery-v1", + "control": "word-inputfits", + "phase": "build", + "argument": 0, + "actualStatus": 2, + "baselineBuilt": true, + "baselineOwnerIdentity": true, + "returnedOwnerIdentity": false, + "ownerPresent": false, + "sameOwnerIdentity": false, + "answerPresent": false, + "observationPresent": false, + "liveStrictPredicate": false, + "livePredicateDiagnostic": "", + "memoryEqual": false, + "baselineInfo": { + "count": 4, + "memoryExtent": 178, + "widthBits": 168, + "arrays": [ + { + "initialized": 8273, + "capacity": 8273, + "requestedBytes": 66208, + "identity": true + }, + { + "initialized": 178, + "capacity": 178, + "requestedBytes": 1448, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 24, + "identity": true + } + ], + "reachableObjects": 187, + "scalarOccurrences": 8450, + "boxedIntegers": 3, + "runtimeReportedObjectBytes": 70696, + "boxedDigitRequestedBytes": 56, + "repackedArrays": 4, + "copiedEntries": 8451, + "exclusiveOwner": 1, + "exactCapacities": 1, + "noRetainedOperationalRoots": 1 + }, + "baselineMemoryLE": [ + "04", + "11", + "26", + "8602", + "00", + "00", + "a8", + "b2", + "04", + "10", + "01", + "10", + "01", + "04", + "01", + "03", + "04", + "06", + "01", + "03", + "01", + "01", + "09", + "01", + "04", + "01", + "07", + "04", + "01", + "0b", + "03", + "06", + "03", + "00", + "01", + "03", + "05", + "07", + "2b", + "2c", + "42", + "45", + "11", + "08", + "04", + "02", + "2c", + "04", + "04", + "01", + "30", + "04", + "04", + "01", + "34", + "04", + "04", + "01", + "38", + "04", + "04", + "01", + "3c", + "40", + "04", + "10", + "7c", + "40", + "04", + "10", + "bc", + "40", + "04", + "10", + "fc", + "40", + "04", + "10", + "3c01", + "02", + "01", + "02", + "3e01", + "02", + "01", + "02", + "4001", + "01", + "01", + "03", + "4101", + "00", + "04", + "00", + "4101", + "06", + "03", + "02", + "4701", + "06", + "03", + "02", + "4d01", + "04", + "03", + "07", + "5101", + "00", + "04", + "00", + "19", + "04", + "04", + "01", + "1d", + "0f", + "05", + "03", + "11", + "08", + "04", + "0b", + "00", + "00", + "00", + "00", + "4602", + "28", + "05", + "08", + "6e02", + "08", + "02", + "04", + "00", + "01", + "5101", + "04", + "01", + "01", + "02", + "5501", + "07", + "02", + "03", + "02", + "5c01", + "07", + "02", + "05", + "02", + "6301", + "07", + "02", + "07", + "24", + "6a01", + "04", + "01", + "2b", + "01", + "fa01", + "01", + "01", + "2c", + "16", + "fb01", + "06", + "02", + "42", + "03", + "3d02", + "03", + "01", + "0000a6000802000221030000000000001001", + "00000000000000000000201303", + "404201", + "0882a6d1344d4bd334a9102148592b15" + ], + "returnedInfo": null, + "returnedMemoryLE": null, + "answerLE": null, + "beforeCleanup": { + "source": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 0, + "nativeHandlesReleased": 0, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "afterCleanup": { + "source": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "replacement": [ + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + }, + { + "initialized": 0, + "capacity": 0, + "requestedBytes": 0, + "identity": false + } + ], + "copiedEntries": 0, + "initializedEntries": 0, + "releasedEntries": 0, + "temporaryArraysCreated": 0, + "temporaryArraysReleased": 0, + "temporaryArraysLive": 0, + "nativeHandlesCreated": 0, + "nativeHandlesReleased": 0, + "nativeHandlesLive": 0, + "retainedOwnerRoots": 0, + "retainedInputRoots": 0, + "retainedArenaRoots": 0, + "retainedKeyRoots": 0, + "retainedHistoryRoots": 0, + "retainedScalarRoots": 0, + "firstMismatchArray": 18446744073709551615, + "firstMismatchIndex": 18446744073709551615, + "sourceCopyCalls": 0, + "sourceCopyCells": 0, + "sourceCopyCapacityTotal": 0, + "sourceCopyCapacityMax": 0, + "sourceCopyExpands": 0, + "ownerExclusive": 0, + "arraysExact": 0, + "valuesEqual": 0, + "strictPublication": 0, + "cleanupComplete": 1, + "copyCounterOverflow": 0 + }, + "acceptanceVerdict": "not-assigned-discovery-only" + }, + "arrayIdentityRelations": [ + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "beforeCleanup" + }, + { + "bothPresent": false, + "bank": 0, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 1, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 2, + "sameIdentity": null, + "phase": "afterCleanup" + }, + { + "bothPresent": false, + "bank": 3, + "sameIdentity": null, + "phase": "afterCleanup" + } + ] + }, + "id": "NC-WORD-INPUTFITS-BUILD" + } + ], + "mappingSHA256": "ea90bd61fb7d226210aa47b3afd38cbca8953debaf3246c238a5785b20e69f2d", + "review": { + "reviewer": "root", + "discoveryReceipt": ".lake\\lifecycle-native1\\native-controls\\20260927T051058239-1758cc65\\RESULT.json", + "discoveryReceiptSHA256": "04e1b2ad7018e23573935ccec3b1df32d54855df072eeb55fdc56b8eb78f5401", + "counts": { + "accept": 4, + "reject-publication": 17, + "nondistinguishing": 1, + "reject-operation": 17, + "reject-before-build": 6, + "reject-before-transfer": 3 + }, + "basis": "Every actual report and raw hash reviewed against the source-defined strict predicate. All fields retained in exact projection except randomized addresses; liveness and bank identity relations retained. No expected verdict was assigned before actual discovery.", + "provenanceRebinding": { + "reviewedUtc": "2026-09-27T07:29:49.672556+00:00", + "reviewer": "root", + "oldManifest": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-refresh-review\\root-rebind-20260927\\NATIVE_EXPECTATIONS.before-rebind.json", + "bytes": 619658, + "sha256": "AC42D3EE867503737956E5C0091A5CD31D8B8822E27101AA458BF05C6844439B" + }, + "oldFingerprint": "4fddb88fdf3b1b8b6d3217a29fc78ff79bcc56bd27e73d39e3c9965d56785047", + "oldFingerprintDefect": "OrderedDictionary path sorting with -Unique collapsed the recipe to its first pin.", + "repairedRecipeReview": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-refresh-review\\root-rebind-20260927\\RECIPE_REVIEW.json", + "bytes": 2060, + "sha256": "7C6F4865C6ED2D7D6E50A0F4EBCE564EA773CD390CF533301D2628104745257A" + }, + "focusedDiscovery": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T072450429-92e7bea9\\RESULT.json", + "bytes": 4535205, + "sha256": "6858B244BB68788411D96FD32CCFE07C63544BB401E7F82EFD9B23D7CE3CF07F" + }, + "sourcePinCount": 7148, + "uniquePinCount": 6013, + "duplicatePinCount": 1135, + "newFingerprint": "494eadb41c09ba18e4d27d84eec77d12a0c220abf04b817b6f1b42a839a83791", + "unchanged48CasesCanonicalSHA256": "5697ab0c52c768001620aeda4ab5c4363c66c8e1d1d2f116d3140ab1c4d00ba9", + "historicalDiscoveryReceiptPinsPreserved": true, + "commentAmendment": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\docs\\internal\\extensions\\lifecycle-native1\\NATIVE_COMMENT_AMENDMENT.json", + "bytes": 4534, + "sha256": "B69C06945A7B13843F5E78176F21624D856C318D7C4B9D0F2DABAC8816BF4E18" + }, + "nativeRefreshEvidence": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\docs\\internal\\extensions\\lifecycle-native1\\NATIVE_REFRESH_EVIDENCE.md", + "bytes": 13294, + "sha256": "E0AF13A847642C36789C67D3FB84BC6A35106C23F263CB44F420E14957809A17" + }, + "conclusion": "Only the top-level recipe fingerprint and this provenance note change. All 48 reviewed case objects, exact projections, verdicts, mappings and historical discovery receipt pins remain unchanged. Fresh complete Replay must reproduce them under the corrected full input recipe." + } + }, + "r1BindingReview": { + "originalExpectations": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\docs\\internal\\extensions\\lifecycle-native1\\NATIVE_EXPECTATIONS.json", + "bytes": 622132, + "sha256": "e67348c7e631fb7facbd9b580a44d1b42729e9db0526a5ac09a2b804143e5466" + }, + "originalReplay": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T073240346-3c38ea74\\RESULT.json", + "bytes": 5263753, + "sha256": "a4545cfc2df8cfde3e92d27c4d7f6cc59c67946dbdae939d3e5c4739d60754e4" + }, + "currentDiscovery": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\4935\\RMQ\\.lake\\lifecycle-native1\\native-controls\\20260927T221003163-b43f5974\\RESULT.json", + "bytes": 4535188, + "sha256": "5760522e34523c2b7386051a52f4297eb83f9c15ec147a73e6b2ebd183e577e6" + }, + "currentRecipeSHA256": "e6d42db6a53666bbb577c69390240fad0520c8f0c2310940b7e239359ba8059d", + "unchangedCasesSHA256": "5697ab0c52c768001620aeda4ab5c4363c66c8e1d1d2f116d3140ab1c4d00ba9", + "boundary": "All48 case objects, including projections, verdicts and historical discovery identities, are unchanged. Only status/input binding/provenance is proposed. Exact-byte external coordinator approval is required before use." + } +} diff --git a/docs/internal/extensions/lifecycle-native1-r1/REPAIR_CASES.json b/docs/internal/extensions/lifecycle-native1-r1/REPAIR_CASES.json new file mode 100644 index 00000000..f78615fa --- /dev/null +++ b/docs/internal/extensions/lifecycle-native1-r1/REPAIR_CASES.json @@ -0,0 +1,863 @@ +{ + "schema": "lifecycle-native1-r1-repair-cases-v1", + "status": "FROZEN_BEFORE_PRODUCTION_EDITS", + "base": "3dbdebedcc6ba6b2a864df0d46dcc09ccaaa7536", + "repairBase": "c52c453a2f0f49c568886f502687e4d0667838e9", + "orderedIds": [ + "H1-MISSING-REPLAY", + "H1-INTEGRITY-AND-CLEANUP", + "H2-native_controls-healthy", + "H2-native_controls-omit-middle", + "H2-native_controls-duplicate-middle", + "H2-native_controls-handler-ascii", + "H2-native_controls-schema-nul", + "H2-native_controls-schema-soft-hyphen", + "H2-native_controls-schema-bom", + "H2-native_controls-schema-zero-width-space", + "H2-native_controls-id-nul", + "H2-native_controls-id-soft-hyphen", + "H2-native_controls-id-bom", + "H2-native_controls-id-zero-width-space", + "H2-native_controls-handler-nul", + "H2-native_controls-handler-soft-hyphen", + "H2-native_controls-handler-bom", + "H2-native_controls-handler-zero-width-space", + "H2-native_controls-discoveryVerdict-nul", + "H2-native_controls-discoveryVerdict-soft-hyphen", + "H2-native_controls-discoveryVerdict-bom", + "H2-native_controls-discoveryVerdict-zero-width-space", + "H2-native_controls-status-nul", + "H2-native_controls-control-nul", + "H2-native_controls-phase-nul", + "H2-native_controls-argument-nul", + "H2-native_controls-surface-nul", + "H2-native_controls-schema-null", + "H2-native_controls-id-null", + "H2-native_controls-handler-null", + "H2-native_controls-discoveryVerdict-null", + "H2-native_controls-status-null", + "H2-native_controls-control-null", + "H2-native_controls-phase-null", + "H2-native_controls-argument-null", + "H2-native_controls-surface-null", + "H2-native_clients-healthy", + "H2-native_clients-omit-middle", + "H2-native_clients-duplicate-middle", + "H2-native_clients-handler-ascii", + "H2-native_clients-schema-nul", + "H2-native_clients-schema-soft-hyphen", + "H2-native_clients-schema-bom", + "H2-native_clients-schema-zero-width-space", + "H2-native_clients-id-nul", + "H2-native_clients-id-soft-hyphen", + "H2-native_clients-id-bom", + "H2-native_clients-id-zero-width-space", + "H2-native_clients-handler-nul", + "H2-native_clients-handler-soft-hyphen", + "H2-native_clients-handler-bom", + "H2-native_clients-handler-zero-width-space", + "H2-native_clients-expectedVerdict-nul", + "H2-native_clients-expectedVerdict-soft-hyphen", + "H2-native_clients-expectedVerdict-bom", + "H2-native_clients-expectedVerdict-zero-width-space", + "H2-native_clients-expectedStdout-nul", + "H2-native_clients-expectedStdout-soft-hyphen", + "H2-native_clients-expectedStdout-bom", + "H2-native_clients-expectedStdout-zero-width-space", + "H2-native_clients-expectedStderr-nul", + "H2-native_clients-expectedStderr-soft-hyphen", + "H2-native_clients-expectedStderr-bom", + "H2-native_clients-expectedStderr-zero-width-space", + "H2-native_clients-variant-nul", + "H2-native_clients-executable-nul", + "H2-native_clients-mode-nul", + "H2-native_clients-schema-null", + "H2-native_clients-id-null", + "H2-native_clients-handler-null", + "H2-native_clients-expectedVerdict-null", + "H2-native_clients-expectedStdout-null", + "H2-native_clients-expectedStderr-null", + "H2-native_clients-variant-null", + "H2-native_clients-executable-null", + "H2-native_clients-mode-null", + "H3-CODEC-dll", + "H3-CODEC-clients", + "H3-CODEC-all", + "H3-default-coverage", + "H3-lean-codec-supported", + "H3-native-body-mutation", + "H3-source-generated-required-set", + "R1-FINAL-healthy", + "R1-FINAL-out-of-scope", + "R1-FINAL-frozen-row", + "R1-FINAL-ledger-prefix", + "R1-FINAL-missing-path", + "R1-FINAL-extra-path", + "R1-FINAL-changed-pin", + "R1-FINAL-extra-stdout", + "R1-FINAL-extra-stderr", + "R1-FINAL-wrong-exit" + ], + "cases": [ + { + "id": "H1-MISSING-REPLAY", + "handler": "setup", + "fault": "missing-replay", + "expectedExit": 1, + "setupComplete": false, + "integritySuccess": true, + "cleanupSuccess": true + }, + { + "id": "H1-INTEGRITY-AND-CLEANUP", + "handler": "setup", + "fault": "changed-pin-then-missing-replay", + "expectedExit": 1, + "setupComplete": false, + "integritySuccess": false, + "cleanupSuccess": true + }, + { + "id": "H2-native_controls-healthy", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 0, + "mutation": "healthy" + }, + { + "id": "H2-native_controls-omit-middle", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "omit" + }, + { + "id": "H2-native_controls-duplicate-middle", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "duplicate" + }, + { + "id": "H2-native_controls-handler-ascii", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "field", + "field": "handler", + "suffix": "X" + }, + { + "id": "H2-native_controls-schema-nul", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "field", + "field": "schema", + "suffix": "\u0000" + }, + { + "id": "H2-native_controls-schema-soft-hyphen", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "field", + "field": "schema", + "suffix": "\u00ad" + }, + { + "id": "H2-native_controls-schema-bom", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "field", + "field": "schema", + "suffix": "\ufeff" + }, + { + "id": "H2-native_controls-schema-zero-width-space", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "field", + "field": "schema", + "suffix": "\u200b" + }, + { + "id": "H2-native_controls-id-nul", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "field", + "field": "id", + "suffix": "\u0000" + }, + { + "id": "H2-native_controls-id-soft-hyphen", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "field", + "field": "id", + "suffix": "\u00ad" + }, + { + "id": "H2-native_controls-id-bom", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "field", + "field": "id", + "suffix": "\ufeff" + }, + { + "id": "H2-native_controls-id-zero-width-space", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "field", + "field": "id", + "suffix": "\u200b" + }, + { + "id": "H2-native_controls-handler-nul", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "field", + "field": "handler", + "suffix": "\u0000" + }, + { + "id": "H2-native_controls-handler-soft-hyphen", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "field", + "field": "handler", + "suffix": "\u00ad" + }, + { + "id": "H2-native_controls-handler-bom", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "field", + "field": "handler", + "suffix": "\ufeff" + }, + { + "id": "H2-native_controls-handler-zero-width-space", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "field", + "field": "handler", + "suffix": "\u200b" + }, + { + "id": "H2-native_controls-discoveryVerdict-nul", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "field", + "field": "discoveryVerdict", + "suffix": "\u0000" + }, + { + "id": "H2-native_controls-discoveryVerdict-soft-hyphen", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "field", + "field": "discoveryVerdict", + "suffix": "\u00ad" + }, + { + "id": "H2-native_controls-discoveryVerdict-bom", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "field", + "field": "discoveryVerdict", + "suffix": "\ufeff" + }, + { + "id": "H2-native_controls-discoveryVerdict-zero-width-space", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "field", + "field": "discoveryVerdict", + "suffix": "\u200b" + }, + { + "id": "H2-native_controls-status-nul", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "field", + "field": "status", + "suffix": "\u0000" + }, + { + "id": "H2-native_controls-control-nul", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "field", + "field": "control", + "suffix": "\u0000" + }, + { + "id": "H2-native_controls-phase-nul", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "field", + "field": "phase", + "suffix": "\u0000" + }, + { + "id": "H2-native_controls-argument-nul", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "field", + "field": "argument", + "suffix": "\u0000" + }, + { + "id": "H2-native_controls-surface-nul", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "field", + "field": "surface", + "suffix": "\u0000" + }, + { + "id": "H2-native_controls-schema-null", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "type", + "field": "schema", + "value": null + }, + { + "id": "H2-native_controls-id-null", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "type", + "field": "id", + "value": null + }, + { + "id": "H2-native_controls-handler-null", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "type", + "field": "handler", + "value": null + }, + { + "id": "H2-native_controls-discoveryVerdict-null", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "type", + "field": "discoveryVerdict", + "value": null + }, + { + "id": "H2-native_controls-status-null", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "type", + "field": "status", + "value": null + }, + { + "id": "H2-native_controls-control-null", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "type", + "field": "control", + "value": null + }, + { + "id": "H2-native_controls-phase-null", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "type", + "field": "phase", + "value": null + }, + { + "id": "H2-native_controls-argument-null", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "type", + "field": "argument", + "value": null + }, + { + "id": "H2-native_controls-surface-null", + "handler": "registry", + "runner": "native_controls", + "expectedExit": 1, + "mutation": "type", + "field": "surface", + "value": null + }, + { + "id": "H2-native_clients-healthy", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 0, + "mutation": "healthy" + }, + { + "id": "H2-native_clients-omit-middle", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "omit" + }, + { + "id": "H2-native_clients-duplicate-middle", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "duplicate" + }, + { + "id": "H2-native_clients-handler-ascii", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "field", + "field": "handler", + "suffix": "X" + }, + { + "id": "H2-native_clients-schema-nul", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "field", + "field": "schema", + "suffix": "\u0000" + }, + { + "id": "H2-native_clients-schema-soft-hyphen", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "field", + "field": "schema", + "suffix": "\u00ad" + }, + { + "id": "H2-native_clients-schema-bom", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "field", + "field": "schema", + "suffix": "\ufeff" + }, + { + "id": "H2-native_clients-schema-zero-width-space", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "field", + "field": "schema", + "suffix": "\u200b" + }, + { + "id": "H2-native_clients-id-nul", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "field", + "field": "id", + "suffix": "\u0000" + }, + { + "id": "H2-native_clients-id-soft-hyphen", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "field", + "field": "id", + "suffix": "\u00ad" + }, + { + "id": "H2-native_clients-id-bom", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "field", + "field": "id", + "suffix": "\ufeff" + }, + { + "id": "H2-native_clients-id-zero-width-space", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "field", + "field": "id", + "suffix": "\u200b" + }, + { + "id": "H2-native_clients-handler-nul", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "field", + "field": "handler", + "suffix": "\u0000" + }, + { + "id": "H2-native_clients-handler-soft-hyphen", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "field", + "field": "handler", + "suffix": "\u00ad" + }, + { + "id": "H2-native_clients-handler-bom", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "field", + "field": "handler", + "suffix": "\ufeff" + }, + { + "id": "H2-native_clients-handler-zero-width-space", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "field", + "field": "handler", + "suffix": "\u200b" + }, + { + "id": "H2-native_clients-expectedVerdict-nul", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "field", + "field": "expectedVerdict", + "suffix": "\u0000" + }, + { + "id": "H2-native_clients-expectedVerdict-soft-hyphen", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "field", + "field": "expectedVerdict", + "suffix": "\u00ad" + }, + { + "id": "H2-native_clients-expectedVerdict-bom", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "field", + "field": "expectedVerdict", + "suffix": "\ufeff" + }, + { + "id": "H2-native_clients-expectedVerdict-zero-width-space", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "field", + "field": "expectedVerdict", + "suffix": "\u200b" + }, + { + "id": "H2-native_clients-expectedStdout-nul", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "field", + "field": "expectedStdout", + "suffix": "\u0000" + }, + { + "id": "H2-native_clients-expectedStdout-soft-hyphen", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "field", + "field": "expectedStdout", + "suffix": "\u00ad" + }, + { + "id": "H2-native_clients-expectedStdout-bom", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "field", + "field": "expectedStdout", + "suffix": "\ufeff" + }, + { + "id": "H2-native_clients-expectedStdout-zero-width-space", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "field", + "field": "expectedStdout", + "suffix": "\u200b" + }, + { + "id": "H2-native_clients-expectedStderr-nul", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "field", + "field": "expectedStderr", + "suffix": "\u0000" + }, + { + "id": "H2-native_clients-expectedStderr-soft-hyphen", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "field", + "field": "expectedStderr", + "suffix": "\u00ad" + }, + { + "id": "H2-native_clients-expectedStderr-bom", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "field", + "field": "expectedStderr", + "suffix": "\ufeff" + }, + { + "id": "H2-native_clients-expectedStderr-zero-width-space", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "field", + "field": "expectedStderr", + "suffix": "\u200b" + }, + { + "id": "H2-native_clients-variant-nul", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "field", + "field": "variant", + "suffix": "\u0000" + }, + { + "id": "H2-native_clients-executable-nul", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "field", + "field": "executable", + "suffix": "\u0000" + }, + { + "id": "H2-native_clients-mode-nul", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "field", + "field": "mode", + "suffix": "\u0000" + }, + { + "id": "H2-native_clients-schema-null", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "type", + "field": "schema", + "value": null + }, + { + "id": "H2-native_clients-id-null", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "type", + "field": "id", + "value": null + }, + { + "id": "H2-native_clients-handler-null", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "type", + "field": "handler", + "value": null + }, + { + "id": "H2-native_clients-expectedVerdict-null", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "type", + "field": "expectedVerdict", + "value": null + }, + { + "id": "H2-native_clients-expectedStdout-null", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "type", + "field": "expectedStdout", + "value": null + }, + { + "id": "H2-native_clients-expectedStderr-null", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "type", + "field": "expectedStderr", + "value": null + }, + { + "id": "H2-native_clients-variant-null", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "type", + "field": "variant", + "value": null + }, + { + "id": "H2-native_clients-executable-null", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "type", + "field": "executable", + "value": null + }, + { + "id": "H2-native_clients-mode-null", + "handler": "registry", + "runner": "native_clients", + "expectedExit": 1, + "mutation": "type", + "field": "mode", + "value": null + }, + { + "id": "H3-CODEC-dll", + "handler": "closure-caller", + "phase": "dll", + "expectedExit": 1 + }, + { + "id": "H3-CODEC-clients", + "handler": "closure-caller", + "phase": "clients", + "expectedExit": 1 + }, + { + "id": "H3-CODEC-all", + "handler": "closure-caller", + "phase": "all", + "expectedExit": 1 + }, + { + "id": "H3-default-coverage", + "handler": "closure-predicate", + "expectedVerdict": "accept-control" + }, + { + "id": "H3-lean-codec-supported", + "handler": "closure-predicate", + "expectedVerdict": "accept-control" + }, + { + "id": "H3-native-body-mutation", + "handler": "closure-predicate", + "expectedVerdict": "accept-control" + }, + { + "id": "H3-source-generated-required-set", + "handler": "closure-predicate", + "expectedVerdict": "accept-control" + }, + { + "id": "R1-FINAL-healthy", + "handler": "scope-final", + "expectedVerdict": "accept" + }, + { + "id": "R1-FINAL-out-of-scope", + "handler": "scope-final", + "expectedVerdict": "reject" + }, + { + "id": "R1-FINAL-frozen-row", + "handler": "scope-final", + "expectedVerdict": "reject" + }, + { + "id": "R1-FINAL-ledger-prefix", + "handler": "scope-final", + "expectedVerdict": "reject" + }, + { + "id": "R1-FINAL-missing-path", + "handler": "scope-final", + "expectedVerdict": "reject" + }, + { + "id": "R1-FINAL-extra-path", + "handler": "scope-final", + "expectedVerdict": "reject" + }, + { + "id": "R1-FINAL-changed-pin", + "handler": "scope-final", + "expectedVerdict": "reject" + }, + { + "id": "R1-FINAL-extra-stdout", + "handler": "scope-final", + "expectedVerdict": "reject" + }, + { + "id": "R1-FINAL-extra-stderr", + "handler": "scope-final", + "expectedVerdict": "reject" + }, + { + "id": "R1-FINAL-wrong-exit", + "handler": "scope-final", + "expectedVerdict": "reject" + } + ] +} diff --git a/docs/internal/extensions/lifecycle-native1-r1/REPORT.md b/docs/internal/extensions/lifecycle-native1-r1/REPORT.md new file mode 100644 index 00000000..cf748e6c --- /dev/null +++ b/docs/internal/extensions/lifecycle-native1-r1/REPORT.md @@ -0,0 +1,200 @@ +Status: CANDIDATE_COMPLETE +I found no assigned or inherited acceptance criterion unmet; coordinator acceptance is still required. + +# LIFE-NATIVE-1-R1 repair report + +The three reviewed certification gaps are repaired at their actual callers. +The complete 93-case repair replay, fresh Lean/native/default builds, native +fixtures, ABI/client cases and approved 48-case native Replay passed. This +candidate declaration is valid only with the external +.lake/lifecycle-native1-r1/delivery/DELIVERY.json binding these final report bytes +to the clean committed source and successful report-sensitive final checks. +It does not record coordinator acceptance, aggregate, blind audit or integration. + +Worktree: C:/Users/poin/.codex/worktrees/4935/RMQ. +Branch: codex/life-native-1-certification-repair. +Repair base: c52c453a2f0f49c568886f502687e4d0667838e9. +Original implementation base: 3dbdebedcc6ba6b2a864df0d46dcc09ccaaa7536. +Governance: 7b227c49ef2ec044b702126cc41c9add847eed01. +START.json preserves the actual runtime/preflight and initial clean Git identity. +Final HEAD/report hashes live in the external receipt to avoid recursive identity. + +## Repairs and controls + +H1 moves disposable acquisition and incremental pinning inside the selector +runner's protected lifetime. Integrity, disposal and durable receipt persistence +receive independent attempts after setup failure. The original failure and +incomplete pin set remain explicit. Both actual setup controls pass, including +an independent integrity failure: scratch is removed and no semantic child runs. +The original missing-source failure, remaining disposable and absent receipt +were reproduced first after the governed checkout restoration. + +H2 requires string type and ordinal identity for every fixed textual registry +field at native_controls Plan and native_clients Validate. Complete ID order, +counts, uniqueness, mappings and unchanged expected verdict restrictions remain. +All 74 registry controls pass: two healthy rosters and 72 corruptions, including +ASCII, NUL, soft-hyphen, BOM, zero-width, null, missing/duplicate middle IDs and +every promised textual field. They reject before output or semantic work. +The original six ignored-character accepts were reproduced before editing. +Expectation fields and complete canonical projection comparison also use ordinal +identity. Native dispatch and semantic/resource predicates are unchanged. + +H3 computes selected imports and the actual Entry closure before outputs, mutex +or tools. Native phases reject a selected closure that omits Entry dependencies; +focused Lean-only compilation remains supported. Codec has 3 modules, Entry 365, +defaults 371, and Codec omits 362 native modules. Seven controls pass, including +the actual dll/clients/all preflight boundaries. Receipt component controls use +the actual predicate on isolated, explicitly test-only full-domain fixtures: +healthy pins pass, then a body-only Entry mutation or missing Entry.c pin rejects. +These are component tests, not compiler failures or an observed stale DLL. +The separate fresh successful native builds consume the full 371/365 closure. + +The remaining ten R1 cases challenge scope and final receipt consumption, including +a real healthy complete scope receipt, extra stdout/stderr/wrong exit, protected +bytes, frozen rows, ledger prefix, missing/extra paths and changed pins. The +out-of-scope case also challenges the actual Git predicate with three labeled +metadata fixtures: protected mode, blob and changed path. No live index is mutated. +The scope checker verifies all 3930 original Git modes, 3925 protected blobs, +regular-file new entries, the exact path roster and all protected raw bytes. + +All 93 ordered IDs passed with integrity/restoration/cleanup. The receipt is +.lake/lifecycle-native1-r1/controls/20260927T222724916-f98084bc/RESULT.json. Executed control/helper code remains exact at final certification. +These controls ran against their pinned report and copied-file snapshot. The later +final_checks.ps1 adjustment affects a copied scope-data file, not code executed by +controls.ps1; its six direct controls and final committed certificate cover the +new consumer. Final report prose is covered separately by that certificate. +Original selector33, control-selector18, client-selector13, recipe11, +final-stream15, final-stream-mapping5 and fresh Windows owned-descendant3 pass. + +## Fresh execution and reviewed binding + +All following receipt directories are under .lake/lifecycle-native1/ and contain +RESULT.json; exact arguments, streams and hashes are in COMMANDS.md and delivery. + +| Execution | Receipt directory | Result | +| --- | --- | --- | +| Four-root Lean and typed consumer | runs/build-20260927T215238511 | PASS | +| Full production/testing DLL closure | runs/build-20260927T215809530 | PASS; 371 selected, 365 native modules | +| C/Rust/C++ build | runs/build-20260927T220443777 | PASS | +| Startup | replay/20260927T220759901-82d4fc6f | PASS | +| Exactly W-TIES in both modes | replay/20260927T220855854-7b9d4a41 | PASS | +| 13 fixtures in both modes | replay/20260927T221101064-4bdc9064 | PASS; 26 processes, 142 requests | +| ABI boundaries | replay/20260927T221558890-59a9881a | PASS; 23 cases | +| C++/Rust clients | clients/20260927T221653032-0d23242a | PASS; 10 cases | +| Healthy Discovery | native-controls/20260927T221003163-b43f5974 | One complete healthy projection matches | +| Complete approved Replay | native-controls/20260927T222714986-044d4db1 | PASS; all 48 ordered cases | +| Required default lake build | default-build/20260927T221856519 | PASS; actual child 219.363954 seconds | + +The coordinator approved the exact binding at the external campaign +C:/Users/poin/Documents/RMQ/lifecycle-implementation-20260920/native1-binding-review-20260927/. +APPROVAL.json SHA256 is +f2742421769bd0cfc70cca740524d5b0f9421ea44ddb8d26298bb6f61f26ca3f. +The copied approved manifest is 647054 bytes, SHA256 +723bb8b4422130282aef59f5d94b623f32ee187d6dc7c7a72c6a45ff5fb23d53. +Only the proposal's top-level status changed. Every original 48-case object, +projection, verdict, explanation and discovery identity is unchanged. +The exact new input recipe is +e6d42db6a53666bbb577c69390240fad0520c8f0c2310940b7e239359ba8059d: +7148 occurrences, 6013 distinct paths and 1135 consistent duplicates. +All inputs and 365 generated/transformed/object/cache/link derivations were +independently reconstructed by the coordinator before this Replay. + +All executable .text sections match the originals; full rebuilt binary hashes +remain distinct. DLL section differences are confined to .buildid and client +section differences to .rdata. These comparisons supplement fresh build/replay +evidence; they are not normalized identities or a universal binary-equivalence +theorem. Verified cache transfer is disclosed; not every module recompiled. + +The worker secondary native review rehashes 6500 distinct inputs and reconstructs +every projection, full recipe, ordinary exit, raw capture and final pin. Verdicts +remain 4 accept, 17 reject-publication, 1 nondistinguishing, 17 reject-operation, +6 reject-before-build and 3 reject-before-transfer. campaignComplete remains false +as initialized by the original runner. Actual coverage follows the exact 48 +selected/result/stage IDs, completeRegistry=true and successful captures. + +The fresh fixture secondary review independently computes leftmost answers and +checks paired memory/owners, live pointer relationships, exact capacities, +10480 backed later reads, 3288 payload reads and actual interior occurrences. +Every non-pointer field matches the original reports. Observed later steps peak +at 28613 on these fixtures, below the formal 160257 model-step budget. Worker +secondary checks are not the future blind external audit. + +## Preservation and final certification + +The initially clean fresh checkout had 64 line-ending materialization differences. +The coordinator independently compared all 3930 original files and authorized +their exact restoration plus identical-content index metadata refresh. Initial +bytes, failed attempts, both dispositions and the successful restoration receipt +remain retained. Staged entries/flags stayed identical; all original raw bytes +matched before repairs. BASE_IDENTITY.json preserves both inventories separately. +The original 44d6 checkout, frozen matrices, registries and captures are unchanged. + +REUSE_APPLICABILITY.json rehashes original source/tool/generated/raw identities +for export34, axiom21 and Rust17 evidence. Its 34 removed disposable export artifact +occurrences match prior audited path/length/hash records; they are not available +executables. No old whole-tree certificate certifies edited harness bytes. +All 55 requirements remain binding and appear byte-exactly once in the new matrix. +The exact original propositions, hypotheses and object-composition chains remain +in protected proof evidence and are quoted in the supplementary R1 matrix. + +The final wrapper covers the complete original-base changed/new surface, including +the final report and all 14 new files, using unchanged production design/claim checkers and strict stream helpers. +The original-base result retains its unchanged consumer. The repair-base result +has an exact19-path, zero-code/WDD-only consumer derived from the same production +classifier literals/functions; six actual checker/parser controls pass. Design +uses both exact bases. It also checks original-byte/row/ledger +preservation, both trust hygiene scans, working and both committed whitespace +ranges, final source pins, HEAD and clean status. External delivery records the +actual final result. One aggregate and a fresh-blind exact-commit audit remain +subsequent coordinator gates; neither is claimed here. + +No DESIGN_DECISIONS.md update is needed for these harness/process changes. +The append-only WORKFLOW_DESIGN_DECISIONS.md records repairs and checkout decisions. +No public theorem/claim surface or protected native annotation changed. No further +worker, push, merge, or branch/worktree deletion was performed. + +## Proof digestion and live assumptions + +The repair makes failure lifetime, exact registry identity and the actual compiled +dependency domain explicit. It changes certification, not Lean/C/Rust/C++ semantics. +The unchanged chain is buildFirst = Ownership.owner -> refinement/READY/halted +guarded packet/canonical memory/empty key banks/8273 numeric entries/complete +modeled capacity, under InputDomain and endpoints below 2^wordWidth. Continuation +uses the actual incoming READY halted owner and represented endpoints; +query = Executable.queryOwner preserves memory and derives the guarded answer +and model-step bound. The thin loop still delegates unchanged executeArray and +equals runOwner for every program/owner/fuel. No output equality became a premise. + +The 160257 bound counts modeled steps. Native publication still recopies all four +arrays; that physical work is additional. Optional read histories remain separately +owned. Compiler/runtime correctness, the pinned Windows profile and valid foreign +caller preconditions remain live. Finite controls do not prove arbitrary C misuse +safe. A skeptical reader should next verify the clean delivery's exact source and +report bindings, then independently audit the repaired boundaries before acceptance. + + +Final-certification recovery: checkpoint9f962a7f passed both production design +checks (109cumulative files:26code/80workflow/3neutral;19repair files:0code/ +18workflow/1neutral), then the old result parser rejected the repair because it +requires both code and workflow ledgers. The failed receipt is retained at +.lake/lifecycle-native1-r1/final-checks/20260927T224625313/RESULT.json. +The owned R1 final wrapper now consumes the already-frozen WDD-only repair domain +explicitly. No production policy/helper or native recipe changed. Its six direct +actual-checker controls passed at final-checks/20260927T225142062/ +REPAIR_DESIGN_CONTROLS.json beneath the R1 evidence directory. This implements the +existing launch scope; it introduces no new design/ledger policy. Final committed +certification and delivery bind the follow-up source and final report bytes. + +Final claim-scan recovery: checkpoint3cbcaba1 timed out after600.12seconds in +unchanged strict paragraph matching across all109 cumulative paths. The failed +receipt remains at final-checks/20260927T225503039/RESULT.json; its source integrity +passed and all four owned children were terminated. Read-only live evidence and +post-timeout diagnosis are retained in claim-scan-recovery/ACTIVE_PROCESS.json +and TIMEOUT_DIAGNOSIS.json beneath the R1 evidence directory. The55,057-line raw +baseline is about2.05times the inherited26,918-line baseline; the observed +178.106-second smaller scan plus plausible quadratic paragraph work motivates +an1,800-second finite bound with more than2x estimated margin. This is a runtime +estimate, not a complexity or success claim. Scanner, policy, all109paths and +frozen raw inventories are unchanged. The owned helper's six direct controls +are refreshed for its final bytes; delivery pins that receipt and the successful +final committed certification. Both earlier failures remain failures. diff --git a/docs/internal/extensions/lifecycle-native1-r1/REUSE_APPLICABILITY.json b/docs/internal/extensions/lifecycle-native1-r1/REUSE_APPLICABILITY.json new file mode 100644 index 00000000..94dcf306 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native1-r1/REUSE_APPLICABILITY.json @@ -0,0 +1,175 @@ +{ + "schema": "lifecycle-native1-r1-reuse-v1", + "status": "PASS", + "createdUtc": "2026-09-27T21:47:40.113834+00:00", + "producingWorktree": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ", + "producingCommit": "c52c453a2f0f49c568886f502687e4d0667838e9", + "currentWorktree": "C:\\Users\\poin\\.codex\\worktrees\\4935\\RMQ", + "repairBase": "c52c453a2f0f49c568886f502687e4d0667838e9", + "originalDelivery": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\delivery\\DELIVERY.json", + "bytes": 46367, + "sha256": "a87969cb5907fa936f75be9da0a7605b8a11e06035e27d8d13a6a412e79060f0" + }, + "originalIdentityClassification": { + "path": "C:\\Users\\poin\\Documents\\RMQ\\lifecycle-implementation-20260920\\native1-review-20260927\\ROOT_IDENTITY_CLASSIFIED.json", + "bytes": 1953, + "sha256": "1df41a870435a5dee2957fd7ffd880bc754ee2303f37b0db3c5d35f9e2268fa4" + }, + "campaigns": [ + { + "campaign": "exportReplay34", + "status": "APPLICABLE_ORIGINAL_EXECUTION", + "receipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\export-mutations\\20260927T084110803-e9431c50\\RESULT.json", + "bytes": 2154830, + "sha256": "341c44469ecb17b4eebb2b45341a71ef8120a3b12fd0d2104496998b30d58866" + }, + "evidence": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\4935\\RMQ\\.lake\\lifecycle-native1-r1\\reuse-20260927T214711\\exportReplay34.json", + "bytes": 3690395, + "sha256": "682c8a1319c20de6f3a3e329b2e5f4ec1abc002ce84901638cbc22aa46d3bb34" + }, + "orderedIds": [ + "EX-WEAK-E01-PROGRAM", + "EX-WEAK-E02-OWNER", + "EX-WEAK-E03-PROJECTION", + "EX-WEAK-E04-READY", + "EX-WEAK-E05-HALTED", + "EX-WEAK-E06-MEMORY", + "EX-WEAK-E07-EMPTYKEYS", + "EX-WEAK-E08-BANK", + "EX-WEAK-E09-CAPACITY", + "EX-WEAK-E10-METADATA", + "EX-WEAK-E11-OBSERVATIONS", + "EX-WEAK-E12-CONTINUATION", + "EX-WEAK-E13-REPACKING", + "EX-WEAK-Q01-SOURCE", + "EX-WEAK-Q02-PROJECTION", + "EX-WEAK-Q03-READY", + "EX-WEAK-Q04-HALTED", + "EX-WEAK-Q05-MEMORY", + "EX-WEAK-Q06-OBSERVATIONS", + "EX-WEAK-Q07-BOUNDARY", + "EX-WEAK-Q08-STEPS", + "EX-WEAK-Q09-BUDGET", + "EX-WEAK-Q10-CAPACITY", + "EX-DELETE-E01-PROGRAM", + "EX-DELETE-Q05-MEMORY", + "EX-SIBLING-E01-FIXED-WORD", + "EX-SIBLING-E02-OTHER-REQUEST", + "EX-SIBLING-Q05-OUTPUT-REFLEXIVITY", + "EX-SIBLING-Q10-INCOMING-CAPACITY", + "EX-ACCEPT-COMMENT", + "EX-ACCEPT-UNUSED-FACT", + "AD-WEAK-COUNT-CONVERSION", + "AD-WEAK-WORD-DOMAIN", + "AD-WEAK-NATURAL-DECODE" + ], + "count": 34, + "consumedPins": 5619, + "currentSourceMappings": 387, + "historicalInputs": 371, + "toolInputs": 4861, + "checkedPinOccurrences": 6419, + "removedArtifactOccurrences": 34 + }, + { + "campaign": "axiomReplay21", + "status": "APPLICABLE_ORIGINAL_EXECUTION", + "receipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\axioms\\20260927T085337097\\RESULT.json", + "bytes": 1428368, + "sha256": "b298894304173a52874593ee066aea530c55574aa2897aa3a14f5cc9918a967f" + }, + "evidence": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\4935\\RMQ\\.lake\\lifecycle-native1-r1\\reuse-20260927T214711\\axiomReplay21.json", + "bytes": 3359077, + "sha256": "f3803c4af8bb4dc6fb777827f22ffa863f198df87bbe14e0410d127ab8df0dea" + }, + "orderedIds": [ + "RMQ.SuccinctFinal.PackedNative.Lifecycle.cached_run", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.export_contract", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.query_contract", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.Repacked.eq", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.repack_transport", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.answer_packet_fits", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.nativeBuildFirst_packet", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.nativeQuery_packet", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.Observations.runAcc_exact", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.Observations.read_occurrence_output", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.ContractChecks.checkO02_firstCategories", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.ContractChecks.checkO06_queryCategories", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.ContractChecks.checkO04_firstRoutes", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.ContractChecks.checkO08_queryRoutes", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.ContractChecks.checkO10_queryReadPosition", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.runThin_eq_runOwner", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.runBoundaryThin_eq_runBoundaryOwner", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.requestProtocolThin_eq_requestProtocolOwner", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.Observations.runAccThin_eq_runAcc", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.Observations.boundaryAccThin_eq_boundaryAcc", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.Observations.Stats.record_eq_recordBefore" + ], + "count": 21, + "consumedPins": 5605, + "currentSourceMappings": 379, + "historicalInputs": 370, + "toolInputs": 4856, + "checkedPinOccurrences": 5613, + "removedArtifactOccurrences": 0 + }, + { + "campaign": "rustReplay17", + "status": "APPLICABLE_ORIGINAL_EXECUTION", + "receipt": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\rust-misuse\\20260927T073749082\\RESULT.json", + "bytes": 138742, + "sha256": "921ceca64185a1ed5950ec219ed5ff3c0c3451bdd14c6507205f71af38844f5d" + }, + "evidence": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\4935\\RMQ\\.lake\\lifecycle-native1-r1\\reuse-20260927T214711\\rustReplay17.json", + "bytes": 127862, + "sha256": "7a02f2e93d93129bd71fe8a00864400952127a881bb6467f7f3671744ac9a380" + }, + "orderedIds": [ + "RS-RUNTIME-SEND", + "RS-RUNTIME-SYNC", + "RS-OWNER-SEND", + "RS-OWNER-SYNC", + "RS-OBSERVATION-SEND", + "RS-OBSERVATION-SYNC", + "RS-NATURAL-SEND", + "RS-NATURAL-SYNC", + "RS-RESULT-SEND", + "RS-RESULT-SYNC", + "RS-OWNER-CLONE", + "RS-IMMUTABLE-QUERY", + "RS-BYTES-ESCAPE", + "RS-RAW-ALIAS", + "RS-RUNTIME-ESCAPE", + "RS-ACCEPT-MUTABLE", + "RS-ACCEPT-BORROW" + ], + "count": 17, + "consumedPins": 112, + "currentSourceMappings": 13, + "historicalInputs": 18, + "toolInputs": 81, + "checkedPinOccurrences": 275, + "removedArtifactOccurrences": 0 + } + ], + "excludedFreshRequired": [ + "four-root focused Lean", + "native DLL and clients builds", + "startup", + "13 fixtures in both modes", + "23 ABI cases", + "10 clients", + "48 native controls", + "changed caller/selector/recipe controls", + "default lake build", + "report-sensitive scope/design/claim/clean certification" + ], + "boundary": "No old harness execution certifies changed harness bytes. All original verdicts and captures stay immutable. Formal all-size propositions, modeled costs, native Windows/runtime/foreign-caller assumptions and finite execution evidence remain distinct." +} diff --git a/docs/internal/extensions/lifecycle-native1-r1/START.json b/docs/internal/extensions/lifecycle-native1-r1/START.json new file mode 100644 index 00000000..e328570a --- /dev/null +++ b/docs/internal/extensions/lifecycle-native1-r1/START.json @@ -0,0 +1,25 @@ +{ + "handle": "LIFE-NATIVE-1-R1", + "taskId": "01a0e4b3-ac6d-7973-b6ca-557f3d21ca34", + "worktree": "C:\\Users\\poin\\.codex\\worktrees\\4935\\RMQ", + "branch": "codex/life-native-1-certification-repair", + "base": "c52c453a2f0f49c568886f502687e4d0667838e9", + "originalBase": "3dbdebedcc6ba6b2a864df0d46dcc09ccaaa7536", + "governance": "7b227c49ef2ec044b702126cc41c9add847eed01", + "cleanExactStart": true, + "preflight": "PASS", + "runtimeProjectSkills": [ + "rmq-audit-prompt", + "rmq-coordinator", + "rmq-proof-sprint" + ], + "requiredSkills": [ + "rmq-coordinator" + ], + "startedUtc": "2026-09-27T21:10:35.5484496Z", + "auditRoot": "C:/Users/poin/Documents/RMQ/lifecycle-implementation-20260920/native1-review-20260927", + "scopeReview": "C:/Users/poin/Documents/RMQ/lifecycle-implementation-20260920/native1-review-20260927/R1_SCOPE_REVIEW.md", + "scopeAdoption": "C:/Users/poin/Documents/RMQ/lifecycle-implementation-20260920/native1-repair-launch-20260927/R1_SCOPE_ADOPTION.md", + "status": "STARTED", + "evidencePlan": "docs/internal/extensions/lifecycle-native1-r1/VERIFICATION_PLAN.md" +} diff --git a/docs/internal/extensions/lifecycle-native1-r1/VERIFICATION_PLAN.md b/docs/internal/extensions/lifecycle-native1-r1/VERIFICATION_PLAN.md new file mode 100644 index 00000000..d9ef35a4 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native1-r1/VERIFICATION_PLAN.md @@ -0,0 +1,93 @@ +# LIFE-NATIVE-1-R1 verification plan + +Status: LOCAL_CANDIDATE_COMPLETE, conditional on the final external delivery binding. Repair base c52c453a2f0f49c568886f502687e4d0667838e9; +original base 3dbdebedcc6ba6b2a864df0d46dcc09ccaaa7536. Governance and runtime +identity are in START.json. All original 55 frozen rows remain binding. + +The complete dependency inventory is +C:/Users/poin/Documents/RMQ/lifecycle-implementation-20260920/native1-review-20260927/R1_SCOPE_REVIEW.md +(SHA256 58a9f0cbbb941e8d7c30e0a7f5e9bb6d3fffc2d345c1fb597cfbd58eab691b17), +with the exact fourteen-file packaging and WDD-only ledger ownership adopted in +../native1-repair-launch-20260927/R1_SCOPE_ADOPTION.md in that campaign directory. +The original implementation prompt, disposition, feedback and three leaf reports +were read completely before production edits. Historical paths retain their origin. + +The order is immutable evidence, current failure reproduction, frozen controls, +four small repairs, cheap actual caller controls, fresh producer chain, fresh +consumers and explicit reuse applicability, final report, clean commit and final +report-sensitive checks. Coordinator review, serialized aggregate, fresh blind +audit and protected integration remain subsequent campaign gates. + +## Exact artifacts and refresh inventory + +- Raw current evidence: C:/Users/poin/.codex/worktrees/4935/RMQ/.lake/lifecycle-native1-r1/. +- Existing runners retain fresh outputs beneath this worktree's .lake/lifecycle-native1/; + exact immutable per-run paths and hashes are recorded in COMMANDS.md and delivery. +- Current baseline: docs/internal/extensions/lifecycle-native1-r1/BASE_IDENTITY.json. +- Frozen repair cases and actual caller driver: REPAIR_CASES.json and controls.ps1 + in this R1 directory. H1 checks missing replay source and independently failing + integrity plus disposal; H2 checks every exact textual registry field with + ASCII/NUL/soft-hyphen/BOM/zero-width-space, missing/duplicate middle IDs and healthy + controls; H3 uses the actual build preflight/receipt functions and source closure. +- Repeat native_selector_controls.ps1 (33), native_control_selector_controls.ps1, + native_client_selector_controls.ps1 (13), native_recipe_controls.ps1 (11), plus + existing exact stream controls affected by the script edits. No registry changes. +- Fresh scripts/lifecycle_native_build.ps1 -Phase lean with all four default roots, + then -Phase dll and -Phase clients with the exact new Lean receipt. Initial + focused deadline 3600 seconds: old warm four-root run 56.835 seconds, with cold + 371-module margin in a fresh worktree. Native stages keep existing 300-second + batch/link limits. Inspect surviving children/progress after any timeout. +- Fresh startup, exactly LN1-W-TIES in both modes, all 13 fixtures in both modes, + all 23 ABI cases, all ten clients, and all 48 native controls. Use retained + prior measured timings to choose positive per-case deadlines (initial 300 seconds). +- One healthy focused native-controls Discovery establishes the final recipe. + New proposal retains all 48 measured projections/verdicts and stays + PENDING_COORDINATOR_REVIEW. Exact immutable bridge/proposal/discovery/source + paths are published at .lake/lifecycle-native1-r1/BINDING_REVIEW_REQUEST.json. + Only external exact-byte coordinator approval supplies NATIVE_EXPECTATIONS.json + with FROZEN_ROOT_REVIEWED for full Replay. Independent work continues meanwhile. +- REUSE_APPLICABILITY.json binds original absolute receipts, raw captures, + source/helper/registry bytes, generated inputs, tools and explicit path mappings + for 34 export cases, 21 axioms, 17 Rust misuse cases and unchanged termination + evidence. No copied old whole-checkout certificate is a current certificate. +- One fresh default_build.ps1 run (3600-second original cold margin), no outer + mutex. All heavy runners own Local\RMQLifecycleImplementationHeavy20260920. +- R1 identity/scope/final controls challenge out-of-scope bytes, frozen rows, + ledger prefixes, missing/extra/path/pin/stream claims in isolated shadows only. +- Final exact clean HEAD/base/branch and complete changed/untracked roster; + original 55 rows and all protected c52 bytes; append-only WDD; strict unchanged + design checker at both bases; strict unchanged claim policy over the entire + original-base changed surface including final R1 report; both hygiene scans; + working, c52..HEAD and original-base..HEAD whitespace. Full aggregate is deferred + to the coordinator, not duplicated locally. +- Final external delivery is .lake/lifecycle-native1-r1/delivery/DELIVERY.json, + pinning final report bytes/hash and committed HEAD after report-sensitive checks. + +No semantic producer, original registry, prior report, global helper, policy or +protected annotation may change. No further worker, push or merge is authorized. + +The completed local execution index and final exact commit/report certification +are in .lake/lifecycle-native1-r1/delivery/DELIVERY.json. Native48 Replay uses the +externally approved647054-byte manifest SHA256 +723bb8b4422130282aef59f5d94b623f32ee187d6dc7c7a72c6a45ff5fb23d53. +All93 repair cases passed, including actual final receipt consumption and scope +holdouts. The native runner's historical campaignComplete=false is retained; +actual coverage is established by its exact48 ordered selected/result/stage IDs, +completeRegistry and successful captures. Subsequent coordinator gates remain open. + +The repair-base strict-design result has its own exact19-path WDD-only consumer; +the original implementation-base consumer still requires both original ledgers. +Both execute the unchanged production design checker. Six actual checker/parser +controls replay with final_checks.ps1 -RepairDesignControls and passed after the +first final certification exposed the original consumer's narrower domain. The +frozen93 suite remains unchanged; final_checks.ps1 was copied file data there, +so final current scope and the six direct controls refresh its changed bytes. + +The final checker deadline is1800seconds after the retained600.12-second claim +scan timeout at final-checks/20260927T225503039/RESULT.json. The CPU-active scanner +was matching a paragraph rule over all109paths; owned termination and source +integrity succeeded. TIMEOUT_DIAGNOSIS.json records the observed178.106-second +smaller scan, doubled raw baseline line count and finite margin estimate. The +existing scanner/policy, full path roster and raw JSON bytes remain exact. Any +new timeout is still an uncovered failure. Refresh the six direct helper controls +and certify the follow-up clean commit; no unchanged heavy build/replay is needed. diff --git a/docs/internal/extensions/lifecycle-native1-r1/controls.ps1 b/docs/internal/extensions/lifecycle-native1-r1/controls.ps1 new file mode 100644 index 00000000..a157baa9 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native1-r1/controls.ps1 @@ -0,0 +1,336 @@ +[CmdletBinding()] +param([ValidateSet('registry','setup','closure','scope-final','all')][string]$Group='all', + [ValidateRange(1,120)][int]$DeadlineSeconds=30) +$ErrorActionPreference='Stop' +. (Join-Path $PSScriptRoot 'identity.ps1') +$root=$script:R1Root;$utf8=$script:R1Utf8 +$casePath=Join-Path $PSScriptRoot 'REPAIR_CASES.json' +$caseBytes=[IO.File]::ReadAllBytes($casePath) +if(-not (Test-R1Exact (Get-LN1BytesHash $caseBytes) 'b51c7c5bc0505f1e9c913c021fdfcd4f4ea0d8efcb1ac2ae8a439a99d3cb0549')){ + throw 'R1-CONTROLS: frozen repair mapping differs' +} +$registry=$utf8.GetString($caseBytes)|ConvertFrom-Json +$selected=@($registry.cases|Where-Object{$Group -eq 'all' -or $_.handler -eq $Group -or ($Group -eq 'closure' -and $_.handler.StartsWith('closure-'))}) +if($selected.Count -eq 0){throw 'R1-CONTROLS: empty selection'} +$run=Join-Path $root ('.lake/lifecycle-native1-r1/controls/'+[DateTime]::UtcNow.ToString('yyyyMMddTHHmmssfff')+'-'+[Guid]::NewGuid().ToString('N').Substring(0,8)) +$scratch=Join-Path $run 'disposable' +$pins=[Collections.Generic.List[object]]::new();$results=[Collections.Generic.List[object]]::new() +$report=[ordered]@{schema='lifecycle-native1-r1-controls-v1';success=$false;group=$Group; + startedUtc=[DateTime]::UtcNow.ToString('o');selected=@($selected.id);results=@();pins=@();failure=$null;integrity=$null;cleanup=$null} +$scopeShadow=$null +$shell=(Get-Process -Id $PID).Path +$prefix='docs/internal/extensions/lifecycle-native1/' +$helpers=@('scripts/lifecycle_native_identity.ps1','scripts/owned_process_tree.ps1', + 'scripts/packed_native_lifecycle_stream_check.ps1','scripts/packed_native_lifecycle_integrity_check.ps1', + 'scripts/packed_native_lifecycle_storage_replay.ps1') +function Copy-R1ControlFile([string]$Relative,[string]$Shadow){ + $source=Join-Path $root $Relative;$dest=Join-Path $Shadow $Relative + $pin=Get-LN1Pin $source;$pins.Add($pin) + [void][IO.Directory]::CreateDirectory((Split-Path $dest -Parent)) + [IO.File]::Copy($source,$dest,$false) + $copy=Get-LN1Pin $dest + if(-not (Test-R1Exact $copy.sha256 $pin.sha256) -or $copy.bytes -ne $pin.bytes){throw 'R1-CONTROLS: source copy differs'} +} +function Invoke-R1Caller([string]$Body,[string]$Name,[string]$Directory,[int]$Limit=$DeadlineSeconds){ + $driver=Join-Path $run ($Name+'-caller.ps1') + $text='$ErrorActionPreference="Stop"'+"`n"+'[Console]::OutputEncoding=[Text.UTF8Encoding]::new($false,$true)'+ + "`ntry {`n"+$Body+"`n"+'exit $LASTEXITCODE'+"`n} catch {`n"+ + '[Console]::Error.Write("R1-CALL ERROR: "+$_.Exception.Message+"`n"); exit 1'+"`n}`n" + [IO.File]::WriteAllText($driver,$text,$utf8);$pins.Add((Get-LN1Pin $driver)) + return Invoke-LNStreamCapture $root $shell @('-NoProfile','-File',$driver) $Directory (Join-Path $run $Name) $Limit $Name +} +try{ + [void][IO.Directory]::CreateDirectory($scratch) + foreach($p in @($PSCommandPath,(Join-Path $PSScriptRoot 'identity.ps1'),$casePath,$shell)){$pins.Add((Get-LN1Pin $p))} + foreach($case in $selected){ + $shadow=Join-Path $scratch $case.id + if($case.handler -ne 'scope-final'){foreach($p in $helpers){Copy-R1ControlFile $p $shadow}} + if($case.handler -eq 'registry'){ + $runner=$prefix+$case.runner+'.ps1';$data=$prefix+$case.runner+'.json' + Copy-R1ControlFile $runner $shadow;Copy-R1ControlFile $data $shadow + $r=[IO.File]::ReadAllText((Join-Path $shadow $data),$utf8)|ConvertFrom-Json + $ids=@($r.orderedIds) + switch($case.mutation){ + 'healthy' {} + 'omit' {$r.cases=@($r.cases[0..3])+@($r.cases[5..($r.cases.Count-1)]);$r.orderedIds=@($r.orderedIds[0..3])+@($r.orderedIds[5..($r.orderedIds.Count-1)])} + 'duplicate' {$r.cases[4]=$r.cases[3];$r.orderedIds[4]=$r.orderedIds[3]} + {$_ -in @('field','type')} { + $target=if($case.field -in @('schema','status')){$r}else{$r.cases[4]} + $value=if($case.mutation -eq 'type'){$case.value}else{[string]$target.($case.field)+$case.suffix} + $target.($case.field)=$value + if($case.field -eq 'id'){$r.orderedIds[4]=$value} + } + default {throw 'R1-CONTROLS: unknown mutation'} + } + if($case.mutation -ne 'healthy'){Write-R1Json (Join-Path $shadow $data) $r} + $retained=Join-Path $run ($case.id+'-registry.json') + [IO.File]::Copy((Join-Path $shadow $data),$retained,$false);$pins.Add((Get-LN1Pin $retained)) + $args=if($case.runner -eq 'native_controls'){' -Mode Plan'}else{' -Phase Validate'} + $capture=Invoke-R1Caller ('& '+(Quote-R1 (Join-Path $shadow $runner))+$args) $case.id $shadow + $out='';$err='' + $label=if($case.runner -eq 'native_controls'){'NATIVE-CONTROLS'}else{'NATIVE-CLIENTS'} + if($case.expectedExit -eq 0){ + $verb=if($case.runner -eq 'native_controls'){' PLAN'}else{' VALIDATED'} + $out=$label+$verb+' cases='+$ids.Count+' ids='+($ids -join ',')+"`r`n" + }else{ + $message=if($case.mutation -eq 'omit' -or $case.field -in @('schema','status')){'registry schema/count differs'}else{'frozen mapping differs at '+$ids[4]} + $err='R1-CALL ERROR: '+$label+': '+$message+"`n" + } + Assert-LNOuterCapture $capture $out $err $case.expectedExit $case.id + if([IO.Directory]::Exists((Join-Path $shadow '.lake'))){throw 'R1-CONTROLS: registry preflight mutated output'} + $results.Add(@{id=$case.id;passed=$true;capture=$capture;registry=(Get-LN1Pin $retained); + expectedExit=$case.expectedExit;expectedStdout=$out;expectedStderr=$err;outputMutation=$false; + boundary='Actual byte-identical Plan/Validate caller; production early return/rejection precedes semantic dispatch and output creation.'}) + }elseif($case.handler -eq 'setup'){ + $runner=$prefix+'native_selector_controls.ps1' + foreach($p in @($runner,($prefix+'native_selector_controls.json'),'scripts/lifecycle_native_cases.json')){Copy-R1ControlFile $p $shadow} + $faultPin=$null + if($case.fault -eq 'changed-pin-then-missing-replay'){ + # Only this disposable helper gains a fault injector: change the already + # pinned owner script just before its first missing replay-source pin. + # The actual owning runner and its finalizers remain byte-identical code. + $helper=Join-Path $shadow 'scripts/lifecycle_native_identity.ps1' + $fault=@' +$script:R1OriginalPin=${function:Get-LN1Pin} +$script:R1FaultFired=$false +function Get-LN1Pin([string]$Path){ + if(-not $script:R1FaultFired -and $Path.EndsWith('lifecycle_native_replay.ps1',[StringComparison]::Ordinal)){ + $script:R1FaultFired=$true + [IO.File]::AppendAllText((Join-Path $script:LN1Root 'docs/internal/extensions/lifecycle-native1/native_selector_controls.ps1'),"`n# R1 disposable integrity fault after owner pin.`n",[Text.UTF8Encoding]::new($false)) + } + & $script:R1OriginalPin $Path +} +'@ + [IO.File]::AppendAllText($helper,"`n"+$fault+"`n",$utf8) + $retainedHelper=Join-Path $run ($case.id+'-fault-helper.ps1') + [IO.File]::Copy($helper,$retainedHelper,$false);$faultPin=Get-LN1Pin $retainedHelper;$pins.Add($faultPin) + } + $missing=Join-Path $shadow 'scripts/lifecycle_native_replay.ps1' + if([IO.File]::Exists($missing)){throw 'R1-CONTROLS: missing-source fixture is present'} + $capture=Invoke-R1Caller ('& '+(Quote-R1 (Join-Path $shadow $runner))) $case.id $shadow + $innerRuns=@(Get-ChildItem -LiteralPath (Join-Path $shadow '.lake/lifecycle-native1/selector-controls') -Directory) + if($innerRuns.Count -ne 1){throw 'R1-CONTROLS: setup caller did not retain exactly one run'} + $inner=$innerRuns[0].FullName;$innerPath=Join-Path $inner 'RESULT.json' + $r=[IO.File]::ReadAllText($innerPath,$utf8)|ConvertFrom-Json + $expectedFailure="Could not find file '"+$missing+"'." + if($r.success -ne $false -or -not (Test-R1Exact $r.failureStage 'setup') -or + -not (Test-R1Exact $r.failure $expectedFailure) -or $r.setup.complete -ne $false -or + $r.setup.pinSetComplete -ne $false -or $r.integrity.initialPinSetComplete -ne $false -or + $r.integrity.attempted -ne $true -or $r.cleanup.attempted -ne $true -or + $r.finalReceiptAttempted -ne $true -or $r.semanticChildInvocations -ne 0 -or + $r.integrity.success -ne $case.integritySuccess -or $r.cleanup.success -ne $true -or + @($r.controls).Count -ne 0 -or $r.integrity.checked -ne 3 -or + [IO.Directory]::Exists((Join-Path $inner 'disposable'))){throw 'R1-CONTROLS: setup/finalization obligations differ'} + if($case.integritySuccess){ + if(@($r.integrity.errors).Count -ne 0){throw 'R1-CONTROLS: unexpected intact-pin error'} + }else{ + if(@($r.integrity.errors).Count -ne 1 -or + -not (Test-R1Exact $r.integrity.errors[0] ('changed source '+(Join-Path $shadow $runner)))){throw 'R1-CONTROLS: exact independent integrity failure absent'} + } + $out='NATIVE-SELECTOR-CONTROLS evidence='+$inner+"`r`n"+'NATIVE-SELECTOR-CONTROLS FAIL '+$expectedFailure+"`r`n" + Assert-LNOuterCapture $capture $out '' 1 $case.id + $saved=Join-Path $run ($case.id+'-inner-RESULT.json');[IO.File]::Copy($innerPath,$saved,$false) + $pins.Add((Get-LN1Pin $saved)) + $results.Add(@{id=$case.id;passed=$true;capture=$capture;innerReceipt=(Get-LN1Pin $saved); + faultHelper=$faultPin;failureStage='setup';initialPinSetComplete=$false; + ordinaryExit=1;semanticChildInvocations=0;disposableRemoved=$true; + integrityAttempted=$true;cleanupAttempted=$true;failureReceiptPersisted=$true}) + }elseif($case.handler.StartsWith('closure-')){ + Copy-R1ControlFile 'scripts/lifecycle_native_build.ps1' $shadow + Copy-R1ControlFile 'scripts/packed_native_identity.ps1' $shadow + $defaults=@('RMQ.Core.WordRAM.Native.Lifecycle','RMQ.Core.WordRAM.Native.Lifecycle.Observations', + 'RMQ.Core.WordRAM.Native.Lifecycle.AdmissionContract','RMQ.Validation.LifecycleNativeContract') + $modules=@(Get-LN1ImportClosure $defaults) + $native=@(Get-LN1ImportClosure @('RMQ.Core.WordRAM.Native.Lifecycle.Entry')) + $codec=@(Get-LN1ImportClosure @('RMQ.Core.WordRAM.Native.Lifecycle.Codec')) + if($modules.Count -ne 371 -or $native.Count -ne 365 -or $codec.Count -ne 3 -or + @($native|Where-Object{$_ -cnotin $codec}).Count -ne 362 -or + @($native|Where-Object{$_ -cnotin $modules}).Count -ne 0){throw 'R1-CONTROLS: recorded source closure fixture differs'} + foreach($module in $modules){Copy-R1ControlFile ($module.Replace('.','/')+'.lean') $shadow} + $builder=Join-Path $shadow 'scripts/lifecycle_native_build.ps1' + if($case.handler -eq 'closure-caller'){ + $capture=Invoke-R1Caller ('& '+(Quote-R1 $builder)+' -Phase '+$case.phase+' -LeanTargets RMQ.Core.WordRAM.Native.Lifecycle.Codec') $case.id $shadow + $err="R1-CALL ERROR: LIFECYCLE-BUILD: LeanTargets omit native Entry closure modules=362; use the default targets or a covering selection`n" + Assert-LNOuterCapture $capture '' $err 1 $case.id + if([IO.Directory]::Exists((Join-Path $shadow '.lake'))){throw 'R1-CONTROLS: unsupported native selection acquired outputs'} + $results.Add(@{id=$case.id;passed=$true;capture=$capture;selectedCount=3;compiledCount=365;uncovered=362;outputMutation=$false;compilerInvocations=0}) + }elseif($case.id -in @('H3-default-coverage','H3-lean-codec-supported')){ + # Execute the exact production prefix up to the FIRST resource acquisition; + # the appended marker is test instrumentation, not a copied guard. + $source=[IO.File]::ReadAllText($builder,$utf8) + $marker='[void][IO.Directory]::CreateDirectory($runRoot)' + $at=$source.IndexOf($marker,[StringComparison]::Ordinal) + if($at -lt 0 -or $source.LastIndexOf($marker,[StringComparison]::Ordinal) -ne $at){throw 'R1-CONTROLS: ambiguous acquisition boundary'} + $probe=$source.Substring(0,$at)+"`n"+'Write-Output ("R1-PREFLIGHT selected="+$modules.Count+" native="+$nativeModules.Count); exit 0'+"`n" + $probePath=Join-Path $shadow 'scripts/preflight.ps1';[IO.File]::WriteAllText($probePath,$probe,$utf8) + $saved=Join-Path $run ($case.id+'-production-prefix.ps1');[IO.File]::Copy($probePath,$saved,$false);$pins.Add((Get-LN1Pin $saved)) + $args=if($case.id -eq 'H3-lean-codec-supported'){' -Phase lean -LeanTargets RMQ.Core.WordRAM.Native.Lifecycle.Codec'}else{' -Phase dll'} + $expected=if($case.id -eq 'H3-lean-codec-supported'){"R1-PREFLIGHT selected=3 native=0`r`n"}else{"R1-PREFLIGHT selected=371 native=365`r`n"} + $capture=Invoke-R1Caller ('& '+(Quote-R1 $probePath)+$args) $case.id $shadow + Assert-LNOuterCapture $capture $expected '' 0 $case.id + if([IO.Directory]::Exists((Join-Path $shadow '.lake'))){throw 'R1-CONTROLS: preflight probe acquired outputs'} + $results.Add(@{id=$case.id;passed=$true;capture=$capture;prefix=(Get-LN1Pin $saved);compilerInvocations=0;boundary='Exact production prefix through closure guard, stopped before acquisition. Fresh full native positive execution is separately required.'}) + }else{ + # A clearly labeled component fixture exercises the ACTUAL receipt + # predicate over the FULL default set. It is never a build certificate. + $origin='C:/Users/poin/.codex/worktrees/44d6/RMQ' + $delivery=[IO.File]::ReadAllText((Join-Path $origin '.lake/lifecycle-native1/delivery/DELIVERY.json'),$utf8)|ConvertFrom-Json + Assert-R1Pin $delivery.verification.leanFourRoots.receipt + $old=[IO.File]::ReadAllText($delivery.verification.leanFourRoots.receipt.path,$utf8)|ConvertFrom-Json + $sourcePins=@(foreach($module in $modules){Get-LN1Pin (Join-Path $shadow ($module.Replace('.','/')+'.lean'))}) + foreach($relative in @('lean-toolchain','lakefile.toml','lake-manifest.json')){Copy-R1ControlFile $relative $shadow;$sourcePins+=@(Get-LN1Pin (Join-Path $shadow $relative))} + $generated=@(foreach($oldPin in $old.generatedPins){ + Assert-R1Pin $oldPin + $relative=[IO.Path]::GetRelativePath($origin,$oldPin.path) + $dest=Join-Path $shadow $relative + [void][IO.Directory]::CreateDirectory((Split-Path $dest -Parent));[IO.File]::Copy($oldPin.path,$dest,$false) + $now=Get-LN1Pin $dest + if($now.bytes -ne $oldPin.bytes -or -not (Test-R1Exact $now.sha256 $oldPin.sha256)){throw 'R1-CONTROLS: generated fixture copy differs'} + $now + }) + $fixture=Join-Path $run ($case.id+'-TEST-ONLY-RECEIPT.json') + Write-R1Json $fixture @{schema='lifecycle-native1-build-v1';success=$true;integrity=@{success=$true}; + testFixtureOnly=$true;origin=$delivery.verification.leanFourRoots.receipt; + boundary='Synthetic predicate input with exact isolated source/artifact copies. Not an actual compiler execution or current-worktree certificate.'; + sourcePins=$sourcePins;generatedPins=$generated;toolPins=$old.toolPins} + $tokens=$null;$errors=$null;$ast=[Management.Automation.Language.Parser]::ParseFile($builder,[ref]$tokens,[ref]$errors) + $function=@($ast.FindAll({param($n)$n -is [Management.Automation.Language.FunctionDefinitionAst] -and $n.Name -eq 'Assert-LN1LeanReceipt'},$true)) + if($errors.Count -or $function.Count -ne 1){throw 'R1-CONTROLS: actual receipt predicate extraction differs'} + $moduleList=(@($modules|ForEach-Object{Quote-R1 $_}) -join ',') + $predicateBody='. '+(Quote-R1 (Join-Path $shadow 'scripts/lifecycle_native_identity.ps1'))+"`n"+ + '$taskRoot='+(Quote-R1 $shadow)+"`n"+'function Add-LN1BuildPin([string]$Path){Get-LN1Pin $Path}'+"`n"+ + $function[0].Extent.Text+"`n"+'Assert-LN1LeanReceipt '+(Quote-R1 $fixture)+' @('+$moduleList+') | Out-Null' + $positive=Invoke-R1Caller ($predicateBody+"`n"+'Write-Output "R1-RECEIPT accepted"') ($case.id+'-healthy') $shadow 600 + Assert-LNOuterCapture $positive "R1-RECEIPT accepted`r`n" '' 0 ($case.id+'-healthy') + $healthyFixture=Join-Path $run ($case.id+'-TEST-ONLY-HEALTHY.json') + [IO.File]::Copy($fixture,$healthyFixture,$false);$pins.Add((Get-LN1Pin $healthyFixture)) + $target=Join-Path $shadow 'RMQ/Core/WordRAM/Native/Lifecycle/Entry.lean' + if($case.id -eq 'H3-native-body-mutation'){ + $body=[IO.File]::ReadAllBytes($target) + $text=$utf8.GetString($body) + $needle="PackedLifecycle.Executable.initialOwner (modelOfComparison comparison) xs`n (decodeMagnitude left) (decodeMagnitude right)" + if($text.Split([string[]]@($needle),[StringSplitOptions]::None).Count -ne 2){throw 'R1-CONTROLS: body mutation source anchor absent'} + $mutated=$text.Replace($needle,"PackedLifecycle.Executable.initialOwner (modelOfComparison comparison) xs`n (decodeMagnitude right) (decodeMagnitude left)") + [IO.File]::WriteAllText($target,$mutated,$utf8) + $savedBody=Join-Path $run ($case.id+'-mutated-Entry.lean');[IO.File]::WriteAllText($savedBody,$mutated,$utf8);$pins.Add((Get-LN1Pin $savedBody)) + $expectedError='LIFECYCLE-BUILD: stale LeanReceipt '+$target + }else{ + $fixtureData=[IO.File]::ReadAllText($fixture,$utf8)|ConvertFrom-Json + $missing=Join-Path $shadow '.lake/build/ir/RMQ/Core/WordRAM/Native/Lifecycle/Entry.c' + $fixtureData.generatedPins=@($fixtureData.generatedPins|Where-Object{-not (Test-R1Exact $_.path $missing)}) + Write-R1Json $fixture $fixtureData + $expectedError='LIFECYCLE-BUILD: missing prior source or artifact '+$missing + } + $capture=Invoke-R1Caller $predicateBody $case.id $shadow + Assert-LNOuterCapture $capture '' ('R1-CALL ERROR: '+$expectedError+"`n") 1 $case.id + $pins.Add((Get-LN1Pin $fixture)) + $results.Add(@{id=$case.id;passed=$true;capture=$capture;healthyCapture=$positive;healthyFixture=(Get-LN1Pin $healthyFixture);fixture=(Get-LN1Pin $fixture);selectedCount=371; + predicateSHA256=(Get-LN1BytesHash ($utf8.GetBytes($function[0].Extent.Text)));compilerInvocations=0; + boundary='Actual full-domain receipt predicate on isolated test-only pins; no fabricated stale DLL or compiler failure.'}) + } + }elseif($case.handler -eq 'scope-final'){ + $baseline=[IO.File]::ReadAllText((Join-Path $PSScriptRoot 'BASE_IDENTITY.json'),$utf8)|ConvertFrom-Json + if($case.id -in @('R1-FINAL-extra-stdout','R1-FINAL-extra-stderr','R1-FINAL-wrong-exit')){ + $suffix=switch($case.id){ + 'R1-FINAL-extra-stdout' {'[Console]::Out.Write("unexpected`n")'} + 'R1-FINAL-extra-stderr' {'[Console]::Error.Write("unexpected`n")'} + 'R1-FINAL-wrong-exit' {'exit 7'} + } + $capture=Invoke-R1Caller ('& '+(Quote-R1 (Join-Path $PSScriptRoot 'scope_check.ps1'))+' -Complete'+"`n"+$suffix) $case.id $root 600 + $head=(& git -c core.excludesfile= -c core.safecrlf=false rev-parse HEAD).Trim() + $paths=@(@(& git -c core.excludesfile= -c core.safecrlf=false diff --name-only $script:R1OriginalBase)+@(& git -c core.excludesfile= -c core.safecrlf=false ls-files --others --exclude-standard)|Sort-Object -Unique) + $rejected=$null + try{[void](Assert-R1FinalScope $capture $root $head $paths)}catch{$rejected=$_.Exception.Message} + $expected=switch($case.id){ + 'R1-FINAL-extra-stdout' {'R1-FINAL-SCOPE: unexpected complete output language'} + 'R1-FINAL-extra-stderr' {'STREAM: r1-final-scope stderr differs'} + 'R1-FINAL-wrong-exit' {'STREAM: r1-final-scope ordinary exit differs'} + } + if(-not (Test-R1Exact $rejected $expected)){throw ('R1-CONTROLS: exact final-stream rejection differs '+$rejected)} + $results.Add(@{id=$case.id;passed=$true;capture=$capture;rejection=$rejected;actualScopeCaller=$true}) + }else{ + # Full file domain, copied once; only isolated bytes are challenged. + if(-not $scopeShadow){ + $scopeShadow=Join-Path $scratch 'scope-repository' + foreach($f in $baseline.files){Copy-R1ControlFile $f.path $scopeShadow} + foreach($p in $script:R1New){if([IO.File]::Exists((Join-Path $root $p))){Copy-R1ControlFile $p $scopeShadow}} + } + $paths=@($baseline.files.path)+@($script:R1New|Where-Object{[IO.File]::Exists((Join-Path $scopeShadow $_))}) + $changedPath=$null;$before=$null;$expected=$null;$rejected=$null;$pin=$null + try{ + switch($case.id){ + 'R1-FINAL-healthy' {} + 'R1-FINAL-out-of-scope' {$changedPath=Join-Path $scopeShadow 'lean-toolchain';$expected='R1-SCOPE: protected raw bytes changed lean-toolchain'} + 'R1-FINAL-frozen-row' {$changedPath=Join-Path $scopeShadow 'docs/internal/extensions/lifecycle-native1/ACCEPTANCE_MATRIX.frozen.md';$expected='R1-SCOPE: protected raw bytes changed docs/internal/extensions/lifecycle-native1/ACCEPTANCE_MATRIX.frozen.md'} + 'R1-FINAL-ledger-prefix' {$changedPath=Join-Path $scopeShadow $script:R1Ledger;$expected='R1-SCOPE: ledger prefix rewritten'} + 'R1-FINAL-missing-path' {$paths=@($paths|Where-Object{$_ -cne 'lean-toolchain'});$expected='R1-SCOPE: missing original path lean-toolchain'} + 'R1-FINAL-extra-path' {$paths+=@('R1_OUTSIDE_SCOPE.txt');$expected='R1-SCOPE: new path outside exact roster R1_OUTSIDE_SCOPE.txt'} + 'R1-FINAL-changed-pin' {$changedPath=Join-Path $scopeShadow 'lean-toolchain';$pin=Get-LN1Pin $changedPath;$expected='R1-IDENTITY: changed pin '+$changedPath} + default {throw 'R1-CONTROLS: unknown scope holdout'} + } + if($changedPath){ + $before=[IO.File]::ReadAllBytes($changedPath);$mutated=[byte[]]$before.Clone();$mutated[0]=$mutated[0] -bxor 1 + [IO.File]::WriteAllBytes($changedPath,$mutated) + $saved=Join-Path $run ($case.id+'-mutated.bin');[IO.File]::WriteAllBytes($saved,$mutated);$pins.Add((Get-LN1Pin $saved)) + } + try{ + if($pin){Assert-R1Pin $pin}else{[void](Assert-R1ScopeFiles $scopeShadow $baseline $paths)} + }catch{$rejected=$_.Exception.Message} + if($case.id -eq 'R1-FINAL-out-of-scope'){ + # Additional metadata holdouts exercise the same production Git + # predicate used by the actual scope caller, without editing an index. + $stageRows=@($baseline.files|ForEach-Object{$_.mode+' '+$_.gitBlob+" 0`t"+$_.path+[char]0}) + $stageText=$stageRows -join '' + [void](Assert-R1GitScope $baseline $stageText @()) + $entry=@($baseline.files|Where-Object{Test-R1Exact $_.path 'lean-toolchain'})[0] + $needle=$entry.mode+' '+$entry.gitBlob+" 0`tlean-toolchain"+[char]0 + $probes=@( + @{name='mode';text=$stageText.Replace($needle,('100755 '+$entry.gitBlob+" 0`tlean-toolchain"+[char]0));changed=@();expected='R1-SCOPE: current Git mode changed lean-toolchain'}, + @{name='blob';text=$stageText.Replace($needle,($entry.mode+' '+('0'*40)+" 0`tlean-toolchain"+[char]0));changed=@();expected='R1-SCOPE: protected Git blob changed lean-toolchain'}, + @{name='path';text=$stageText;changed=@('lean-toolchain');expected='R1-SCOPE: Git change outside exact roster lean-toolchain'}) + $gitHoldouts=@(foreach($probe in $probes){ + $failure=$null + try{[void](Assert-R1GitScope $baseline $probe.text $probe.changed)}catch{$failure=$_.Exception.Message} + if(-not (Test-R1Exact $failure $probe.expected)){throw ('R1-CONTROLS: Git metadata rejection differs '+$failure)} + $fixturePath=Join-Path $run ('R1-GIT-'+$probe.name+'-TEST-ONLY.json') + Write-R1Json $fixturePath $probe;$pins.Add((Get-LN1Pin $fixturePath)) + @{name=$probe.name;fixture=(Get-LN1Pin $fixturePath);rejection=$failure;actualPredicate=$true;liveIndexWrites=0} + }) + $report.gitMetadataHoldouts=$gitHoldouts + } + if($case.expectedVerdict -eq 'accept'){ + if($null -ne $rejected){throw ('R1-CONTROLS: healthy complete file-domain rejected '+$rejected)} + $healthyScope=Invoke-R1Caller ('& '+(Quote-R1 (Join-Path $PSScriptRoot 'scope_check.ps1'))+' -Complete') ($case.id+'-caller') $root 600 + $head=(& git -c core.excludesfile= -c core.safecrlf=false rev-parse HEAD).Trim() + $currentPaths=@(@(& git -c core.excludesfile= -c core.safecrlf=false diff --name-only $script:R1OriginalBase)+@(& git -c core.excludesfile= -c core.safecrlf=false ls-files --others --exclude-standard)|Sort-Object -Unique) + $healthyConsumed=Assert-R1FinalScope $healthyScope $root $head $currentPaths + $report.healthyFinalScope=@{capture=$healthyScope;consumed=$healthyConsumed} + }elseif(-not (Test-R1Exact $rejected $expected)){throw ('R1-CONTROLS: wrong scope rejection '+$rejected)} + $results.Add(@{id=$case.id;passed=$true;checkedOriginalFiles=3930;rejection=$rejected; + boundary='Actual R1 file/pin predicate on complete isolated current source roster; no live protected bytes changed.'}) + }finally{ + if($changedPath -and $null -ne $before){ + [IO.File]::WriteAllBytes($changedPath,$before) + if(-not (Test-R1Exact (Get-LN1BytesHash ([IO.File]::ReadAllBytes($changedPath))) (Get-LN1BytesHash $before))){throw 'R1-CONTROLS: shadow restoration failed'} + } + } + } + }else{throw ('R1-CONTROLS: unknown handler '+$case.handler)} + } + if(-not (Test-R1Exact ($results.id -join '|') ($selected.id -join '|'))){throw 'R1-CONTROLS: completed ordered roster differs'} + $report.success=$true +}catch{$report.failure=$_.Exception.Message} +finally{ + $errors=[Collections.Generic.List[string]]::new() + foreach($p in $pins){try{Assert-R1Pin $p}catch{$errors.Add($_.Exception.Message)}} + $report.integrity=@{success=($errors.Count -eq 0);checked=$pins.Count;errors=@($errors.ToArray())} + try{Remove-R1Scratch $scratch $run;$report.cleanup=@{success=$true;scratchAbsent=$true}} + catch{$report.cleanup=@{success=$false;error=$_.Exception.Message}} + $report.success=$report.success -and $report.integrity.success -and $report.cleanup.success + $report.results=@($results.ToArray());$report.pins=@($pins.ToArray());$report.completedUtc=[DateTime]::UtcNow.ToString('o') + [void][IO.Directory]::CreateDirectory($run) + Write-R1Json (Join-Path $run 'RESULT.json') $report +} +Write-Output ('R1-CONTROLS evidence='+$run) +if(-not $report.success){Write-Output ('R1-CONTROLS FAIL '+$report.failure);exit 1} +Write-Output ('R1-CONTROLS PASS count='+$results.Count) diff --git a/docs/internal/extensions/lifecycle-native1-r1/final_checks.ps1 b/docs/internal/extensions/lifecycle-native1-r1/final_checks.ps1 new file mode 100644 index 00000000..d0d47f7b --- /dev/null +++ b/docs/internal/extensions/lifecycle-native1-r1/final_checks.ps1 @@ -0,0 +1,227 @@ +[CmdletBinding()] +param([switch]$Committed,[switch]$RepairDesignControls) +$ErrorActionPreference='Stop' +$root=[IO.Path]::GetFullPath((Join-Path $PSScriptRoot '../../../..')) +. (Join-Path $PSScriptRoot 'identity.ps1') +. (Join-Path $root 'docs/internal/extensions/lifecycle-native1/final_streams.ps1') +$utf8=[Text.UTF8Encoding]::new($false,$true) +$base='3dbdebedcc6ba6b2a864df0d46dcc09ccaaa7536' +$run=Join-Path $root ('.lake/lifecycle-native1-r1/final-checks/'+[DateTime]::UtcNow.ToString('yyyyMMddTHHmmssfff')) +[void][IO.Directory]::CreateDirectory($run) +$pins=[Collections.Generic.List[object]]::new() +$stages=[Collections.Generic.List[object]]::new() +$shell=(Get-Process -Id $PID).Path +$git=(Get-Command git -CommandType Application|Select-Object -First 1).Source +$rg=(Get-Command rg -CommandType Application|Select-Object -First 1).Source +$report=[ordered]@{schema='lifecycle-native1-r1-final-checks-v1';repairBase=$script:R1Base;success=$false;base=$base; + committed=[bool]$Committed;head=$null;startedUtc=[DateTime]::UtcNow.ToString('o'); + deadlineSeconds=1800;deadlineRationale='Preserved all109-path scan timeout600.12s with CPU-active paragraph matcher and successful owned cleanup. Original83-path scan178.106s; new raw baseline55057lines versus26918 suggests about4.18x paragraph scan work before additional frozen data. Reserve1800seconds, more than2x that estimate, including cold/contended margin. Exact scanner, policy, paths and raw inventories remain unchanged; any timeout remains failure.'; + claimPaths=@();pins=@();stages=@();failure=$null;integrity=$null;cleanup=$null} +function Pin-Final([string]$Path){$p=Get-LN1Pin $Path;$pins.Add($p);return $p} +function Run-Final([string]$Name,[string]$File,[string[]]$Arguments,[int]$ExpectedExit=0){ + $capture=Invoke-LNStreamCapture $root $File $Arguments $root (Join-Path $run $Name) $report.deadlineSeconds $Name + $stages.Add(@{name=$Name;file=$File;arguments=$Arguments;capture=$capture}) + foreach($p in $capture.raw){[void](Pin-Final $p.path)} + $stdout=Read-LNExactStream $capture.spec.stdout + $stderr=Read-LNExactStream $capture.spec.stderr + Assert-LNOuterCapture $capture $stdout $stderr $ExpectedExit $Name + return $capture +} +function Git-Final([string]$Name,[string[]]$Arguments){ + $c=Run-Final $Name $git (@('-c','core.excludesfile=','-c','core.safecrlf=false')+$Arguments) + if(-not [StringComparer]::Ordinal.Equals((Read-LNExactStream $c.spec.stderr),'')){throw ('FINAL-CHECKS: unexpected Git stderr '+$Name)} + return Read-LNExactStream $c.spec.stdout +} +function Git-EmptyFinal([string]$Name,[string[]]$Arguments){ + $c=Run-Final $Name $git (@('-c','core.excludesfile=','-c','core.safecrlf=false')+$Arguments) + Assert-LNOuterCapture $c '' '' 0 $Name +} +function Assert-R1RepairDesign($Capture,[string[]]$Paths){ + $requested=Get-LNFinalPathSet $Paths + $allowed=Get-LNFinalPathSet (@($script:R1Old)+@($script:R1Ledger)+@($script:R1New)) + if(-not $requested.SetEquals($allowed)){throw 'R1-FINAL-DESIGN: exact repair roster required'} + $checker=Join-Path $root 'scripts/design_decision_check.ps1' + $checkerPin=Get-LN1Pin $checker;$ast=Get-LNFinalCheckerAst $checker + foreach($name in @('neutralEvidencePatterns','workflowRootPatterns','codeRootPatterns','proofCodePattern', + 'workflowCodePattern','nativeSourcePattern','nativeCodePatterns','nativeWorkflowPatterns')){ + Set-Variable -Name $name -Value (Get-LNFinalLiteral $ast $name) -Scope Local + } + $definitions=@(foreach($name in @('Test-AnyPattern','Get-PathDisposition')){ + $nodes=@($ast.FindAll({param($node)$node -is [Management.Automation.Language.FunctionDefinitionAst] -and $node.Name -ceq $name},$true)) + if($nodes.Count -ne 1){throw 'R1-FINAL-DESIGN: ambiguous production classifier'} + $nodes[0].Extent.Text + }) + $classifier=[scriptblock]::Create("param([string]`$ClassifiedPath)`n"+($definitions -join "`n")+"`nGet-PathDisposition -Path `$ClassifiedPath") + $code=0;$workflow=0;$neutral=0 + foreach($path in $Paths){ + $rows=@(& $classifier $path) + if($rows.Count -ne 1 -or $rows[0].Unclassified){throw 'R1-FINAL-DESIGN: unclassified repair path'} + if($rows[0].NeedsCode){$code++};if($rows[0].NeedsWorkflow){$workflow++};if($rows[0].Neutral){$neutral++} + } + # This consumer is only for the frozen four-script/fourteen-file/WDD repair. + # The original cumulative implementation still uses its unchanged consumer. + if($code -ne 0 -or $workflow -ne 18 -or $neutral -ne 1 -or + -not $requested.Contains($script:R1Ledger) -or $requested.Contains('docs/internal/DESIGN_DECISIONS.md')){ + throw 'R1-FINAL-DESIGN: repair workflow-only classification differs' + } + $expected='DESIGN-CHECK: checked '+$Paths.Count+' changed files ('+$code+' code, '+$workflow+' workflow, '+$neutral+' neutral)'+[Environment]::NewLine + Assert-LNOuterCapture $Capture $expected '' 0 'r1-final-design' + [void](Assert-LNFinalPin $checkerPin $checker) + return @{checkerPin=$checkerPin;summary=@{paths=$Paths.Count;code=$code;workflow=$workflow;neutral=$neutral; + boundary='Exact frozen repair roster; classification comes from unchanged production literals/functions. Only the workflow ledger is required by this zero-code scope.'}} +} +if($RepairDesignControls){ + if($Committed){throw 'R1-DESIGN-CONTROLS: incompatible certification flag'} + $controlReport=[ordered]@{schema='lifecycle-native1-r1-repair-design-controls-v1';success=$false;results=@();pins=@();failure=$null;integrity=$null;cleanup=$null} + $controlPins=[Collections.Generic.List[object]]::new();$controlResults=[Collections.Generic.List[object]]::new() + try{ + foreach($p in @($PSCommandPath,(Join-Path $PSScriptRoot 'identity.ps1'),(Join-Path $root 'scripts/design_decision_check.ps1'),(Join-Path $root 'docs/internal/extensions/lifecycle-native1/final_streams.ps1'))){$controlPins.Add((Get-LN1Pin $p))} + $repairPaths=@($script:R1Old)+@($script:R1Ledger)+@($script:R1New) + $driver=Join-Path $run 'repair-design-control-driver.ps1' + $driverText=@' +$count=0 +$inherited=[Environment]::GetEnvironmentVariable('GIT_CONFIG_COUNT','Process') +if($null -ne $inherited -and (-not [int]::TryParse($inherited,[ref]$count) -or $count -lt 0 -or $count -gt ([int]::MaxValue-2))){throw 'Invalid inherited Git configuration count'} +[Environment]::SetEnvironmentVariable(('GIT_CONFIG_KEY_'+$count),'core.excludesfile','Process') +[Environment]::SetEnvironmentVariable(('GIT_CONFIG_VALUE_'+$count),(Join-Path $PSScriptRoot 'empty-git-exclude'),'Process') +[Environment]::SetEnvironmentVariable(('GIT_CONFIG_KEY_'+($count+1)),'core.safecrlf','Process') +[Environment]::SetEnvironmentVariable(('GIT_CONFIG_VALUE_'+($count+1)),'false','Process') +$env:GIT_CONFIG_COUNT=[string]($count+2) +& './scripts/design_decision_check.ps1' -Strict -Base 'c52c453a2f0f49c568886f502687e4d0667838e9' +exit $LASTEXITCODE +'@ + [IO.File]::WriteAllBytes((Join-Path $run 'empty-git-exclude'),[byte[]]@()) + $controlPins.Add((Get-LN1Pin (Join-Path $run 'empty-git-exclude'))) + [IO.File]::WriteAllText($driver,($driverText+"`n"),$utf8);$controlPins.Add((Get-LN1Pin $driver)) + $healthy=Invoke-LNStreamCapture $root $shell @('-NoProfile','-File',$driver) $root (Join-Path $run 'healthy') 60 'repair-design-healthy' + foreach($p in $healthy.raw){$controlPins.Add($p)} + [void](Assert-R1RepairDesign $healthy $repairPaths) + $controlResults.Add(@{id='healthy';passed=$true;capture=$healthy}) + foreach($case in @( + @{id='missing-ledger';paths=@($repairPaths|Where-Object{$_ -cne $script:R1Ledger});expected='R1-FINAL-DESIGN: exact repair roster required'}, + @{id='extra-code-ledger';paths=@($repairPaths)+@('docs/internal/DESIGN_DECISIONS.md');expected='R1-FINAL-DESIGN: exact repair roster required'})){ + $failure=$null;try{[void](Assert-R1RepairDesign $healthy $case.paths)}catch{$failure=$_.Exception.Message} + if(-not (Test-R1Exact $failure $case.expected)){throw 'R1-DESIGN-CONTROLS: path rejection differs'} + $controlResults.Add(@{id=$case.id;passed=$true;paths=$case.paths;rejection=$failure;capture=$healthy}) + } + foreach($case in @( + @{id='extra-stdout';suffix='[Console]::Out.Write("extra`n")';expected='STREAM: r1-final-design stdout differs'}, + @{id='extra-stderr';suffix='[Console]::Error.Write("extra`n")';expected='STREAM: r1-final-design stderr differs'}, + @{id='wrong-exit';suffix='exit 7';expected='STREAM: r1-final-design ordinary exit differs'})){ + $caller=Join-Path $run ($case.id+'-caller.ps1') + [IO.File]::WriteAllText($caller,('& '+(Quote-R1 $driver)+"`n"+$case.suffix+"`n"),$utf8);$controlPins.Add((Get-LN1Pin $caller)) + $capture=Invoke-LNStreamCapture $root $shell @('-NoProfile','-File',$caller) $root (Join-Path $run $case.id) 60 $case.id + foreach($p in $capture.raw){$controlPins.Add($p)} + $failure=$null;try{[void](Assert-R1RepairDesign $capture $repairPaths)}catch{$failure=$_.Exception.Message} + if(-not (Test-R1Exact $failure $case.expected)){throw ('R1-DESIGN-CONTROLS: exact rejection differs '+$failure)} + $controlResults.Add(@{id=$case.id;passed=$true;capture=$capture;rejection=$failure}) + } + $controlReport.success=$true + }catch{$controlReport.failure=$_.Exception.Message} + finally{ + $errors=@(foreach($p in $controlPins){try{Assert-R1Pin $p}catch{$_.Exception.Message}}) + $controlReport.integrity=@{success=($errors.Count -eq 0);errors=$errors};$controlReport.cleanup=@{success=$true;liveSourceWrites=0;disposableWrites=0} + $controlReport.success=$controlReport.success -and $controlReport.integrity.success + $controlReport.pins=@($controlPins.ToArray());$controlReport.results=@($controlResults.ToArray()) + Write-R1Json (Join-Path $run 'REPAIR_DESIGN_CONTROLS.json') $controlReport + } + Write-Output ('R1-DESIGN-CONTROLS success='+$controlReport.success+' evidence='+$run) + if(-not $controlReport.success){Write-Output $controlReport.failure;exit 1};exit 0 +} +try{ + foreach($p in @($PSCommandPath,$shell,$git,$rg, + (Join-Path $root 'scripts/lifecycle_native_identity.ps1'), + (Join-Path $root 'scripts/owned_process_tree.ps1'), + (Join-Path $root 'scripts/packed_native_lifecycle_stream_check.ps1'), + (Join-Path $root 'scripts/packed_native_lifecycle_storage_replay.ps1'), + (Join-Path $root 'scripts/packed_native_lifecycle_integrity_check.ps1'), + (Join-Path $root 'scripts/claim_drift_scan.ps1'), + (Join-Path $root 'docs/internal/CLAIM_DRIFT_POLICY.json'), + (Join-Path $root 'scripts/design_decision_check.ps1'), + (Join-Path $PSScriptRoot 'scope_check.ps1'), + (Join-Path $root 'docs/internal/extensions/lifecycle-native1/final_streams.ps1'),(Join-Path $PSScriptRoot 'identity.ps1'))){[void](Pin-Final $p)} + $report.head=(Git-Final 'head' @('rev-parse','HEAD')).Trim() + $changed=(Git-Final 'changed' @('diff','--name-only','-z',$base)) -split [char]0|Where-Object{$_} + $new=(Git-Final 'new' @('ls-files','--others','--exclude-standard','-z')) -split [char]0|Where-Object{$_} + $paths=@(@($changed)+@($new)|Sort-Object -Unique) + if($paths.Count -eq 0){throw 'FINAL-CHECKS: vacuous changed surface'} + foreach($p in $paths){[void](Pin-Final (Join-Path $root $p))} + $report.claimPaths=$paths + # The scanner receives an actual structured array, including process records + # and exact frozen JSON evidence. No renamed/omitted allowance surface. + $quoted=@($paths|ForEach-Object{"'"+$_.Replace("'","''")+"'"}) -join ",`n" + $driver=Join-Path $run 'claims-driver.ps1' + $body="`$paths=@(`n"+$quoted+"`n)`n& './scripts/claim_drift_scan.ps1' -Strict -IncludeProcessRecords -Path `$paths`nexit `$LASTEXITCODE`n" + [IO.File]::WriteAllText($driver,$body,$utf8);[void](Pin-Final $driver) + $scope=Run-Final 'scope' $shell @('-NoProfile','-File',(Join-Path $PSScriptRoot 'scope_check.ps1'),'-Complete') + $report.scope=Assert-R1FinalScope $scope $root $report.head $paths + foreach($p in @($report.scope.pin)+@($report.scope.pins)){ + $now=Pin-Final $p.path + if($now.bytes -ne $p.bytes -or $now.sha256 -cne $p.sha256){throw ('FINAL-CHECKS: scope receipt/input changed '+$p.path)} + } + # Only this fresh child receives Git advice/exclude overrides. Repository and + # user configuration are unchanged; the exact driver is a pinned input. + $designDriver=Join-Path $run 'design-driver.ps1' + $emptyExclude=Join-Path $run 'empty-git-exclude' + [IO.File]::WriteAllBytes($emptyExclude,[byte[]]@());[void](Pin-Final $emptyExclude) + $designBody=@' +$count=0 +$inheritedCount=[Environment]::GetEnvironmentVariable('GIT_CONFIG_COUNT','Process') +if($null -ne $inheritedCount -and (-not [int]::TryParse($inheritedCount,[ref]$count) -or $count -lt 0 -or $count -gt ([int]::MaxValue-2))){ + throw 'FINAL-DESIGN: invalid inherited Git configuration count' +} +# Preserve the sandbox's inherited safe.directory and other command-local +# entries. Replacing GIT_CONFIG_COUNT would discard that required context. +[Environment]::SetEnvironmentVariable(('GIT_CONFIG_KEY_'+$count),'core.excludesfile','Process') +[Environment]::SetEnvironmentVariable(('GIT_CONFIG_VALUE_'+$count),(Join-Path $PSScriptRoot 'empty-git-exclude'),'Process') +[Environment]::SetEnvironmentVariable(('GIT_CONFIG_KEY_'+($count+1)),'core.safecrlf','Process') +[Environment]::SetEnvironmentVariable(('GIT_CONFIG_VALUE_'+($count+1)),'false','Process') +$env:GIT_CONFIG_COUNT=[string]($count+2) +& './scripts/design_decision_check.ps1' -Strict -Base '3dbdebedcc6ba6b2a864df0d46dcc09ccaaa7536' +exit $LASTEXITCODE +'@ + [IO.File]::WriteAllText($designDriver,($designBody+"`n"),$utf8);[void](Pin-Final $designDriver) + $design=Run-Final 'design' $shell @('-NoProfile','-File',$designDriver) + $report.design=Assert-LNFinalDesign $design $paths + $repairChanged=(Git-Final 'repair-changed' @('diff','--name-only','-z',$script:R1Base)) -split [char]0|Where-Object{$_} + $repairPaths=@(@($repairChanged)+@($new)|Sort-Object -Unique) + $repairDriver=Join-Path $run 'repair-design-driver.ps1' + [IO.File]::WriteAllText($repairDriver,($designBody.Replace($base,$script:R1Base)+"`n"),$utf8);[void](Pin-Final $repairDriver) + $repairDesign=Run-Final 'repair-design' $shell @('-NoProfile','-File',$repairDriver) + $report.repairDesign=Assert-R1RepairDesign $repairDesign $repairPaths + $claims=Run-Final 'claims' $shell @('-NoProfile','-File',$driver) + $report.claims=Assert-LNFinalClaims $claims $root (Join-Path $root 'docs/internal/CLAIM_DRIFT_POLICY.json') $paths + $trust=Run-Final 'trust' $rg @('-n','\b(sorry|admit|axiom|unsafe|opaque|implemented_by|partial|extern|noncomputable)\b|import Mathlib','RMQ','lakefile.toml') 1 + Assert-LNOuterCapture $trust '' '' 1 'trust' + $smoke=Run-Final 'native-decide' $rg @('-n','native_decide|Lean\.ofReduceBool','RMQ') 1 + Assert-LNOuterCapture $smoke '' '' 1 'native-decide' + Git-EmptyFinal 'working-whitespace' @('diff','--check') + if($Committed){ + Git-EmptyFinal 'committed-whitespace' @('diff','--check',($base+'..HEAD')) + Git-EmptyFinal 'repair-committed-whitespace' @('diff','--check',($script:R1Base+'..HEAD')) + Git-EmptyFinal 'clean-tree' @('status','--porcelain=v1','--untracked-files=all') + } + $report.success=$true +}catch{$report.failure=$_.Exception.Message} +finally{ + $errors=[Collections.Generic.List[string]]::new() + try{ + $endHead=(Git-Final 'final-head' @('rev-parse','HEAD')).Trim() + $endChanged=(Git-Final 'final-changed' @('diff','--name-only','-z',$base)) -split [char]0|Where-Object{$_} + $endNew=(Git-Final 'final-new' @('ls-files','--others','--exclude-standard','-z')) -split [char]0|Where-Object{$_} + $endPaths=@(@($endChanged)+@($endNew)|Sort-Object -Unique) + $report.finalIdentity=@{head=$endHead;paths=$endPaths} + if($endHead -cne $report.head -or ($endPaths -join "`n") -cne ($report.claimPaths -join "`n")){ + throw 'FINAL-CHECKS: HEAD or complete changed/new roster changed during certification' + } + }catch{$errors.Add($_.Exception.Message)} + foreach($p in $pins){try{$now=Get-LN1Pin $p.path;if($now.bytes -ne $p.bytes -or $now.sha256 -cne $p.sha256){throw ('changed pin '+$p.path)}}catch{$errors.Add($_.Exception.Message)}} + $report.integrity=@{success=($errors.Count -eq 0);checked=$pins.Count;errors=@($errors.ToArray())} + $report.cleanup=@{success=$true;disposableWrites=0;retainedEvidence=$run;liveSourceWrites=0} + $report.success=$report.success -and $report.integrity.success + $report.pins=@($pins.ToArray());$report.stages=@($stages.ToArray());$report.completedUtc=[DateTime]::UtcNow.ToString('o') + [IO.File]::WriteAllText((Join-Path $run 'RESULT.json'),($report|ConvertTo-Json -Depth 40),$utf8) +} +Write-Output ('FINAL-CHECKS evidence='+$run) +if(-not $report.success){Write-Output ('FINAL-CHECKS FAIL '+$report.failure);exit 1} +Write-Output ('FINAL-CHECKS PASS files='+$report.claimPaths.Count+' committed='+[bool]$Committed) diff --git a/docs/internal/extensions/lifecycle-native1-r1/identity.ps1 b/docs/internal/extensions/lifecycle-native1-r1/identity.ps1 new file mode 100644 index 00000000..32a63df1 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native1-r1/identity.ps1 @@ -0,0 +1,138 @@ +# R1 consumers use the unchanged raw-process/contract helpers. +$script:R1Root=[IO.Path]::GetFullPath((Join-Path $PSScriptRoot '../../../..')) +. (Join-Path $script:R1Root 'scripts/lifecycle_native_identity.ps1') +$script:R1Utf8=[Text.UTF8Encoding]::new($false,$true) +$script:R1Base='c52c453a2f0f49c568886f502687e4d0667838e9' +$script:R1OriginalBase='3dbdebedcc6ba6b2a864df0d46dcc09ccaaa7536' +$script:R1Branch='codex/life-native-1-certification-repair' +$script:R1Old=@('scripts/lifecycle_native_build.ps1', + 'docs/internal/extensions/lifecycle-native1/native_controls.ps1', + 'docs/internal/extensions/lifecycle-native1/native_clients.ps1', + 'docs/internal/extensions/lifecycle-native1/native_selector_controls.ps1') +$script:R1Ledger='docs/internal/WORKFLOW_DESIGN_DECISIONS.md' +$script:R1New=@('START.json','BASE_IDENTITY.json','REPAIR_CASES.json','controls.ps1','identity.ps1', + 'scope_check.ps1','final_checks.ps1','NATIVE_EXPECTATIONS.json','REUSE_APPLICABILITY.json', + 'REPORT.md','ACCEPTANCE_MATRIX.md','COMMANDS.md','GUIDE.md','VERIFICATION_PLAN.md') | + ForEach-Object{'docs/internal/extensions/lifecycle-native1-r1/'+$_} +function Test-R1Exact($Actual,$Expected){ + return $Actual -is [string] -and $Expected -is [string] -and + [string]::Equals($Actual,$Expected,[StringComparison]::Ordinal) +} +function Write-R1Json([string]$Path,$Value){ + [IO.File]::WriteAllText($Path,($Value|ConvertTo-Json -Depth 80),$script:R1Utf8) +} +function Quote-R1([string]$Text){return "'"+$Text.Replace("'","''")+"'"} +function Assert-R1Pin($Pin){ + $now=Get-LN1Pin $Pin.path + if($now.bytes -ne $Pin.bytes -or ($Pin.sha256 -isnot [string]) -or $Pin.sha256 -cnotmatch '\A[0-9a-fA-F]{64}\z' -or -not [string]::Equals($now.sha256,$Pin.sha256,[StringComparison]::OrdinalIgnoreCase)){ + throw ('R1-IDENTITY: changed pin '+$Pin.path) + } +} +function Remove-R1Scratch([string]$Scratch,[string]$Run){ + $full=[IO.Path]::GetFullPath($Scratch) + $expected=[IO.Path]::GetFullPath((Join-Path $Run 'disposable')) + if(-not (Test-R1Exact $full $expected)){throw 'R1-CLEANUP: not the owned disposable directory'} + if([IO.Directory]::Exists($full)){ + foreach($entry in @((Get-Item -LiteralPath $full))+@(Get-ChildItem -LiteralPath $full -Recurse -Force)){ + if($entry.Attributes -band [IO.FileAttributes]::ReparsePoint){throw 'R1-CLEANUP: reparse point'} + } + Remove-Item -LiteralPath $full -Recurse -Force + } + if([IO.Directory]::Exists($full)){throw 'R1-CLEANUP: scratch remains'} +} +function Assert-R1ScopeFiles([string]$Root,$Baseline,[string[]]$Paths,[switch]$RequireComplete){ + if(-not (Test-R1Exact $Baseline.base $script:R1Base) -or + -not (Test-R1Exact $Baseline.originalBase $script:R1OriginalBase)){ + throw 'R1-SCOPE: baseline base identity differs' + } + $known=[Collections.Generic.HashSet[string]]::new([StringComparer]::Ordinal) + $roster=[Collections.Generic.HashSet[string]]::new([StringComparer]::Ordinal) + foreach($p in $Paths){if(-not $roster.Add($p)){throw 'R1-SCOPE: duplicate current path'}} + $changed=[Collections.Generic.List[object]]::new() + foreach($old in $Baseline.files){ + if(-not $known.Add($old.path)){throw 'R1-SCOPE: duplicate baseline path'} + if(-not $roster.Contains($old.path)){throw ('R1-SCOPE: missing original path '+$old.path)} + $path=Join-Path $Root $old.path + if(-not [IO.File]::Exists($path)){throw ('R1-SCOPE: missing original file '+$old.path)} + $bytes=[IO.File]::ReadAllBytes($path);$hash=Get-LN1BytesHash $bytes + if($bytes.Length -eq $old.rawBytes -and [string]::Equals($hash,$old.rawSHA256,[StringComparison]::OrdinalIgnoreCase)){continue} + if(Test-R1Exact $old.path $script:R1Ledger){ + if($bytes.Length -lt $old.rawBytes){throw 'R1-SCOPE: ledger prefix shortened'} + $prefix=[byte[]]::new($old.rawBytes);[Array]::Copy($bytes,$prefix,$prefix.Length) + if(-not [string]::Equals((Get-LN1BytesHash $prefix),$old.rawSHA256,[StringComparison]::OrdinalIgnoreCase)){ + throw 'R1-SCOPE: ledger prefix rewritten' + } + }elseif(-not [Linq.Enumerable]::Contains([string[]]$script:R1Old,[string]$old.path,[StringComparer]::Ordinal)){ + throw ('R1-SCOPE: protected raw bytes changed '+$old.path) + } + $changed.Add(@{path=$old.path;pin=(Get-LN1Pin $path)}) + } + $added=[Collections.Generic.List[object]]::new() + foreach($p in $Paths){ + if($known.Contains($p)){continue} + if(-not [Linq.Enumerable]::Contains([string[]]$script:R1New,$p,[StringComparer]::Ordinal)){ + throw ('R1-SCOPE: new path outside exact roster '+$p) + } + $added.Add(@{path=$p;pin=(Get-LN1Pin (Join-Path $Root $p))}) + } + if($RequireComplete){foreach($p in $script:R1New){if(-not $roster.Contains($p)){throw ('R1-SCOPE: missing required new path '+$p)}}} + return @{checkedBaseFiles=$known.Count;changes=@($changed.ToArray());newFiles=@($added.ToArray()); + contract=(Assert-LN1FrozenContract $Root)} +} +function Assert-R1GitScope($Baseline,[string]$StageText,[string[]]$ChangedPaths){ + $allowed=[Collections.Generic.HashSet[string]]::new([StringComparer]::Ordinal) + foreach($p in @($script:R1Old)+@($script:R1Ledger)+@($script:R1New)){[void]$allowed.Add($p)} + foreach($p in $ChangedPaths){if(-not $allowed.Contains($p)){throw ('R1-SCOPE: Git change outside exact roster '+$p)}} + $entries=[Collections.Generic.Dictionary[string,object]]::new([StringComparer]::Ordinal) + foreach($row in ($StageText -split [char]0|Where-Object{$_})){ + if($row -cnotmatch '\A([0-9]+) ([0-9a-f]{40}) 0\t([^\r\n]+)\z'){throw 'R1-SCOPE: unresolved or malformed current Git entry'} + if($entries.ContainsKey($Matches[3])){throw 'R1-SCOPE: duplicate current Git entry'} + $entries.Add($Matches[3],@{mode=$Matches[1];blob=$Matches[2]}) + } + foreach($f in $Baseline.files){ + if(-not $entries.ContainsKey($f.path)){throw ('R1-SCOPE: missing current Git entry '+$f.path)} + $entry=$entries[$f.path] + if(-not (Test-R1Exact $entry.mode $f.mode)){throw ('R1-SCOPE: current Git mode changed '+$f.path)} + if(-not $allowed.Contains($f.path) -and -not (Test-R1Exact $entry.blob $f.gitBlob)){ + throw ('R1-SCOPE: protected Git blob changed '+$f.path) + } + [void]$entries.Remove($f.path) + } + foreach($p in $entries.Keys){ + if(-not [Linq.Enumerable]::Contains([string[]]$script:R1New,[string]$p,[StringComparer]::Ordinal) -or + -not (Test-R1Exact $entries[$p].mode '100644')){throw ('R1-SCOPE: new Git entry outside regular-file roster '+$p)} + } + return @{success=$true;protectedBaseModes=$Baseline.files.Count;protectedBaseBlobs=($Baseline.files.Count-$script:R1Old.Count-1);newStaged=$entries.Count;changedPaths=$ChangedPaths} +} +function Assert-R1FinalScope($Capture,[string]$Root,[string]$Head,[string[]]$Paths){ + $stdout=Read-LNExactStream $Capture.spec.stdout + Assert-LNOuterCapture $Capture $stdout '' 0 'r1-final-scope' + $match=[regex]::Match($stdout,'\AR1-SCOPE success=True receipt=([^\r\n\x00]+)\r\n\z') + if(-not $match.Success){throw 'R1-FINAL-SCOPE: unexpected complete output language'} + $dir=$match.Groups[1].Value;$stamp=[IO.Path]::GetFileName($dir) + if($stamp -cnotmatch '\A[0-9]{8}T[0-9]{9}-[0-9a-f]{8}\z' -or + -not (Test-R1Exact $dir (Join-Path $Root ('.lake/lifecycle-native1-r1/scope/'+$stamp)))){ + throw 'R1-FINAL-SCOPE: misplaced receipt' + } + $path=Join-Path $dir 'RESULT.json';$pin=Get-LN1Pin $path + $r=[IO.File]::ReadAllText($path,$script:R1Utf8)|ConvertFrom-Json + if(-not (Test-R1Exact $r.schema 'lifecycle-native1-r1-scope-v1') -or $r.success -ne $true -or + $r.integrity.success -ne $true -or $r.complete -ne $true -or $null -ne $r.failure -or + -not (Test-R1Exact $r.base $script:R1Base) -or -not (Test-R1Exact $r.originalBase $script:R1OriginalBase) -or + -not (Test-R1Exact $r.branch $script:R1Branch) -or -not (Test-R1Exact $r.head $Head) -or + $r.checked.checkedBaseFiles -ne 3930 -or $r.checked.contract.count -ne 55 -or + $r.startup.success -ne $true -or $r.startup.exactInsertions -ne 5 -or + $r.gitScope.success -ne $true -or $r.gitScope.protectedBaseModes -ne 3930 -or $r.gitScope.protectedBaseBlobs -ne 3925){throw 'R1-FINAL-SCOPE: unsuccessful or differently bound receipt'} + $actual=[Collections.Generic.HashSet[string]]::new([StringComparer]::Ordinal) + foreach($p in @($r.cumulativePaths)+@($r.untracked)){[void]$actual.Add($p)} + $expected=[Collections.Generic.HashSet[string]]::new([StringComparer]::Ordinal) + foreach($p in $Paths){if(-not $expected.Add($p)){throw 'R1-FINAL-SCOPE: duplicate expected path'}} + if(-not $actual.SetEquals($expected)){throw 'R1-FINAL-SCOPE: complete cumulative path roster differs'} + foreach($p in $r.pins){Assert-R1Pin $p} + $baseline=[IO.File]::ReadAllText((Join-Path $Root 'docs/internal/extensions/lifecycle-native1-r1/BASE_IDENTITY.json'),$script:R1Utf8)|ConvertFrom-Json + $checked=Assert-R1ScopeFiles $Root $baseline @($r.paths) -RequireComplete + if($checked.changes.Count -ne $r.checked.changes.Count -or $checked.newFiles.Count -ne $r.checked.newFiles.Count){throw 'R1-FINAL-SCOPE: current scope differs'} + $allPins=@($r.pins)+@($r.checked.changes|ForEach-Object pin)+@($r.checked.newFiles|ForEach-Object pin) + foreach($p in $allPins){Assert-R1Pin $p} + return @{pin=$pin;pins=$allPins;checkedBaseFiles=$checked.checkedBaseFiles;newFileCount=$checked.newFiles.Count;paths=$Paths} +} diff --git a/docs/internal/extensions/lifecycle-native1-r1/scope_check.ps1 b/docs/internal/extensions/lifecycle-native1-r1/scope_check.ps1 new file mode 100644 index 00000000..247ddadb --- /dev/null +++ b/docs/internal/extensions/lifecycle-native1-r1/scope_check.ps1 @@ -0,0 +1,70 @@ +[CmdletBinding()] +param([string]$Root=[IO.Path]::GetFullPath((Join-Path $PSScriptRoot '../../../..')),[switch]$Complete) +$ErrorActionPreference='Stop' +. (Join-Path $PSScriptRoot 'identity.ps1') +$run=Join-Path $Root ('.lake/lifecycle-native1-r1/scope/'+[DateTime]::UtcNow.ToString('yyyyMMddTHHmmssfff')+'-'+[Guid]::NewGuid().ToString('N').Substring(0,8)) +[void][IO.Directory]::CreateDirectory($run) +$git=(Get-Command git -CommandType Application|Select-Object -First 1).Source +$pins=[Collections.Generic.List[object]]::new();$stages=[Collections.Generic.List[object]]::new() +$result=[ordered]@{schema='lifecycle-native1-r1-scope-v1';success=$false;base=$script:R1Base; + originalBase=$script:R1OriginalBase;head=$null;branch=$null;complete=[bool]$Complete; + startedUtc=[DateTime]::UtcNow.ToString('o');paths=@();cumulativePaths=@();checked=$null;stages=@();pins=@();failure=$null;integrity=$null} +function Git-R1Scope([string]$Name,[string[]]$Arguments){ + $capture=Invoke-LNStreamCapture $Root $git (@('-c','core.excludesfile=','-c','core.safecrlf=false')+$Arguments) $Root (Join-Path $run $Name) 60 $Name + $stages.Add(@{name=$Name;file=$git;arguments=$Arguments;capture=$capture}) + $out=Read-LNExactStream $capture.spec.stdout + Assert-LNOuterCapture $capture $out '' 0 $Name + return $out +} +try{ + $baselinePath=Join-Path $PSScriptRoot 'BASE_IDENTITY.json' + foreach($p in @($PSCommandPath,(Join-Path $PSScriptRoot 'identity.ps1'),$baselinePath,$git, + (Join-Path $PSScriptRoot 'START.json'),(Join-Path $Root 'scripts/lifecycle_native_identity.ps1'))){$pins.Add((Get-LN1Pin $p))} + $baselineBytes=[IO.File]::ReadAllBytes($baselinePath) + # This literal freezes the startup inventory; a coordinator-authorized checkout + # restoration must explicitly replace it with the retained corrected inventory. + if(-not [string]::Equals((Get-LN1BytesHash $baselineBytes),'D580D08779FA5699BBD15022F11B66AE8EBBBD3E989890816A6BF82387D25B68',[StringComparison]::OrdinalIgnoreCase)){ + throw 'R1-SCOPE: frozen baseline inventory bytes differ' + } + $baseline=$script:R1Utf8.GetString($baselineBytes)|ConvertFrom-Json + $start=[IO.File]::ReadAllText((Join-Path $PSScriptRoot 'START.json'),$script:R1Utf8)|ConvertFrom-Json + if(-not (Test-R1Exact $start.base $script:R1Base) -or -not (Test-R1Exact $start.branch $script:R1Branch) -or + -not (Test-R1Exact $start.preflight 'PASS') -or -not $start.cleanExactStart){throw 'R1-SCOPE: start identity differs'} + $result.head=(Git-R1Scope 'head' @('rev-parse','HEAD')).Trim() + $result.branch=(Git-R1Scope 'branch' @('branch','--show-current')).Trim() + if(-not (Test-R1Exact $result.branch $script:R1Branch)){throw 'R1-SCOPE: branch differs'} + [void](Git-R1Scope 'ancestry' @('merge-base','--is-ancestor',$script:R1Base,'HEAD')) + [void](Git-R1Scope 'original-ancestry' @('merge-base','--is-ancestor',$script:R1OriginalBase,$script:R1Base)) + $tree=Git-R1Scope 'base-tree' @('ls-tree','-r','-z',$script:R1Base) + $baseGit=[Collections.Generic.Dictionary[string,object]]::new([StringComparer]::Ordinal) + foreach($row in ($tree -split [char]0|Where-Object{$_})){ + if($row -cnotmatch '^([0-9]+) blob ([0-9a-f]{40})\t([^\r\n]+)$'){throw 'R1-SCOPE: unsupported base Git entry'} + $baseGit.Add($Matches[3],@{mode=$Matches[1];blob=$Matches[2]}) + } + if($baseGit.Count -ne @($baseline.files).Count){throw 'R1-SCOPE: base Git roster differs'} + foreach($f in $baseline.files){ + if(-not $baseGit.ContainsKey($f.path) -or -not (Test-R1Exact $baseGit[$f.path].mode $f.mode) -or + -not (Test-R1Exact $baseGit[$f.path].blob $f.gitBlob)){throw ('R1-SCOPE: base Git identity differs '+$f.path)} + } + $paths=@((Git-R1Scope 'current-paths' @('ls-files','--cached','--others','--exclude-standard','-z')) -split [char]0|Where-Object{$_}) + $result.paths=$paths + $result.checked=Assert-R1ScopeFiles $Root $baseline $paths -RequireComplete:$Complete + $currentStages=Git-R1Scope 'current-stages' @('ls-files','--stage','-z') + $repairChanged=@((Git-R1Scope 'repair-changed' @('diff','--name-only','-z',$script:R1Base)) -split [char]0|Where-Object{$_}) + $result.gitScope=Assert-R1GitScope $baseline $currentStages $repairChanged + $result.startup=Assert-LN1StartupWitnesses $Root + $result.cumulativePaths=@((Git-R1Scope 'cumulative-paths' @('diff','--name-only','-z',$script:R1OriginalBase)) -split [char]0|Where-Object{$_}) + $result.untracked=@((Git-R1Scope 'untracked-paths' @('ls-files','--others','--exclude-standard','-z')) -split [char]0|Where-Object{$_}) + if($result.cumulativePaths.Count -eq 0){throw 'R1-SCOPE: vacuous original-base surface'} + $result.success=$true +}catch{$result.failure=$_.Exception.Message} +finally{ + $errors=[Collections.Generic.List[string]]::new() + foreach($p in $pins){try{Assert-R1Pin $p}catch{$errors.Add($_.Exception.Message)}} + $result.integrity=@{success=($errors.Count -eq 0);errors=@($errors.ToArray());checked=$pins.Count} + $result.success=$result.success -and $result.integrity.success + $result.pins=@($pins.ToArray());$result.stages=@($stages.ToArray());$result.completedUtc=[DateTime]::UtcNow.ToString('o') + Write-R1Json (Join-Path $run 'RESULT.json') $result +} +Write-Output ('R1-SCOPE success='+$result.success+' receipt='+$run) +if(-not $result.success){Write-Output $result.failure;exit 1} diff --git a/docs/internal/extensions/lifecycle-native1/ACCEPTANCE_MATRIX.frozen.md b/docs/internal/extensions/lifecycle-native1/ACCEPTANCE_MATRIX.frozen.md new file mode 100644 index 00000000..95f3ade9 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native1/ACCEPTANCE_MATRIX.frozen.md @@ -0,0 +1,63 @@ +# LIFE-NATIVE-1 frozen acceptance matrix + +Frozen before production edits. CONTRACT_REQUIREMENTS.json preserves strict UTF-8 source text, exact byte spans and hashes. Source line breaks are displayed as
; source CR/LF bytes remain in JSON. Complete frozen Markdown row bytes are separately pinned. Prospective plans are evidence suggestions, not added requirements, checked theorem declarations or outcomes. Every semantic subclaim of each verbatim requirement remains binding. All rows are Open at freeze. + +Update evidence/status only in ACCEPTANCE_MATRIX.md and separate evidence artifacts. The frozen source, requirement text and ordered IDs cannot change without an explicit coordinator amendment. Coordinator campaign review/aggregate/blind audit/acceptance remain distinct from this local rung. + +| ID | Exact frozen requirement | Scope | Evidence needed (exact proposition/check) | Named consumer and identity/composition chain | Anti-vacuity challenge attempted and outcome | Evidence obtained | Status / residual gap | +| --- | --- | --- | --- | --- | --- | --- | --- | +| N1-01 | Prove a small export-facing Lean result for the actual word and comparison lifecycle runners: on the declared InputDomain and represented endpoints, build-and-first-query produces the actual Ownership.owner, correct halted optionNatPacket answer, canonical produced memory, empty key banks, fixed numeric bank and the same complete modeled retained-capacity bound. Derive these facts from the existing capstone/refinement; do not accept final-memory or answer equality as a hypothesis. Native admission limits are separately labeled and do not weaken the all-size Lean theorem. | Local production consumer | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: For es := Ownership.owner model xs left right: es is the runOwner result on initialOwner; es.toState equals continuousRun.final; Ready xs es; status = halted(optionNatPacket(queryTraceResult xs left right).value); keys/keyRegs = #[]; regs.size = numericBank; capacity model es * wordWidth xs.length <= 2*xs.length+retainedRho xs.length. Canonical memory is derived, not assumed. | Ownership.refinement/ready/halted/Ready.capacity_bound -> new export contract -> LifecycleNativeContract -> generated build-and-first-query -> native owner/status | Planned, not attempted: Delete each mandatory answer/memory/key/bank/capacity projection; Same-size sibling owner substitution; Add answer/memory equality as a hypothesis; Empty/reversed/out-of-bounds first query guard; Native ceiling cannot narrow Lean theorem | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| N1-02 | The compiled production path executes Lifecycle runOwner from Executable.initialOwner and uses Executable.queryOwner or a proved definitionally/extensionally equal cached-program adapter thereafter. First inspect emitted C and bounded execution for suspected reference-count-driven copies. If actual measurements justify an observation-erasing loop, it may delegate the unchanged executeArray and must prove equality to runOwner for every program/state/fuel, including stopped/fault/missing-fetch cases; it may not replace any primitive evaluator or weaken the admitted domain. It must not call the old Native/LimbMachine query interpreter as a substitute, rebuild buildMemory/canonicalImage/buildPayload, invoke a reference RMQ answer, or reconstruct state from a reference trace. The actual returned C/Rust result must come from this runner's status. | Local production consumer | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Actual compiled first path runs runOwner on initialOwner; continuation runs queryOwner or proved equal cached adapter. Optional observation-erasing loop equals runOwner for ALL program/state/fuel and delegates unchanged executeArray. Returned result depends on runner.status. | initialOwner -> runOwner/executeArray -> Owner.status -> C packet -> Rust result; queryOwner thereafter | Planned, not attempted: Inspect emitted C and bounded copies before adapter choice; Zero fuel/stopped/fault/missing-fetch adapter equality; Old interpreter/oracle/rebuild substitution rejected by actual route dependence, not assumed answer divergence; Change returned status while leaving logs unchanged | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| N1-03 | Define and prove the successful admission/representation bridge used by the exports, including exact signed Int encoding for word input, arbitrary signed finite integers for comparison input, canonical endpoint words and model selection. Word InputFits failures and host format/resource limits reject explicitly; no silent fallback to comparison input or narrower u64/u128 arithmetic. Carry the actual count and query-independent word profile, and derive READY n/M from produced metadata rather than trusted caller duplicates. | Local production consumer | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Successful admission decodes exact signed Int list and canonical Nat endpoints under selected model; InputFits/resource/format failures reject; actual input count and query-independent profile feed construction; READY n/M derive from produced metadata. | host bytes -> proved codec/admission relation -> InputDomain -> initialOwner -> produced metadata -> owner publication | Planned, not attempted: Negative/wider-than-128-bit roundtrip; Malformed sign/magnitude/length/overflow; Word failure cannot fall back to comparison; Caller duplicate metadata mismatch; Checked resource boundary rejects before transfer | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| N1-04 | Separate malformed/native-domain rejection, represented invalid RMQ range with ordinary None answer, model fault and exhausted fuel. Empty, reversed and out-of-bounds represented ranges retain the correct formal guard throughout combined fields. A represented invalid first or later query still returns a reusable canonical owner when the formal route does. Unrepresentable requests are rejected before consuming a healthy owner; temporary parsing/admission allocations and Lean codec calls are allowed before transfer if cleaned on failure. No rejection is silently reported as successful execution. | Local production consumer | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Result alternatives separate native rejection, represented invalid range None, fault and exhausted fuel; invalid represented queries retain reusable canonical owner as formally proved; unrepresentable request preserves prior healthy owner and cleans parsing temporaries. | prevalidation -> guarded lifecycle run -> status/tag -> C/Rust result; transfer only after valid native representation | Planned, not attempted: Empty/reversed/out-of-bounds then valid query; Unrepresentable endpoint preserves old root/content/usability; Separate forced fault/exhaustion tags; Temporary allocation cleanup; Mutate combined-field guard | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| N1-05 | Prove exact export/owner projection and value-preserving array repacking interfaces sufficient for the actual native boundary. Expose a single coherent small public export contract and an independent expected-type Lean consumer in RMQ/Validation/LifecycleNativeContract.lean that uses each mandatory projection at the fixed objects/domain. Attempt deletion/weakening/sibling substitution of load-bearing facts and replay the intended client rejection only after successful producer compilation. C/runtime implementation correctness remains an explicit trust boundary supported by actual controls, not falsely kernel-proved. | Local production consumer | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Exact small export contract and value-preserving array repack bridge feed independently fixed expected types. Each mandatory projection has producer-compiling deletion/weakening/sibling mutation that fails intended client. C/runtime correctness remains explicit trust. | produced Owner -> logical repack relation -> export contract -> LifecycleNativeContract -> actual native helper | Planned, not attempted: Every projection deletion after producer repair; Weakening/object/domain sibling substitution; Expected-accept packet-only control; Wrong copied value/offset; Producer compile failure alone cannot close client rejection | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| N1-06 | Repeated native calls continue on the same produced canonical allocation through the existing four charged request/control boundary events and finite setup. Here allocation equality means the actual produced modeled contents/extents, transported through a proved value-preserving native repacking boundary before publication; it is not a theorem of unchanged native pointer address. Measure physical identity/capacity separately and disclose any further native replacement. The uninterrupted first query does not prepend the four external re-entry events. Prove the export continuation inherits Ready.query, answer correctness, preserved memory and the 160257 model-step upper bound. Do not reset halted state, registers or metadata for free, and do not retain the original input to recreate the owner per request. | Local production consumer | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Ready xs es plus halted es and represented endpoints imply queryOwner is Ready, correct halted packet, identical memory, queryArray.toRun = Reusable.queryRun and steps <= 160257. Repacking preserves logical values/extents; physical replacement is measured. Four charged re-entry events apply only to later requests. | repacked produced owner -> requestProtocolOwner -> queryOwner -> Ready.query -> next publication | Planned, not attempted: Dirty registers/metadata must use charged setup; Ordered four re-entry events and none prepended to first query; Replacement pointer may differ while values/extents agree; Repeated invalid/valid memory preservation; Retained input/rebuild closure rejection | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| N1-07 | Production owners contain only the finite operational arrays/scalars and explicit native handle metadata. Drop temporary parsed input/list roots, old owner roots, comparison keys/registers, old arena containers and result-wrapper references at the documented transfer point. Validation histories/read receipts are optional separately owned artifacts and must not be retained in the production owner, input closure, Rust cache or query result. Establish actual compiled closure/root identity, not only logical fields. | Local production consumer | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Published compiled closure retains finite operational arrays/scalars and explicit handle metadata only. Parsed/list/input, old owner/arena/key/register banks and wrapper roots release at transfer; diagnostic histories are separately owned. | parse -> initialOwner -> runOwner -> take/repack -> published handle; retired roots -> release | Planned, not attempted: Retained input/list root; Retained old owner/arena/key root; History in owner/cache/result; Actual root/closure inspection rather than destructor-only logs | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| N1-08 | Replace excess-capacity backing arrays at native READY publication after the first query using the reviewed consume/replacement route and preserve all logical entries. Every subsequently published reusable state must retain the same declared capacity guarantees; extra native replacement work is separately accounted. Measure actual initialized size, capacity and requested outer-container storage for every retained array, including zero-sized key banks, plus reachable boxed/scalar representation and shared fixed code separately. Operationally release old backing roots. Array.pop/size, zero logical extents, destructor counters alone, or generic P0 observations do not prove this production capacity claim. Do not equate requested bytes with allocator usable bytes or RSS. | Local production consumer | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Consume/replacement preserves all logical entries and enforces declared publication capacity on each retained array, including empty key banks. Record initialized size/capacity/requested outer bytes; boxed/scalar and shared code separately; release old roots at every publication. | halted produced owner -> production repack helper -> logical bridge -> published arrays -> repeated capacity/root measurements | Planned, not attempted: Skipped replacement on excess capacity; Empty keys retaining old backing; Wrong copied entry/offset; Old arena alias; Every subsequent publication; Requested bytes cannot stand for RSS/usable allocator bytes | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| N1-09 | Make ownership transfer explicit in the C contract and enforceable safe Rust types: no safe clone/raw-alias escape, borrowed result data cannot outlive its owner, destruction exactly once on the initializing thread, and a mutation requires unique handle access. Identify trusted foreign-caller preconditions precisely; finite alias tests cannot quantify over arbitrary C misuse. Deliberate extra-root controls must not earn the strict exclusive-transfer conclusion, and no test may dereference freed objects. Shared immutable scalar values and fixed program objects need not have reference count one; distinguish these permitted references from extra operational owner/input/arena roots. | Local production consumer | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: C states unique-transfer/thread preconditions; safe Rust has no clone/raw alias escape, owner-bound borrows, unique mutation and exactly-once initializing-thread destruction. Shared immutable scalar/code roots are permitted separately from extra operational roots. | C contract -> Rust Runtime/Owner/lifetimes -> &mut query -> Drop | Planned, not attempted: Compile-fail clone/raw escape/borrow-after-drop/shared mutation; Actual normal/error/drop exactly-once paths; Extra operational alias fails same exclusivity predicate; Shared immutable scalar/code aliases accepted; No freed dereference tests | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| N1-10 | Specify and implement the complete state table for validation-before-consumption failures, controlled failures during allocation/copy/transfer, successful transfer and destruction. Keep a valid old owner when rejected before consumption; after an irrevocable take, either return exactly one valid replacement or return an explicit empty/poisoned handle with all initialized temporary resources released. Exercise both sides and partial-copy boundaries on actual production helpers. Ordinary Lean allocation failure may be fatal under the pinned runtime; do not present it as recoverable injected failure. | Local production consumer | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: State table: pre-take rejection preserves valid old owner; allocation/copy/transfer success returns one replacement; post-take failure returns one replacement or explicit empty/poisoned handle and releases all initialized temporaries; destruction releases once. Fatal runtime OOM is distinct from injected failure. | prevalidate -> take -> allocate/copy/transfer -> publish or poison/cleanup -> Rust state | Planned, not attempted: Before-take preservation; First/middle/last partial-copy production-helper failures; Post-take poison/replacement uniqueness; Success/destruction cleanup; Do not relabel actual Lean OOM as controlled recovery | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| N1-11 | Compile actual Lean source with the pinned Lean 4.22 toolchain and bind generated symbols, prototypes, object/library hashes, transitive source closure and compiler/runtime identity to the tested DLL. Verify cache provenance includes relevant source and tool/compiler identities before reuse. Inspect generated initialization and calls so proofs, whole trace witnesses or large proof-only reference payloads are not evaluated at import/startup. An import or linker list naming a module is not proof the returned route executes it. | Local production consumer | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Actual Lean 4.22 source/transitive closure, generated symbols/prototypes, objects/libraries and compiler/runtime hashes bind tested DLL. Cache reuse checks all relevant identities. Generated initialization evaluates no proof-only payload/trace; route dependence reaches returned result. | frozen imports/source -> emitted C -> objects/libraries -> DLL -> loaded client result | Planned, not attempted: Transitive source/tool change invalidates cache; DLL/object hash corruption; Initializer proof-only witness inspection; Bounded startup first; Broken route despite unchanged import/linker names | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| N1-12 | Reuse one checked fixed program representation per input model through the native lifecycle without input-specialized code or reconstructing the program list/array per query. If an additive cached-array adapter is needed, prove it equals Layout.program.toArray and prove the resulting run equals the accepted runner. Account for shared code and native representation explicitly; code constants are not free hidden payload and modeled encoded words are not native heap bytes. | Local production consumer | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: One fixed program representation per model equals Layout.program.toArray and adapter run equals accepted runner; no input-specialized/per-query reconstruction. Shared native code/representation and modeled words accounted distinctly. | Layout.program -> checked cached array -> fixed model program root -> lifecycle runner | Planned, not attempted: Alter cached instruction; Vary input/query, inspect fixed root; Reconstruction per query changes allocation/init evidence; Input-specific code literal accounting; Native bytes not equated to encoded model words | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| N1-13 | Keep modeled construction/finalization/re-entry work, host admission/conversion, native repacking, fixed-code initialization, optional observation cost and native timings separate. Preserve original linear modeled construction and complete READY 2n+rho conclusions at the proved owner. State any host resource ceiling and its admitted domain precisely. No generic all-input practical speed or native 2n+o(n)-heap claim follows from the interpreter theorem. | Local production consumer | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Same owner retains original modeled linear construction and complete Ready <= 2n+rho capacity. Construction/finalization/re-entry, admission/conversion, repack, fixed code, observation and timings have distinct measures; explicit host ceiling/domain. | formal lifecycle cost/capacity -> export; native categorized measurements -> truthful docs | Planned, not attempted: Missing charged category fails own projection; Sibling owner cost/space conjunction; Host-ceiling edge rejection; No model-step-to-clock/all-input-speed/native-heap promotion | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| N1-14 | Implement runtime initialization, cross-thread restrictions, handle lifetimes, C result access and Rust RAII around the real ABI. Rust owner/runtime types must encode !Send/!Sync or an equally explicit checked restriction; document foreign callers' matching obligations. Reuse the existing crate-level runtime-claim guard so only one chosen Lean runtime is initialized per process; incompatible old/new runtime acquisition must reject, including after initialization failure. Coexistence of old and new runtime owners is not required. Inspect actual DLL/runtime linkage rather than assuming two imported bridges share runtime state. Include compile-time misuse controls for safe Rust plus real normal/error/drop paths, and avoid undefined-behavior tests as purported safety evidence. | Local production consumer | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Real runtime/ABI lifetime/result/RAII behavior respects initializing thread; safe types !Send/!Sync or checked equivalent. Existing runtime claim guard rejects old/new incompatible acquisition, including after initialization failure; actual PE/runtime linkage inspected. | crate runtime-claim guard -> loaded DLL/runtime -> thread-bound Rust runtime/owner -> result -> Drop | Planned, not attempted: Compile-fail thread move/share; Actual init/error/drop; Old/new acquisition both orders and failed-init conflict; PE imports/library identities; Exclude UB controls | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| N1-15 | Return canonical arbitrary-width answer/status representations through the C ABI and Rust facade, with no lossy host-sized intermediate. Endpoint and input conversions use tested/proved codecs with exact lengths/sign/magnitude/overflow rules. Values wider than128bits and negative comparison keys must reach actual construction. Host-sized indices/counts may be used only under explicit checked bounds and a proven conversion relation. | Local production consumer | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Canonical arbitrary-width answers/status and exact length/sign/magnitude/overflow codecs have no lossy host-sized intermediate. >128-bit values and negative comparison keys reach actual builder; host indices/counts only with checked/proved bounds. | host bytes -> formal codecs -> Int/Nat -> actual construction/status -> canonical C/Rust packet | Planned, not attempted: Wide positive/negative comparison input; Word/endpoint codec edge cases; Malformed encoding/host overflow; u64/u128 truncation; None/Some/fault/exhaustion canonical distinctions | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| N1-16 | Supply real C, safe Rust and C++ clients of the same generated DLL, including construction, at least two later queries and destruction. The C++ example uses the actual C ABI and its errors, not a second implementation. Keep existing NativeImage ABI and its regression route intact; old query evidence is background and cannot substitute for new lifecycle-client execution. | Local production consumer | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Same hashed DLL is executed by C, safe Rust and C++ clients, each doing construction/real first query, >=2 later queries, errors and destruction. Existing NativeImage ABI remains intact; shared-glue regressions run if affected. | generated DLL -> lifecycle_owner.c/lifecycle_rust.rs/lifecycle.cpp -> actual statuses/releases | Planned, not attempted: Two subsequent queries each client; C++ errors through real ABI; Different DLL hash; Mutate new route while old still passes; Shared Cargo/lib conditional regression | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| N1-17 | Freeze meaningful exact fixture IDs and independent expected answers before the final run. Cover both models; empty/singleton/two elements; duplicates/leftmost ties; negative and wider-than128bit values under the proper domains; representative sizes24/83; actual same-block, different-block/fringe/interior/crossing-cell query paths when reachable; represented invalid/reversed/out-of-bounds endpoints; malformed/unrepresentable input; and repeated valid queries after admitted invalid ones. Record actual route coverage or a precise absence, not guessed labels. Expected values come from the independent reference semantics, not the executed answer. | Local production consumer | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Frozen exact fixture IDs/independent expectations cover both models, 0/1/2, ties, negative/wide proper domains, 24/83, actual reachable route classes, represented invalid and malformed requests, valid after invalid. Route absence is precise. | independent half-open leftmost List Int expectations -> frozen registry -> actual new lifecycle requests/route observations | Planned, not attempted: Wrong leftmost tie expected index; Guessed route label without producing state; Missing model/size/edge fixture; Invalid-then-valid must use same owner; Implementation output cannot be expected oracle | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| N1-18 | Compare optional observed runs with production using a proved same-final-owner bridge, preserving actual ordered read/reply occurrences and charged categories across construction, retirement and repeated queries. Use actual producing prestates; global observations concatenate segments and only the query suffix equals query-only evidence. Prove each advertised counter/category fold-to-trace projection separately: the existing counted_owner final-state equality alone does not prove those counters. Avoid constructing a huge retained trace merely to count steps. At native test points confirm observed and unobserved modes return identical answers/canonical memory while only the explicit observation object retains diagnostics. | Local production consumer | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Observed production bridge has same final owner; actual occurrence position/multiplicity/instruction/prestate/replies survive concatenation; query-only evidence equals suffix only. Each counter/category separately projects fold to trace; counting does not retain huge traces. Native observed/unobserved answers/memory agree; diagnostics owned separately. | actual producing segment prestates -> observed runs/ordered occurrences -> counter folds -> final-owner bridge -> native comparisons | Planned, not attempted: Repeated equal event positions; Mutate counter with unchanged owner; Confuse whole trace with query suffix; Wrong prestate/invocation; Diagnostics retained by production; Huge trace merely for count | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| N1-19 | Production ownership/capacity controls must challenge skipped replacement, retained old arena/input/key/history roots, wrong copied value/offset, extra alias, partial-copy cleanup, failed admission before transfer, post-take failure and repeated-query memory preservation using the same acceptance predicates as successful controls. Demonstrate changed answers or actual state/resource differences where that is the claim; a changed log alone is insufficient. A correct reference oracle may agree on every answer, so forbidden oracle substitution is checked by actual evaluator dependence/compiled route evidence and a valid route challenge, not an invented guaranteed answer divergence. Define and measure new fixture challenges before assigning their exact expected rejection; preserve the frozen property while disclosing a challenge that does not distinguish it. Name each mutation kind and exact oracle; do not label a synthetic helper component an actual end-to-end native failure. | Local production consumer | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Same positive root/capacity/content/admission predicates judge actual production-helper failures. New challenge discrimination is measured before required negative verdict freezes. Route dependence tests oracle substitution without assuming answer divergence. | actual production predicate/helper -> measured mutation -> exact physical/value/status observation -> frozen verdict | Planned, not attempted: Skipped replacement/arena/input/key/history/alias separately; Wrong value/offset must change state/answer where claimed; Partial-copy/pre-admission/post-take table; Repeated memory corruption; Disclose nondistinguishing challenges; Do not promote synthetic helper to end-to-end evidence | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| N1-20 | New replay verification must preserve the actual ordinary exit, timeout/overflow, complete captured stdout/stderr and exact intended diagnostic. Reject expected plus unrelated diagnostics on either stream. If claiming literal UTF-8 output, decode strictly and compare ordinally without stripping BOM/NUL/newlines or culture normalization, using actual caller-level holdouts. State any inherited returned-line loss limit explicitly. Source/tool/artifact integrity and disposable cleanup run independently in finally even after partial setup or earlier stage failure. | Local production consumer | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Actual ordinary exit/timeout/overflow and complete raw stdout/stderr are preserved; exact diagnostic excludes unrelated text. Literal text uses strict UTF-8 ordinal equality preserving BOM/NUL/newline. Independent finally integrity/cleanup runs after any earlier failure; line-loss limits disclosed. | owned process -> retained raw captures -> strict stream check -> exact verdict -> independent finally checks | Planned, not attempted: Expected plus unrelated stdout/stderr; Invalid UTF-8/BOM/NUL/newline caller holdouts; Wrong ordinary exit; Timeout/overflow; Partial setup still executes both cleanup/integrity | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| N1-21 | Replay selectors validate the full request before any semantic child or output mutation. Omission may select the declared full registry; explicitly empty/null/whitespace/unknown/duplicate selectors reject. A focused request executes exactly its one named case. Check ordered ID-to-handler/verdict mappings and complete counts, not pass totals. Commit reproducible controls for omitted/duplicated middle IDs, known/unknown selectors and real parameter-binding boundaries. | Local production consumer | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Whole request validates at real bound-parameter boundary before child/output mutation: omitted means full declared registry; explicit empty/null/whitespace/unknown/duplicate rejects; focused means exactly one case; ordered ID/handler/verdict mapping/count exact. | PowerShell caller binding -> validated selector -> frozen registry -> dispatch -> per-ID verdict | Planned, not attempted: Bound empty/null/whitespace versus omission; Known/unknown/duplicate selectors; Missing/duplicate middle registry ID; Wrong handler/verdict with same pass total; Invalid selector causes no child/output mutation | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| N1-22 | Use positive evidence-based deadlines and the existing owned-process facility for every external build/compiler/native stage; preserve failures and terminate only the owned tree. Exercise one cheap established descendant termination control on the platform actually certified. Use Local\RMQLifecycleImplementationHeavy20260920 for expensive work; one heavy runner per cache, one full aggregate owner. Unsupported platforms/timeouts are uncovered. No quiet-run restart, unchanged duplicate full build/replay, broad global helper rewrite or weakened timeout verdict. | Local production consumer | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Every external stage has positive evidence-based deadline and owned-tree termination; failures preserved. Cheap certified-Windows descendant control proves root+child absent. Named Local\RMQLifecycleImplementationHeavy20260920 mutex serializes expensive work, one runner/cache and aggregate owner; unrun platforms/timeouts uncovered. | new wrappers -> owned_process_tree -> Windows job -> stream/integrity cleanup -> command ledger | Planned, not attempted: Cheap descendant timeout; Timeout/overflow remains failure; Concurrent mutex acquisition; Quiet-run restart/shorter-than-evidence deadline rejected; Windows evidence cannot certify POSIX | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| N1-23 | Preserve all predecessor frozen rows, source/probe/registry/history bytes and producer identities. The private join creates new current ledger identities; do not run a historical producer's whole-checkout pin as though it described this new branch, rewrite old captures, or silently rebase old source paths. Establish reused source/evidence applicability explicitly. New final execution evidence binds its actual source; final report-sensitive checks bind final report/ledger/claim input bytes without recursive self-hashes. | Local production consumer | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Preserve exact predecessor rows/source/probe/registry/history and identities. Reused evidence maps unchanged consumed-source bytes to original producer applicability. New execution source freeze is separate from final report/ledger/prose pins and external delivery receipt. | reviewed producers -> exact-union base -> unchanged source -> new source freeze/execution -> final report-sensitive inputs -> external receipt | Planned, not attempted: One-byte predecessor mutation; Historical whole-tree pin applied to join; Source change invalidates consumers; Report/ledger change needs narrow recertification; No recursive self-hash | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| N1-24 | Deliver a compact worked guide explaining input admission, actual builder/finalizer, READY transfer/repacking, one subsequent request and cleanup, with theorem names/types and ABI ownership diagrams or tables where useful. Add narrowly truthful family/digestion/native docs and DD/WDD decisions. Separate kernel facts, generated-code/FFI assumptions, measured native controls and unproved native performance. Complete the entire production consumer and its controls before candidate declaration; a route-ready probe is not the assigned endpoint. | Local production consumer | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Worked guide traces admission/builder/finalizer/halted READY repack/one later request/cleanup with types and ownership table. Narrow docs and DD/WDD separate kernel, FFI, native measurements, unproved performance. Entire assigned local rung closes before candidate. | exact export/ABI -> guide/report -> family/digestion/native docs -> coordinator review | Planned, not attempted: Unsupported theorem/measurement sentence; Missing error/cleanup state; Native clock/RSS/all-platform promotion; Any open assigned row blocks candidate | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| INV-STORE-IDENTITY | the exact payload/store executed is the payload/store
counted by the public space theorem; a theorem about a sibling payload is
insufficient; | Inherited at export/native boundary | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Preserve the complete quoted invariant at the actual lifecycle produced Owner, exact model/width/store/domain and export/continuation objects; expand the consuming theorem type, not just its name. Detailed prospective predicates: N1-01, N1-05, N1-06. | Consumed inherited formal producer -> new export projection at exact objects -> LifecycleNativeContract -> actual native boundary, with generated C/FFI assumptions explicit. | Planned, not attempted: Sibling same-size store; use the same accepted predicate/guards/quantifiers or a checked implication for rejection. | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| INV-VALUE-DEPENDENCY | returned values and routing decisions depend on
actual charged reads, not a semantic answer computed before the reads. When
the requirement concerns the returned answer or route, evidence must constrain
that value, state, or route; inequality of an enclosing trace record can be
satisfied by its log alone and is insufficient; | Inherited at export/native boundary | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Preserve the complete quoted invariant at the actual lifecycle produced Owner, exact model/width/store/domain and export/continuation objects; expand the consuming theorem type, not just its name. Detailed prospective predicates: N1-02, N1-19. | Consumed inherited formal producer -> new export projection at exact objects -> LifecycleNativeContract -> actual native boundary, with generated C/FFI assumptions explicit. | Planned, not attempted: Oracle result with decorative reads/log-only differences; use the same accepted predicate/guards/quantifiers or a checked implication for rejection. | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| INV-SEMANTIC-NONVACUITY | semantic coverage, liveness, ownership, and
refinement predicates are derived from the operational construction they
describe. A predicate defined to be `True`, an enumeration restated as
membership, or a separately hand-written consumer label does not establish
operational liveness by itself; | Inherited at export/native boundary | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Preserve the complete quoted invariant at the actual lifecycle produced Owner, exact model/width/store/domain and export/continuation objects; expand the consuming theorem type, not just its name. Detailed prospective predicates: N1-01, N1-07, N1-19. | Consumed inherited formal producer -> new export projection at exact objects -> LifecycleNativeContract -> actual native boundary, with generated C/FFI assumptions explicit. | Planned, not attempted: True predicate or hand-written consumer label; use the same accepted predicate/guards/quantifiers or a checked implication for rejection. | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| INV-TRACE-EXECUTION | traces and footprints are derived from the execution
they describe; | Inherited at export/native boundary | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Preserve the complete quoted invariant at the actual lifecycle produced Owner, exact model/width/store/domain and export/continuation objects; expand the consuming theorem type, not just its name. Detailed prospective predicates: N1-02, N1-18. | Consumed inherited formal producer -> new export projection at exact objects -> LifecycleNativeContract -> actual native boundary, with generated C/FFI assumptions explicit. | Planned, not attempted: Fabricated event/wrong producing prestate; use the same accepted predicate/guards/quantifiers or a checked implication for rejection. | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| INV-STORE-AGREEMENT | supplied-store agreement determines result, cost, and
the relevant trace; | Inherited at export/native boundary | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Preserve the complete quoted invariant at the actual lifecycle produced Owner, exact model/width/store/domain and export/continuation objects; expand the consuming theorem type, not just its name. Detailed prospective predicates: N1-05, N1-06, N1-18. | Consumed inherited formal producer -> new export projection at exact objects -> LifecycleNativeContract -> actual native boundary, with generated C/FFI assumptions explicit. | Planned, not attempted: Changed read cell despite same size; use the same accepted predicate/guards/quantifiers or a checked implication for rejection. | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| INV-READ-BACKING | every successful read is backed positionally by the
counted store; | Inherited at export/native boundary | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Preserve the complete quoted invariant at the actual lifecycle produced Owner, exact model/width/store/domain and export/continuation objects; expand the consuming theorem type, not just its name. Detailed prospective predicates: N1-01, N1-05, N1-18. | Consumed inherited formal producer -> new export projection at exact objects -> LifecycleNativeContract -> actual native boundary, with generated C/FFI assumptions explicit. | Planned, not attempted: Wrong physical offset/backing; use the same accepted predicate/guards/quantifiers or a checked implication for rejection. | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| INV-WORD-WIDTH | stored and returned words fit one declared modeled
machine word; | Inherited at export/native boundary | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Preserve the complete quoted invariant at the actual lifecycle produced Owner, exact model/width/store/domain and export/continuation objects; expand the consuming theorem type, not just its name. Detailed prospective predicates: N1-03, N1-15. | Consumed inherited formal producer -> new export projection at exact objects -> LifecycleNativeContract -> actual native boundary, with generated C/FFI assumptions explicit. | Planned, not attempted: Wide value truncation/out-of-profile word; use the same accepted predicate/guards/quantifiers or a checked implication for rejection. | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| INV-ADDRESS-WIDTH | every executed address, dead/sentinel address, and
encoded instruction operand fits the modeled machine word, not merely the
host array bounds. Constructor-exhaustive evidence must include register
identifiers, branch/jump targets, dormant code, and arithmetic operands; | Inherited at export/native boundary | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Preserve the complete quoted invariant at the actual lifecycle produced Owner, exact model/width/store/domain and export/continuation objects; expand the consuming theorem type, not just its name. Detailed prospective predicates: N1-01, N1-03, N1-12. | Consumed inherited formal producer -> new export projection at exact objects -> LifecycleNativeContract -> actual native boundary, with generated C/FFI assumptions explicit. | Planned, not attempted: Oversized dead/sentinel/dormant-register/branch operand; use the same accepted predicate/guards/quantifiers or a checked implication for rejection. | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| INV-INSTRUCTION-ATOMICITY | each modeled small step performs the familiar
primitive operation it advertises. A constructor whose evaluator body hides
recursion, a variable-length scan, repeated rank/select work, decoding, or
several arithmetic categories is a macro-step unless that work is expanded
into charged transitions or bounded by an explicitly accepted primitive; | Inherited at export/native boundary | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Preserve the complete quoted invariant at the actual lifecycle produced Owner, exact model/width/store/domain and export/continuation objects; expand the consuming theorem type, not just its name. Detailed prospective predicates: N1-02, N1-13. | Consumed inherited formal producer -> new export projection at exact objects -> LifecycleNativeContract -> actual native boundary, with generated C/FFI assumptions explicit. | Planned, not attempted: Uncharged variable scan/alternate evaluator; use the same accepted predicate/guards/quantifiers or a checked implication for rejection. | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| INV-PROGRAM-ACCOUNTING | input-dependent constants and metadata carried by
executable code are counted machine data or are derived uniformly from
counted/public inputs. Calling shape-specialized data "program code" does
not remove it from the payload/state accounting obligation; | Inherited at export/native boundary | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Preserve the complete quoted invariant at the actual lifecycle produced Owner, exact model/width/store/domain and export/continuation objects; expand the consuming theorem type, not just its name. Detailed prospective predicates: N1-03, N1-12, N1-13. | Consumed inherited formal producer -> new export projection at exact objects -> LifecycleNativeContract -> actual native boundary, with generated C/FFI assumptions explicit. | Planned, not attempted: Input-specialized uncounted code literal; use the same accepted predicate/guards/quantifiers or a checked implication for rejection. | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| INV-ORACLE-INDEPENDENCE | executable fixtures and edge-case expected values
come from an independent specification or a theorem already connected to it,
never from the implementation result being tested; | Inherited at export/native boundary | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Preserve the complete quoted invariant at the actual lifecycle produced Owner, exact model/width/store/domain and export/continuation objects; expand the consuming theorem type, not just its name. Detailed prospective predicates: N1-17, N1-19. | Consumed inherited formal producer -> new export projection at exact objects -> LifecycleNativeContract -> actual native boundary, with generated C/FFI assumptions explicit. | Planned, not attempted: Implementation-derived expected answer; use the same accepted predicate/guards/quantifiers or a checked implication for rejection. | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| INV-VALIDATION-REACH | executable validation imports and runs the new
semantic layer. A validator for the predecessor implementation is regression
evidence only and does not validate the new machine; | Inherited at export/native boundary | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Preserve the complete quoted invariant at the actual lifecycle produced Owner, exact model/width/store/domain and export/continuation objects; expand the consuming theorem type, not just its name. Detailed prospective predicates: N1-02, N1-11, N1-16. | Consumed inherited formal producer -> new export projection at exact objects -> LifecycleNativeContract -> actual native boundary, with generated C/FFI assumptions explicit. | Planned, not attempted: New evaluator mutation while predecessor passes; use the same accepted predicate/guards/quantifiers or a checked implication for rejection. | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| INV-ALL-SIZE | exactness covers all assigned sizes and edge cases without
hidden readiness or compatibility dispatch; | Inherited at export/native boundary | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Preserve the complete quoted invariant at the actual lifecycle produced Owner, exact model/width/store/domain and export/continuation objects; expand the consuming theorem type, not just its name. Detailed prospective predicates: N1-01, N1-03, N1-04. | Consumed inherited formal producer -> new export projection at exact objects -> LifecycleNativeContract -> actual native boundary, with generated C/FFI assumptions explicit. | Planned, not attempted: Hidden size/readiness/domain dispatch; use the same accepted predicate/guards/quantifiers or a checked implication for rejection. | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| INV-PROOF-SEPARATION | proof-only fields never carry answers or uncharged
routing information; | Inherited at export/native boundary | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Preserve the complete quoted invariant at the actual lifecycle produced Owner, exact model/width/store/domain and export/continuation objects; expand the consuming theorem type, not just its name. Detailed prospective predicates: N1-02, N1-07, N1-11. | Consumed inherited formal producer -> new export projection at exact objects -> LifecycleNativeContract -> actual native boundary, with generated C/FFI assumptions explicit. | Planned, not attempted: Proof answer/route or closed initializer payload; use the same accepted predicate/guards/quantifiers or a checked implication for rejection. | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| INV-NO-SYNTHETIC | synthetic events, decorative rereads, and post-hoc replay
do not support the execution claim; | Inherited at export/native boundary | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Preserve the complete quoted invariant at the actual lifecycle produced Owner, exact model/width/store/domain and export/continuation objects; expand the consuming theorem type, not just its name. Detailed prospective predicates: N1-02, N1-18, N1-19. | Consumed inherited formal producer -> new export projection at exact objects -> LifecycleNativeContract -> actual native boundary, with generated C/FFI assumptions explicit. | Planned, not attempted: Decorative reread/post-hoc trace; use the same accepted predicate/guards/quantifiers or a checked implication for rejection. | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| INV-CATEGORY-SEPARATION | payload bits, proof fields, model ticks, machine
state, Lean runtime, and measured performance remain distinct. | Inherited at export/native boundary | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Preserve the complete quoted invariant at the actual lifecycle produced Owner, exact model/width/store/domain and export/continuation objects; expand the consuming theorem type, not just its name. Detailed prospective predicates: N1-08, N1-13, N1-24. | Consumed inherited formal producer -> new export projection at exact objects -> LifecycleNativeContract -> actual native boundary, with generated C/FFI assumptions explicit. | Planned, not attempted: Requested bytes promoted to RSS/model steps to clock; use the same accepted predicate/guards/quantifiers or a checked implication for rejection. | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| INV-PUBLIC-COMPOSITION | a theorem combining space, exactness, cost,
provenance, or machine claims proves them about the same construction and
execution and over the same validity domain. Conjoining true theorems about
different payloads or guarded and unguarded executions is not closure. | Inherited at export/native boundary | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Preserve the complete quoted invariant at the actual lifecycle produced Owner, exact model/width/store/domain and export/continuation objects; expand the consuming theorem type, not just its name. Detailed prospective predicates: N1-01, N1-04, N1-05, N1-06. | Consumed inherited formal producer -> new export projection at exact objects -> LifecycleNativeContract -> actual native boundary, with generated C/FFI assumptions explicit. | Planned, not attempted: Guarded/unguarded or sibling-object conjunction; use the same accepted predicate/guards/quantifiers or a checked implication for rejection. | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| INV-CERTIFICATE-ANTI-BYPASS | every mandatory field advertised by a public
certificate is projected by a checked typed consumer at the exact proposition
and object arguments required by the acceptance contract. Deleting or
weakening a field, or replacing it with a sibling fact, must break that
consumer rather than leave only constructor initializers and prose unchanged. | Inherited at export/native boundary | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Preserve the complete quoted invariant at the actual lifecycle produced Owner, exact model/width/store/domain and export/continuation objects; expand the consuming theorem type, not just its name. Detailed prospective predicates: N1-05. | Consumed inherited formal producer -> new export projection at exact objects -> LifecycleNativeContract -> actual native boundary, with generated C/FFI assumptions explicit. | Planned, not attempted: Field deletion/weakening/sibling fact after producer repair; use the same accepted predicate/guards/quantifiers or a checked implication for rejection. | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| INV-MUTATION-REPRODUCIBILITY | when acceptance relies on an exhaustive,
production, or public-dependency mutation campaign, the candidate contains a
versioned runner or fixtures that replay every claimed case, check the exact
expected failure/acceptance surface, restore tracked state, and leave the tree
clean. Report prose, copied terminal output, and dangling Git objects are not
replayable evidence. A public theorem additionally has a checked exact-type
consumer that fails when the advertised dependency is removed; `#print
axioms` over the theorem's current type is not such a consumer. | Inherited at export/native boundary | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Preserve the complete quoted invariant at the actual lifecycle produced Owner, exact model/width/store/domain and export/continuation objects; expand the consuming theorem type, not just its name. Detailed prospective predicates: N1-05, N1-19, N1-20, N1-21. | Consumed inherited formal producer -> new export projection at exact objects -> LifecycleNativeContract -> actual native boundary, with generated C/FFI assumptions explicit. | Planned, not attempted: Missing mutation/accept control/restoration or mutable-type-only check; use the same accepted predicate/guards/quantifiers or a checked implication for rejection. | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| INV-GLOBAL-PHYSICAL-MACHINE | a physical-machine claim supplies one
pre-execution store/word array and a checked address translation for every
executed segment, including failed/dead accesses. A theorem for one suffix or
component is not a whole-machine embedding. | Inherited at export/native boundary | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Preserve the complete quoted invariant at the actual lifecycle produced Owner, exact model/width/store/domain and export/continuation objects; expand the consuming theorem type, not just its name. Detailed prospective predicates: N1-01, N1-05, N1-18. | Consumed inherited formal producer -> new export projection at exact objects -> LifecycleNativeContract -> actual native boundary, with generated C/FFI assumptions explicit. | Planned, not attempted: Query-suffix embedding mislabeled whole construction/retirement/query run; use the same accepted predicate/guards/quantifiers or a checked implication for rejection. | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| INV-WIDTH-SCALING | one query-independent word-width declaration bounds all
stored words, addresses, sentinels, operands, and primitive results, and its
capacity/width is related to input size in the form required by the public
word-RAM claim. A standalone asymptotic fact about an unconstrained width
function is insufficient. | Inherited at export/native boundary | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Preserve the complete quoted invariant at the actual lifecycle produced Owner, exact model/width/store/domain and export/continuation objects; expand the consuming theorem type, not just its name. Detailed prospective predicates: N1-01, N1-03, N1-12. | Consumed inherited formal producer -> new export projection at exact objects -> LifecycleNativeContract -> actual native boundary, with generated C/FFI assumptions explicit. | Planned, not attempted: Query-specific or unconstrained width; use the same accepted predicate/guards/quantifiers or a checked implication for rejection. | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| CHK-SCOPE | exact base, branch, allowed paths, complete raw/Git identities, immutable prior matrix/history and clean committed candidate verified; both design ledgers and new import/consumer references close transitive scope. No broad .gitattributes/configuration/policy allowance. | Verification/process | Domain/objects: Exact base, declared branch/worktree, final owned diff and predecessor identities. Intended predicate: Exact base/branch/allowed additive paths/append-only ledgers; complete raw/Git identities, immutable predecessor bytes and clean committed final candidate; import/consumer transitive scope. | base -> START -> changed-path/source freeze -> final committed range/identity receipt | Planned, not attempted: Outside-scope one-byte mutation; Ledger prefix change; Unexpected source dependency; Untracked/staged final change | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| CHK-LEAN | focused new roots and independent export contract compile, their axiom inventories retain the permitted Lean/Std trust base, all required exact-type mutations replay at the intended client, and one final default lake build passes after implementation changes. No sorry/admit/axiom/native_decide/Lean.ofReduceBool or new unsafe/extern/implemented_by theorem shortcuts; legitimate existing runtime/FFI trust is documented. | Verification/process | Domain/objects: Exact new Lean dependency closure and final source freeze. Intended predicate: Focused exports/consumer and final default lake build succeed; new axiom inventory permitted; exact-type mutations reject intended client after producer passes; no new trust shortcuts. | new exports -> LifecycleNativeContract -> validators -> final build/axiom/hygiene | Planned, not attempted: Producer-only mutation failure insufficient; New trust shortcut; Axiom print cannot replace independently expected consumer | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| CHK-NATIVE | bounded startup, one exact selector, then complete frozen actual new-native registry and C/Rust/C++ consumers pass on frozen producing source with owned exits/streams/identities/capacity/failure controls. Preserve exact counts and attempted negative types; do not confuse components, retained captures and fresh actual native processes. | Verification/process | Domain/objects: Certified Windows x64 MSVC Lean 4.22 profile only. Intended predicate: Bounded startup then one selector then full frozen actual registry and same-DLL C/Rust/C++ clients pass; owned exit/streams/identity/capacity/failure evidence/counts complete. | startup -> one exact selector -> full registry -> clients -> compact execution index | Planned, not attempted: Missing/duplicate/misbound ID; Retained capture substituted for fresh process; Timeout/unrelated diagnostic treated as pass | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| CHK-REPORT | complete durable report/matrix/guide exist and final committed git diff --check plus strict exact-base design certification and unchanged-policy strict changed-surface claim checks cover the final prose/code/ledger inputs. Final HEAD, report bytes/hash, source commits, actual commands/results and applicability of reused evidence are separately pinned in an external delivery receipt. | Verification/process | Domain/objects: Final report/ledger/claim bytes and exact base..HEAD, separately from execution source. Intended predicate: Durable report/matrix/guide complete; final working/committed whitespace, exact-base strict design and strict final changed-source/prose claim checks bind final inputs; external receipt binds HEAD/report hash/source/applicability. | execution freeze -> report/ledger/claims -> narrow final checks -> commit -> external delivery receipt | Planned, not attempted: Post-check report edit; Strict design without exact Base; Omitted changed claim surface; Recursive hash | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| REPLAY-EXACT-REGISTRY | a replay harness must declare the exact ordered
frozen case registry, reject missing or duplicate IDs, verify any ID-to-field
or ID-to-object mapping, and check exact verdict counts; a total pass count
alone is insufficient. | Verification/process | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Whole request validates at real bound-parameter boundary before child/output mutation: omitted means full declared registry; explicit empty/null/whitespace/unknown/duplicate rejects; focused means exactly one case; ordered ID/handler/verdict mapping/count exact. | PowerShell caller binding -> validated selector -> frozen registry -> dispatch -> per-ID verdict | Planned, not attempted: Missing/duplicate middle ID; changed handler/verdict but unchanged count | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| REPLAY-SELECTOR-NONVACUITY | focused selection must execute exactly one
requested frozen ID and must reject unknown IDs. Add cheap named controls for
an omitted middle ID, duplicated middle ID, valid frozen ID, and unknown ID.
Distinguish an omitted selector parameter from an explicitly bound empty or
whitespace value at the real script boundary; only omission may select the
full registry when the frozen contract permits that mode. | Verification/process | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Whole request validates at real bound-parameter boundary before child/output mutation: omitted means full declared registry; explicit empty/null/whitespace/unknown/duplicate rejects; focused means exactly one case; ordered ID/handler/verdict mapping/count exact. | PowerShell caller binding -> validated selector -> frozen registry -> dispatch -> per-ID verdict | Planned, not attempted: Actual bound empty/null/whitespace/unknown/duplicate; omission and one valid selector | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| REPLAY-SUBPROCESS-DEADLINE | every external compiler/tool stage in a replay
harness must have a positive evidence-based deadline, classify timeout as
failure, terminate its owned process tree, and run cleanup plus live-tree
integrity checks in `finally`. Implement and exercise owned-tree termination
on every operating system that runs the required gate. Add a cheap sleeper
self-test that spawns a descendant and proves both root and child are absent;
do not discover this control by hanging the full semantic campaign.
- When ordered dynamic-read agreement is primary and safe-footprint agreement
is a corollary, prove the read-region/segment containment bridge directly
from execution or program structure. It must not invoke the legacy safe
complete-result equality before reaching the ordered-dynamic theorem.
- If a public wrapper guards valid inputs, ensure every combined field uses the
same guard/domain. Raw adequacy may occur only under the valid-range premise
or in a guarded packet with matching invalid semantics; a bridge theorem does
not justify leaving raw adequacy unconditional in the same public record.
Test invalid, reversed, and out-of-bounds cases.
- For a whole physical-machine claim, cover every read-producing segment in one
pre-execution word array and relate its query-independent width/capacity to
input size. A component slice or unconstrained little-o width fact is not
enough.
- For classifier/linter work, treat named mutation fixtures as lower bounds,
not the acceptance boundary. Freeze the category being classified; add
category-level holdouts and allowance-bypass mutations; and exercise the
production final verdict, including strictness, path/line context, focused
single-file input, and absolute-path normalization where supported. Do not
validate a copied detector in place of the production classifier.
- Strict branch certification with scripts/design_decision_check.ps1 must use
-Strict -Base followed by the task's exact 40-character base commit.
Omitting -Base is a production failure, not a clean zero-change result.
Reserve the no-Base form for deliberate non-strict local-worktree advice. | Verification/process | Domain/objects: Formal: every InputModel and xs : List Int with InputDomain model xs, endpoints left/right < 2^wordWidth xs.length. Native: explicit checked Windows x64 MSVC Lean 4.22 admission, separately from the all-size theorem. Intended predicate: Every external stage has positive evidence-based deadline and owned-tree termination; failures preserved. Cheap certified-Windows descendant control proves root+child absent. Named Local\RMQLifecycleImplementationHeavy20260920 mutex serializes expensive work, one runner/cache and aggregate owner; unrun platforms/timeouts uncovered. | new wrappers -> owned_process_tree -> Windows job -> stream/integrity cleanup -> command ledger | Planned, not attempted: Cheap owned root+descendant timeout; independent cleanup/integrity after early failure | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| FROZEN-ACCEPTANCE-ROW-BYTE-INTEGRITY | when a prompt says inherited matrix
rows are frozen, verbatim, or byte-for-byte preserved, validate that claim
before any expensive verification. Decode the exact base blob and candidate
file as strict UTF-8, extract the complete frozen row for every inherited
stable ID, reject missing or duplicate IDs, and require exact UTF-8 byte
equality for each row. A row count, normalized text comparison, visual review,
or a read/write round trip through a locale-sensitive shell is insufficient.
Also reject recognizable mojibake such as `¬` or `“...”`, but treat that scan
only as a negative control: absence of those spellings does not replace exact
row equality. Record the base ref, candidate ref, inherited-ID count, and exact
changed IDs in the evidence ledger. | Verification/process | Domain/objects: 55 assigned IDs and complete inherited source definitions; prior matrices separately at exact base. Intended predicate: Strict UTF-8 source/base spans and complete frozen row bytes compare exactly; exact ordered IDs reject missing/duplicate/reordered/changed rows. Original requirement/source-row hashes are separate from readable Markdown row hashes; predecessor matrices remain pinned independently. | prompt/canonical source spans -> CONTRACT_REQUIREMENTS -> frozen row bytes -> candidate evidence and identity checker | Planned, not attempted: One-byte requirement change; Missing/duplicate/reordered ID; Mojibake; Normalized equality hiding byte changes | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| NAMED-REGRESSION-REALITY | before a prompt requires an immutable negative
fixture to fail, the coordinator must independently reproduce that failure
from the exact objects with the same decoder, predicate, guards, and
quantifiers required in the prompt. Record the observed result. A mixed-
decoder transcript, worker narrative, or unverified inference cannot become
a mandatory negative control. | Verification/process | Domain/objects: Each named immutable negative fixture and its exact intended oracle. Intended predicate: Exact fixture negative verdict must first be observed at identical objects/decoder/predicate/guards/quantifiers; novel native challenges measured before expected rejection freezes. Coordinator prelaunch duty remains distinct. | exact objects -> initial challenge observation -> same-domain predicate -> frozen expected verdict | Planned, not attempted: Mixed decoder/domain; Log-only discrimination for resource/value claim; Nondistinguishing challenge honestly remains open | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | +| ARCH-LIFECYCLE-ACYCLIC-EVIDENCE-ORDER | before launch, write the task's
evidence and decision order explicitly. Separate owner choices that genuinely
gate evidence collection from choices whose justification depends on that
evidence. An output-dependent decision cannot be a prerequisite for launching
the task that produces its evidence. Review the order as a dependency DAG:
every producer must precede its consumers, and any cycle makes the prompt
`DRAFT_DO_NOT_SEND` until the lifecycle is repaired. Preserve legitimate
two-phase architecture governance: approve scope, model, and acceptance gates
before a spike; choose the route or successor matrix only after the spike
results exist. | Verification/process | Domain/objects: Worker evidence/decision DAG and distinct coordinator acceptance stages. Intended predicate: Acyclic order: reviewed producers/scope -> inventory/freeze -> Lean export proof -> C consumption -> positive native observations -> conclusions -> frozen source/full replay -> report/final checks -> coordinator review/aggregate/blind audit/acceptance. Observation-dependent design follows observations. | contract -> proof -> native -> evidence -> report -> coordinator-only closure | Planned, not attempted: Output-dependent gate before evidence-producing implementation; Adapter before bounded C-copy observation; Final checks before report bytes | None at freeze. | Open; exact checked types, actual controls/outcomes and same-predicate/domain bridges pending. | diff --git a/docs/internal/extensions/lifecycle-native1/ACCEPTANCE_MATRIX.md b/docs/internal/extensions/lifecycle-native1/ACCEPTANCE_MATRIX.md new file mode 100644 index 00000000..2097bfe2 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native1/ACCEPTANCE_MATRIX.md @@ -0,0 +1,100 @@ +# LIFE-NATIVE-1 acceptance evidence + +The 55 requirements, IDs, order and scope remain frozen in CONTRACT_REQUIREMENTS.json and ACCEPTANCE_MATRIX.frozen.md. Their first three cells below are byte-exact. The mutable evidence/status cells describe local candidate closure; coordinator acceptance is separate. Final certification applies only with the external `.lake/lifecycle-native1/delivery/DELIVERY.json` binding this ledger and REPORT.md to the clean final commit and successful report-sensitive checks. Positive/negative execution receipts and exact propositions follow below. + +| ID | Exact frozen requirement | Scope | Evidence needed (exact proposition/check) | Named consumer and identity/composition chain | Anti-vacuity challenge attempted and outcome | Evidence obtained | Status / residual gap | +| --- | --- | --- | --- | --- | --- | --- | --- | +| N1-01 | Prove a small export-facing Lean result for the actual word and comparison lifecycle runners: on the declared InputDomain and represented endpoints, build-and-first-query produces the actual Ownership.owner, correct halted optionNatPacket answer, canonical produced memory, empty key banks, fixed numeric bank and the same complete modeled retained-capacity bound. Derive these facts from the existing capstone/refinement; do not accept final-memory or answer equality as a hypothesis. Native admission limits are separately labeled and do not weaken the all-size Lean theorem. | Local production consumer | Under D: B=Ownership.owner, B.toState=cr.final, Ready(B), halted(packet), pointwise memory=mem/exact extent, empty keys/keyRegs, regs.size8273 and C(B)*w≤2n+rho. No output equality premise. | P E01–E11/E13,U02/U03: buildFirst_eq→Ownership.refinement/ready/halted/capacity_bound→export_contract; independent expanded READY/capacity at actual B. | Export34 Discovery passed all 23 weakenings, two deletions, four sibling substitutions, two accepts and three admission/codec mutations; producer success precedes intended consumer failure. Root reviewed and froze complete diagnostics; all 34 cases now replay exactly. | L four roots/typed consumers compiled actualexit0,5979pins,cleanup. F both models/invalid requests pass; native limits separate. | Local candidate complete. Same actual owner, domain, answer, memory and complete modeled capacity derived; fixed-type and mutation consumers pass. | +| N1-02 | The compiled production path executes Lifecycle runOwner from Executable.initialOwner and uses Executable.queryOwner or a proved definitionally/extensionally equal cached-program adapter thereafter. First inspect emitted C and bounded execution for suspected reference-count-driven copies. If actual measurements justify an observation-erasing loop, it may delegate the unchanged executeArray and must prove equality to runOwner for every program/state/fuel, including stopped/fault/missing-fetch cases; it may not replace any primitive evaluator or weaken the admitted domain. It must not call the old Native/LimbMachine query interpreter as a substitute, rebuild buildMemory/canonicalImage/buildPayload, invoke a reference RMQ answer, or reconstruct state from a reference trace. The actual returned C/Rust result must come from this runner's status. | Local production consumer | ∀program owner fuel, runThin=runOwner including stopped/fault/missing fetch; query=Executable.queryOwner via equal cache; returned packet derives actual status. | P T01–T07/B11–B18; G nativeInitial→initialOwner→thin loop→unchanged executeArray→Owner.status→nativePacket→C/Rust. | G excludes old Native/LimbMachine/reference answer/buildMemory rebuild on returned route; NC actual fault/fuel challenges status. No invented guaranteed oracle-answer divergence. | S startup5.4340775s; historical H100steps1copy8273cells versus historical69/570837; current F26freshprocesses pass. Residual copy is consistent with the persistent initial numeric array; exact instruction attribution remains source inference, not a measured PC/stack sample. Imported symbols differ from reachable callees. | Local candidate complete. Universal thin-runner equality and actual compiled return path established; compiler/runtime correctness remains trusted. | +| N1-03 | Define and prove the successful admission/representation bridge used by the exports, including exact signed Int encoding for word input, arbitrary signed finite integers for comparison input, canonical endpoint words and model selection. Word InputFits failures and host format/resource limits reject explicitly; no silent fallback to comparison input or narrower u64/u128 arithmetic. Carry the actual count and query-independent word profile, and derive READY n/M from produced metadata rather than trusted caller duplicates. | Local production consumer | nativeAdmit success⇒actual decoded n, signed xs, canonical endpoints, InputDomain and host limits. READY cell0=n/cell7=memory.size; Word InputFits explicit, comparison Int arbitrary. | P B01–B18: nativeAdmit_source→nativeBuildFirst_correct/packet; nativeQueryAdmit_iff→nativeQuery_correct/packet; same model/xs/endpoints and produced metadata. | A bad sign/negativezero/emptymagnitude/short-long endpoints/4096-4097; NC WordFits rejects2 without fallback; query malformed pre-take preserves owner/memory. | A23/F pass; current NC48 Replay exact predicates. count4096 width240/30bytes. Total-magnitude overflow unreachable after component bounds, not claimed exercised. | Local candidate complete. Admission and representation bridges compose at the actual input/count/endpoints; native host ceilings remain separate. | +| N1-04 | Separate malformed/native-domain rejection, represented invalid RMQ range with ordinary None answer, model fault and exhausted fuel. Empty, reversed and out-of-bounds represented ranges retain the correct formal guard throughout combined fields. A represented invalid first or later query still returns a reusable canonical owner when the formal route does. Unrepresentable requests are rejected before consuming a healthy owner; temporary parsing/admission allocations and Lean codec calls are allowed before transfer if cleaned on failure. No rejection is silently reported as successful execution. | Local production consumer | D/QD invalid represented range⇒halted0 and READY. Native malformed/domain, fault and fuel statuses distinct; pre-take reject preserves old owner. | P E13/Q11/B consumers→C prevalidate/take/actual-status classifier→Rust state table; matching represented guards throughout. | F empty/reversed/out-of-range first/later and valid-after-invalid; A malformed; NC injected fault7/fuel8, pretransfer1/9, posttake empty outputs. | F/A/CL pass; current NC48 Replay preserves exact identity/ordered memory before take and cleans after take. Invalid packet0 is successful execution. | Local candidate complete. Represented invalid ranges, malformed requests, fault and fuel remain distinct; pre-transfer preservation and post-take cleanup pass. | +| N1-05 | Prove exact export/owner projection and value-preserving array repacking interfaces sufficient for the actual native boundary. Expose a single coherent small public export contract and an independent expected-type Lean consumer in RMQ/Validation/LifecycleNativeContract.lean that uses each mandatory projection at the fixed objects/domain. Attempt deletion/weakening/sibling substitution of load-bearing facts and replay the intended client rejection only after successful producer compilation. C/runtime implementation correctness remains an explicit trust boundary supported by actual controls, not falsely kernel-proved. | Local production consumer | B.toState=cr.final; Q.toState=qr.final. Four ArrayCopy size+entry relations plus pc/status imply target=source, equal state/status/capacity, READY iff and future query equality. | P E01–E13/Q01–Q11 fixed independent consumer; E12 universal repack transport. Actual C copying validates equality; C correctness is not kernel-proved. | Export34 includes23weakenings/2deletions/4siblings/2accepts/3codec changes; producer compilation before intended client rejection. NC8 copied value/offset cases attack actual entries. | L exact consumer and EXC15 controls pass. Full34 Discovery: 66 clean producer/descendant stages,32 intended rejects,2 accepts,50 diagnostic objects; complete diagnostics independently reviewed/frozen. Current NC48 Replay includes all8 intended bank/index mismatches. | Local candidate complete. Exact projections/repacking interface and all mandatory expected types survive positive compilation and reject all required mutations; C correctness is external. | +| N1-06 | Repeated native calls continue on the same produced canonical allocation through the existing four charged request/control boundary events and finite setup. Here allocation equality means the actual produced modeled contents/extents, transported through a proved value-preserving native repacking boundary before publication; it is not a theorem of unchanged native pointer address. Measure physical identity/capacity separately and disclose any further native replacement. The uninterrupted first query does not prepend the four external re-entry events. Prove the export continuation inherits Ready.query, answer correctness, preserved memory and the 160257 model-step upper bound. Do not reset halted state, registers or metadata for free, and do not retain the original input to recreate the owner per request. | Local production consumer | QD⇒READY(Q),halted(packet),Q.memory=owner.memory,qr.steps=4+4+8271+compactQueryRun.steps≤160257,C(Q)*w≤2n+rho. Repack is logical value, not pointer equality. | E12+continuation→Q01–Q11→Ready.query/query_owner_refinement/query_correct; Q07 two requestAdmission+two controlEntry; first run no external re-entry prefix. | F all later memory/invalid-to-valid reuse/first0 later4 counters; NC query copy/alias/posttake same strict predicate. | F142publications/26processes,71requests per mode,maxlater28613. Every publication copies four arrays8273+M entries including whole memory; O(M) native work outside modeled query bound. | Local candidate complete. Continuation preserves the same modeled contents and four charged events with the 160257 bound; native pointer identity/constant time is not claimed. | +| N1-07 | Production owners contain only the finite operational arrays/scalars and explicit native handle metadata. Drop temporary parsed input/list roots, old owner roots, comparison keys/registers, old arena containers and result-wrapper references at the documented transfer point. Validation histories/read receipts are optional separately owned artifacts and must not be retained in the production owner, input closure, Rust cache or query result. Establish actual compiled closure/root identity, not only logical fields. | Local production consumer | Owner only regs/memory/keys/keyRegs/pc/status; native metadata/results/observations separately inventoried. Parsed xs/list/old owner/backing/wrapper roots released; no production xs/history. | G exact emitted Entry/Run/ThinRun/Observations fields/callees/decrements→C take/repack/publish/cleanup; recordBefore releases prestate before primitive; observations separate. | NC retained input/arena/key/history/alias challenge same strict predicate as healthy controls; copy cuts count actual released initialized entries/arrays. | G compiled-root inventory; current NC48 Replay exact root/exclusivity and cleanup projections; F empty key banks/paired memory. | Local candidate complete. Compiled root inspection and actual retention controls pass; ready-shape and generation-local counters are not a global heap census. | +| N1-08 | Replace excess-capacity backing arrays at native READY publication after the first query using the reviewed consume/replacement route and preserve all logical entries. Every subsequently published reusable state must retain the same declared capacity guarantees; extra native replacement work is separately accounted. Measure actual initialized size, capacity and requested outer-container storage for every retained array, including zero-sized key banks, plus reachable boxed/scalar representation and shared fixed code separately. Operationally release old backing roots. Array.pop/size, zero logical extents, destructor counters alone, or generic P0 observations do not prove this production capacity claim. Do not equate requested bytes with allocator usable bytes or RSS. | Local production consumer | Published size=capacity=[8273,M,0,0],requested outer bytes24+8*capacity,entries equal source,operational containers exclusive; repack transports READY. | P E12→actual C copying/strict_info; N each array and separately shared code/scalars; retired backing containers decremented. | NC skip-build excess capacity rejects; skip-query nondistinguishing already-exact capacities; copied-value/offset/alias/arena same positive predicate. | F142 exact publications; current NC48 Replay17publication rejects and skip-query success0copied entries. Code16829160bytes overlaps globals179203176bytes; GMP16bytes separate. | Local candidate complete. Actual exact capacities, entries and retired operational roots checked; requested bytes are not allocator usable bytes or RSS. | +| N1-09 | Make ownership transfer explicit in the C contract and enforceable safe Rust types: no safe clone/raw-alias escape, borrowed result data cannot outlive its owner, destruction exactly once on the initializing thread, and a mutation requires unique handle access. Identify trusted foreign-caller preconditions precisely; finite alias tests cannot quantify over arbitrary C misuse. Deliberate extra-root controls must not earn the strict exclusive-transfer conclusion, and no test may dereference freed objects. Shared immutable scalar values and fixed program objects need not have reference count one; distinguish these permitted references from extra operational owner/input/arena roots. | Local production consumer | Rust unique mutation/no Clone/private raw/borrowed result/runtime-bound !Send/!Sync; C live unique same-runtime initializing-thread handles. Immutable scalar/program sharing permitted. | GUIDE/N/R table→Rust lifetimes/PhantomData→same C ABI; strict_info checks operational containers, not scalar RC1. | R15reject Send/Sync five types,Clone,immutable mutate,result escape,private raw,owner beyond runtime;2accept. NC alias rejects/shared scalar accepts actual count1. | Current R17 compiler Replay073749082 passes15 intended rejects/2accepts; CL normal/error/drop clients pass; current NC48 Replay073240346 passes the same predicates without freed dereferences. | Local candidate complete. Safe Rust type/lifetime checks and actual ownership controls pass; foreign uniqueness/thread/runtime obligations remain explicit. | +| N1-10 | Specify and implement the complete state table for validation-before-consumption failures, controlled failures during allocation/copy/transfer, successful transfer and destruction. Keep a valid old owner when rejected before consumption; after an irrevocable take, either return exactly one valid replacement or return an explicit empty/poisoned handle with all initialized temporary resources released. Exercise both sides and partial-copy boundaries on actual production helpers. Ordinary Lean allocation failure may be fatal under the pinned runtime; do not present it as recoverable injected failure. | Local production consumer | Before take reject preserves exact owner; after take one strict replacement or empty outputs/all initialized temporaries released; exactly-once handle destruction. | GUIDE state table→C allocate/copy/take/strict/publish/cleanup; P repack only after actual equality; generation-local balances supplement inspection. | NC cuts0,1,8272,8273,8274 build/query; pretransfer allocation/admission/posttake/prepublish failure. Prepublish strictPublication1 then cleanup is not predicate rejection. | current NC48 Replay all balances/cleanup and pretransfer3 identity/full memory pass; CL error/posttake clients pass. Injection only native handle allocation, Lean OOM may be fatal. | Local candidate complete. Complete state-table controls pass; injected native allocation failure does not imply recoverable Lean allocation failure. | +| N1-11 | Compile actual Lean source with the pinned Lean 4.22 toolchain and bind generated symbols, prototypes, object/library hashes, transitive source closure and compiler/runtime identity to the tested DLL. Verify cache provenance includes relevant source and tool/compiler identities before reuse. Inspect generated initialization and calls so proofs, whole trace witnesses or large proof-only reference payloads are not evaluated at import/startup. An import or linker list naming a module is not proof the returned route executes it. | Local production consumer | Tested DLL binds Lean4.22/tool/runtime/transitive sources/exact generated symbols/prototypes/objects. Startup excludes evaluated proof-only reference payload; cache rechecks relevant identities. | L→DLL5stages→clients8stages→F/A/CL staged binaries; G initializers/callees. Approved five macro_inline annotations preserve names/types/bodies/propositions. | Import names alone insufficient; G follows actual returned closure. Measured initializer defect/pre-thin copies precede scoped fixes; before/after source/tool/artifact pins checked. | DLL7091/client7143pins all exit0; productionDLL03c17dd0fbacff8f72e707f40ba737096daf096059ace99ec7a0c9fd69c1772d; S5.4340775s; G no proof-wrapper evaluation in actual closure. | Local candidate complete. Current source/tool/generated closure, initialization and tested DLL are bound; only the approved five protected annotations differ. | +| N1-12 | Reuse one checked fixed program representation per input model through the native lifecycle without input-specialized code or reconstructing the program list/array per query. If an additive cached-array adapter is needed, prove it equals Layout.program.toArray and prove the resulting run equals the accepted runner. Account for shared code and native representation explicitly; code constants are not free hidden payload and modeled encoded words are not native heap bytes. | Local production consumer | cachedProgram model=Layout.program.toArray; any cached run equals accepted runner; only two model-fixed programs; C(owner) includes encodedProgram.length. | P E01/cached_run/T→actual build/query; G persistent globals→instruction fetch→executeArray; no xs-specialized/per-query code reconstruction. | Export program weakening/sibling targets exact equality; generated allocation/callgraph checks reuse; physical code measured separately. | L consumer passes; N223371/223379 fixed program instruction-array entries,16829160byte program graph; all current program weakening/sibling controls reject at intended fixed types in reviewed full34 Discovery and complete exact Replay. | Local candidate complete. Exact two-model cache and uniform runner refinement established; modeled encoded words and measured native code remain distinct. | +| N1-13 | Keep modeled construction/finalization/re-entry work, host admission/conversion, native repacking, fixed-code initialization, optional observation cost and native timings separate. Preserve original linear modeled construction and complete READY 2n+rho conclusions at the proved owner. State any host resource ceiling and its admitted domain precisely. No generic all-input practical speed or native 2n+o(n)-heap claim follows from the interpreter theorem. | Local production consumer | Inherited modeled construction bound and C(B)*w≤2n+rho are separate from host admission, initialization, native copies, observations, runtime heap and time. | Capstone ConstructionChain/ExecutedOwner/uniform→P exact B/Q projections; N per-size M/first-steps/code/global/latency tables; GUIDE native ceilings. | F observed/unobserved pairs; H first100copy cost; NC skip-query shows physical replacement cannot be inferred from model ticks. Arbitrary comparison Int keys are separate. | N actual13pairs6.8472172–8.1477043s,maxlater28613; every publication copies8273+M entries. Code/global graphs overlap; GMP/runtime costs separate; finite samples only. | Local candidate complete. All resource layers and measured limits remain separated; no all-input practical-speed or native succinct-heap theorem is claimed. | +| N1-14 | Implement runtime initialization, cross-thread restrictions, handle lifetimes, C result access and Rust RAII around the real ABI. Rust owner/runtime types must encode !Send/!Sync or an equally explicit checked restriction; document foreign callers' matching obligations. Reuse the existing crate-level runtime-claim guard so only one chosen Lean runtime is initialized per process; incompatible old/new runtime acquisition must reject, including after initialization failure. Coexistence of old and new runtime owners is not required. Inspect actual DLL/runtime linkage rather than assuming two imported bridges share runtime state. Include compile-time misuse controls for safe Rust plus real normal/error/drop paths, and avoid undefined-behavior tests as purported safety evidence. | Local production consumer | One crate runtime claim/process; !Send/!Sync Runtime/Owner/Observation/Natural/QueryResult; failed init retains incompatible-runtime claim. Foreign thread/lifetime/uniqueness obligations explicit. | R type restrictions→actual ABI; CL conflict/error/drop; A initializing/secondary thread; N PE/runtime linkage and predecessor reuse provenance. | R17compile; CL three acquisition orders/INIT-FAILURE/OWNER-ERRORS/POST-TAKE; A secondarythread4 unchanged outputs. No UB test as safety evidence. | CL10 exact exits/streams, current R17 Replay,A23 pass. PREDECESSOR_DLL_REUSE pins historical binaries/limited current-source applicability, no fresh old build. | Local candidate complete. Actual initialization/thread/runtime-claim and destruction clients pass; C caller obligations remain trusted. | +| N1-15 | Return canonical arbitrary-width answer/status representations through the C ABI and Rust facade, with no lossy host-sized intermediate. Endpoint and input conversions use tested/proved codecs with exact lengths/sign/magnitude/overflow rules. Values wider than128bits and negative comparison keys must reach actual construction. Host-sized indices/counts may be used only under explicit checked bounds and a proven conversion relation. | Local production consumer | READY+halted(packet) derives packet<2^w; nativePacket=encodeEndpoint w packet,canonical bytes,decodeMagnitude=packet. Exact signed input/endpoint lengths; bounded host sizes separate. | P B01–B18: bytes→actual xs/count/model→runner status→canonical bytes; Rust Natural retains arbitrary-width bytes, no u64/u128 answer conversion. | A length/sign/negativezero/empty/limits; F negative/>128bit construction; NC WordFits2; export codec/admission weakenings target conversion bridge. | L byte/metadata consumers compile; F/A pass actual current DLL; count4096width240/30bytes. Component magnitude/count limits explicit. | Local candidate complete. Arbitrary-width codecs, typed bridges and wide signed native fixtures pass without u64/u128 domain substitution. | +| N1-16 | Supply real C, safe Rust and C++ clients of the same generated DLL, including construction, at least two later queries and destruction. The C++ example uses the actual C ABI and its errors, not a second implementation. Keep existing NativeImage ABI and its regression route intact; old query evidence is background and cannot substitute for new lifecycle-client execution. | Local production consumer | Actual C/safe Rust/C++ use same generated ABI for construction,≥2later queries and destruction. Existing NativeImage remains separate regression route. | DLL/client build→CL ordered10 current-DLL processes; F actual C replay; C++ invokes C ABI ownership/errors, no second RMQ implementation. | CL CPP/RUST word/comparison plus owner-error/posttake/conflict/init-failure; CC real selectors/handler/verdict mapping. | CL10 actualexit0,0.1209255–2.6918382s,7292pins,cleanup/restoration true; F142 C requests. OldDLL conflict fixture applicability15/19 and29/31 disclosed as historical. | Local candidate complete. C, safe Rust and thin C++ clients execute the same current lifecycle DLL with independent expected results. | +| N1-17 | Freeze meaningful exact fixture IDs and independent expected answers before the final run. Cover both models; empty/singleton/two elements; duplicates/leftmost ties; negative and wider-than128bit values under the proper domains; representative sizes24/83; actual same-block, different-block/fringe/interior/crossing-cell query paths when reachable; represented invalid/reversed/out-of-bounds endpoints; malformed/unrepresentable input; and repeated valid queries after admitted invalid ones. Record actual route coverage or a precise absence, not guessed labels. Expected values come from the independent reference semantics, not the executed answer. | Local production consumer | Frozen13 independent expected fixtures cover models,n0/1/2/4/24/83,ties,negative/wide,invalid and valid-after-invalid; route labels require source-signature/actual-read joins. | F registry/reference oracle→mode pairs; RC unique comparison signatures→block/interior conditions plus actual ordered payload addresses/replies. | RC does not infer actual payload read from constant8192,20 (110static occurrences) or crossing from load8266,8261 alone (193occurrences); dynamic context joins required. | F26processes142requests+independentreview PASS. RC same20/cross32/interiorNonempty20/interiorEmpty12/marker360/crossingSecondLoad46;10480 later reads all backed,3288payload. Marker360≠360payload reads. | Local candidate complete. Required finite route/fixture evidence is present with actual read backing; exhaustive reachable-route coverage is not claimed. | +| N1-18 | Compare optional observed runs with production using a proved same-final-owner bridge, preserving actual ordered read/reply occurrences and charged categories across construction, retirement and repeated queries. Use actual producing prestates; global observations concatenate segments and only the query suffix equals query-only evidence. Prove each advertised counter/category fold-to-trace projection separately: the existing counted_owner final-state equality alone does not prove those counters. Avoid constructing a huge retained trace merely to count steps. At native test points confirm observed and unobserved modes return identical answers/canonical memory while only the explicit observation object retains diagnostics. | Local production consumer | Observed final owner=production; counter15=steps,each0–14=its category fold,routes0–12=countP actual marker,ordered reads=model reads; indexed occurrence has actual prestate/primitive; session=first++queries. | P T/Stats bridges→O01–O11; O09 runOwner prefix+stepArray; O10 same indexed query transition→query_array_refinement→backed mem reply; O11 exact segment order. | F paired owner/memory plus independently typed category/read projections; export observation weakenings; RC occurrence joins. Final-owner equality alone does not prove counters. | L all O consumers; F71requests/mode answers/memory identical,first0/later4boundary; diagnostics only separate observation. Thin counters avoid huge retained full trace. | Local candidate complete. Exact observation owner/fold/prestate types and actual paired execution/read evidence pass; diagnostics are separately owned. | +| N1-19 | Production ownership/capacity controls must challenge skipped replacement, retained old arena/input/key/history roots, wrong copied value/offset, extra alias, partial-copy cleanup, failed admission before transfer, post-take failure and repeated-query memory preservation using the same acceptance predicates as successful controls. Demonstrate changed answers or actual state/resource differences where that is the claim; a changed log alone is insufficient. A correct reference oracle may agree on every answer, so forbidden oracle substitution is checked by actual evaluator dependence/compiled route evidence and a valid route challenge, not an invented guaranteed answer divergence. Define and measure new fixture challenges before assigning their exact expected rejection; preserve the frozen property while disclosing a challenge that does not distinguish it. Name each mutation kind and exact oracle; do not label a synthetic helper component an actual end-to-end native failure. | Local production consumer | Healthy and mutated actual helpers use same strict_info/value/capacity/cleanup predicates; claimed failures require measured state/resource difference, not changed log. | NC actual helper→nativeJSON→ordered48mapping/projections→independent review→frozen NATIVE_EXPECTATIONS→final Replay; P repack identifies logical copy predicate. | 48:4accept,1nondist skip-query,17publication reject,17operation reject,6prebuild,3pretransfer. Roots/copy/alias/partial/posttake/admission included. Oracle exclusion uses G dependency, not imaginary answer divergence. | Current NC48 Replay073240346 PASS,7638pins,exact48 ordered projections. Independent review rehashed every final pin (6500 distinct review inputs) and reconstructed recipe494eadb4… from7148 source/6013 unique/1135 duplicate pins. All4accept/1nondist/17publication/17operation/6prebuild/3pretransfer verdicts match unchanged reviewed oracles. | Local candidate complete. All 48 current native controls replay unchanged reviewed oracles; nondistinction, injected failures and counter scope are explicit. | +| N1-20 | New replay verification must preserve the actual ordinary exit, timeout/overflow, complete captured stdout/stderr and exact intended diagnostic. Reject expected plus unrelated diagnostics on either stream. If claiming literal UTF-8 output, decode strictly and compare ordinally without stripping BOM/NUL/newlines or culture normalization, using actual caller-level holdouts. State any inherited returned-line loss limit explicitly. Source/tool/artifact integrity and disposable cleanup run independently in finally even after partial setup or earlier stage failure. | Local production consumer | Preserve ordinary exit,timeout/overflow,bounded raw streams; strictUTF8 ordinal equality rejects unrelated text,BOM/NUL/newline/invalidUTF8. Finally integrity/cleanup independent after partial setup. | SC/CC/EC/EXC/RS real binders/capture; ODC production finally; F/CL/A/R/NC actual raw captures, not reconstructed returned lines. | SC extra stdout/stderr,exit7,BOM/NUL/LF,rawFF,17MiB overflow vs16MiB; ODC forced setup/pin changes; CC104rawcaptures/36pins rechecked. | SC33/CC13/EC18/EXC15/RS15/ODC3/NR11 pass. Current F/CL/A,NC48 and R17 Replay pass exact exits/streams/pins/cleanup. Overflow ordinary producer exit null remains failure; returned-line limitations disclosed. | Local candidate complete. Complete raw streams, ordinary exits, owned deadlines, integrity and cleanup checked; timeout is never an accepted semantic rejection. | +| N1-21 | Replay selectors validate the full request before any semantic child or output mutation. Omission may select the declared full registry; explicitly empty/null/whitespace/unknown/duplicate selectors reject. A focused request executes exactly its one named case. Check ordered ID-to-handler/verdict mappings and complete counts, not pass totals. Commit reproducible controls for omitted/duplicated middle IDs, known/unknown selectors and real parameter-binding boundaries. | Local production consumer | Actual omission may select full; bound null/empty/whitespace/unknown/duplicate rejects before semantic child/output mutation; knownfocus exactly1; full ordered ID/handler/verdict mapping checked. | SC33 fixture/CC13 client/EC18 native-control/EXC15 export/RS15 Rust real caller Plan/Validate→frozen mappings. | Actual omitted/empty scalar-array/null/whitespace/unknown/duplicate; missing/dup/reorderedmiddle/handler/verdict tampering. Hash guard rejection not mislabeled structural classifier; Int32 binder limits separate from native codec. | Current cheap controls pass exact exits/streams/pins/cleanup; F13/focus1,CL10,R17 and NC48 Replay dispatch exact orders. Corrected NC-focus runs exactly NC-NONE-BUILD; EX34 Discovery exact order. | Local candidate complete. Complete ordered mappings, real selector boundary controls and all final semantic rosters pass. | +| N1-22 | Use positive evidence-based deadlines and the existing owned-process facility for every external build/compiler/native stage; preserve failures and terminate only the owned tree. Exercise one cheap established descendant termination control on the platform actually certified. Use Local\RMQLifecycleImplementationHeavy20260920 for expensive work; one heavy runner per cache, one full aggregate owner. Unsupported platforms/timeouts are uncovered. No quiet-run restart, unchanged duplicate full build/replay, broad global helper rewrite or weakened timeout verdict. | Local production consumer | Positive evidence-based deadlines/owned process capture; timeout failure/only owned tree killed; one heavy owner Local\RMQLifecycleImplementationHeavy20260920 and one aggregate owner. | ODC Windows helper/tree barriers; runner identities/finally restore; root serializes heavy Lean/DLL/native/compiler work. | Cheap sleeper spawns child,deadline expires,both absent twice; forced setup/pin faults prove independent cleanup. No full semantic hang or quiet duplicate restart. | ODC3 PASS:inner8.093s root36368/child36440 absent;outerexit0 11.14s≤30; F120s/A-CL-NC120s unreached. Timeout -1 is sentinel, not ordinary exit. | Local candidate complete. Windows process-tree/deadline controls pass; battery sleep was diagnosed before focused recovery and complete retry. Other OS profiles remain uncovered. | +| N1-23 | Preserve all predecessor frozen rows, source/probe/registry/history bytes and producer identities. The private join creates new current ledger identities; do not run a historical producer's whole-checkout pin as though it described this new branch, rewrite old captures, or silently rebase old source paths. Establish reused source/evidence applicability explicitly. New final execution evidence binds its actual source; final report-sensitive checks bind final report/ledger/claim input bytes without recursive self-hashes. | Local production consumer | Preserve predecessor raw/Git rows/history/identities; current joins mint new ledgers. Reuse exact applicable sourcepins or disclose historical binary provenance. Final report inputs separately pinned without recursive self-hash. | Frozen contract/matrix→scope_check exact base inventory; user-approved exact five annotations exception; CC retained review/PREDECESSOR_DLL_REUSE; F/CL/A current DLL. | Historical scope3844raw/Git; current table55first3cells exact UTF8 against frozen. No immutable/historical capture rewritten; final current-tree scope/report checks are externally pinned. | Scope historical20260923T082034341 PASS; frozenSHA05b3435261d9b531837e5879b8c6390eb7b298ce4b61dc34e425ac48f5607ea3 unchanged; current N exact identities. | Local candidate complete. Exact-base preservation, approved exception, current applicability and final report-sensitive identities are certified by the external committed receipt. | +| N1-24 | Deliver a compact worked guide explaining input admission, actual builder/finalizer, READY transfer/repacking, one subsequent request and cleanup, with theorem names/types and ABI ownership diagrams or tables where useful. Add narrowly truthful family/digestion/native docs and DD/WDD decisions. Separate kernel facts, generated-code/FFI assumptions, measured native controls and unproved native performance. Complete the entire production consumer and its controls before candidate declaration; a route-ready probe is not the assigned endpoint. | Local production consumer | Worked guide covers admission→builder/finalizer→READY replace/take→next request→cleanup,typed contracts/state table; claims separate kernel/FFI/compiler/measurements/performance. | GUIDE/P/G/N/RC/NC/R→ledger→root REPORT; DD/WDD LIFE-NATIVE1 decisions/evidence order/thin route; all controls precede candidate declaration. | Review checks logical vs pointer equality,wholememory native copy cost,host bounds,oldDLL reuse,route marker limits,exact formal replay status; no route-ready endpoint substitution. | Guide/focused docs and55row reconstruction present; REPORT complete local candidate; final public/family/digestion/decision/claim bytes certified by the matching external delivery receipt. | Local candidate complete. Complete report, guide, matrix, public summaries, decisions and command/file indexes delivered; coordinator acceptance remains separate. | +| INV-STORE-IDENTITY | the exact payload/store executed is the payload/store
counted by the public space theorem; a theorem about a sibling payload is
insufficient; | Inherited at export/native boundary | B=Ownership.owner,B.toState=cr.final,B.memory entries/extent=mem; C(B) counts that same memory/regs/code/metadata; Q preserves incoming memory; Repacked gives exact owner equality. | P E02/E03/E06/E09/E12,Q01/Q05/Q10; Capstone ExecutedOwner uses identical owner for refinement,READY,capacity. | Export owner/projection/memory/capacity weakenings/siblings; NC copy/index corruption makes actual memory equality false. | L expanded exact consumers compile; F retained memory/capacity pass; current NC48 Replay8 intended copy rejects. | Local candidate complete. Same produced/counted/query store joined by checked contracts and fixed-object mutation consumers. | +| INV-VALUE-DEPENDENCY | returned values and routing decisions depend on
actual charged reads, not a semantic answer computed before the reads. When
the requirement concerns the returned answer or route, evidence must constrain
that value, state, or route; inequality of an enclosing trace record can be
satisfied by its log alone and is insufficient; | Inherited at export/native boundary | Returned packet comes from actual executeArray/runThin status; charged loads update registers used by routing/answer. Matched dynamic-read agreement constrains status/categories,not log alone. | G returned-calculation callgraph+P universal thin equality; inherited lifecycle_store_determinism: initial State.Agree and DynamicReadsAgree at same program/fuel⇒run Agree,equal status/orderedreads/allcategorycounts. | NC wrong-copy requires actual entry mismatch/rejection; fault/fuel actual status; RC branch/read context. No promised answer divergence for correct forbidden oracle. | G/F actual dependency/results pass; current NC48 Replay exact state/resource changes; inherited dynamic-read theorem remains guarded. | Local candidate complete. Returned route follows actual charged execution and Owner.status; compiler/FFI assumptions remain explicit. | +| INV-SEMANTIC-NONVACUITY | semantic coverage, liveness, ownership, and
refinement predicates are derived from the operational construction they
describe. A predicate defined to be `True`, an enumeration restated as
membership, or a separately hand-written consumer label does not establish
operational liveness by itself; | Inherited at export/native boundary | ExpectedReady expands canonical memory/extent,zero keys/keyRegs/extents,register bound/Fits and8273bank; actual halted packet/capacity derived from B,not assumed/True. | P E04 independent expanded ExpectedCanonical/ExpectedReady,E05/E09,Q03/Q04/Q10; export only D/query only QD. | Export weakening READY/answer/capacity to True and siblingowner rejects the fixed consumer after producer/descendant success in current full34 Discovery. | L independent exact consumer passes; EX34 all intended diagnostics independently reviewed/frozen; F and current NC48 operational READY checks. | Local candidate complete. Operational predicates are derived; full fixed-type mutation Replay rejects mandatory weakenings and sibling substitutions. | +| INV-TRACE-EXECUTION | traces and footprints are derived from the execution
they describe; | Inherited at export/native boundary | Ownership.observations.toRun=cr;queryArray.toRun=qr; native reads/categories fold actual transitions; indexed occurrence actual runprefix prestate+stepArray. | P E11/Q06/O01–O11 via runAcc/recordBefore/thin equality; Capstone construction/PhysicalRun shares continuousRun. | F pair comparison supplements independently typed folds; export observation recipes; RC positional addresses/replies. | L O consumers; F71pairedrequests/RC10480later reads; session first++queries,only querysuffix=query-only evidence. | Local candidate complete. Observation traces/folds and indexed prestates derive from actual transitions, with paired compiled evidence. | +| INV-STORE-AGREEMENT | supplied-store agreement determines result, cost, and
the relevant trace; | Inherited at export/native boundary | ∀model fuel s t,State.Agree s t→DynamicReadsAgree(Layout.program model)fuel s t→run Agree,equal final.status,equal ordered reads,∀category equal categoryCount. | Capstone lifecycle_store_determinism→run_agree_of_dynamic_reads same program/fuel; P B/Q projection+thin equality preserves actual exported run identity. | Inspect matched-step read guards and status/category conclusions; NC actual copied-entry challenge. Do not substitute whole-result equality as a read premise. | Inherited exact theorem source/imported current compiled closure; L/DLL pass. F tests particular canonical stores,not universal agreement. | Local candidate complete. Inherited guarded agreement composes at the supplied modeled store; no arbitrary foreign-store theorem is claimed. | +| INV-READ-BACKING | every successful read is backed positionally by the
counted store; | Inherited at export/native boundary | Indexed query read address<2^w,reply=mem[address]?,present value<2^w. Construction read uses its actual indexed producing prestate/Physical.lookup/checkedAddress with boundedphysical address. | P O09/O10 via actual query_array_refinement/Reusable.query_read_occurrence; Capstone PhysicalRun full continuous prefixes; E06/Q05 identifies counted query store. | RC actual ordered pairs checked against canonical memory/source interior segments; NC value/offset corruptions change entries,not just trace log. | L consumers; RC10480later pairs all backed,3288payload; evolving builder prestate not falsely replaced by final canonical memory. | Local candidate complete. Formal positional backing and all finite native read/reply occurrences checked against the counted store. | +| INV-WORD-WIDTH | stored and returned words fit one declared modeled
machine word; | Inherited at export/native boundary | One w=wordWidth n bounds numeric store/register/result/packet; canonical byte length from w. Comparison arbitrary Int keys are separately counted. | P ExpectedCanonical.Fits/Bpacket/Q-O10; Capstone safety/PhysicalRun same w; actual metadata n→native profile,noquery-dependent width. | Fwide/negative; Aprofile4096/endpoint malformed; NCwordoverflow2; export codec/admission weakening. | L types/F-A wide canonicalbytes pass; host count/magnitude ceilings explicit additional native bounds. | Local candidate complete. Declared modeled width and exact arbitrary-width packet/admission bridge preserved. | +| INV-ADDRESS-WIDTH | every executed address, dead/sentinel address, and
encoded instruction operand fits the modeled machine word, not merely the
host array bounds. Constructor-exhaustive evidence must include register
identifiers, branch/jump targets, dormant code, and arithmetic operands; | Inherited at export/native boundary | Capstone PrefixProfile each prefix/Transition.Safe; PhysicalRun bounds extent/values/checked physical+logical reads; uniform bounds every encodedProgram word including dormant operands. | Capstone continuousConstructionQuery_holds D→safety/physical/uniform via all_encoded_fields_fit; P actual B/cr,Q/qr+Ready Fits same w; inherited constructor-exhaustive safety unchanged. | Inspect primitive/layout/encoded-field proof,not only host bounds; RC actual addresses. Export mutation covers exported width/metadata,not exhaustive new mutation of all inherited constructors. | Current compiled closure retains safety/physical proofs; L/RC pass; dormant encoded operands covered by universal membership,not samples. | Local candidate complete. Inherited whole-field modeled-width chain preserved; no host-pointer-width theorem is claimed. | +| INV-INSTRUCTION-ATOMICITY | each modeled small step performs the familiar
primitive operation it advertises. A constructor whose evaluator body hides
recursion, a variable-length scan, repeated rank/select work, decoding, or
several arithmetic categories is a macro-step unless that work is expanded
into charged transitions or bounded by an explicitly accepted primitive; | Inherited at export/native boundary | runThin calls unchanged executeArray and equals runOwner ∀program/state/fuel; only observation packaging removed,not charged primitive work. | P T01–T07; G emitted actualcallee; protected instruction/layout unchanged; boundary4 and finite8271setup remain. | Inspect no substitute primitive/reference scan/old interpreter; H separates runtimecopies from ticks; final scope checks protected bytes except5approved annotations. | L universal consumers/G callgraph/H-F execute pass; native copy/arbitraryNat runtime work outside primitive ticks. | Local candidate complete. The thin adapter delegates unchanged executeArray; universal equality preserves primitive semantics. | +| INV-PROGRAM-ACCOUNTING | input-dependent constants and metadata carried by
executable code are counted machine data or are derived uniformly from
counted/public inputs. Calling shape-specialized data "program code" does
not remove it from the payload/state accounting obligation; | Inherited at export/native boundary | C(owner)=memory.size+encodedProgram.length+regs.size+8 at same w; cached program depends only model,not xs. | P E01/E09/Q10 expanded capacity→Ownership.capacity; Capstone uniform encoded wordsfit; N native code/global inventory separately. | Export program/capacity weakenings/siblings; G no input-specialized/per-query generated program. | L exact capacity consumer; N223371/223379 fixed program instruction-array entries,16829160bytegraph separately from owner and overlapping globals. | Local candidate complete. Exact fixed cached program equality and modeled/native code accounting are connected and separately labeled. | +| INV-ORACLE-INDEPENDENCE | executable fixtures and edge-case expected values
come from an independent specification or a theorem already connected to it,
never from the implementation result being tested; | Inherited at export/native boundary | Frozen expected answers derive independent scan/leftmost semantics; native state/control expectations independently reviewed after measurement,before Replay,not copied answer-as-oracle. | F independent reference→packets; NC fixedxs[3,-1,-1,7],range[0,4)⇒packet2 and exact canonical memory; frozen rootreview records each resource/state oracle. | Tie/invalid/wide; RC source/dynamiclabels; discovery-before-freeze explicitly retains skip-query nondist/sharedscalar accept. | Current F independent13 review passes. Historical NC48/R17 measured oracles preserved; fresh native48 exact projections and Rust17 complete diagnostic cases match them after reviewed provenance rebinding. EX34 complete diagnostics independently reviewed/frozen. | Local candidate complete. Reviewed reference/native/compiler oracles precede frozen expectations and current exact Replays. | +| INV-VALIDATION-REACH | executable validation imports and runs the new
semantic layer. A validator for the predecessor implementation is regression
evidence only and does not validate the new machine; | Inherited at export/native boundary | New consumer imports current Lifecycle/Observations/AdmissionContract; actual native clients link current generated DLL and return that runner status. | L→DLL5stage→client8stage→F/CL/A exact stagedbinary; G actualcallgraph distinguishes import from execution. | Focused current LN1-W-TIES bothmodes before full13; CL real three-language/error/reuse; oldDLL only compatibility background. | F26freshprocesses,CL10,A23 pass currentDLL03c17dd0fbacff8f72e707f40ba737096daf096059ace99ec7a0c9fd69c1772d with pins. | Local candidate complete. Focused Lean roots and actual current DLL/client campaigns reach the new lifecycle layer; default build separately checks regressions. | +| INV-ALL-SIZE | exactness covers all assigned sizes and edge cases without
hidden readiness or compatibility dispatch; | Inherited at export/native boundary | ∀model xs endpoints,InputDomain+represented endpoints⇒ExportContract; word requires InputFits,comparison no key bound; no readiness/n-threshold premise; invalid packet0+READY. | P U02/U03/E-Q→all-size Ownership/Continuous capstone; native finite host ceilings kept outside Lean conclusion. | F n0/1/2/4/24/83,invalid thenvalid; Ahostbounds; fixed consumers state complete hypotheses/guards. | L wrappers/types/F-A pass; empirical sizes not proof for alln. | Local candidate complete. All-size guarded source domain remains unchanged; finite host ceilings and fixture coverage are separate. | +| INV-PROOF-SEPARATION | proof-only fields never carry answers or uncharged
routing information; | Inherited at export/native boundary | InitialOwner/thin/executeArray/status carries operational arrays/scalars only; no proof answer/route; startup must not evaluate proof-only reference payload. | G initializers/returned closure; P erased proofs+actualproducer; approved5macro_inline remove expensive wrapper initialization without proposition change. | Actual initializedglobals/callees rather than imports; Sstartup/H-Fexecute; original discovered defect documented. | G exact hashes/lines,S5.4340775s; no owner xs/trace closure; optional observations separate. | Local candidate complete. Compiled closure/startup checked under the approved annotation exception; compiler erasure remains trusted. | +| INV-NO-SYNTHETIC | synthetic events, decorative rereads, and post-hoc replay
do not support the execution claim; | Inherited at export/native boundary | Stats/receipts fold actual primitive transitions; occurrence has runprefix prestate and producing step; route labels need source semantics beyond instruction marker. | P O01–O11/T/recordBefore; G observedrunner; RC source signatures+ordered actualpayload addresses/replies. | Marker11 not actualpayload count; nonunique crossingload requires context; pairedfinal equality not used alone to justify folds. | L separate folds,Fpairs,RC10480laterreads/interior occurrence joins pass. | Local candidate complete. Actual transition/read/return evidence supports the claim; no decorative or reconstructed reference trace substitutes for execution. | +| INV-CATEGORY-SEPARATION | payload bits, proof fields, model ticks, machine
state, Lean runtime, and measured performance remain distinct. | Inherited at export/native boundary | Modelwords/bits,proofs,ticks/categories,nativecontainers/scalars/code/globals,GMP andwalltime distinct; conversion/init/repack/observation not inside160257ticks. | P capacity/steps/folds→N resource table→GUIDE/report assumptions. | Fmodepairs/NCskip-query show same result with different physical copy; avoid adding overlapping code+globals; requested≠usable/RSS. | N4exactarrays,8273+Mentrycopy/publication,graph overlap,GMP16; H hooks limited to emitted-C copy calls. | Local candidate complete. Modeled payload/ticks, native storage/copies, code, diagnostics and measured time remain distinct. | +| INV-PUBLIC-COMPOSITION | a theorem combining space, exactness, cost,
provenance, or machine claims proves them about the same construction and
execution and over the same validity domain. Conjoining true theorems about
different payloads or guarded and unguarded executions is not closure. | Inherited at export/native boundary | All owner/memory/guardedpacket/capacity/observations/metadata fields concern same model/xs/endpoints; continuation same incomingREADY/haltedowner andrepresentedendpoints. | P E01–E13/Q01–Q11,E12/B bridge; Capstone construction/physical/safety/executable/reusable/uniform same continuousRun/w. | Export siblings/weakening/deletion must break consumer; invalidE13/Q11 READY+halted0,not unconditional rawvalid adequacy. | L fixedconsumer; F invalid/reversed/out-of-bounds thenvalid; P exactfield/hypothesis tables. | Local candidate complete. Same objects and guards compose throughout exports, continuation and fixed-type consumers; complete anti-bypass Replay passes. | +| INV-CERTIFICATE-ANTI-BYPASS | every mandatory field advertised by a public
certificate is projected by a checked typed consumer at the exact proposition
and object arguments required by the acceptance contract. Deleting or
weakening a field, or replacing it with a sibling fact, must break that
consumer rather than leave only constructor initializers and prose unchanged. | Inherited at export/native boundary | All23mandatory fields independently projected at exact expectedobjects/types; B/O/T extra consumers; producer compile success required before rejection counts. | P E/Q table+LifecycleNativeContract→frozen EXPORT_MUTATIONS34→intended theorem/range/type diagnostics. | 23 weakenings/2 deletions/4 siblings/2 accepts/3 codecs all executed in current full34 Discovery; EXC15 real diagnostic/selector/deadline holdouts. Discovery is distinct from exact frozen Replay. | L consumer/EXC15 pass; EX34 32 intended rejects/2 accepts,50 diagnostics,5618pins and cleanup; all diagnostics independently reviewed and EXPORT_DIAGNOSTICS frozen. | Local candidate complete. All 34 exact cases replay: 32 intended rejections after producer success and two accepts; axiom inventory is additional evidence. | +| INV-MUTATION-REPRODUCIBILITY | when acceptance relies on an exhaustive,
production, or public-dependency mutation campaign, the candidate contains a
versioned runner or fixtures that replay every claimed case, check the exact
expected failure/acceptance surface, restore tracked state, and leave the tree
clean. Report prose, copied terminal output, and dangling Git objects are not
replayable evidence. A public theorem additionally has a checked exact-type
consumer that fails when the advertised dependency is removed; `#print
axioms` over the theorem's current type is not such a consumer. | Inherited at export/native boundary | Versioned orderedrecipes/accept-reject/verdictsurfaces/finallyintegrity-cleanup; final delivery commits replayable files and exact identity. | EXPORT34/NATIVE48/RUST17+callercontrols→rawactual receipts; frozen expectations distinct from discoverycandidate. | R15reject2accept; NC4accept1nondist43reject measured/reviewed before freeze; exportproducer thenclient; ODCsetup/pin challenges. | Current R17 Replay112pins and NC48 Replay7638pins pass exact unchanged reviewed cases/projections. EX34 Discovery/review/freeze passes; all actual restoration/cleanup retained. Current selector/recipe controls pass. | Local candidate complete. Literal cases, complete mappings, expected diagnostics and replay runners are committed; final clean identity is externally pinned. | +| INV-GLOBAL-PHYSICAL-MACHINE | a physical-machine claim supplies one
pre-execution store/word array and a checked address translation for every
executed segment, including failed/dead accesses. A theorem for one suffix or
component is not a whole-machine embedding. | Inherited at export/native boundary | PhysicalRun covers every continuous prefix boundedextent/lookup; indexedread actual runprestate+checkedtranslation+backedvalue; fetchedencoding backed by codeaddress. | Capstone D→PhysicalRun/safety/uniform; initialState common preexecutionmachine evolves through imageTrace; P B/cr,Q/qr preserve sourceobject. | Inspect builder/finalizer/query coverage; RC laterread suffix not substituted for wholemachine proof; dead/failed/encoded operands covered inherited safety/Fits/uniform. | Current compiled inherited physicalclosure/Lrefinement; E06/Q05 canonicalquerystore counted; no additional uncounted readstore. | Local candidate complete. Inherited whole-machine modeled embedding preserved; native pointer/runtime layout remains a separate trusted boundary. | +| INV-WIDTH-SCALING | one query-independent word-width declaration bounds all
stored words, addresses, sentinels, operands, and primitive results, and its
capacity/width is related to input size in the form required by the public
word-RAM claim. A standalone asymptotic fact about an unconstrained width
function is insufficient. | Inherited at export/native boundary | Same w=wordWidth n obeys log2(n+2)+1≤w≤192*(log2(n+2)+1); all codewords<2^w; C(B)*w≤2n+rho with LittleOLinear rho; Q same bound. | Capstone uniform+ExecutedOwner/ReusableOwner at same n/model; P E09/Q10actualcapacity/E01program; producedmetadata fixes n independent of query. | Siblingcapacity/program challenges; F/A profiles incln4096w240 do not replace allsize proof. | L export/inheriteduniform compile; N separates nativebytes and comparisonkeys; no unconstrainedfreewidth. | Local candidate complete. Inherited query-independent logarithmic width and complete same-owner capacity chain preserved. | +| CHK-SCOPE | exact base, branch, allowed paths, complete raw/Git identities, immutable prior matrix/history and clean committed candidate verified; both design ledgers and new import/consumer references close transitive scope. No broad .gitattributes/configuration/policy allowance. | Verification/process | Final exact base3dbdebedcc6ba6b2a864df0d46dcc09ccaaa7536/branch/allowedpaths/3844rawGit/frozen55/bothledgers/importclosure/cleancommit must pass. | scope_check exactbase inventory+approved5annotation patch; governance7b227c49ef2ec044b702126cc41c9add847eed01 skillpreflight passed; root final_checks/commit. | Frozenhash/per-rowUTF8 reject preservation drift; no broadconfig/policy allowance; finalcheck restricts protected exception exactly. | Historicalscope20260923T082034341 PASS; current55first3cells/frozenhash verified below; tree intentionally uncommitted during finalwork. | Local candidate complete. Final exact-base scope, full frozen-row/raw-Git preservation, strict design and clean committed identity are pinned externally. | +| CHK-LEAN | focused new roots and independent export contract compile, their axiom inventories retain the permitted Lean/Std trust base, all required exact-type mutations replay at the intended client, and one final default lake build passes after implementation changes. No sorry/admit/axiom/native_decide/Lean.ofReduceBool or new unsafe/extern/implemented_by theorem shortcuts; legitimate existing runtime/FFI trust is documented. | Verification/process | Current narrowroots/consumer,21rootaxioms,34requiredmutations and onefinaldefault build must pass permitted Lean/Std trustbase without new shortcuts. | L4roots→export34→AX21 exact inventory→DB final default build; root finalhygiene/scope. | Producer-success/intended-client-failure controls; hygiene distinguishes existingruntimeunsafe/extern from forbidden theoremshortcut. | L actualexit0/5979pins; EXC15 and EX34 Discovery/review/freeze pass; AX21 Discovery/review/freeze passes21 diagnostics/5604pins. DB actual lake build passed374 jobs,ordinary0,empty stderr,6056pins,cleanup; root reviewed all16 raw capture pins. | Local candidate complete. Four focused roots, complete 34-case Replay, exact 21-root axiom Replay, default build and final hygiene pass. | +| CHK-NATIVE | bounded startup, one exact selector, then complete frozen actual new-native registry and C/Rust/C++ consumers pass on frozen producing source with owned exits/streams/identities/capacity/failure controls. Preserve exact counts and attempted negative types; do not confuse components, retained captures and fresh actual native processes. | Verification/process | Boundedstartup→focus→full13fixtures/10clients/23ABI/48controls plus17Rustcompile bind actualsource/exits/streams/predicates/cleanup. | S→focusLN1-W-TIES→F+independentreview; DLL/client→CL/A; NC48Discovery→review/freeze→Replay; R17Replay. | SC/CC/EC/RS realbinders/ODCtermination; NC state/resource faults with exactaccept/nondist/reject; distinguishfreshprocesses/retainedreview/Plan. | Current S,F26processes142requests,CL10,A23,corrected NC48 Replay and current-source R17 Replay pass. NC48 independent review verifies all48 projections/7638 pins; Rust17 preserves15 intended rejects/2accepts/112pins. ABI23 report differs from fixturecount0. | Local candidate complete. Fresh producers/startup/13 fixtures/10 clients/23 ABI cases plus complete native48 and Rust17 Replay pass on the pinned Windows profile. | +| CHK-REPORT | complete durable report/matrix/guide exist and final committed git diff --check plus strict exact-base design certification and unchanged-policy strict changed-surface claim checks cover the final prose/code/ledger inputs. Final HEAD, report bytes/hash, source commits, actual commands/results and applicability of reused evidence are separately pinned in an external delivery receipt. | Verification/process | Final report/matrix/guide/publicdocs/ledgers; strict unchanged-policy changedsurfaceclaims/design -Strict -Base exact40charbase; committed diffcheck/externaldelivery finalHEAD/prose/sourcepins. | RootREPORT/final_checks→exactbase scope/design/claims/whitespace→commit→externalreceipt; matrixrequirementbytes frozen. | Gates must bind finalprose/code/ledger; strictnoBase cannot count as zerochanges; preservepolicy/history. | Guide/evidencedocs/55rows present; REPORT complete; final committed report hash, external receipt and strict final verdict are pinned externally. | Local candidate complete. Final prose/code/ledger bytes, unchanged-policy strict claim coverage, strict design and committed whitespace are externally certified. | +| REPLAY-EXACT-REGISTRY | a replay harness must declare the exact ordered
frozen case registry, reject missing or duplicate IDs, verify any ID-to-field
or ID-to-object mapping, and check exact verdict counts; a total pass count
alone is insufficient. | Verification/process | Full orderedID→handler/verdict mapping/count checked; missing/duplicate/reorderedmiddle/mapping drift reject before semanticdispatch. | SC13fixtures/CC10clients/EC48native/EXC34export/RS17Rust→frozenregistries; actualreports matchedIDs/argv/projections,notpasstats. | Actualcaller missing/dup/reorderedmiddle/handler/verdict controls; hashrejection meansmappingintegrity,not more-specificclassifier verdict. | SC33/CC13/EC18/EXC15/RS15/NR11 pass; current F13/CL10/A23/R17/NC48 and EX34 Discovery exact actual dispatch reviewed. Corrected NC-focus exactly1; complete current NC48 recipe includes all6013 unique pins. | Local candidate complete. Every complete ordered native48/Rust17/export34 roster and independently frozen mapping is checked; no partial roster earns completion. | +| REPLAY-SELECTOR-NONVACUITY | focused selection must execute exactly one
requested frozen ID and must reject unknown IDs. Add cheap named controls for
an omitted middle ID, duplicated middle ID, valid frozen ID, and unknown ID.
Distinguish an omitted selector parameter from an explicitly bound empty or
whitespace value at the real script boundary; only omission may select the
full registry when the frozen contract permits that mode. | Verification/process | Only parameteromission may selectfull; boundempty/null/whitespace/unknown/duplicate reject; knownfocus exactlyone; invalidselection no semanticchild/outputmutation. | Five realrunnerbinder controlreceipts; CC historicalreuse rechecks36sourcepins/104rawcaptures. | Actualmissing/duplicate-middle,known/unknown,omitted/boundempty/null plusInt32 binderedges; focusedPlan distinguishedfromactualsemanticfocus. | All current cheap controls pass; actual F LN1-W-TIES and corrected NC-NONE-BUILD each exactly1. Current F/CL/R17/NC48 and EX34 Discovery orders match. | Local candidate complete. Actual omission/focus/null/empty/unknown/duplicate/ordinal-edge callers and complete semantic selection pass. | +| REPLAY-SUBPROCESS-DEADLINE | every external compiler/tool stage in a replay
harness must have a positive evidence-based deadline, classify timeout as
failure, terminate its owned process tree, and run cleanup plus live-tree
integrity checks in `finally`. Implement and exercise owned-tree termination
on every operating system that runs the required gate. Add a cheap sleeper
self-test that spawns a descendant and proves both root and child are absent;
do not discover this control by hanging the full semantic campaign.
- When ordered dynamic-read agreement is primary and safe-footprint agreement
is a corollary, prove the read-region/segment containment bridge directly
from execution or program structure. It must not invoke the legacy safe
complete-result equality before reaching the ordered-dynamic theorem.
- If a public wrapper guards valid inputs, ensure every combined field uses the
same guard/domain. Raw adequacy may occur only under the valid-range premise
or in a guarded packet with matching invalid semantics; a bridge theorem does
not justify leaving raw adequacy unconditional in the same public record.
Test invalid, reversed, and out-of-bounds cases.
- For a whole physical-machine claim, cover every read-producing segment in one
pre-execution word array and relate its query-independent width/capacity to
input size. A component slice or unconstrained little-o width fact is not
enough.
- For classifier/linter work, treat named mutation fixtures as lower bounds,
not the acceptance boundary. Freeze the category being classified; add
category-level holdouts and allowance-bypass mutations; and exercise the
production final verdict, including strictness, path/line context, focused
single-file input, and absolute-path normalization where supported. Do not
validate a copied detector in place of the production classifier.
- Strict branch certification with scripts/design_decision_check.ps1 must use
-Strict -Base followed by the task's exact 40-character base commit.
Omitting -Base is a production failure, not a clean zero-change result.
Reserve the no-Base form for deliberate non-strict local-worktree advice. | Verification/process | Owned positive deadlines/finally cleanup; direct read containment, matching guards, wholemachine/width and strict exact-base design. Conditional classifier obligations apply to added output-language/diagnostic validators; unchanged claim-scanner policy is consumed by the final gate. | ODC helper; P O09/O10 occurrence→Reusable.query_read_occurrence; E13/Q11; CapstonePhysicalRun/uniform; EXC actual diagnostic validator; FS actual component-language validator; root production strict claim/design calls. | ODC sleeper root+child absent/setup-pin faults; SC UTF8/overflow; EXC diagnostic holdouts; FS15 fresh byte-emitter categories and five actual mapping callers exercise the actual validators. Supported input contexts only; these do not claim production claim-policy mutation coverage. | ODC3/SC33/EXC15/FS15 and five FS mapping controls pass on Windows; directread/guardproof/F invalidcases pass. O10 reaches occurrence without legacy safe complete-result equality. Final unchanged claim scanner -Strict -IncludeProcessRecords over complete changed roster and design -Strict -Base 3dbdebedcc6ba6b2a864df0d46dcc09ccaaa7536 remain required. | Local candidate complete. Owned-process and added-validator controls pass; actual strict production claim/design calls are separately certified. Other OS profiles remain uncovered. | +| FROZEN-ACCEPTANCE-ROW-BYTE-INTEGRITY | when a prompt says inherited matrix
rows are frozen, verbatim, or byte-for-byte preserved, validate that claim
before any expensive verification. Decode the exact base blob and candidate
file as strict UTF-8, extract the complete frozen row for every inherited
stable ID, reject missing or duplicate IDs, and require exact UTF-8 byte
equality for each row. A row count, normalized text comparison, visual review,
or a read/write round trip through a locale-sensitive shell is insufficient.
Also reject recognizable mojibake such as `¬` or `“...”`, but treat that scan
only as a negative control: absence of those spellings does not replace exact
row equality. Record the base ref, candidate ref, inherited-ID count, and exact
changed IDs in the evidence ledger. | Verification/process | StrictUTF8 exactbase/candidate predecessorrows equalbystableID,noomission/duplicate; mutabletable ID/requirement/scope cells equalfrozen55. Mojibake negative scan supplementary. | Immutable frozenmatrix/contract→baseinventory/scopechecker; thisedit retainsfirst3cellstrings directly; rootfinalcommittedbasecomparison pinned externally. | Before/after55ordereduniqueIDs,8cells,first3UTF8byteequality andfrozenhash; changedimmutableIDs=[]; no localecollation/reflow. | FrozenSHA05b3435261d9b531837e5879b8c6390eb7b298ce4b61dc34e425ac48f5607ea3 unchanged; all55first3celltuples match; historicalbaseinventorypass; finalcommit pinned in external delivery receipt. | Local candidate complete. All 55 local immutable tuples remain byte-exact; complete predecessor/raw-Git preservation is certified at the exact committed candidate. | +| NAMED-REGRESSION-REALITY | before a prompt requires an immutable negative
fixture to fail, the coordinator must independently reproduce that failure
from the exact objects with the same decoder, predicate, guards, and
quantifiers required in the prompt. Record the observed result. A mixed-
decoder transcript, worker narrative, or unverified inference cannot become
a mandatory negative control. | Verification/process | Mandatorynegative requires independent reproduction atexactdecoder/predicate/object/guards; nondistinguishing controls disclosed. | Historical NC48 Discovery→independent486pin/projectionreview→unchanged frozenoracles→current full-recipe rebind→NC48 Replay/independent6500-input review. Historical R17 diagnostics→current Discovery/equal17cases→rebind→Replay. EX34 Discovery→independent review→frozen diagnostics. | Skip-query measuredsuccess exactcapacity0copies; sharedscalarvalidaccept; forbiddenroots/copies actualstatepredicatechanges; no imaginary oracleanswernegative. | Current NC48 reproduces4accept/1nondist/43reject with each state/resource oracle separately checked. Current R17 reproduces all17 unchanged diagnostics/verdicts. EX34 intended diagnostics independently reviewed/frozen; no old whole-checkout pin asserted current. | Local candidate complete. All named negative and expected-accept outcomes have actual reviewed same-predicate measurements and exact current Replay. | +| ARCH-LIFECYCLE-ACYCLIC-EVIDENCE-ORDER | before launch, write the task's
evidence and decision order explicitly. Separate owner choices that genuinely
gate evidence collection from choices whose justification depends on that
evidence. An output-dependent decision cannot be a prerequisite for launching
the task that produces its evidence. Review the order as a dependency DAG:
every producer must precede its consumers, and any cycle makes the prompt
`DRAFT_DO_NOT_SEND` until the lifecycle is repaired. Preserve legitimate
two-phase architecture governance: approve scope, model, and acceptance gates
before a spike; choose the route or successor matrix only after the spike
results exist. | Verification/process | Scope/model/acceptance freeze beforeimplementation; measured route/copy/diagnostics before dependentdecision/exactexpectationfreeze; Replay/certificationafterproducers. | Frozencontract/approvedamendment→boundedinitializer-copyevidence→thin decision→currentDLL/fixtures/controls→review/freeze→Replay→finalsource/prosechecks. | Historical NC oracles preserve skip-query/sharedscalar classifications. Corrected recipe independently reconstructed before provenance rebind/current full Replay; independent Replay review follows. Current R17 Discovery matched all17 prior cases before rebind/Replay. EX34/AX21 discovered then independently reviewed/frozen; no output-dependent decision gates its own producer. | CONTINUITY/DD/WDD and P/N/NC receiptchronology recordorder; originalfreezeimmutable; explicituserexception; finalgates consume concrete receipts. | Local candidate complete. Frozen contract and authorized exception precede implementation; actual measurements precede review/freeze/Replay and final committed certification. | + +Append detailed evidence keyed by the exact IDs below. Preserve exact requirement cells and order. Only the coordinator records ACCEPTED. + + +## Proposition notation and exact evidence key + +P is [PROOF_EVIDENCE.md](PROOF_EVIDENCE.md), including its exact proposition/consumer tables. Let n=xs.length, w=PackedWordRAM.wordWidth n, mem=PackedWordRAM.buildMemory xs, packet l r=PackedWordRAM.optionNatPacket (SuccinctClassic.queryTraceResult xs l r).value, B=Lifecycle.buildFirst model xs left right, Q=Lifecycle.query model left right owner, cr=Continuous.continuousRun model xs left right, and qr=Reusable.queryRun model left right owner.toState. D is exactly InputDomain model xs and both endpoints<2^w. QD is exactly Ownership.Ready xs owner, owner.status=.halted answer, and both endpoints<2^w. No final memory/answer equality is assumed. Invalid represented ranges retain READY and guarded packet0. + +C(owner)=owner.memory.size+(encodedProgram model).length+owner.regs.size+8, independently expanded by the consumer. ExpectedReady expands bank8273 and ExpectedCanonical: canonical memory/extent, empty key function, zero key-register function, both key extents0, numeric registers beyond8272 zero, and Fits w. ArrayCopy means equal sizes and every in-bounds entry equal. Repacked is all four ArrayCopy relations plus equal pc/status; it implies owner equality and transports state/status/READY/capacity/query. It is not pointer equality. + +The unchanged inherited `RMQ/Core/WordRAM/Lifecycle/Capstone.lean` connects ConstructionChain, ExecutedOwner, ReusableOwner, PhysicalRun and ContinuousConstructionQuery on the same continuousRun. PhysicalRun uses the actual evolving prestate at every indexed read/fetch; canonical final query memory is not substituted for builder memory. lifecycle_store_determinism requires State.Agree and matched DynamicReadsAgree at the same Layout.program/fuel and concludes run agreement, status, ordered reads and every category count. The uniform field combines LittleOLinear retainedRho, logarithmic lower/upper bounds for the same wordWidth n, and all encoded instruction words' fit. Current B/Q refinements preserve these inherited objects. Compiler correctness, C ownership preconditions, runtime allocation and foreign implementation remain explicit assumptions. + +All receipt paths below are relative to `.lake/lifecycle-native1/`. Exact source/tool/artifact/capture identities and cleanup details are retained in each receipt and linked focused evidence. A retained receipt, read-only review, cheap Plan control and fresh semantic execution are distinct evidence types. + +- **L:** current four-root compile `runs/build-20260927T062313663/RESULT.json` SHA256 `c68286c3166128c0794f8ad9f790c37da7687f62d6a873a0dab4d3cd3eee99b1`: actual exit0,5979pins,cleanup; cached Lean stage0.890s,overall44.741s. Independent `RMQ/Validation/LifecycleNativeContract.lean` consumes E01–E13,Q01–Q11,U02/U03,B01–B18,O01–O11,T01–T07 at the exact propositions in P. Earlier043334915/043614629 compiles remain historical checkpoints. +- **G:** [COMPILED_ROUTE_EVIDENCE.md](COMPILED_ROUTE_EVIDENCE.md), exact emitted/source C hashes/lines, field inventory, actual returned callees, initializers and release sites. [STARTUP_AMENDMENT.md](STARTUP_AMENDMENT.md) records the explicit user authorization for exactly five protected-file macro_inline annotations. +- **N / DLL:** [NATIVE_EXECUTION_EVIDENCE.md](NATIVE_EXECUTION_EVIDENCE.md); DLL `runs/build-20260927T063830290/RESULT.json` SHA256 `77984ad82686ce42a69e779ee2da5f4c81c1c07fce6947380056e9e2cb8f74eb`; clients `runs/build-20260927T064222779/RESULT.json` SHA256 `6dd359050473a2604ab6370ef65813ba90ef0f3b4acd3ffaa776a08118caf699`. Five/eight stages actual exit0,7091/7143pins. Production DLL `03c17dd0fbacff8f72e707f40ba737096daf096059ace99ec7a0c9fd69c1772d`; testing DLL `160f2b9e0beb5d25de80d3852608d5f5bb8309a860c3faee6da9c90c92736218`. Lean4.22/tool/runtime/transitive closure bound by receipts; current365-module root derivation review is linked in G/N. +- **S / H:** current startup `replay/20260927T064556967-9557393a/RESULT.json` SHA256 `bbbea35884980851f3bbe2b538929c245b7b7f0ef2444a8a05f50aec880c2fe3` (5.4340775s,7154pins). Historical fuel100 `replay/20260927T045020119-a225cb45/RESULT.json` measured expected status8,empty outputs,1copy8273cells,no expansion; it was not rerun for the current recipe and is not successful construction. Historical pre-thin69copies570837cells is comparison evidence. First-write attribution remains source inference. +- **F:** current focused `replay/20260927T064716438-5960f47b/RESULT.json` SHA256 `11d9b8279c8701a76b8fd6d0763af0c6a73176017f42f99c807500e678ceb7f9`; full13 `replay/20260927T064849543-b1d28b93/RESULT.json` SHA256 `02060b1e4615bcb812bafff8794341271257eb447625dcfdcd62b7a319b36493`. 26freshprocesses142requests,6.8472172–8.1477043s,7192pins,cleanup. Independent `native-refresh-review/secondary-20260927/FIXTURE_REVIEW.json` SHA256 `bbeb482b4a3b12a11f07c294de4158754ef172ad972554826393728272dac1c7` preserves all nonpointer values and validated address relationships. **RC:** [ROUTE_COVERAGE_EVIDENCE.md](ROUTE_COVERAGE_EVIDENCE.md), exact source/signature/dynamic occurrence joins and counter limits. +- **CL:** current `clients/20260927T065517097-e55bf689/RESULT.json` SHA256 `769cd0530d4f69667cd49288963482fbf8678c74dc4ebd1e206c56896b5c3d34`;10actual clients ordinary exit0/exactstreams,0.1209255–2.6918382s,7292pins,cleanup/path/error restoration true/liveRestorationWrites0. Independent `native-refresh-review/secondary-20260927/NATIVE_SEMANTIC_REVIEW.json` SHA256 `6eafcedf3878f591daf7a4dad73fa5a798f22b4e386942bc69da9b2c96ac8eba`. [PREDECESSOR_DLL_REUSE.md](PREDECESSOR_DLL_REUSE.md) pins historical conflict binaries and limited source applicability; no fresh predecessor build claimed. +- **A:** current `replay/20260927T065401229-f97e3be7/RESULT.json` SHA256 `166cc9a094bb54e9d08600182e7bf856cc2116d8262f104701015e747ef16f9b`; `abi-boundaries.json` SHA256 `84b8cb2b305780f758ab77228fc78530256bce043b64b7b504a5c3f2b5d8ed7c`, byte-equal to historical report.23exact cases in one2.6355578s actual process,7154pins/cleanup;4success,14malformed,4resource,1wrong-thread. Separate fixture count0 is not ABI count0. +- **NC / EC / NR:** current complete Replay `native-controls/20260927T073240346-3c38ea74/RESULT.json` SHA256 `a4545cfc2df8cfde3e92d27c4d7f6cc59c67946dbdae939d3e5c4739d60754e4` passes exactordered48,7638pins,zero live source writes and independent cleanup/PATH/error-mode/mutex restoration. Counts4accept/1nondistinguishing/17publication-reject/17operation-reject/6prebuild/3pretransfer. Frozen `NATIVE_EXPECTATIONS.json` SHA256 `e67348c7e631fb7facbd9b580a44d1b42729e9db0526a5ac09a2b804143e5466`; unchanged complete48 cases canonical SHA256 `5697ab0c52c768001620aeda4ab5c4363c66c8e1d1d2f116d3140ab1c4d00ba9`. Independent `native-control-independent-review/20260927T073240346-3c38ea74/REVIEW.json` SHA256 `39c6f5155edcf143b5b4a85884c5f6a96c39d5efa27bee60846ee52802de4f2f` compares every full projection/exact stream/ordinary exit and rehashes every final pin (6500 distinct review inputs), preserving all integers. Reconstructed recipe `494eadb41c09ba18e4d27d84eec77d12a0c220abf04b817b6f1b42a839a83791` binds7148 source/6013 unique/1135 duplicate pins. Corrected **NC-focus** `native-controls/20260927T072450429-92e7bea9/RESULT.json` ran exactly NC-NONE-BUILD first. Mapping `ea90bd61fb7d226210aa47b3afd38cbca8953debaf3246c238a5785b20e69f2d` unchanged. **EC18** `control-selector-controls/20260927T070655548-bc3d2d0d/RESULT.json` (87pins) and **NR11** `native-recipe-controls/20260927T071017981-3341822f/RESULT.json` (18pins) pass. [NATIVE_CONTROL_EVIDENCE.md](NATIVE_CONTROL_EVIDENCE.md) and [NATIVE_REFRESH_EVIDENCE.md](NATIVE_REFRESH_EVIDENCE.md) retain historical48 Discovery051058239-1758cc65 and Replay052620110-f51e89eb: reviewed measurements remain oracle provenance, but their old fingerprint covered only the first runner pin. Current full-recipe Replay supplies fresh execution closure. Generation-local counters are not a global live-reference census. +- **R / RS:** current Discovery `rust-misuse/20260927T072740867/RESULT.json` SHA256 `b7fae4e0276428c4bf33dbce9c2ff2ae35dc965bb70424defb559f8bf24393eb` matches all17 complete historical diagnostic cases; root rechecks111source/tool/fixture pins and144raw captures before provenance rebinding. Frozen `RUST_DIAGNOSTICS.json` SHA256 `985835ed2ac39483dae006c327f656a0fd92546d60c91ef97122f67b6d795141`, unchanged17cases canonical SHA256 `9d686c79df9b519227035fd9051dcd79e3b4d9a3b55ba8bf216cef4d9290ed26`. Current Replay `rust-misuse/20260927T073749082/RESULT.json` SHA256 `921ceca64185a1ed5950ec219ed5ff3c0c3451bdd14c6507205f71af38844f5d` passes exactordered17,15intended rejects/2accepts,full raw streams/ordinary exits,112pins,cleanup/mutex. Current fingerprint `12c2881f6c9b5a08698a2a8d29054adf11a3c1e5175a2b0a5f1ef862eefd6a58`; mapping `8c5f71775d51a892b23267b79ddf60982b77bdb1174ca83ee7efe0e977ec7de6` unchanged. [RUST_MISUSE_EVIDENCE.md](RUST_MISUSE_EVIDENCE.md) retains historical Discovery050848252 and Replay051519397 as original diagnostic provenance. Current **RS15** caller controls `rust-selector-controls/20260927T063015001/RESULT.json` pass. Rust recipe retains all93 source/tool rows in the runtime-produced permutation and is order-sensitive; neither insertion order nor canonical path sorting is claimed. +- **SC / CC:** [NATIVE_SELECTOR_CONTROL_EVIDENCE.md](NATIVE_SELECTOR_CONTROL_EVIDENCE.md), current **SC33** `selector-controls/20260927T063333385-e85600e9/RESULT.json` (10pins), including nine new actual caller ordinal-boundary holdouts. [NATIVE_CLIENT_SELECTOR_EVIDENCE.md](NATIVE_CLIENT_SELECTOR_EVIDENCE.md), retained **CC13** `client-selector-controls/20260923T093748354-584c85f0/RESULT.json` SHA256 `60ed495d2249a487c889fe314ee24eac040dd8cb544d85afc70f6edb5c036107` plus `REVIEW-20260926.json` rechecking36applicable sourcepins/104raw captures. Caller controls execute no Lean/native semantics; unchanged consumed source pins establish retained applicability. +- **EXC / EX34:** P mutation section; current **EXC15** caller/diagnostic/deadline controls `export-mutations/20260927T062447298-5d548bf4/RESULT.json` pass. Registry SHA256 `15034dc9ce6e6077d27487bc4dddd7990cef6b39c66de39dff2d9be8a6825660`; unchanged fixed consumer `4075aa30a3587995091debe002aea8ca0b111dddbf210082f0e9a019fd6314c2`. Full34 Discovery `export-mutations/20260927T070116393-4514a722/RESULT.json` SHA256 `a17d0f53da280bd5b827a41a43e739ad63f526c0b1cbde412a603c08cbf42ea0` passes exactordered34,66clean producer/descendant stages,32 intended rejects/2accepts,50diagnostic objects,5618pins,zero restoration writes,shadow/mutex cleanup. Independent first25 review `export-independent-review/20260927T070116393-first25/REVIEW.json` SHA256 `5a0246223fcb1c09f66df046c416c336563e737761b9fced9ef5e7ef8219b6e1` plus root last9 comparison underlie frozen `EXPORT_DIAGNOSTICS.json` SHA256 `8688e2089ff225de19b741327af451eef2c019f0997e4652dfccecd181b0c542`. Signature-freeze line hints remain historical coordinates; actual source ranges/exact signatures/raw positions govern diagnostics. Complete exact Replay passes; final receipt is indexed in EX34-FINAL below. +- **AX21:** `axioms/20260927T072200262/RESULT.json` SHA256 `2c2c431209356be1e8df87c8a74d7da276b3531dde0e28ceb227cf1d2801250a`;21 exact informational diagnostics,ordinary exit0 in34.811s,6693stdout bytes,empty stderr,5604pins,zero restoration writes,shadow/environment/mutex cleanup. Root reviewed all sets and froze `AXIOMS.json` (17615bytes) SHA256 `a9b0ffcd5c9527d18936d2f76a6afc4964d517c47743e895f86a1c6a59d78895`. Observed sets are subsets of {propext,Quot.sound,Classical.choice}; complete exact Replay passes; final receipt is indexed in AX21-FINAL below. +- **DB:** final default `lake build` at `default-build/20260927T074010540/RESULT.json`,1547952bytes,SHA256 `3b4a40505c289403d28c71520a57c112a1a573ea7196ed13e31c1af8bf5a1eaf`, passes374 default jobs,actual207.869s/overall248.640s,ordinary exit0 and empty stderr. Integrity checks6056pins:1183sources,4856tools,host and16raw capture pins; cleanup/mutex passes. Root independently rehashed all16raw captures. This is the required final default build, separate from completed formal exact Replay and report-sensitive certification. +- **FS:** current15 actual component-language controls `final-stream-controls/20260927T064348259-8b9ba5b5/RESULT.json` (4accepts/11rejects,161pins), plus five actual mapping callers in [FINAL_STREAM_MAPPING_EVIDENCE.md](FINAL_STREAM_MAPPING_EVIDENCE.md). They invoke the actual added stream validator with fresh byte emitters; unchanged production claim/design checker runs are separate final authority. +- **ODC:** [OWNED_DESCENDANT_CONTROL_EVIDENCE.md](OWNED_DESCENDANT_CONTROL_EVIDENCE.md),3controls `owned-controls/20260923T091922860-5b5f618f/RESULT.json`: Windows descendant timeout and2partialsetup/finally controls with retained source applicability; root/child absent twice. Other platforms uncovered. + +- **EX34-FINAL:** `export-mutations/20260927T084110803-e9431c50/RESULT.json`, SHA256 `341c44469ecb17b4eebb2b45341a71ef8120a3b12fd0d2104496998b30d58866`. Complete exact Replay passes all 34 ordered cases with the frozen source/diagnostic identities; ordinary producer/consumer exits, full raw streams, integrity and restoration/cleanup are checked. +- **AX21-FINAL:** `axioms/20260927T085337097/RESULT.json`, SHA256 `b298894304173a52874593ee066aea530c55574aa2897aa3a14f5cc9918a967f`. All 21 declared exact sets and complete raw diagnostics reproduce AXIOMS.json; permitted trust base unchanged. +- **FINAL:** `COMMANDS.md` records exact entry arguments and row purposes. The external `delivery/DELIVERY.json` pins final strict scope/design/unchanged-policy claims, both hygiene scans, working/committed whitespace, clean commit and the complete final report/ledger input identities. + +## Reconstruction and final certification + +Strict UTF8 reconstruction verifies55unique IDs in contract order,8cells per row, and exact byte equality of each ID/requirement/scope cell against ACCEPTANCE_MATRIX.frozen.md. Changed immutable tuples: []. Frozen SHA256 `05b3435261d9b531837e5879b8c6390eb7b298ce4b61dc34e425ac48f5607ea3`; CONTRACT_REQUIREMENTS.json and frozen matrix were not edited. This local requirement-cell check does not replace final exact-base complete predecessor-row/raw-Git preservation or committed candidate identity. + +All required local execution evidence is complete. Final strict exact-base design/scope, unchanged-policy changed-surface claims, hygiene, working/committed whitespace and clean candidate identity are bound by the external delivery receipt. Historical fuel probes and predecessor DLLs retain only their explicitly documented applicability. No aggregate, blind coordinator audit, integration or acceptance is claimed. diff --git a/docs/internal/extensions/lifecycle-native1/AXIOMS.json b/docs/internal/extensions/lifecycle-native1/AXIOMS.json new file mode 100644 index 00000000..3a0a09a2 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native1/AXIOMS.json @@ -0,0 +1,289 @@ +{ + "schema": "lifecycle-native1-axioms-v1", + "reviewStatus": "FROZEN_ROOT_REVIEWED", + "consumerSourceSHA256": "82206b4cb35497ec19f92ae430fd23d812ed8ab43f5381a4b95a80b8149fa54a", + "consumedIdentitySHA256": "ba012458c4f3c7b379572beffbb7d9cda9aea7a8d9d4df2f8c4d9a39b95ddb76", + "leanSHA256": "9b5af669d8dc9b5826a1f5427584915eeca659e9bf34c7ee72667b93c0bfdcb0", + "declarations": [ + "RMQ.SuccinctFinal.PackedNative.Lifecycle.cached_run", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.export_contract", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.query_contract", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.Repacked.eq", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.repack_transport", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.answer_packet_fits", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.nativeBuildFirst_packet", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.nativeQuery_packet", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.Observations.runAcc_exact", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.Observations.read_occurrence_output", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.ContractChecks.checkO02_firstCategories", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.ContractChecks.checkO06_queryCategories", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.ContractChecks.checkO04_firstRoutes", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.ContractChecks.checkO08_queryRoutes", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.ContractChecks.checkO10_queryReadPosition", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.runThin_eq_runOwner", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.runBoundaryThin_eq_runBoundaryOwner", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.requestProtocolThin_eq_requestProtocolOwner", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.Observations.runAccThin_eq_runAcc", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.Observations.boundaryAccThin_eq_boundaryAcc", + "RMQ.SuccinctFinal.PackedNative.Lifecycle.Observations.Stats.record_eq_recordBefore" + ], + "permittedTrustBase": [ + "propext", + "Quot.sound", + "Classical.choice" + ], + "inventory": [ + { + "id": "AX01", + "declaration": "RMQ.SuccinctFinal.PackedNative.Lifecycle.cached_run", + "axioms": [ + "propext", + "Quot.sound" + ], + "line": 3, + "column": 0, + "messageSHA256": "003f9fc55ee9040580f0d49ad24b69a8798a2713f1404d96e0a71d1e6d3f216b" + }, + { + "id": "AX02", + "declaration": "RMQ.SuccinctFinal.PackedNative.Lifecycle.export_contract", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "line": 4, + "column": 0, + "messageSHA256": "b65acebd5e4f22f4bc5c7145d2d6f0465504dcfa8a85c19c922e480b3577648b" + }, + { + "id": "AX03", + "declaration": "RMQ.SuccinctFinal.PackedNative.Lifecycle.query_contract", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "line": 5, + "column": 0, + "messageSHA256": "006ffd9d1b20d4a962be8d647a7075de1b70a4b8f0196f4234b1ad74bed08354" + }, + { + "id": "AX04", + "declaration": "RMQ.SuccinctFinal.PackedNative.Lifecycle.Repacked.eq", + "axioms": [], + "line": 6, + "column": 0, + "messageSHA256": "d926c8908653416182493b175ec3d1601f5ad79775a071bc99aeca4a11af4f5d" + }, + { + "id": "AX05", + "declaration": "RMQ.SuccinctFinal.PackedNative.Lifecycle.repack_transport", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "line": 7, + "column": 0, + "messageSHA256": "e6aff5079318b88c8c05d16bf957a58fc9ccbe8d5cf413d254745921c9359ffc" + }, + { + "id": "AX06", + "declaration": "RMQ.SuccinctFinal.PackedNative.Lifecycle.answer_packet_fits", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "line": 8, + "column": 0, + "messageSHA256": "b60b69c23e327cfbf04b1b916fc49b8f9e9f542a2d769f9b55ee7e109f336f87" + }, + { + "id": "AX07", + "declaration": "RMQ.SuccinctFinal.PackedNative.Lifecycle.nativeBuildFirst_packet", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "line": 9, + "column": 0, + "messageSHA256": "d6475bb6e8b7288ed81cc37274503c467b31a1caa17fd44127e167ee8f312699" + }, + { + "id": "AX08", + "declaration": "RMQ.SuccinctFinal.PackedNative.Lifecycle.nativeQuery_packet", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "line": 10, + "column": 0, + "messageSHA256": "7866a39261f939fef9593000e3c8eba8171e2b6f51029d2f4c82c3a96642b6bf" + }, + { + "id": "AX09", + "declaration": "RMQ.SuccinctFinal.PackedNative.Lifecycle.Observations.runAcc_exact", + "axioms": [ + "propext" + ], + "line": 11, + "column": 0, + "messageSHA256": "1edfe18f3992983efcf2ba94e0335d2f40685661659586fbfd81a89055cecfd1" + }, + { + "id": "AX10", + "declaration": "RMQ.SuccinctFinal.PackedNative.Lifecycle.Observations.read_occurrence_output", + "axioms": [ + "propext" + ], + "line": 12, + "column": 0, + "messageSHA256": "2a672013bd043c5472506526b2c1b60228328ef93180af469b27c86a7f013079" + }, + { + "id": "AX11", + "declaration": "RMQ.SuccinctFinal.PackedNative.Lifecycle.ContractChecks.checkO02_firstCategories", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "line": 13, + "column": 0, + "messageSHA256": "353e335c5b8e328dd1ddfb4929b2134b4b284319c12b26b763a8fc1f7f693ba1" + }, + { + "id": "AX12", + "declaration": "RMQ.SuccinctFinal.PackedNative.Lifecycle.ContractChecks.checkO06_queryCategories", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "line": 14, + "column": 0, + "messageSHA256": "c238276866bb970af83745bc60566dea84f016b60cff349d9b2c2241cb72f979" + }, + { + "id": "AX13", + "declaration": "RMQ.SuccinctFinal.PackedNative.Lifecycle.ContractChecks.checkO04_firstRoutes", + "axioms": [ + "propext", + "Quot.sound" + ], + "line": 15, + "column": 0, + "messageSHA256": "0c1fd64890b25cf73f80e07dc48e696d973f3a6c5910dabb517e09a86a73efea" + }, + { + "id": "AX14", + "declaration": "RMQ.SuccinctFinal.PackedNative.Lifecycle.ContractChecks.checkO08_queryRoutes", + "axioms": [ + "propext", + "Quot.sound" + ], + "line": 16, + "column": 0, + "messageSHA256": "975e7b7a05847434b661ef343b4cabced86cc934d46e972d2f04b2efa6bc3417" + }, + { + "id": "AX15", + "declaration": "RMQ.SuccinctFinal.PackedNative.Lifecycle.ContractChecks.checkO10_queryReadPosition", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "line": 17, + "column": 0, + "messageSHA256": "3ee3f75625e50966f6566af33c04a94797834625bfd6f71f2268bb227dd9f8a1" + }, + { + "id": "AX16", + "declaration": "RMQ.SuccinctFinal.PackedNative.Lifecycle.runThin_eq_runOwner", + "axioms": [ + "propext" + ], + "line": 18, + "column": 0, + "messageSHA256": "f2519a52f2ff9eb19de80edf9f7461d4ec4eaf039eecfd4d7b3d77c90227d793" + }, + { + "id": "AX17", + "declaration": "RMQ.SuccinctFinal.PackedNative.Lifecycle.runBoundaryThin_eq_runBoundaryOwner", + "axioms": [ + "propext" + ], + "line": 19, + "column": 0, + "messageSHA256": "c23d6af4a0b7f668dba1f388d14e3dd973a34a014494439110df054b487253a5" + }, + { + "id": "AX18", + "declaration": "RMQ.SuccinctFinal.PackedNative.Lifecycle.requestProtocolThin_eq_requestProtocolOwner", + "axioms": [ + "propext" + ], + "line": 20, + "column": 0, + "messageSHA256": "83d8bb8214fb5e07ba9fabc48b77530bb429346fb5612d0bff942e1e1ad3a8a2" + }, + { + "id": "AX19", + "declaration": "RMQ.SuccinctFinal.PackedNative.Lifecycle.Observations.runAccThin_eq_runAcc", + "axioms": [ + "propext" + ], + "line": 21, + "column": 0, + "messageSHA256": "82b2dddc1540034f8cc89329af5f7d29cc6f3a961f4c192c8a320d72ee48063f" + }, + { + "id": "AX20", + "declaration": "RMQ.SuccinctFinal.PackedNative.Lifecycle.Observations.boundaryAccThin_eq_boundaryAcc", + "axioms": [ + "propext" + ], + "line": 22, + "column": 0, + "messageSHA256": "359622acf74639f331303126cd7e4ec4a82d0809a533bac9518e70c6c44a9079" + }, + { + "id": "AX21", + "declaration": "RMQ.SuccinctFinal.PackedNative.Lifecycle.Observations.Stats.record_eq_recordBefore", + "axioms": [ + "propext" + ], + "line": 23, + "column": 0, + "messageSHA256": "169ae15563a862a0e300e028bf4adc2cbf0a2323b5f71f73a019385da203357e" + } + ], + "stdout": "{\"severity\":\"information\",\"pos\":{\"line\":3,\"column\":0},\"kind\":\"[anonymous]\",\"keepFullRange\":false,\"isSilent\":false,\"fileName\":\"AxiomInventory.lean\",\"endPos\":{\"line\":3,\"column\":6},\"data\":\"'RMQ.SuccinctFinal.PackedNative.Lifecycle.cached_run' depends on axioms: [propext, Quot.sound]\",\"caption\":\"\"}\n{\"severity\":\"information\",\"pos\":{\"line\":4,\"column\":0},\"kind\":\"[anonymous]\",\"keepFullRange\":false,\"isSilent\":false,\"fileName\":\"AxiomInventory.lean\",\"endPos\":{\"line\":4,\"column\":6},\"data\":\"'RMQ.SuccinctFinal.PackedNative.Lifecycle.export_contract' depends on axioms: [propext, Classical.choice, Quot.sound]\",\"caption\":\"\"}\n{\"severity\":\"information\",\"pos\":{\"line\":5,\"column\":0},\"kind\":\"[anonymous]\",\"keepFullRange\":false,\"isSilent\":false,\"fileName\":\"AxiomInventory.lean\",\"endPos\":{\"line\":5,\"column\":6},\"data\":\"'RMQ.SuccinctFinal.PackedNative.Lifecycle.query_contract' depends on axioms: [propext, Classical.choice, Quot.sound]\",\"caption\":\"\"}\n{\"severity\":\"information\",\"pos\":{\"line\":6,\"column\":0},\"kind\":\"[anonymous]\",\"keepFullRange\":false,\"isSilent\":false,\"fileName\":\"AxiomInventory.lean\",\"endPos\":{\"line\":6,\"column\":6},\"data\":\"'RMQ.SuccinctFinal.PackedNative.Lifecycle.Repacked.eq' does not depend on any axioms\",\"caption\":\"\"}\n{\"severity\":\"information\",\"pos\":{\"line\":7,\"column\":0},\"kind\":\"[anonymous]\",\"keepFullRange\":false,\"isSilent\":false,\"fileName\":\"AxiomInventory.lean\",\"endPos\":{\"line\":7,\"column\":6},\"data\":\"'RMQ.SuccinctFinal.PackedNative.Lifecycle.repack_transport' depends on axioms: [propext, Classical.choice, Quot.sound]\",\"caption\":\"\"}\n{\"severity\":\"information\",\"pos\":{\"line\":8,\"column\":0},\"kind\":\"[anonymous]\",\"keepFullRange\":false,\"isSilent\":false,\"fileName\":\"AxiomInventory.lean\",\"endPos\":{\"line\":8,\"column\":6},\"data\":\"'RMQ.SuccinctFinal.PackedNative.Lifecycle.answer_packet_fits' depends on axioms: [propext, Classical.choice, Quot.sound]\",\"caption\":\"\"}\n{\"severity\":\"information\",\"pos\":{\"line\":9,\"column\":0},\"kind\":\"[anonymous]\",\"keepFullRange\":false,\"isSilent\":false,\"fileName\":\"AxiomInventory.lean\",\"endPos\":{\"line\":9,\"column\":6},\"data\":\"'RMQ.SuccinctFinal.PackedNative.Lifecycle.nativeBuildFirst_packet' depends on axioms: [propext,\\n Classical.choice,\\n Quot.sound]\",\"caption\":\"\"}\n{\"severity\":\"information\",\"pos\":{\"line\":10,\"column\":0},\"kind\":\"[anonymous]\",\"keepFullRange\":false,\"isSilent\":false,\"fileName\":\"AxiomInventory.lean\",\"endPos\":{\"line\":10,\"column\":6},\"data\":\"'RMQ.SuccinctFinal.PackedNative.Lifecycle.nativeQuery_packet' depends on axioms: [propext, Classical.choice, Quot.sound]\",\"caption\":\"\"}\n{\"severity\":\"information\",\"pos\":{\"line\":11,\"column\":0},\"kind\":\"[anonymous]\",\"keepFullRange\":false,\"isSilent\":false,\"fileName\":\"AxiomInventory.lean\",\"endPos\":{\"line\":11,\"column\":6},\"data\":\"'RMQ.SuccinctFinal.PackedNative.Lifecycle.Observations.runAcc_exact' depends on axioms: [propext]\",\"caption\":\"\"}\n{\"severity\":\"information\",\"pos\":{\"line\":12,\"column\":0},\"kind\":\"[anonymous]\",\"keepFullRange\":false,\"isSilent\":false,\"fileName\":\"AxiomInventory.lean\",\"endPos\":{\"line\":12,\"column\":6},\"data\":\"'RMQ.SuccinctFinal.PackedNative.Lifecycle.Observations.read_occurrence_output' depends on axioms: [propext]\",\"caption\":\"\"}\n{\"severity\":\"information\",\"pos\":{\"line\":13,\"column\":0},\"kind\":\"[anonymous]\",\"keepFullRange\":false,\"isSilent\":false,\"fileName\":\"AxiomInventory.lean\",\"endPos\":{\"line\":13,\"column\":6},\"data\":\"'RMQ.SuccinctFinal.PackedNative.Lifecycle.ContractChecks.checkO02_firstCategories' depends on axioms: [propext,\\n Classical.choice,\\n Quot.sound]\",\"caption\":\"\"}\n{\"severity\":\"information\",\"pos\":{\"line\":14,\"column\":0},\"kind\":\"[anonymous]\",\"keepFullRange\":false,\"isSilent\":false,\"fileName\":\"AxiomInventory.lean\",\"endPos\":{\"line\":14,\"column\":6},\"data\":\"'RMQ.SuccinctFinal.PackedNative.Lifecycle.ContractChecks.checkO06_queryCategories' depends on axioms: [propext,\\n Classical.choice,\\n Quot.sound]\",\"caption\":\"\"}\n{\"severity\":\"information\",\"pos\":{\"line\":15,\"column\":0},\"kind\":\"[anonymous]\",\"keepFullRange\":false,\"isSilent\":false,\"fileName\":\"AxiomInventory.lean\",\"endPos\":{\"line\":15,\"column\":6},\"data\":\"'RMQ.SuccinctFinal.PackedNative.Lifecycle.ContractChecks.checkO04_firstRoutes' depends on axioms: [propext, Quot.sound]\",\"caption\":\"\"}\n{\"severity\":\"information\",\"pos\":{\"line\":16,\"column\":0},\"kind\":\"[anonymous]\",\"keepFullRange\":false,\"isSilent\":false,\"fileName\":\"AxiomInventory.lean\",\"endPos\":{\"line\":16,\"column\":6},\"data\":\"'RMQ.SuccinctFinal.PackedNative.Lifecycle.ContractChecks.checkO08_queryRoutes' depends on axioms: [propext, Quot.sound]\",\"caption\":\"\"}\n{\"severity\":\"information\",\"pos\":{\"line\":17,\"column\":0},\"kind\":\"[anonymous]\",\"keepFullRange\":false,\"isSilent\":false,\"fileName\":\"AxiomInventory.lean\",\"endPos\":{\"line\":17,\"column\":6},\"data\":\"'RMQ.SuccinctFinal.PackedNative.Lifecycle.ContractChecks.checkO10_queryReadPosition' depends on axioms: [propext,\\n Classical.choice,\\n Quot.sound]\",\"caption\":\"\"}\n{\"severity\":\"information\",\"pos\":{\"line\":18,\"column\":0},\"kind\":\"[anonymous]\",\"keepFullRange\":false,\"isSilent\":false,\"fileName\":\"AxiomInventory.lean\",\"endPos\":{\"line\":18,\"column\":6},\"data\":\"'RMQ.SuccinctFinal.PackedNative.Lifecycle.runThin_eq_runOwner' depends on axioms: [propext]\",\"caption\":\"\"}\n{\"severity\":\"information\",\"pos\":{\"line\":19,\"column\":0},\"kind\":\"[anonymous]\",\"keepFullRange\":false,\"isSilent\":false,\"fileName\":\"AxiomInventory.lean\",\"endPos\":{\"line\":19,\"column\":6},\"data\":\"'RMQ.SuccinctFinal.PackedNative.Lifecycle.runBoundaryThin_eq_runBoundaryOwner' depends on axioms: [propext]\",\"caption\":\"\"}\n{\"severity\":\"information\",\"pos\":{\"line\":20,\"column\":0},\"kind\":\"[anonymous]\",\"keepFullRange\":false,\"isSilent\":false,\"fileName\":\"AxiomInventory.lean\",\"endPos\":{\"line\":20,\"column\":6},\"data\":\"'RMQ.SuccinctFinal.PackedNative.Lifecycle.requestProtocolThin_eq_requestProtocolOwner' depends on axioms: [propext]\",\"caption\":\"\"}\n{\"severity\":\"information\",\"pos\":{\"line\":21,\"column\":0},\"kind\":\"[anonymous]\",\"keepFullRange\":false,\"isSilent\":false,\"fileName\":\"AxiomInventory.lean\",\"endPos\":{\"line\":21,\"column\":6},\"data\":\"'RMQ.SuccinctFinal.PackedNative.Lifecycle.Observations.runAccThin_eq_runAcc' depends on axioms: [propext]\",\"caption\":\"\"}\n{\"severity\":\"information\",\"pos\":{\"line\":22,\"column\":0},\"kind\":\"[anonymous]\",\"keepFullRange\":false,\"isSilent\":false,\"fileName\":\"AxiomInventory.lean\",\"endPos\":{\"line\":22,\"column\":6},\"data\":\"'RMQ.SuccinctFinal.PackedNative.Lifecycle.Observations.boundaryAccThin_eq_boundaryAcc' depends on axioms: [propext]\",\"caption\":\"\"}\n{\"severity\":\"information\",\"pos\":{\"line\":23,\"column\":0},\"kind\":\"[anonymous]\",\"keepFullRange\":false,\"isSilent\":false,\"fileName\":\"AxiomInventory.lean\",\"endPos\":{\"line\":23,\"column\":6},\"data\":\"'RMQ.SuccinctFinal.PackedNative.Lifecycle.Observations.Stats.record_eq_recordBefore' depends on axioms: [propext]\",\"caption\":\"\"}\n", + "stderr": "", + "stdoutBytes": 6693, + "stderrBytes": 0, + "stdoutSHA256": "83931a56f66839913be61bf11056389b09681e1ed3f23598c8df041451983e8a", + "stderrSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "review": { + "reviewedUtc": "2026-09-27T07:25:40.408652+00:00", + "reviewer": "root", + "discovery": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\axioms\\20260927T072200262\\RESULT.json", + "bytes": 1428124, + "sha256": "2c2c431209356be1e8df87c8a74d7da276b3531dde0e28ceb227cf1d2801250a" + }, + "candidate": { + "path": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ\\.lake\\lifecycle-native1\\axioms\\20260927T072200262\\AXIOMS.candidate.json", + "bytes": 16868, + "sha256": "b816b3060ebf8da7424be5c2a1d94fbf5fc97acdc007ab399e7da4e5ba1f1eeb" + }, + "all21ExactSetsReadAndChecked": true, + "rawCapturePinsRechecked": 8, + "conclusion": "The exact declared theorem roster uses only propext, Quot.sound and Classical.choice. Repacked.eq is axiom-free; the six thin-loop/record bridges use only propext. This inventory supplements fixed-type consumers and mutation replay; it does not prove the native C/runtime implementation." + } +} diff --git a/docs/internal/extensions/lifecycle-native1/BASE_IDENTITY.json b/docs/internal/extensions/lifecycle-native1/BASE_IDENTITY.json new file mode 100644 index 00000000..7906711f --- /dev/null +++ b/docs/internal/extensions/lifecycle-native1/BASE_IDENTITY.json @@ -0,0 +1,26918 @@ +{ + "schema": "life-native1-base-identity-v1", + "base": "3dbdebedcc6ba6b2a864df0d46dcc09ccaaa7536", + "worktree": "C:\\Users\\poin\\.codex\\worktrees\\44d6\\RMQ", + "utc": "2026-09-23T02:06:19.363916+00:00", + "trackedCount": 3844, + "rawBytes": 160701016, + "files": [ + { + "path": ".agents/skills/rmq-audit-prompt/SKILL.md", + "mode": "100644", + "gitBlob": "7d6e7d91d8d564b49381cf138de17e79d8dbcdb3", + "rawBytes": 7761, + "rawSHA256": "b9251c2fc767b062c619f7a4f1f374bbcf68754d20ad4c86c36d7025fdde40fb" + }, + { + "path": ".agents/skills/rmq-audit-prompt/agents/openai.yaml", + "mode": "100644", + "gitBlob": "f69fd9e873460adb911115421689c7a6dc07e85c", + "rawBytes": 249, + "rawSHA256": "6ea8ce45a5160862c6646748ea359571f9fa40724705130da060a9bf86c8a12b" + }, + { + "path": ".agents/skills/rmq-coordinator/SKILL.md", + "mode": "100644", + "gitBlob": "33333638703f8f1871156df1de1706fd23971511", + "rawBytes": 34066, + "rawSHA256": "7f8a7515709636f103ffce5feaafbb5de6287485d5e1c76d1d9b17541640b357" + }, + { + "path": ".agents/skills/rmq-coordinator/agents/openai.yaml", + "mode": "100644", + "gitBlob": "eccfe94be283ac1bf6fff0f7637da61764702a5f", + "rawBytes": 365, + "rawSHA256": "9da8e978450241010880dc28e5cbde5cbf0ec46aefa07ad1adedd18874feb2a9" + }, + { + "path": ".agents/skills/rmq-proof-sprint/SKILL.md", + "mode": "100644", + "gitBlob": "bfc615ac32c4b737b34b21dab2f2d0dab672fabf", + "rawBytes": 10289, + "rawSHA256": "945a6bdd960a377b13facc3d83f1dd78d40431027f17b35ad5a8a582455c1e9c" + }, + { + "path": ".agents/skills/rmq-proof-sprint/references/COMPLETION_GATE.md", + "mode": "100644", + "gitBlob": "b39ada83794b428be7184e0c633d3c1f2359f604", + "rawBytes": 31640, + "rawSHA256": "b760f0df4f3c2b5949352ff926d672cfc4d04afa43916218c5d207ed8f294330" + }, + { + "path": ".agents/skills/rmq-proof-sprint/references/KNOWN_FAILURE_MODES.md", + "mode": "100644", + "gitBlob": "dd32a880681871be6bb855f71809a8711c051a84", + "rawBytes": 22689, + "rawSHA256": "5c005d0611182863e39f4897b89f66f842dbf4956b208942eec1e95f694c9ecd" + }, + { + "path": ".claude/skills/rmq-audit-prompt/SKILL.md", + "mode": "100644", + "gitBlob": "12df22787fb2239d3375a44c3c6fed1aba213a99", + "rawBytes": 1175, + "rawSHA256": "34a08a144703633031be7bcc97c09f5754c74526a077ed07925f64369cea9afc" + }, + { + "path": ".claude/skills/rmq-coordinator/SKILL.md", + "mode": "100644", + "gitBlob": "9cab66de6ee49d9c3d027f643a2fe7a00b6b9470", + "rawBytes": 1599, + "rawSHA256": "54394177dbe1f39dfc3230813737588f2a819dd9cbded6e18d6a5f30c57582d8" + }, + { + "path": ".claude/skills/rmq-proof-sprint/SKILL.md", + "mode": "100644", + "gitBlob": "c662632d335d3fca5a2c75db15e455f3f725d886", + "rawBytes": 1339, + "rawSHA256": "ec1a2ab7dda9106adc446d91637f8b23205275aff7951f062e34d46b22adb920" + }, + { + "path": ".codex/agents/rmq-frontier-explorer.toml", + "mode": "100644", + "gitBlob": "f54ef34cece2fd9d2fcaa5d80e534a0f5cabdd76", + "rawBytes": 964, + "rawSHA256": "d66ead12f9f150ed7d9f2f57d083996ee35bc9e7c8153981c71365843e551c34" + }, + { + "path": ".codex/agents/rmq-proof-auditor.toml", + "mode": "100644", + "gitBlob": "65f377ee0a6421e9d90746f3a77bb65d60cf9d65", + "rawBytes": 980, + "rawSHA256": "e7048894e4907017ac30ead0ff3ccf2a45d1937a3786366daf833a6d931d6626" + }, + { + "path": ".gitattributes", + "mode": "100644", + "gitBlob": "97bb4605994f95b9537c5101f6e8ebc04f28db46", + "rawBytes": 2651, + "rawSHA256": "ea89e2a9e267b015cb36b496862cade043e11bbcbc5f0155867ad2ca76d76d13" + }, + { + "path": ".github/ISSUE_TEMPLATE/audit.yml", + "mode": "100644", + "gitBlob": "5889caf0b7108144faa4745dfa07f9f6e915b037", + "rawBytes": 942, + "rawSHA256": "21f3b3ca815bc0d3a5a9a99757b3de1f362c6f9d3845e7f62cff94da00a43ec8" + }, + { + "path": ".github/ISSUE_TEMPLATE/worker.yml", + "mode": "100644", + "gitBlob": "805bca44e1e6cf9651d5b852e7ecec70619a21f5", + "rawBytes": 1069, + "rawSHA256": "67244747915328742fa4e60a6a5b788af9beec99106ab01e5767f5890b23c3d5" + }, + { + "path": ".github/pull_request_template.md", + "mode": "100644", + "gitBlob": "94d0423b1e267753e1914ce39242af5037d2a897", + "rawBytes": 583, + "rawSHA256": "65626244603557a30398f495c22fbd400b2ce08b0818fbac94e0ccbcbd33fe89" + }, + { + "path": ".github/workflows/artifact-repro.yml", + "mode": "100644", + "gitBlob": "fbf428a2ac5d61f18aaa9561bfb5c7f986f67490", + "rawBytes": 2512, + "rawSHA256": "28f486036af3a54a7efa779083e8f9fd24df134290740db76dcf57dcbc9896b4" + }, + { + "path": ".github/workflows/ci.yml", + "mode": "100644", + "gitBlob": "6c4ffb3a4cb78445018f5f20b837fbcebab71962", + "rawBytes": 7319, + "rawSHA256": "13530e6f68d1f227c15d1c1cfb03fa5682a61ff48f2ecca8a4706aa9b92eaf2d" + }, + { + "path": ".github/workflows/release-artifact.yml", + "mode": "100644", + "gitBlob": "16cff4ba7fddabe6238878cb4985ea1c0a8189a0", + "rawBytes": 2657, + "rawSHA256": "f9b3d23371d036a81021287d2dd1abb2a4fa3e418738cb41d61a5045dcf2eac9" + }, + { + "path": ".gitignore", + "mode": "100644", + "gitBlob": "488f3de89e106041cb078900c50b77ac5051eaf5", + "rawBytes": 621, + "rawSHA256": "49d597d1e8070a701ca1258753583d528ef183fe8d7f6ad7f4dfae3da10e102e" + }, + { + "path": "AGENTS.md", + "mode": "100644", + "gitBlob": "84dfcce40ad902fb3a11fea8d37f8664812ab9da", + "rawBytes": 10445, + "rawSHA256": "b057081a28a8b8bedbdd8d0b33f2d311bd9dba4591d7db4764924bf267d1192e" + }, + { + "path": "CITATION.cff", + "mode": "100644", + "gitBlob": "514a6954dc371219dce5500545553f401e180fc2", + "rawBytes": 709, + "rawSHA256": "354676e89ecd2e3f4e9df1c91f1b1910abe43e434cfea9f2792be504aae9dade" + }, + { + "path": "LICENSE", + "mode": "100644", + "gitBlob": "67ec935563b584f1b6821d6122cc2aee79f7968b", + "rawBytes": 10613, + "rawSHA256": "d470bce9f61c9f29fb6c6048a496a337b1f0c688217bed9e266017748d8bbd29" + }, + { + "path": "README.md", + "mode": "100644", + "gitBlob": "0b0521c844890d7628a7ced6108022e109d81f70", + "rawBytes": 33813, + "rawSHA256": "d2b55f25df211647af32323b167790791e3031acdc2f5b5082439e4220c9c3fa" + }, + { + "path": "RMQ.lean", + "mode": "100644", + "gitBlob": "cdc7d2282a5bfb547c55960f54f89e198dc03c47", + "rawBytes": 6849, + "rawSHA256": "db3b465f5fdf14f03d1b637f2ad76610ffac8bdca855fdeb201806eea4e72eeb" + }, + { + "path": "RMQ/Archive.lean", + "mode": "100644", + "gitBlob": "cc4d7de492a35594c0e9c872102cb328964d5e06", + "rawBytes": 121, + "rawSHA256": "06bb171fb4b694e3d86582f94b6446fe88cdbeef7c0eb1decbb6646b0d60acfa" + }, + { + "path": "RMQ/Archive/BPSpecializedCapstone.lean", + "mode": "100644", + "gitBlob": "9e4dd55c36468d16c10d573913eef33afcb78cc8", + "rawBytes": 589, + "rawSHA256": "98e4efccbdea73fcd6f473360dbbe573d04acc342f8db3fe0e90edb67c767e74" + }, + { + "path": "RMQ/Archive/SelectCompatibility.lean", + "mode": "100644", + "gitBlob": "e4b53c95fc68b4e962f495ed1da1d64f7bfc7cd3", + "rawBytes": 748, + "rawSHA256": "fcf3f44ad517c6d8b231d3df9ba629c5c3d1489fb7813f90301f4cefd7786faa" + }, + { + "path": "RMQ/Archive/SelectObstructions.lean", + "mode": "100644", + "gitBlob": "4e54d93533f255a62ff05980d106a3f0874a6180", + "rawBytes": 4888, + "rawSHA256": "345120256155e07dea1780b2c5340a20b8fc0cd47d46605761bf51acc8eac007" + }, + { + "path": "RMQ/Core/Amortized.lean", + "mode": "100644", + "gitBlob": "3704e354f66031252aa77745cb9b5b8c0e815ddc", + "rawBytes": 3560, + "rawSHA256": "f728a46fa03cbf2b7e527b695d1dda37cd06a1dc820e9031523027e86d3b8fc4" + }, + { + "path": "RMQ/Core/AmortizedSequence.lean", + "mode": "100644", + "gitBlob": "985dccf1078f47ea9f94bad6f5387fe076023107", + "rawBytes": 5593, + "rawSHA256": "d32a05363608e5aacac83535279368672f1f86c2bc1a6bc800e283f924062a94" + }, + { + "path": "RMQ/Core/BPCloseNavigation.lean", + "mode": "100644", + "gitBlob": "8ef2dc65cf9ce155f87c9577a6c4a6529cff329b", + "rawBytes": 397, + "rawSHA256": "9137d0eb03be2137a7dffdaf6c305041bf504684c818e96e6524f2f7d988f068" + }, + { + "path": "RMQ/Core/BPNavigationPublic.lean", + "mode": "100644", + "gitBlob": "7521c7796b0b2ef1096573c1a77ea3a56213da79", + "rawBytes": 71180, + "rawSHA256": "24592eceb6bfd4a7b337234a0176adb57ff70eb9e25654d0cc37d38803b01dbc" + }, + { + "path": "RMQ/Core/BPNavigationRAM.lean", + "mode": "100644", + "gitBlob": "93a78d77cea669c0448ad684d68a8bd785a51332", + "rawBytes": 117209, + "rawSHA256": "2116d4244ae2799b51eced28d7edb798069c785c45d1dbbfe1777409e26bc9d2" + }, + { + "path": "RMQ/Core/Backend.lean", + "mode": "100644", + "gitBlob": "98ef173870adf0f499dcefb7d70d3dddb557f8e8", + "rawBytes": 2179, + "rawSHA256": "8d911857ed6e9669936d5f8818149e23ebf4874c2c508d63ceea889660acc751" + }, + { + "path": "RMQ/Core/Cartesian.lean", + "mode": "100644", + "gitBlob": "2d3aec25e13ffc53227babb8aebe865327d1f1a6", + "rawBytes": 58487, + "rawSHA256": "a0c175425b7df234f8cf59e177b36e3ed593d81d78337d40e6e2ed74028d9580" + }, + { + "path": "RMQ/Core/Cost.lean", + "mode": "100644", + "gitBlob": "1b6e0c28eb22efa8fdeb2a08a84e18abe6652f7d", + "rawBytes": 4898, + "rawSHA256": "887cdcca893969756f6b7f785e1ca2249106f215a4155c6ba6fe714a6373baa4" + }, + { + "path": "RMQ/Core/CostKernels.lean", + "mode": "100644", + "gitBlob": "ce894658ca90684799a4bf544b082848df05b9b3", + "rawBytes": 9261, + "rawSHA256": "e0576caef6459d8518a086ae1c83089b5482818e3de1991b143061f28254d5e3" + }, + { + "path": "RMQ/Core/EncodingLowerBound.lean", + "mode": "100644", + "gitBlob": "62d880a3df139ac6e74bdacdfa5834141034efc3", + "rawBytes": 75412, + "rawSHA256": "ba555aadfa7f3ab3bf0b8dc1d09e093a33de6a4747dce6ba707fa68bcbae61e5" + }, + { + "path": "RMQ/Core/EncodingVariableLowerBound.lean", + "mode": "100644", + "gitBlob": "5104dde50c44670ed460d841ec8bb893beff3b62", + "rawBytes": 14505, + "rawSHA256": "6659e77713800e028df7904370fa868c1c5ae6c7fcf7b641884daa9ade595fd5" + }, + { + "path": "RMQ/Core/GenericSelect.lean", + "mode": "100644", + "gitBlob": "ec79f7bdc908086b1b32da0f7a1c7f22ebbc8f0f", + "rawBytes": 839, + "rawSHA256": "a228c7410792cbb98960e95888098d7967a189c6bd51e240fac42290d422661a" + }, + { + "path": "RMQ/Core/GenericSelect/Arithmetic.lean", + "mode": "100644", + "gitBlob": "4855508e65a7b1168ab49870ad8556c8255d13a8", + "rawBytes": 7120, + "rawSHA256": "188659dfe14431fa924c60be82d03ee1733cfc01ac5e5db046fab129db4b88ac" + }, + { + "path": "RMQ/Core/GenericSelect/BPCompat.lean", + "mode": "100644", + "gitBlob": "358fe47e00c50073e52ccb18c46994b89212f986", + "rawBytes": 818, + "rawSHA256": "6e381a9cd5d679327aa67704a6f6e967a9f83db61dcbdbd1e3e2ba8b919689f7" + }, + { + "path": "RMQ/Core/GenericSelect/DenseEntryTable.lean", + "mode": "100644", + "gitBlob": "a4d2da7e6a6897390570ad44b854c6f762f2e182", + "rawBytes": 24752, + "rawSHA256": "9af07d6ec8a806e0f7966d3f62801989f8e7dec84a20c245a9a80555f0655eab" + }, + { + "path": "RMQ/Core/GenericSelect/DenseWord.lean", + "mode": "100644", + "gitBlob": "618fcc69f88be89e2a5ea7e59549c756ff460aed", + "rawBytes": 2843, + "rawSHA256": "771195f6125e8de11c24f1f94876b620151cd4a2ea86db3464e0c9e6e26fa728" + }, + { + "path": "RMQ/Core/GenericSelect/Directory.lean", + "mode": "100644", + "gitBlob": "b632c1770b65bf4ef4b139c433e437be340bce98", + "rawBytes": 12532, + "rawSHA256": "1b99217374a50a1da29b9e2625d8884f89b1ef255fff3ec643a32da58ce246b9" + }, + { + "path": "RMQ/Core/GenericSelect/Entries.lean", + "mode": "100644", + "gitBlob": "dc70a09554c3d831ae2de40c29ab3ff8b4906328", + "rawBytes": 4640, + "rawSHA256": "ae17f58ff740414fe9dfb6df59b1ee92d2912a26e50d0ab042dd26c813c341f8" + }, + { + "path": "RMQ/Core/GenericSelect/Family.lean", + "mode": "100644", + "gitBlob": "d2fe2f2f01bd208df25762624def8d2a7939a633", + "rawBytes": 14943, + "rawSHA256": "982ba48d8eb6ee8271fe6037bd0a84a0920ac1a5cfe6076b8800211eaa0f891f" + }, + { + "path": "RMQ/Core/GenericSelect/FlagRank.lean", + "mode": "100644", + "gitBlob": "d40802621c488d33f427b05b9de54d67a22721d9", + "rawBytes": 34185, + "rawSHA256": "25ef697c1d68e47dead370fff58717279317e3bb7b5103cd9a5fd8e71896359c" + }, + { + "path": "RMQ/Core/GenericSelect/LowLevel.lean", + "mode": "100644", + "gitBlob": "b5ca40073719b7f43d03d42e9a197b04fcd8a8ee", + "rawBytes": 541, + "rawSHA256": "d80dc849e26e30eb31487c03865098cd582a62e89eeb2bcd7cae1020ab306535" + }, + { + "path": "RMQ/Core/GenericSelect/Params.lean", + "mode": "100644", + "gitBlob": "f0030b8340bdf8f8fc00fbddd525c902d1945b11", + "rawBytes": 2278, + "rawSHA256": "05f8e4cb75a07792f6b51e5f561ee5e20eeb8f7f51ec05664cddaf0e55440ea1" + }, + { + "path": "RMQ/Core/GenericSelect/Primitives.lean", + "mode": "100644", + "gitBlob": "430d6b28f7a2fd4868074b50d9a3a6a0cd8583ce", + "rawBytes": 39274, + "rawSHA256": "eaf0c05a429b425a40e8cc77044f268bc8ff36f8b9bb648473d6576f53df6840" + }, + { + "path": "RMQ/Core/GenericSelect/RAM.lean", + "mode": "100644", + "gitBlob": "6143b2e670e3e52ea8bb0410c0f116d6375827b4", + "rawBytes": 111264, + "rawSHA256": "fee4d7be36077d93f928716e4909b4773f818ce39fda17bc17e85e944ec2892f" + }, + { + "path": "RMQ/Core/GenericSelect/RAMStoreParam.lean", + "mode": "100644", + "gitBlob": "524d591d01fb49113f5ce05070aca9df74234d2a", + "rawBytes": 64263, + "rawSHA256": "f17c7f141928adea7320b3187c98f2983b34e3d95b9e6f629860ab4c1313a277" + }, + { + "path": "RMQ/Core/GenericSelect/RelativeSplit.lean", + "mode": "100644", + "gitBlob": "1d7334f67412184204726f60a24436837518b64c", + "rawBytes": 2281, + "rawSHA256": "89e4188223b34f322480147fe5ea4d57542e79a00763408b2ec45d4c80dd9c36" + }, + { + "path": "RMQ/Core/GenericSelect/RelativeTables.lean", + "mode": "100644", + "gitBlob": "cf79740ad57e99750245bd1afb2547c015ae5fd5", + "rawBytes": 59093, + "rawSHA256": "7131a37475059e917d114531ba34726e1c34432bc9df271d56c166370dc9f1ec" + }, + { + "path": "RMQ/Core/GenericSelect/SelectFacts.lean", + "mode": "100644", + "gitBlob": "69abcd54c8c260281e7431f7a2ae1ce6e95f6d66", + "rawBytes": 11804, + "rawSHA256": "df6e9cb61e7feee0659b62960379fb8cd851b6bd914347a2d3bd06785cf93c69" + }, + { + "path": "RMQ/Core/GenericSelect/SelectSource.lean", + "mode": "100644", + "gitBlob": "e0834e880f064703ecdc4fbc9c8f2de3ed36187e", + "rawBytes": 1220, + "rawSHA256": "222526c0d6d8ad56eb1e4fd5678111471961a6d3674614790bd5ace58098d57a" + }, + { + "path": "RMQ/Core/GenericSelect/Slots.lean", + "mode": "100644", + "gitBlob": "497af76a21b762d2a87e55293fc25ec9b1e34bab", + "rawBytes": 44242, + "rawSHA256": "ae96b766a1d0cf34ce468b3ee9c9fdf82195ae25fa4aca41e150ae426fa59051" + }, + { + "path": "RMQ/Core/GenericSelect/Source.lean", + "mode": "100644", + "gitBlob": "88bb4ce92623fdc5db9f69de83706910710d9cbd", + "rawBytes": 105875, + "rawSHA256": "d1a404009fb648d1f256afb0efc396594c00b6e0ec85192f978b16bc0f08932e" + }, + { + "path": "RMQ/Core/GenericSelect/SuccinctSelectLegacyNames.lean", + "mode": "100644", + "gitBlob": "76baf3b2d1231a390ef2a9c819946a08189ee0ed", + "rawBytes": 1492, + "rawSHA256": "b35df308cc58f983d936656e5546e4f3f8328a61ee4c0466546351c289754db6" + }, + { + "path": "RMQ/Core/GenericSelectBPCompat.lean", + "mode": "100644", + "gitBlob": "15f8de2b5c4dba9092ccecea79a131dc170de41c", + "rawBytes": 248, + "rawSHA256": "0096c7b78a76989da01890b14d0da27fce77c507c98470a50d99a3a8be8350ed" + }, + { + "path": "RMQ/Core/LCA.lean", + "mode": "100644", + "gitBlob": "e86dbb789225380edd59586ffb1f81b4d5a84333", + "rawBytes": 117400, + "rawSHA256": "e981d40a5c3429a6794bd7857aeb01a0b49653f869c1139232afb8766f1b053c" + }, + { + "path": "RMQ/Core/ListLemmas.lean", + "mode": "100644", + "gitBlob": "3ab20ea828a62409ec2516003cc39c9b5510f9d0", + "rawBytes": 313, + "rawSHA256": "e4df7a2d19754bc5ba77ba05235ec72e839df226b00d4a38baeb452b46eca1fa" + }, + { + "path": "RMQ/Core/LowerBound.lean", + "mode": "100644", + "gitBlob": "4b308477d25958476ff640ae5cc1eda1b3df7333", + "rawBytes": 12042, + "rawSHA256": "fefe56a46f206f5233c7e4b9edafc6bc1fa5cb0e04b03494fb94d9d0dfd6df56" + }, + { + "path": "RMQ/Core/Microtable.lean", + "mode": "100644", + "gitBlob": "f0e39fe25cad9b55bdac752574bac6d70970aaa0", + "rawBytes": 19165, + "rawSHA256": "7ac16582b05226a39314cb12cf4032394bcc9802e01867697e1271bbd9c21a80" + }, + { + "path": "RMQ/Core/ModelHub.lean", + "mode": "100644", + "gitBlob": "bf6c5e4300c8d3815814f5ff468da5385a03dae1", + "rawBytes": 464, + "rawSHA256": "2c91a59ec51e3eb161ae15d288047e1f3f38bc06477e085bfbba2f906fd200f4" + }, + { + "path": "RMQ/Core/PayloadLowerBound.lean", + "mode": "100644", + "gitBlob": "a00aab777e13c1f7d67e893508f78d74b31cb73c", + "rawBytes": 12120, + "rawSHA256": "24523ec8d3dd5859738ddbdf69bcc14c41fb0e21d7175addd494072fff1bca55" + }, + { + "path": "RMQ/Core/PlusMinusOne.lean", + "mode": "100644", + "gitBlob": "29e44ad0a9c66950a2a6ddfbc1a42687aaac2d75", + "rawBytes": 14979, + "rawSHA256": "f66cfc4256fa0f3806e4c64eb3dc530e9675a86f3d1c3082af349dfa9a3f74ef" + }, + { + "path": "RMQ/Core/RAM.lean", + "mode": "100644", + "gitBlob": "6c9a930e494d4c2112a6bd7dbd6aa95abeb0295b", + "rawBytes": 10331, + "rawSHA256": "208e621844ca2a0f5ca73312b3c5688406afd330eb753506987dab603aadef4f" + }, + { + "path": "RMQ/Core/RankSelectCompressed.lean", + "mode": "100644", + "gitBlob": "e609b2f644140f270d1875020f323dfbf9ac345d", + "rawBytes": 360, + "rawSHA256": "11d0d018293c63d496d63ad37894fbbca663f27f3cfd30a4ef1efa09d0db3160" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Base.lean", + "mode": "100644", + "gitBlob": "22ab0b7d6c41db5320c3d91e6a007f7538681fcf", + "rawBytes": 827, + "rawSHA256": "36cb6ad2fecce3695a8e0f87320242fbab50d20fcc42ec0195cc51d57ec75462" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Base/ClassLengthEnvelope.lean", + "mode": "100644", + "gitBlob": "8651d57e6b4262fa5ac4546f84e4ecf38688d168", + "rawBytes": 153950, + "rawSHA256": "2ac9c81e77d27600b7644a1bfa17ed953c137f02959a1afe527a559835bc48a9" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Base/Core.lean", + "mode": "100644", + "gitBlob": "3cd18bfd1c25963d345fbdee25e005e2eec06c55", + "rawBytes": 550, + "rawSHA256": "ac0de53341b4d67bece40494ca9a9416a36038cbd129dd0a1e1ea05f6835475a" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Base/Core/Auxiliary.lean", + "mode": "100644", + "gitBlob": "cc18ceacf6a66be1c6d2d75980679f6dcdd81348", + "rawBytes": 69320, + "rawSHA256": "cce12c6c94e7ebdfe0fb64f708a16bcd2b84d0f2a2c809ee8ba6cf1c7ec424d0" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Base/Core/LocalRRR.lean", + "mode": "100644", + "gitBlob": "9496ba796fad7a2aadd7f98f97f0d93b77ca97cd", + "rawBytes": 59358, + "rawSHA256": "50f1d1031dd10306e438f130b1ba5e5d2f253897c8ddf27953ff770d17dbcf03" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Base/Core/RouteTables.lean", + "mode": "100644", + "gitBlob": "577f926ab19d6689054059ecd0e1b03eadc4a758", + "rawBytes": 49233, + "rawSHA256": "3ed334f08ec484be5eec2c012d67b6a306a505c9f0910c843a9a6c0d7106b31e" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Base/Core/TableBacked.lean", + "mode": "100644", + "gitBlob": "d975ef5eec7d5a381c053450bf3a0cbace0677da", + "rawBytes": 16926, + "rawSHA256": "60e223dd682c54c30d901467314c2e8f2d7b98f52cd8d33cffe88b3d887f40f7" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Base/DecodedRoutes.lean", + "mode": "100644", + "gitBlob": "8d06a25419649be8d5c658a9e34444bdbaf73d2a", + "rawBytes": 67525, + "rawSHA256": "fcf7ffdf75ae228285f008eba348b62e76a077bfbe390126c1f9b561c6b99ec3" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Base/LogChunks.lean", + "mode": "100644", + "gitBlob": "94b2467a07ae01c0d3077ad61cd54961d8ed96f1", + "rawBytes": 46397, + "rawSHA256": "339e8d1a5f129bb37b21fc8be317ce95889bcd9006d6fec6356185192023ac42" + }, + { + "path": "RMQ/Core/RankSelectCompressed/FixedWeightCodec.lean", + "mode": "100644", + "gitBlob": "e153398d3d9587948b2e34994eba6bfad3201bb0", + "rawBytes": 24068, + "rawSHA256": "8a6448a5e6fed38c083c2d6a31d5f052779ba4a010c965d75e8bfc38d28220bf" + }, + { + "path": "RMQ/Core/RankSelectCompressed/Readback.lean", + "mode": "100644", + "gitBlob": "a7a40db75b200737879a6dc09bd6108274167493", + "rawBytes": 27080, + "rawSHA256": "dd8432abdb30b392ab4afba052017850e3364acdd936d9ac0813c52b10250bd6" + }, + { + "path": "RMQ/Core/RankSelectCompressed/TableRAM.lean", + "mode": "100644", + "gitBlob": "b3b08991fede6db7fde13baca0367df234e7089e", + "rawBytes": 85137, + "rawSHA256": "f14ea19d2f1bdc5140aa3a95d62c02188783bc57d66dc96d0d133a3143dc8b0b" + }, + { + "path": "RMQ/Core/RankSelectCompressedSplit.lean", + "mode": "100644", + "gitBlob": "f6abb9d96c94ea64613f74c0433dc998e9910e65", + "rawBytes": 59934, + "rawSHA256": "4d5001e41e3ba858364ff364cec7141694b000e27beb49c5eba2ceafb1e60a38" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLog.lean", + "mode": "100644", + "gitBlob": "467c8aac4109a2bd257dd8f7133fce8654f5bbd9", + "rawBytes": 107461, + "rawSHA256": "8375a9291724f3cd2d1ced79bc2d0cebc647ba4f31697d29c0ab7b4fa777aa42" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogDenseWord.lean", + "mode": "100644", + "gitBlob": "f4db180de198d9fb24403776b5b4d7b59bd16d3d", + "rawBytes": 37815, + "rawSHA256": "ae50d15c00085e4cf939493556d9edc36fe968f3578aef69d563419df93677b6" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogDirectory.lean", + "mode": "100644", + "gitBlob": "cdc590a21c0f9d56b6f6fdc9d915c07afdd52b55", + "rawBytes": 14899, + "rawSHA256": "d103bab037ed5384e9ad67a7c75c1413ca12e69da133d9ddce50b504421a1269" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogPackedClark.lean", + "mode": "100644", + "gitBlob": "3a217cfe12c7b35da0c4e8cf370ac0067988035a", + "rawBytes": 22634, + "rawSHA256": "6680bc3363ba3fdd53cc969009a01c4b3798087d8eac6625fa5f8259e12c3482" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogRAM.lean", + "mode": "100644", + "gitBlob": "7caa006d57460f179eaecd9cdcdfcf4c05bd8231", + "rawBytes": 693, + "rawSHA256": "4e88202592d1d079aa9d28c42791bbf6465f25b0b8fe7354718d1780a31f5bfa" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogRAM/AccessRank.lean", + "mode": "100644", + "gitBlob": "8b27619a1027a8431d92efddd4fb7d1098a6d5c8", + "rawBytes": 39877, + "rawSHA256": "3534baaa57f6f89890190a834ec525de855f7e5386d39be34e84e6277ecc1914" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogRAM/BoundedProfile.lean", + "mode": "100644", + "gitBlob": "368fc337f12cd550ba386228aad635850e563003", + "rawBytes": 30376, + "rawSHA256": "252dab632af6357420d51fdf067d011455a8cb4d8e898d3d1432543973da2427" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogRAM/GlobalStore.lean", + "mode": "100644", + "gitBlob": "95e117cb569058c6602ebb529dbaa7ecbe2905c1", + "rawBytes": 40797, + "rawSHA256": "73233117828f3f68e73a9c08956e72e4824081224df65e55d3f93b2b8c2716cf" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogRAM/Select.lean", + "mode": "100644", + "gitBlob": "73e0e1d7098280b56444bf910b29d1e21c129de6", + "rawBytes": 96209, + "rawSHA256": "5fe065f75fb55fff37bfcace55e90bea77aa803ef7216aebc61e47873e130553" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogRankRoute.lean", + "mode": "100644", + "gitBlob": "33789cb8f370c331d331b3118d3db10837e9831c", + "rawBytes": 42290, + "rawSHA256": "e1da9e164906d33e64e07896828d2c03edc87c04c19694bf95dc52fdaecb856b" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogRoute.lean", + "mode": "100644", + "gitBlob": "8b225e804ae9de091c31b44a8ea1a133d7b0f7e8", + "rawBytes": 18358, + "rawSHA256": "350302f2cf8791098f6083d56baeacf54e65030e0487780258cc237facd7c12e" + }, + { + "path": "RMQ/Core/RankSelectCompressedSubLogSelectRoute.lean", + "mode": "100644", + "gitBlob": "27af0637e8c7a4617d0d321192302abbd6ff3b2f", + "rawBytes": 10533, + "rawSHA256": "5b65a9ed62da564c7e6c601efd9134e87af3ff82ed2c3f9b96576fcbcc826977" + }, + { + "path": "RMQ/Core/RankSelectPublic.lean", + "mode": "100644", + "gitBlob": "9c2179edebb3576efcd0c23ead4b9734328f8d34", + "rawBytes": 302, + "rawSHA256": "d7edc9a444df1b31dd630d149dc8ce2cff83c1ad95ed139b3d808c1c7b7d5cbe" + }, + { + "path": "RMQ/Core/RankSelectPublic/Capstones.lean", + "mode": "100644", + "gitBlob": "7ace87b3d6e1aa7a7e0e0e0a74e335b2ebf5add6", + "rawBytes": 11344, + "rawSHA256": "09e4a34adb9cc435c429975c40cdb8ef888c3b3d295c67d710a9bb82e4d152a4" + }, + { + "path": "RMQ/Core/RankSelectPublic/FixedWeight.lean", + "mode": "100644", + "gitBlob": "ab55aa2ca31745f3c2e70f48163b18838886c4af", + "rawBytes": 53031, + "rawSHA256": "50c7fa4c967a673a432c3154f291f5c821635b6740ff3fa6b2d86bda7f953057" + }, + { + "path": "RMQ/Core/RankSelectPublic/Profiles.lean", + "mode": "100644", + "gitBlob": "46b3035ef581885e273b55aed6e7a2a845e84034", + "rawBytes": 127952, + "rawSHA256": "686c599b3d6854203036bdbafbca4655b37da84dbf88dcb6de5a868faf465f5d" + }, + { + "path": "RMQ/Core/RankSelectPublicRAM.lean", + "mode": "100644", + "gitBlob": "e3339975d1c04e4165975d275c47b9d2c4acdf76", + "rawBytes": 62840, + "rawSHA256": "4d75c1ac9e941c4610555aefe5e26fbb7e2c0cd714037a4617a2eab32e806f1c" + }, + { + "path": "RMQ/Core/RankSelectSpec.lean", + "mode": "100644", + "gitBlob": "6d8ccaf62462655b0b0ce282e0bffd442b43c7a4", + "rawBytes": 11211, + "rawSHA256": "2d48b2089432b601337e7fdb6cf9b081d8382a44019068d5df64fbc4867dbcd1" + }, + { + "path": "RMQ/Core/RankSelectTwoLevel.lean", + "mode": "100644", + "gitBlob": "8c220cfa8ac8d84aa69fe5607a6209f4135868c4", + "rawBytes": 10352, + "rawSHA256": "d8b45961567f50a3b679db7ca454e717f105bca4e931d7c9e1515e852d36bb22" + }, + { + "path": "RMQ/Core/Recursion.lean", + "mode": "100644", + "gitBlob": "dbd658aa8a3aaea0951902588e2325c74f318984", + "rawBytes": 17263, + "rawSHA256": "80ecadd010103a8197c845c285199186341f627fa266cc7b4491bfcceb155b85" + }, + { + "path": "RMQ/Core/Reduction.lean", + "mode": "100644", + "gitBlob": "0ecc969d61e989643fb8dbbc3ec3f6d05e7a7446", + "rawBytes": 11885, + "rawSHA256": "a15808ca01f085c691cc30f73eeeb88e8aa858670d4bf0b707f2ded1aa1791ef" + }, + { + "path": "RMQ/Core/Refine.lean", + "mode": "100644", + "gitBlob": "ec8239cabaf375f3bfc214b6cc154c641403bd65", + "rawBytes": 7088, + "rawSHA256": "75953f297de26411af75ea9be3cdbf2fd6d0403ee0ae88e3310ddcd5abbbeb2a" + }, + { + "path": "RMQ/Core/SampledLayoutBudget.lean", + "mode": "100644", + "gitBlob": "e58a66eb35ef0936413b31ee3ad8736c87dbc136", + "rawBytes": 4929, + "rawSHA256": "b3f7627ef1903c5c590a405146c53a5b07469d5e45d59ca5a56d097fe07cd4ab" + }, + { + "path": "RMQ/Core/Schedule.lean", + "mode": "100644", + "gitBlob": "fcced7cb3c1047680835b2abce5f872d82112f3b", + "rawBytes": 1629, + "rawSHA256": "7361d7f853f3dfce417a22b3ba4703d032e21f3f8789a8a2065e2fdd1ea847ab" + }, + { + "path": "RMQ/Core/Shape.lean", + "mode": "100644", + "gitBlob": "61ed0680524d79d62b059a447638f9ae944996f9", + "rawBytes": 72219, + "rawSHA256": "a29366b989e786a5c762764c2da1ffc9df1487be212a113a122384d9a1e2c863" + }, + { + "path": "RMQ/Core/Spec.lean", + "mode": "100644", + "gitBlob": "603ca44bc712453e67d902798e74a78b702520e5", + "rawBytes": 8783, + "rawSHA256": "d32b9ef9873e9c9d8e2aefe1227770f2b565122fae01c0ae86737fa750f74ae3" + }, + { + "path": "RMQ/Core/Succinct.lean", + "mode": "100644", + "gitBlob": "b460c95c2bf20dc03edeab6d265a88d8c0d057c4", + "rawBytes": 51368, + "rawSHA256": "c81af4978110198561b109893832045509d8c8846cf2fcb179c809b5ba67e74e" + }, + { + "path": "RMQ/Core/SuccinctClose.lean", + "mode": "100644", + "gitBlob": "8ee061df2db2a1ba62edd7511ec3c9ec60d4385b", + "rawBytes": 560, + "rawSHA256": "d0dcf4a2d323a65fe03d901ad6c37189281522a75df01447b2c9cf9fde56718d" + }, + { + "path": "RMQ/Core/SuccinctClose/BlockLocal.lean", + "mode": "100644", + "gitBlob": "569a5cc3c03291b3a3cc5ff0e5217932bf95ba96", + "rawBytes": 37150, + "rawSHA256": "818d93bc4665385fd6f5e45431dfc783e1a1d0860dca35dcb9b75efcdb5f0b62" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe.lean", + "mode": "100644", + "gitBlob": "458aa665971c7c7cffe71f26d48f3de64623621e", + "rawBytes": 332, + "rawSHA256": "47f178b980d4386fa297a3bc8352f5d8ffd73ae9ca5c8e5ce8c5994fac04f6f3" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/EndpointMacro.lean", + "mode": "100644", + "gitBlob": "34089d1d97e38401562fef7d6699888830fc1d8f", + "rawBytes": 340, + "rawSHA256": "466d70e742c3b92ee02833f796b1776ddfc3bea4cf487f0eb2f1734b48005732" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/EndpointMacro/MicroCodebook.lean", + "mode": "100644", + "gitBlob": "38329d0ad318d0ac3bd93d2803b32a8d5c4a9674", + "rawBytes": 67344, + "rawSHA256": "3e9dfffd9c463376798509e1e88919a47ea52c39d7df18d8369996954929bf04" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/EndpointMacro/RangeMacro.lean", + "mode": "100644", + "gitBlob": "40b4e597a0fa852cfa830f4ad71348cc20997da1", + "rawBytes": 326, + "rawSHA256": "f9e7c1471b2167bdaf3d049e187224e27aab87971c3404c5f17298c55e0a99d9" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/EndpointMacro/RangeMacro/Concrete.lean", + "mode": "100644", + "gitBlob": "0e3f3210b373d23d4be91110331678bebcbca06e", + "rawBytes": 11573, + "rawSHA256": "1a72c3a22d9ec67b1f7d728e4e369e0af4cc33384c8922583a971ca4224e74b2" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/EndpointMacro/RangeMacro/PayloadMacro.lean", + "mode": "100644", + "gitBlob": "1d699ea46e1c0b615a8e680572994b2f82cc4d66", + "rawBytes": 104028, + "rawSHA256": "9fa35fd83c7f46fba374b549ae1f85f2733a2409ffb03b9ccbeafcc6510cd08b" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/EndpointMacro/RangeMacro/RangeTables.lean", + "mode": "100644", + "gitBlob": "8e0b0bc90120bfa202a46739c3cfc6c9da91dfd1", + "rawBytes": 14161, + "rawSHA256": "c036f7b736abf755a8b8d9b1a02ce5810ad441cdac7f546993f8d5b5af63f041" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/EndpointMacro/RangeMacro/RelativeMerge.lean", + "mode": "100644", + "gitBlob": "8f06664a417869aac1f4733bc3a24dcf86683f35", + "rawBytes": 3278, + "rawSHA256": "abdeaebf1c169c5ede34ef2323c2c942d26c8052be68c6e1e21d2fe0a86c09ef" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate.lean", + "mode": "100644", + "gitBlob": "5ca201264fc579ddcf4fdb1f1e96f2656450fa3b", + "rawBytes": 365, + "rawSHA256": "948813c73489c2642729997dc9ab448eb8fcfb70966a9f6307783f4de5434bcc" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/Candidate.lean", + "mode": "100644", + "gitBlob": "e067e2942b2e845c872886763c774a430ed029ba", + "rawBytes": 18447, + "rawSHA256": "c843aabe9adca16a463efc1307cf629604470e8847d3591131ec29784d4c6d83" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/InteriorDirectory.lean", + "mode": "100644", + "gitBlob": "6d74a5b2a8e982ae5e3d109657ece0b849c9642b", + "rawBytes": 512, + "rawSHA256": "92a2322e6dd91d8d2718e65f52b5dac2572c142297501f0df3882bf84534bc16" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/InteriorDirectory/Base.lean", + "mode": "100644", + "gitBlob": "89e5bda6d58ebf50e115591781fb84f8d7717b23", + "rawBytes": 197085, + "rawSHA256": "65522f59e57be29618bca88a624f9a867c8de02469a42c526b48e087751391a1" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/InteriorDirectory/SparseLevelWidth.lean", + "mode": "100644", + "gitBlob": "091662b3466ce7f5665e27049bd660b3b1c34e7b", + "rawBytes": 98278, + "rawSHA256": "25a067e1c7e41c525680e44bb0767868eeeace8d09825f232cb957ee000996b1" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/InteriorDirectory/ValueDependency.lean", + "mode": "100644", + "gitBlob": "19a52aca2b9587c515cbca9a96c78f666ce32ac3", + "rawBytes": 57308, + "rawSHA256": "b10110a3a0231d1fad754a830ee0397a55ecb894c16b0864b6dd8a0b6f607d2c" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/InteriorRAM.lean", + "mode": "100644", + "gitBlob": "4a14369e2544e5fee6537b1af15bc939688d2326", + "rawBytes": 138383, + "rawSHA256": "e6850be91b2120958019452ee26658ab2aa13cdafd42bdde649b6ba177efd956" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/LocalGlobalSparse.lean", + "mode": "100644", + "gitBlob": "ba73eba0435506a003eb8171f2c583b46a3fb887", + "rawBytes": 62216, + "rawSHA256": "b2a3b8866e5fcb52cc5a0884b22afbe6de2b74c92ced3d36b6f5c1cb8d29efa6" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/RelativeScan.lean", + "mode": "100644", + "gitBlob": "398eab70ba29652f9b277543cc3dfbac7a0ab143", + "rawBytes": 19800, + "rawSHA256": "ad29744da234215194478a2d8d0f2bf31fcca119e5e9c9554a11970f2c9e0b21" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/TwoLevelCandidate.lean", + "mode": "100644", + "gitBlob": "6878e676d40435e66576dc18f81b5e09a6a88776", + "rawBytes": 30465, + "rawSHA256": "6900b5ddeb67df79ba9a1a2b39682fefcd9ea975e2e408ecd8291316748d15a8" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/WordReads.lean", + "mode": "100644", + "gitBlob": "021cc54525f70430c4674b5647a5c53390fbb37d", + "rawBytes": 21966, + "rawSHA256": "995f2e38d1f5c43fcaa1e4815fd2235ea481f7dbdcffe3738eb5cff7bacc37f6" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/PrefixRange.lean", + "mode": "100644", + "gitBlob": "951d7577d4c570889876a04d516e57c45815cb95", + "rawBytes": 361, + "rawSHA256": "a0fed5ee46f3152d63ef42f8791d802fa34ccf8ae9d4a98a3288df1425302b0d" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/PrefixRange/AnswerSemantics.lean", + "mode": "100644", + "gitBlob": "e6b9080d609b8d54ca9bc056365ded1d4051c7b1", + "rawBytes": 38669, + "rawSHA256": "148b0e1db197aadfd8f0927a82a89195d5f066f98b8bff31c92718dca1d66a9f" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/PrefixRange/LocalSparseOffset.lean", + "mode": "100644", + "gitBlob": "583fe8753c3a91d74ee1d15df25a77282eea79f3", + "rawBytes": 23523, + "rawSHA256": "717a2514a0255d9994d780c87e0ba952d193ee791effaff440d194438765b82d" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/PrefixRange/PrefixArgMin.lean", + "mode": "100644", + "gitBlob": "e268cad4f307f063a6e39181e05282cba91dbf26", + "rawBytes": 19463, + "rawSHA256": "02eac18e6679b60a7a78ba101c39e3269c18eaf8202178b3c0335441fe548cad" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/PrefixRange/PrefixWitnessTable.lean", + "mode": "100644", + "gitBlob": "bd8dda3d4b12d29c9d9c32f9196c52203ea4618b", + "rawBytes": 11747, + "rawSHA256": "07538d0e27689bcb02915f5101ed158b5258a168abb172f35de0cf5733c2b56b" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/PrefixRange/RelativeSummaryCandidate.lean", + "mode": "100644", + "gitBlob": "2cc25fc32a01faa71ec17aafd5ce1b83a9cb7891", + "rawBytes": 24349, + "rawSHA256": "4092148fddbf60a1f481128dc96effb2fabd121cad14f8eaa0142ddf6f30ecaa" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/PrefixRange/SparseArgMin.lean", + "mode": "100644", + "gitBlob": "d8b7cc5835d0c4500800542e8c5aebd35b589c01", + "rawBytes": 26488, + "rawSHA256": "bd98af45f9d43b75768e23013eaec66400850215124102c7720be4ca115a774e" + }, + { + "path": "RMQ/Core/SuccinctClose/EndpointFringe/PrefixRange/SparseLevelTable.lean", + "mode": "100644", + "gitBlob": "442916dd0d855afedf97f6017e8b34852462c5f8", + "rawBytes": 10643, + "rawSHA256": "15e23994297d09d37cabdcfb2277bc8f819ff76c307636ac6e3889c1b7e61043" + }, + { + "path": "RMQ/Core/SuccinctClose/RangeSummary.lean", + "mode": "100644", + "gitBlob": "3a7d2c6565961a4df9bbc04d8b5bc8b600a54f6d", + "rawBytes": 40726, + "rawSHA256": "4dbe30022d3066fb44c1405d2c52fd8d4469537b6de0c589db6f99fbabb9a7ee" + }, + { + "path": "RMQ/Core/SuccinctClose/RangeWitness.lean", + "mode": "100644", + "gitBlob": "e8d520c51bf1d0499d6b1e7187e4cb7b18833313", + "rawBytes": 53161, + "rawSHA256": "4a9ef0fad0b84ed02f55a1313353375f5159322da5b159dbc6081e8781f378dc" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro.lean", + "mode": "100644", + "gitBlob": "0ebcb3785a41601599b63b4c16236b0d9f88afcd", + "rawBytes": 421, + "rawSHA256": "9f55f443ed0234e9c509664f31cc90884c455c2783491fdb6eba058fdfcd27ec" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/AbstractMacro.lean", + "mode": "100644", + "gitBlob": "f63c676eb883768f42e5432b28ffc9a6dc552bc8", + "rawBytes": 15565, + "rawSHA256": "4a368521fb415863e5fd77a7b0f4ed83cbd49983dbf4a7cd4a2b6921a0407553" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedFringeChunks.lean", + "mode": "100644", + "gitBlob": "337c4fc4d45377dd66c7fe7cd4d5bd32cad7dae8", + "rawBytes": 82770, + "rawSHA256": "7d3c02bf0f79ff53008d322c7fb92a99449252aa1303fb539222bb4f0b75cc6a" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedFringeSpace.lean", + "mode": "100644", + "gitBlob": "b87d4da61d9c810c3e475605e42fcf5946208bb4", + "rawBytes": 3057, + "rawSHA256": "9aba710a3cf3dd8b830a03fafc7643d79dd30ebb97e2ceb2dbee8a432001cb0c" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedFringeSubstitution.lean", + "mode": "100644", + "gitBlob": "9fe5a3eb571d91f005766ad73b2173fb3e38d34c", + "rawBytes": 20474, + "rawSHA256": "a76b18f22f18d2f26f60136eca544921fc6177b55718e092d6c92a74071d9beb" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedFringeTableFacts.lean", + "mode": "100644", + "gitBlob": "7d65c1129bb43803addbb4d3097b159258eb25b7", + "rawBytes": 10551, + "rawSHA256": "cd0e8f62e7aa6f58eff3cb7c937f2025b98d99af5798c7b8ec55676224670744" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedFringeTrace.lean", + "mode": "100644", + "gitBlob": "acebacbfdaeea14d8de6d8c48749a36c37c76e23", + "rawBytes": 74753, + "rawSHA256": "3958821f9ffb5fe5a3e51664ecf50191af3bc27fef1303bca27565d772b61e26" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedFringeWiring.lean", + "mode": "100644", + "gitBlob": "1a8f2906dd8980e5a3ce9693a46571f3cf22dc67", + "rawBytes": 32250, + "rawSHA256": "be36ba283c012ea66699a85aacc45d435465bd6c535f6bd142f53a231bf2c117" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedRankSelectLeafTrace.lean", + "mode": "100644", + "gitBlob": "b60987b668c0877871ba2532f19897ca768d506c", + "rawBytes": 75619, + "rawSHA256": "418aab560f5e0a6db37cb4d5b3245d44580be8004adcc3a98528dec598b87c96" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedRankSelectLeaves.lean", + "mode": "100644", + "gitBlob": "48ed35549651e348dd1502afb76b6aaf5ce6c66e", + "rawBytes": 29199, + "rawSHA256": "4964ad5844644f486df44f75abc31862dffd3be4a507b503e120a615657bb418" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedRankSelectTrace.lean", + "mode": "100644", + "gitBlob": "8c068a82ac6e13bc730681d1f078847bf1972e9d", + "rawBytes": 29916, + "rawSHA256": "d22d91d49051a544bc511fbb7d0663069323f41bad782b092b147185707fb595" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedRankSelectWiring.lean", + "mode": "100644", + "gitBlob": "a943e146c835d31a5155737dee16d32fabcf96a2", + "rawBytes": 47685, + "rawSHA256": "e4cb679dba4b995b33c411a7fdb49859c4dda0b2d4402ed14c8f673f072d9570" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedSameBlockChunks.lean", + "mode": "100644", + "gitBlob": "aaa722b010cef2771317068ced8e16557af7f4db", + "rawBytes": 12425, + "rawSHA256": "f3e233edd10fc8de7098ed037a3a173a3096fb026043f6f81e9aa83f09d34470" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedSameBlockSubstitution.lean", + "mode": "100644", + "gitBlob": "4057bf9cfd07a629cf2772ca6984f442b3837841", + "rawBytes": 9052, + "rawSHA256": "caa29118f8302cd07d50b7e824afcc30a31c58991446de9af841ca99da7b8c77" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedSameBlockTrace.lean", + "mode": "100644", + "gitBlob": "4ef06fd441d354b64d2da5f679cb6485c7d7a36b", + "rawBytes": 28767, + "rawSHA256": "f68059b658962aa7d00942da93b27415b19d2d04a9d6e5a1614706a914d37373" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedTableRegime.lean", + "mode": "100644", + "gitBlob": "d6684eb8056439c13952a82b6cb6082dc3e4971d", + "rawBytes": 14583, + "rawSHA256": "5988a169fa0aff43326e67252a63fb2c714ad4b2716a0d0f042e409027d38a08" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ChargedWordChunks.lean", + "mode": "100644", + "gitBlob": "8f90421bcd0ce9c9837dab054b49fbdfe30a01af", + "rawBytes": 52061, + "rawSHA256": "32aff7472532a2cd3fdbd8deecb92148466abba6780ceaff695be52f83f467c8" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/CompactEndpoint.lean", + "mode": "100644", + "gitBlob": "bbff25d0a619aa246633377df0af032e4b837aad", + "rawBytes": 24687, + "rawSHA256": "383f30b3c6662f9c455632e6ae96f5935adca6eb65d25642676139db08681761" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ConcreteDirectory.lean", + "mode": "100644", + "gitBlob": "895e3ae4f2c67e5eeee01ff85e6b658dbdb50d7d", + "rawBytes": 104087, + "rawSHA256": "823081f1ff979f77970ba2477cd9f9f5bb6e1255ea15129c061b726ba62cb7ce" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ConcreteDirectoryRAM.lean", + "mode": "100644", + "gitBlob": "15d6269a84fd881fce67bb18f5eb89421c926369", + "rawBytes": 179195, + "rawSHA256": "0ced594de17f432c8fdb3bbdff926faf26f051bcace6b9eb5040d70a91172e49" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/ConcreteDirectoryRAMStoreParam.lean", + "mode": "100644", + "gitBlob": "3ad2cb80ea2286de321d1f174d12e0ee913bf4f4", + "rawBytes": 215174, + "rawSHA256": "074ae2026220430f9b6d00805fc51ba46917c8c0c50fd599a777245e029cc31e" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/EndpointCodebook.lean", + "mode": "100644", + "gitBlob": "c626e0488bd823c04db0105bf7890c5a0d269978", + "rawBytes": 53366, + "rawSHA256": "5029e982326ab8dea8d0e0f22b0a29081f2d802b2c78770e5d7584158bdb66a7" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/LocalBPDecoder.lean", + "mode": "100644", + "gitBlob": "faa3508bc4cd4f0d8c17bd3a1a053e25dba3237a", + "rawBytes": 108893, + "rawSHA256": "54cad93011fda3a464be6f93d102332a375712e3993e4a8380d88eddbe5f5b8a" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeRmmMacro/MacroMicroFamily.lean", + "mode": "100644", + "gitBlob": "d2307e9ccf38c3e0b99460c7ec3e8c95660f82ee", + "rawBytes": 38377, + "rawSHA256": "9d3ceed171681840d7a81d65e2d6507aa1c8922c4a268da9eb4ab0253c01e642" + }, + { + "path": "RMQ/Core/SuccinctClose/RelativeSummary.lean", + "mode": "100644", + "gitBlob": "da0cefdd39bace8e0df283f1724e58eef71ed8b9", + "rawBytes": 181993, + "rawSHA256": "14346d7a6e5c881da559c423a53ce82170ee2a78d77f7ed31282671504af034e" + }, + { + "path": "RMQ/Core/SuccinctCloseProposal.lean", + "mode": "100644", + "gitBlob": "156bd6b2cfa097f0ca2aa474ddd6369fd0a06246", + "rawBytes": 37352, + "rawSHA256": "cff28161c7cdef76f9a9c4b2164f101de8702ccae68312dc7da0ca36e47c3baa" + }, + { + "path": "RMQ/Core/SuccinctFinal.lean", + "mode": "100644", + "gitBlob": "dfcc8f94113a9e2a11682d603aa0481d9e7f4e27", + "rawBytes": 112899, + "rawSHA256": "372a0c59d175950dc6111acbd1e6e71ff8b913b2738912220ccb17d4c08bcfec" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/AnswerValueDependency.lean", + "mode": "100644", + "gitBlob": "bd1b0038ef759d56c0535e90e5458e366937873d", + "rawBytes": 37376, + "rawSHA256": "98337d3b6531adc12573115fb89a70a37c73135d0e66faf8777a9ebbac691f6b" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/ChargePolicyDependency.lean", + "mode": "100644", + "gitBlob": "c94c4983db7afa7b34705e9d1572a5f073b15a15", + "rawBytes": 7656, + "rawSHA256": "963c8592ff3ace70eb6f32367b1367197608b0c52c94b78d8cb645a33025b443" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/FlatPayload.lean", + "mode": "100644", + "gitBlob": "abecf3e426f2672be5abe200d8fc55c50a61ae66", + "rawBytes": 114145, + "rawSHA256": "104480bb2e138921504fb96deb7153d11b603dfa4085fa1dde36b274244a07c3" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/GeometryClosure.lean", + "mode": "100644", + "gitBlob": "38a83b01367b56e5ed6e639efe5b96b1960f9ac8", + "rawBytes": 78203, + "rawSHA256": "67907f202156d3d0583041e4508d3bc33a57623598cb59a57407c41b02d3ddcb" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/Address.lean", + "mode": "100644", + "gitBlob": "ebc70588aeaa33d3acb15aef4d2dbba378589ce2", + "rawBytes": 3578, + "rawSHA256": "6e8f3ec58e4a1c7588ff98c425ce71098916932c5e8acc26e244c8ee5426a119" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/Boundaries.lean", + "mode": "100644", + "gitBlob": "8914eb883e911674243db83f287d573cd8f562a1", + "rawBytes": 16584, + "rawSHA256": "ccf5d924505569fe557db6bf3b6974ada7322393c215656ab0d48dd35c5c5bef" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ExecutedUniverse.lean", + "mode": "100644", + "gitBlob": "c8158a39d161b6941804c5b0287f835f6dd8ca01", + "rawBytes": 13274, + "rawSHA256": "f2a04d822f298bbcebdf7d00cb27cd8e8cd5d018b3b888d23662feb133a194d3" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/Header.lean", + "mode": "100644", + "gitBlob": "7b7e7d04457b10a1b73ee1ae21e7cf8fd1e5587d", + "rawBytes": 10048, + "rawSHA256": "2711a6f855f3a6d83c053b7c32c0a42f4940793266a44959fd804d9886644a2d" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/Memory.lean", + "mode": "100644", + "gitBlob": "a6d761a0d22a890996cedb8ed0a179544e356363", + "rawBytes": 11186, + "rawSHA256": "64f8bf4f8fd67ce1ada3635cfa5608be6f9235cbf3a502342c475e65a1eddede" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/Payload.lean", + "mode": "100644", + "gitBlob": "e3b05f37485fdd5e846d1cb0690bc93fc166dfc9", + "rawBytes": 3060, + "rawSHA256": "500e2ade7d46b6f9c884ebe06d19c031c1cfe7a75852150e3ec50c449ca54808" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/PhysicalRead.lean", + "mode": "100644", + "gitBlob": "4c7c769d3e78c70cd88bf8cd5dfd324a55cd3c7e", + "rawBytes": 20896, + "rawSHA256": "bb56cef34e6e743b4ce522afb8c85882d992e0c6c2128edeb5c71970001724ea" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/Probe.lean", + "mode": "100644", + "gitBlob": "61fce2cf25b936c5d64b446e3159285d823d4a26", + "rawBytes": 36670, + "rawSHA256": "34e468f86dd5c6a35c83b4a5b36e9e217f4661cd94ba219709001c207473709b" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReadProgram.lean", + "mode": "100644", + "gitBlob": "d79bc285b16c4bf26708d2239730bc919479e9f4", + "rawBytes": 109273, + "rawSHA256": "391d87d69679a4d9a263af6193dfdd1df0979541c8b5805569b6215e3998be15" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerArchitectureCapstone.lean", + "mode": "100644", + "gitBlob": "0ff047d065b64bb1ad7f1076b014d31f233cfe36", + "rawBytes": 45254, + "rawSHA256": "4b0ba7708f943095d030448f3fb5b439afeefde0155cf4dd15f037a48e33d7e1" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerCapstone.lean", + "mode": "100644", + "gitBlob": "fd70769b0e7440d6a39dd2c969a40d1a0d8d3441", + "rawBytes": 147820, + "rawSHA256": "81eea178fca3bca16139111db452247addf1cdf1f823164d693a9080558c2394" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerCloseGeometry.lean", + "mode": "100644", + "gitBlob": "f947fbf9bcb771769babd6e44d94ea637aea8b64", + "rawBytes": 6388, + "rawSHA256": "b0828658cbd2453b7bc4178ec859d9c9c77006899c3b20195131f6ca8d8c270b" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerCloseRead.lean", + "mode": "100644", + "gitBlob": "91af3069b59c18350b04a8fa78eea04a5f3c77f5", + "rawBytes": 25600, + "rawSHA256": "e3377018d62a378d745b2402ae46bd61382a10d7f6b490727659e6f0724df399" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerCloseWidth.lean", + "mode": "100644", + "gitBlob": "b8c35e4f11885d78d98697223105f935d8e71c55", + "rawBytes": 9430, + "rawSHA256": "e69298e7d3c8167609c2d74387d5482198f9a6cb783955bb6c6ff0f5bb20768e" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerClosedGeometry.lean", + "mode": "100644", + "gitBlob": "18ca8fdaae1cef137138d1f48ed864c30f7d18fd", + "rawBytes": 21018, + "rawSHA256": "3f97100e132680ea8f901884aa383532031224f99dea4255ab807e8e20b677ae" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerComponentAccess.lean", + "mode": "100644", + "gitBlob": "04881332b811821d2846d80c027281b47982dee9", + "rawBytes": 26856, + "rawSHA256": "35dd259730f4861fa6a3b7cf01af9e9c5b8d4bdb2f0f2f2c214236b7d7585336" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerConcatIndex.lean", + "mode": "100644", + "gitBlob": "af346375821b8054cbc818a9c3b8d17eb2f8bfe2", + "rawBytes": 2676, + "rawSHA256": "b7417d93358ded4340df33ce8a04c4c4c925e54937789ce214488e0c940504d7" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerController.lean", + "mode": "100644", + "gitBlob": "bbd7a6b591a02a8674711a4b1aba44f272437b3b", + "rawBytes": 18511, + "rawSHA256": "ad9943085cf3e19d2f72129d5832af1894c183229cd468dc6eecdbec06572c4c" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerControllerAtomicStateProof.lean", + "mode": "100644", + "gitBlob": "57f72f0fd426bd60288c273b5124194363c55e85", + "rawBytes": 80787, + "rawSHA256": "32f77ac4a2e5cd72610ffb19d2f120aa9250d6f22f44a0cdae825cc5238f8cee" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerControllerInteriorStateProof.lean", + "mode": "100644", + "gitBlob": "a86164d6d74f777e78ff6dd7e49a334821ef57be", + "rawBytes": 169358, + "rawSHA256": "04c50199443ef903cb2a0394b47df18cdbc2fce75893ffd33b34ca0817c95064" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerControllerProof.lean", + "mode": "100644", + "gitBlob": "5948c993ad3ea8d877f524b1248c3f50e302eee1", + "rawBytes": 267859, + "rawSHA256": "1225a5d847b0f3d4d9653a51dfaa39a51a744a13d524261236286fc98e993401" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerControllerStateProof.lean", + "mode": "100644", + "gitBlob": "444998dad04b49577dc4eeef976dbb6591894a4b", + "rawBytes": 666290, + "rawSHA256": "1370f7c9761438a5a552b7d14ae408f680c77a5feff90f8ba96ecfe904cebf58" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerCrossing.lean", + "mode": "100644", + "gitBlob": "c7153e9b189d8b8d4f18752dce746780f4a999bc", + "rawBytes": 6949, + "rawSHA256": "003be10aa05f2b025f83ece30ec7a91a4f092ca9179b5ff2ef33ceb433a2ae28" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerEntryAddress.lean", + "mode": "100644", + "gitBlob": "c0b2838b27f82f08f95aba2060a66495802103b7", + "rawBytes": 4461, + "rawSHA256": "41e67f063a92159e64467a56fef20828ad65e8ac585a53cf815812177b96b214" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerEntryChunks.lean", + "mode": "100644", + "gitBlob": "0d00015db8fab7b4f74fb96e4cd1090d1d8bc69e", + "rawBytes": 5696, + "rawSHA256": "9b365ef07a62fe3d989c3edda7119d72d765b9676c88a40fdf258d12460a4fd9" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerInteriorCount.lean", + "mode": "100644", + "gitBlob": "60256fe7847d3d4a67cf7caefe13b77e3f5ba021", + "rawBytes": 5697, + "rawSHA256": "4f07d21a9fb1c6799131c4d4f778616a60bc18ccda0b42c4d27251663f2731e3" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerInteriorProtocol.lean", + "mode": "100644", + "gitBlob": "d2854754dc95a9e31e51dc195a241b71fedd1632", + "rawBytes": 18142, + "rawSHA256": "ac1eca986a2411b88393c5006c89caaeba97c86cebd0b4ab67a8cd958547d159" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerInteriorRead.lean", + "mode": "100644", + "gitBlob": "8e9c438fed0647458f7a1327f75793606863a0da", + "rawBytes": 67674, + "rawSHA256": "074780f3536806de36bc094bda66ac0448529992e5c406f85824c63edd75b1df" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerInteriorWidths.lean", + "mode": "100644", + "gitBlob": "e1f31da3b9d75d7e39a15c9e737fb1ae35ee7572", + "rawBytes": 4120, + "rawSHA256": "f08390b3a3c5acf0036dafead1a6384607317681c31299e7b4225971eaf43b7a" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerLcaProtocol.lean", + "mode": "100644", + "gitBlob": "dfbb331734acb2caec2ac0a93bd3dfd2ad808a59", + "rawBytes": 14664, + "rawSHA256": "b06e4d6c57bafa21eb75f76af099b18bb975fface9025f3ab5f7ea2ef8016d7a" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerLength.lean", + "mode": "100644", + "gitBlob": "f90134ab632650a472376a717a16f42da3126eba", + "rawBytes": 9730, + "rawSHA256": "3589bc63e435f307a5a6457da7043dca5a2af9dd4018f615ebed4a194c1068cf" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerLogicalLowering.lean", + "mode": "100644", + "gitBlob": "2761635255e7ecd0fc21657ed9b13671ea95e97d", + "rawBytes": 17195, + "rawSHA256": "ce1f85f0181467ac28e431df8be90010649fdb541038278a20d29d82cb3db895" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerLogicalProtocol.lean", + "mode": "100644", + "gitBlob": "e7ae736b75083987ba8bab9145c3b869e87b107a", + "rawBytes": 21803, + "rawSHA256": "e9169be01037693a6893cb46e5f99e4ae8f2aa79c415f0c9d2baf0098da19bb7" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerLogicalSimulation.lean", + "mode": "100644", + "gitBlob": "a6cc3b1e1af37c9bd8823575a2d393b043723491", + "rawBytes": 321234, + "rawSHA256": "7f2f353f7d53ed1e0bcb0d963a162193b6c87c912a8d80d5fcc683e0ba06e5b1" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerMachineWords.lean", + "mode": "100644", + "gitBlob": "9a99e1ff78af3cef013b8d6aff6337c7629edc95", + "rawBytes": 5023, + "rawSHA256": "63aae89d756e47255ad8821b336b3d3d2fe1607fc03c7771f2b36c6a35bc400a" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerMemory.lean", + "mode": "100644", + "gitBlob": "ef3f7d4ea754abd4c0c3546cf1b2b4d36b8465b9", + "rawBytes": 8450, + "rawSHA256": "b25d62bcba1bff603ee1e364b8ea355a36010906d159927aac800eb1145179f8" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerPayload.lean", + "mode": "100644", + "gitBlob": "0159323644e76ef425870fc819603dd8edd3e2c2", + "rawBytes": 3868, + "rawSHA256": "f383ac00585ef7389c72610ba44e2941f45f6b6e9cc13ad6fa39eddd38b4c75c" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerPhysicalRead.lean", + "mode": "100644", + "gitBlob": "1986df34c14482836893e4d7bb3e8a9edf74e691", + "rawBytes": 17684, + "rawSHA256": "4c773ad3fa0eec82dfabbe8f142a07ad583b4dbae9455abfd57cc593d1ab833b" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerProbe.lean", + "mode": "100644", + "gitBlob": "58bdcf99bb16576ed803a67f411a4d6eeb039bef", + "rawBytes": 24594, + "rawSHA256": "01280eabbc2cdb4bb38e1ea22e3a55e6c64fcb9ef8ac4723d11bc26215317bbc" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerSelectProtocol.lean", + "mode": "100644", + "gitBlob": "3081c1fb9cfc055c075aa6a3e2f35b00df976799", + "rawBytes": 15312, + "rawSHA256": "6bf0867042f07b9a4b8a26ef8ac83e5144c0a533932f10ea9e747bbc010f0a3c" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerSourceAddress.lean", + "mode": "100644", + "gitBlob": "0c5dec614ce2126b39c673cfe8b61701120ceda1", + "rawBytes": 15768, + "rawSHA256": "93eb4ef3697ded2867172d7e46e690550ebffbcbc3d9003ca83863c2115dd9ba" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerSpace.lean", + "mode": "100644", + "gitBlob": "c7057764aa6b1f8c1a82e343d9009bd13ac4003e", + "rawBytes": 4177, + "rawSHA256": "56918f51dbde05f1b69e449a6e41e944d706a65f2423d549426a3037b2d76bbf" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerSparsePrelude.lean", + "mode": "100644", + "gitBlob": "c87a9c2b16b7c2d97aec3ac36819b9f239edbc7b", + "rawBytes": 48493, + "rawSHA256": "3a99ba036f6651eee2a0823dbf2a6bac365d5d6ab78a52949dda0d480ece8da4" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerWholeProtocol.lean", + "mode": "100644", + "gitBlob": "5cf50ea9ff605f87dbb030434272cdeaa8d47778", + "rawBytes": 7961, + "rawSHA256": "492436c51e2cad4efc13ab2b6d20704492780eedb5f2b4bd9e3213f0331e045c" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/ReviewerWidth.lean", + "mode": "100644", + "gitBlob": "2fae800525e8c8369c4e5074ff62847daa53251e", + "rawBytes": 8932, + "rawSHA256": "07f0a4d08ca3a599bd1da8d747cb7298376a74dc24d8f722b411b41ad64e16d6" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/SourceFactorization.lean", + "mode": "100644", + "gitBlob": "acf7bb30e858cbe32c1647db2af04c03fdba6c2e", + "rawBytes": 54824, + "rawSHA256": "04500a8a27354b5b2a19be2db4067ed56d85268a8d266e4f411a82e7b9f4c693" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/SourceGeometry.lean", + "mode": "100644", + "gitBlob": "93255811da5f1425eee0de3d6be09c573f502090", + "rawBytes": 24195, + "rawSHA256": "99cced87772781d6c4311f92831277dc08bb5481ef411bef24db8a5a0aa351f6" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/SourceWords.lean", + "mode": "100644", + "gitBlob": "e789fa5ca1abc60baa34da12545a4807bae30a6a", + "rawBytes": 46805, + "rawSHA256": "901cbe8a30f7ffa92aad48f3deb7e01b5384cfb17a7b912d32d999ff020b5f23" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/Space.lean", + "mode": "100644", + "gitBlob": "bf01a751a9fc492cbcc559889ebf88d1ff8df654", + "rawBytes": 7427, + "rawSHA256": "e128db764c24210cfb01ca197cac427eae126dd743d5695f580c414071791fe4" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/PackedCellProbe/WordWidth.lean", + "mode": "100644", + "gitBlob": "f2d02a7e57e5a2d64df9b137ab6c60c70ae729c9", + "rawBytes": 15289, + "rawSHA256": "462c7120f2480cec505eb53e2f6f49feadfb92eb968504912b1d9ada086992a0" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/RankSamplePresence.lean", + "mode": "100644", + "gitBlob": "27de147785acd15a0ab9e6d982df9fefb76ad088", + "rawBytes": 3533, + "rawSHA256": "7ccde8f52d75ab0f61ec809847ded226c93e3f167c35522e8e923aca4db1446c" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/ReviewerPhysical.lean", + "mode": "100644", + "gitBlob": "2bb6feeb97019a0272d2187731525a38a46ff935", + "rawBytes": 109271, + "rawSHA256": "0e506752e7843836ce715c57287ca3fc016d7cbb13e817c77a8de6ac9d27ddb1" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/ReviewerReachability.lean", + "mode": "100644", + "gitBlob": "fb7118cf5d3290ee506d7db8a6fb79746449458f", + "rawBytes": 2229, + "rawSHA256": "aeebf633c95249b42363291497fab824930fa00389b218cc5e7f3c611e564b92" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/ReviewerReachabilityLong.lean", + "mode": "100644", + "gitBlob": "bba67f1127442705e77960222ad8e04a7712a0a0", + "rawBytes": 45733, + "rawSHA256": "564d7071713bd24a65324fc2ba323f652e3d446ff893d580878c27e4cc12f17c" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/ReviewerReachabilitySmall.lean", + "mode": "100644", + "gitBlob": "a6d1a0bc2c62742f224f4ead56129aa2e5fdcb6d", + "rawBytes": 181882, + "rawSHA256": "0e0fe1e5f7e56104eb8007bff55b844b1ec9627f88f5cb519b0a8db625297a18" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/ReviewerReachabilitySparse.lean", + "mode": "100644", + "gitBlob": "4e7f89b5ed2ab1c410f802fd6514737fd1f733e6", + "rawBytes": 52496, + "rawSHA256": "d9c8b7d2c3fa7d8412e2752f773aefb3a92a3b107a9094f1d50b65860c1b4c11" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/Segments.lean", + "mode": "100644", + "gitBlob": "6810dd6d61d2abcccfd7ba66275cfefbe08da882", + "rawBytes": 13423, + "rawSHA256": "f99920a82633074ff9018646d221154b2d23cebef860a3ba3ff09164d0abac81" + }, + { + "path": "RMQ/Core/SuccinctFinal/RAM/SourceInventory.lean", + "mode": "100644", + "gitBlob": "f5bcc60a95064495ad4c1281f0514fb225cf393e", + "rawBytes": 29029, + "rawSHA256": "5577b4ec99644dbd95e5bafa326559dc039cea3a33398b108ad51faa949eae04" + }, + { + "path": "RMQ/Core/SuccinctFinalModelAdequacy.lean", + "mode": "100644", + "gitBlob": "3825f4a6f4f69bdeeb96bd9eff39f9bdca45929c", + "rawBytes": 64523, + "rawSHA256": "c86323db215e020cb46b88b2d92baff8dc210d8270e2b821b60eacd22f3e11b4" + }, + { + "path": "RMQ/Core/SuccinctFinalRAM.lean", + "mode": "100644", + "gitBlob": "0322bf5a41be302b34d896d0af4376e6cb99a186", + "rawBytes": 477273, + "rawSHA256": "86e5424b05bd18a81baa544c4a0e1638b536a6b4a6ff3b7fa818e61297d3fc33" + }, + { + "path": "RMQ/Core/SuccinctFinalSemanticProvenanceAdequacy.lean", + "mode": "100644", + "gitBlob": "f5e97ca118f226b3a0b59b10b7f05112923065a7", + "rawBytes": 9411, + "rawSHA256": "9587364b193c18afd385cb821f1e28e2048d7dd2011bc420d5a53817e99a1bb7" + }, + { + "path": "RMQ/Core/SuccinctFinalStoreParam.lean", + "mode": "100644", + "gitBlob": "14c0afabd2a1805872f5cc4bc7e82f872f5396b4", + "rawBytes": 177042, + "rawSHA256": "466df9555bab1ebe77567dc6d269c2de7f73c421bd78be15c0271b0d292c4636" + }, + { + "path": "RMQ/Core/SuccinctRMQ.lean", + "mode": "100644", + "gitBlob": "4feda48014aa356025889981762b78e31ed9f899", + "rawBytes": 478, + "rawSHA256": "73ca46469d58dd6c83a1d98e685d96c8bf148ea64192d6bc194c81592b5158e9" + }, + { + "path": "RMQ/Core/SuccinctRMQClassic.lean", + "mode": "100644", + "gitBlob": "01b511aad872612ce166c1d0d96d6081ba59b04a", + "rawBytes": 76386, + "rawSHA256": "07d34d2d79dc23b04235802d61abff2695f521131d0816304e79b3c1c6ecc177" + }, + { + "path": "RMQ/Core/SuccinctRMQClassicProvenance.lean", + "mode": "100644", + "gitBlob": "a37ca75cd7669238e05f4d19ee139e1242dc0940", + "rawBytes": 526, + "rawSHA256": "8e287fe880c7d032c577a1a5a3eff2efd7ca0474775f8b8206fc5557b9c9323a" + }, + { + "path": "RMQ/Core/SuccinctRank.lean", + "mode": "100644", + "gitBlob": "ba1ba86a9ab526bbcf5746c4c5400c57dd73062c", + "rawBytes": 85740, + "rawSHA256": "164f2c7bf988559db4efe7fc8c933e91db66737c9c6f0297d6993831ffff335b" + }, + { + "path": "RMQ/Core/SuccinctRankSelect.lean", + "mode": "100644", + "gitBlob": "82ebfd14204b919f3141fd7362afea7e1871756a", + "rawBytes": 401, + "rawSHA256": "6789432b6e1c59b2ecbce3e5fc1decf5a7cc2d82b4fd3a4deaa98fdfb7d60fe3" + }, + { + "path": "RMQ/Core/SuccinctReduction.lean", + "mode": "100644", + "gitBlob": "94a75f24fa25cdc5426d5cfea4a1cef25b403804", + "rawBytes": 6584, + "rawSHA256": "966b4471c7205b46bbf1c318cd0eb72839af33c4a787c50f1f08bf3ce5057b1d" + }, + { + "path": "RMQ/Core/SuccinctSelect.lean", + "mode": "100644", + "gitBlob": "dfce8f0617117c1b293fe9bc9da81c2c3c5bc182", + "rawBytes": 513, + "rawSHA256": "77af4c71d354803ba080f4c07cb78112bd1ab5ec5efe9b245596c75682f027ff" + }, + { + "path": "RMQ/Core/SuccinctSelect/AsymptoticFacts.lean", + "mode": "100644", + "gitBlob": "58c23a12a99c3fdad48652701c7715352d22b0f5", + "rawBytes": 4446, + "rawSHA256": "8e628e9c4a94f239ac78157f9a2874e5596b5c8e9cf37e765968ca1382086bfb" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect.lean", + "mode": "100644", + "gitBlob": "c5fddddf9a85fbce80438ac2b74c69c0bccb267b", + "rawBytes": 313, + "rawSHA256": "90e100621f7052b4545c153a3f97cffb273cfa3ec8db909885091deb69ccb658" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/Basic.lean", + "mode": "100644", + "gitBlob": "69853b8a71f3024992567c410d0f005b53679e33", + "rawBytes": 11068, + "rawSHA256": "b845bf8d2d94d1c92bad544d5a1bc8afd7f13f2d2be451d370d36ca3e20d0283" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/BuiltRouting.lean", + "mode": "100644", + "gitBlob": "2e109af66d7cd139b59c7dddecc8bb567f1f2e39", + "rawBytes": 288, + "rawSHA256": "6d7093c011db8b7172463714b57556cfed2f22d19528002936dc67008748dfce" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/BuiltRouting/FlagRankTables.lean", + "mode": "100644", + "gitBlob": "3360f878dffbc4661b1b8fd24ffdaf1de3157c12", + "rawBytes": 38260, + "rawSHA256": "f4ac00df7b9c78ab09b9962f7a18d9aab68a6fa1b6ac152d7e2c7258276ee069" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/BuiltRouting/LookupDense.lean", + "mode": "100644", + "gitBlob": "b02bdd80627bdb720b4d1a6fa1e6841f64dba8c0", + "rawBytes": 69962, + "rawSHA256": "29fb384ace2db0c5716e07211e52707345da8e9e492a9030155ea419900a3b47" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/BuiltRouting/RelativeEntries.lean", + "mode": "100644", + "gitBlob": "5ddfae27199921e419672c3c37648fc808086f07", + "rawBytes": 34046, + "rawSHA256": "125c26c48d1bf6faec9d2f22af23a171a3920f803c42f502692fa1d649b22361" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/BuiltRouting/SlotBasics.lean", + "mode": "100644", + "gitBlob": "e469e746c7765371ff3872d3fadb052529fd6a94", + "rawBytes": 21244, + "rawSHA256": "f71f91bc5cc954ec2bd4b979837f1d6d2e7924aea42af76b495f1867a3baedfe" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/BuiltRouting/SpanBudgets.lean", + "mode": "100644", + "gitBlob": "19c93d634b808f142daa3a4efb7931cd1272adc3", + "rawBytes": 48486, + "rawSHA256": "393e33b53c6311fb5982839d0a1adf4b89f470a893cda779ae98fc053c590a6b" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/BuiltRouting/WidthBounds.lean", + "mode": "100644", + "gitBlob": "f08f6a261fa432eba35412a6e569ee797dc0ead9", + "rawBytes": 24531, + "rawSHA256": "0f179c2cd32543c45759957ffd726e426400954f8a045d1c0ac880e3ad55b955" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/RelativeSplit.lean", + "mode": "100644", + "gitBlob": "3f863a3f82dc237bed13456dc9750261189dc191", + "rawBytes": 63699, + "rawSHA256": "9ac682ea9a955744e44e79235112fc7609bcaabe6af3f04dbe63e6bf50631bf1" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/SparseExceptionCloseData.lean", + "mode": "100644", + "gitBlob": "8a10e10b09ba760fedef5f0459192f379f72053c", + "rawBytes": 291, + "rawSHA256": "4cc881e966d4fbdeb725e2810718338464741c339f934aecc09aa747796ae482" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/SparseExceptionCloseData/BuildProfile.lean", + "mode": "100644", + "gitBlob": "506da76c581dbd3d93c2a06769ca4f0c51b07390", + "rawBytes": 21950, + "rawSHA256": "5b43a04b43b22e69abad58a00394a6f54b519b84e9938473638a2cfb6d4609c4" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/SparseExceptionCloseData/BuiltExact.lean", + "mode": "100644", + "gitBlob": "b0e90c53da64b634b5783d591d375096aadc27e4", + "rawBytes": 52144, + "rawSHA256": "d1fa216a2236b3dd3ca6924373af9a93d0644dea9bcb338f2bcda18c76c3df36" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/SparseExceptionCloseData/DataSurface.lean", + "mode": "100644", + "gitBlob": "44cbd5a1e69af52a787b564b488eadf01bfa3a27", + "rawBytes": 37534, + "rawSHA256": "42ed0155c69a52fab233c97d370fd8d94a112497e527af21a4c5ae08c56d02ab" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/SparseExceptionCloseData/Obstructions.lean", + "mode": "100644", + "gitBlob": "a5ee14903331f8ace20f90bb2eebd0fb573ec24f", + "rawBytes": 14078, + "rawSHA256": "f8a9efe1125544e95cdfdf72d1be46e215e2f470298c65de5f47e1868d4ec837" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/SparseExceptionDirectory.lean", + "mode": "100644", + "gitBlob": "283fa43325de9f3385663ccb1f3b8c589a9da1b3", + "rawBytes": 12680, + "rawSHA256": "60ce8cb87f721a02edcab06ce16fdd164c276c93e393d51a911cb5e8d35e6a7e" + }, + { + "path": "RMQ/Core/SuccinctSelect/CloseSelect/TwoLevelObstruction.lean", + "mode": "100644", + "gitBlob": "3291b9b7af347fb9bcf5217442a2908e96d8f8d0", + "rawBytes": 10997, + "rawSHA256": "e77b820c1c3505cecb3f9da5a8dab6e0cac55ca7de6cd9c0f00787931e0f696f" + }, + { + "path": "RMQ/Core/SuccinctSelect/DenseLocalTables.lean", + "mode": "100644", + "gitBlob": "fa88b2ae3d53b69e2573977945f5e8004a6aa479", + "rawBytes": 29803, + "rawSHA256": "eb63021d1866bf0f9a621270fcfbb0d43fd5cac72feaaec230d3ca0fb57245bf" + }, + { + "path": "RMQ/Core/SuccinctSelect/Obstructions.lean", + "mode": "100644", + "gitBlob": "5e798a009b817f5af9daf132d5eafe0374b29646", + "rawBytes": 4942, + "rawSHA256": "793840f544cf0ba04fde983e19cd19fab4b37fb86dc3e0442b0ee4b399599f30" + }, + { + "path": "RMQ/Core/SuccinctSelect/TwoLevel.lean", + "mode": "100644", + "gitBlob": "bb789ffa7b1fc5a667e4dd38e6899d35d98fbca3", + "rawBytes": 308, + "rawSHA256": "016c04966b6641d8dd2011856d1bc953f5a8769c2808b7eda81416e94b8de74e" + }, + { + "path": "RMQ/Core/SuccinctSelect/TwoLevel/BPCloseNavigation.lean", + "mode": "100644", + "gitBlob": "06db1a1962d39a7591b7f59a7b17210373382ffa", + "rawBytes": 31111, + "rawSHA256": "4bef79b1c636f11defe0a48035461c25958a4b203f3d2c6bf04b1d3e812a825e" + }, + { + "path": "RMQ/Core/SuccinctSelect/TwoLevel/ClarkSource.lean", + "mode": "100644", + "gitBlob": "a12c8e170af24ae46ec589a1c17875fdd19a610d", + "rawBytes": 40412, + "rawSHA256": "5bc9b60b0a33ee3ce6ecf02a9e6f4b05a8d308fbdc1a83905110f78fe598ed86" + }, + { + "path": "RMQ/Core/SuccinctSelect/TwoLevel/RankSelectAdapters.lean", + "mode": "100644", + "gitBlob": "a2ae1db530305b1a4c0e850d4a5a5c8723fdc18a", + "rawBytes": 48810, + "rawSHA256": "4eaef65f1bf992e99862e839c2b66eb928280812fe696a29f3c53593cee51c61" + }, + { + "path": "RMQ/Core/SuccinctSelect/TwoLevel/SelectData.lean", + "mode": "100644", + "gitBlob": "9d472b979908fb983b5e298edf46d9508d5b10bf", + "rawBytes": 44328, + "rawSHA256": "9d53aa16d945be4ac2ef041ad3850f7150fefd99b7696a0cb75aa38b4246092c" + }, + { + "path": "RMQ/Core/SuccinctSelect/TwoLevel/SelectSamples.lean", + "mode": "100644", + "gitBlob": "3517212958a3693e10dad86c687190413d6074c5", + "rawBytes": 18838, + "rawSHA256": "03b22a47cca422eda459fad2b14eff1ee8fa822f0d54b254a72c7d6ae9a8a329" + }, + { + "path": "RMQ/Core/SuccinctSelect/TwoLevel/WordExact.lean", + "mode": "100644", + "gitBlob": "581f2c827a37acc6eb74bdde22cf1e37168b7394", + "rawBytes": 52552, + "rawSHA256": "c50b1cf6d8b98ae698918955b84ee490df1bdcc662b68b5b0e8a3441aad9bc22" + }, + { + "path": "RMQ/Core/SuccinctSpace.lean", + "mode": "100644", + "gitBlob": "d783c95f6cb3df03726974799c3c5c45d4a9eeb5", + "rawBytes": 973, + "rawSHA256": "2db86ca92d7efbeb75b4deb59a039aca1e1c9dfe9bd597330a814568a12d7feb" + }, + { + "path": "RMQ/Core/SuccinctSpace/Asymptotics.lean", + "mode": "100644", + "gitBlob": "af612389cd21990dd0ef4d9bb01d463acde8ed16", + "rawBytes": 26945, + "rawSHA256": "39493f9bd2b86c041ed7471c310244e4fced9de831c566a8feb8593ea783ffce" + }, + { + "path": "RMQ/Core/SuccinctSpace/BPAccess.lean", + "mode": "100644", + "gitBlob": "b62d57c1c04c29150f263d9b1447997524213fff", + "rawBytes": 52646, + "rawSHA256": "f79b2360503863665f30953566aeff88bac736063f725c599858460f13f344df" + }, + { + "path": "RMQ/Core/SuccinctSpace/BPCloseLCA.lean", + "mode": "100644", + "gitBlob": "9d66a2f1e072b06b6b04f4b04dc595f8d8266e44", + "rawBytes": 17239, + "rawSHA256": "00c85beea48b2dfa4befa8a3daaf70ada06f876b71f7dae6cc185ff47dc465af" + }, + { + "path": "RMQ/Core/SuccinctSpace/BPCloseLCARAM.lean", + "mode": "100644", + "gitBlob": "ac21de8f4ba5461e8c51097d651d57d947a70c00", + "rawBytes": 5072, + "rawSHA256": "776d7f64c12cf9f6515d121fecfaa28c963887c0c9dd34e834cfc9b2fef3c1df" + }, + { + "path": "RMQ/Core/SuccinctSpace/BPCloseLCARegisterRAM.lean", + "mode": "100644", + "gitBlob": "8607c7e164cc3a9c302d141c2d4c92d68473a72c", + "rawBytes": 4528, + "rawSHA256": "b0a06aa49afce16a491b65a4ccef84b0c406c00da2c6e66a2470d1326c6c65e4" + }, + { + "path": "RMQ/Core/SuccinctSpace/BPCloseRMQNavigation.lean", + "mode": "100644", + "gitBlob": "e8e8389d7d3dd442a58b134b84a568e1137e08ce", + "rawBytes": 59260, + "rawSHA256": "9f7fa7ccddb6f4106559d483ea35313bd1ae34b00f27259723da6ad9e4a1ab55" + }, + { + "path": "RMQ/Core/SuccinctSpace/BPCloseRMQNavigationRAM.lean", + "mode": "100644", + "gitBlob": "42ba05060237de74f6921164e0078bba0e446a04", + "rawBytes": 16474, + "rawSHA256": "11541f260779f41468bece8c941b16b6ed06ab32487aeea9f916279dc36248de" + }, + { + "path": "RMQ/Core/SuccinctSpace/BPShape.lean", + "mode": "100644", + "gitBlob": "b83298be618d812bd3d7e0c313fd98f1a57734f3", + "rawBytes": 17600, + "rawSHA256": "633c2cfcee96751d7cb84b5492a16e1de3a79b7be4904c799188363d5b75a00f" + }, + { + "path": "RMQ/Core/SuccinctSpace/BroadwordRMQ.lean", + "mode": "100644", + "gitBlob": "84c7b31c15a4ba1eab3737e7331847b69ee04677", + "rawBytes": 21930, + "rawSHA256": "fb21261792e59fec4a48350a968076ca8e45454f7f7cba32ef36538db5f163ad" + }, + { + "path": "RMQ/Core/SuccinctSpace/MachineChunkedTable.lean", + "mode": "100644", + "gitBlob": "26a623359419bf1491798cfcd9d1bc4155c3ddd5", + "rawBytes": 19547, + "rawSHA256": "ca5804e728e7ccb5aee8c8bc2ebc220d5e7ae27a5bd286599337bc6eb682576a" + }, + { + "path": "RMQ/Core/SuccinctSpace/MachineChunkedTableProgram.lean", + "mode": "100644", + "gitBlob": "7466cf23d244db2b6e548a2fc4a9cdd4d8958aee", + "rawBytes": 21392, + "rawSHA256": "e8baa33aa98dbbc67cd12e033b85da1bc0b3a46303938a6a47a400c5fe34fb80" + }, + { + "path": "RMQ/Core/SuccinctSpace/RankSelect.lean", + "mode": "100644", + "gitBlob": "131618d64c79cbb4ad657ed53afd65e367b63a11", + "rawBytes": 54995, + "rawSHA256": "8ddb5d45c8ea60413ec5a0478c968895172406e855a4b1e5bb8405ecfe66b4a4" + }, + { + "path": "RMQ/Core/SuccinctSpace/RankSelectRAM.lean", + "mode": "100644", + "gitBlob": "3eb3b4e8c0607c54848dfb03e6ec3ee597132240", + "rawBytes": 19827, + "rawSHA256": "42ce073d6492ee4fad5e45a3d41f26b73bbe6493b33acc189aeab8681342f0ee" + }, + { + "path": "RMQ/Core/SuccinctSpace/SelectSamples.lean", + "mode": "100644", + "gitBlob": "10cdeafad9e07c0b8a476be754f2128e85c5198a", + "rawBytes": 26310, + "rawSHA256": "62b18fa9cb7301daa61490224c65068a38b3fb10d48b9e9fef57359194b23495" + }, + { + "path": "RMQ/Core/SuccinctSpace/SelectSamplesRAM.lean", + "mode": "100644", + "gitBlob": "1cd7e04d03968c80346d1fe316f6e1c07ae29720", + "rawBytes": 6806, + "rawSHA256": "4931e8c80a9490df33add8de32ed3de84041fb16a7e01b8031f400c44c01aff4" + }, + { + "path": "RMQ/Core/SuccinctSpace/Tables.lean", + "mode": "100644", + "gitBlob": "6c88706b7cc13246ecb83ca81e057c35bf31f12f", + "rawBytes": 21024, + "rawSHA256": "5676c8b39b17eb0c183c9ce7c7e5b7210ceb947182d44933355a24bfb34a3bbf" + }, + { + "path": "RMQ/Core/SuccinctSpace/TablesRAM.lean", + "mode": "100644", + "gitBlob": "27090541304ff011ec275db5059355b5adb4cf57", + "rawBytes": 11069, + "rawSHA256": "6e5e99094b6b9d4c273af2a6d3988c7627feacc8ee0f75adabb2652fad4322be" + }, + { + "path": "RMQ/Core/SuccinctSpace/WordStore.lean", + "mode": "100644", + "gitBlob": "3c07a23045937c7ad80fdcc7803ec009555f119d", + "rawBytes": 26560, + "rawSHA256": "e508f5eeba21d642e94d391b29e0da85228a941539c341bcc97b333d2a23bc34" + }, + { + "path": "RMQ/Core/SuccinctSpace/WordStoreRAM.lean", + "mode": "100644", + "gitBlob": "c23a0e494a12689299f48c09d65cca477bebf609", + "rawBytes": 4183, + "rawSHA256": "e73d6d9db3d61e28cfa9f108e23c97e8ca3c7176a59c28e14b91c320574ea5c3" + }, + { + "path": "RMQ/Core/TableModel.lean", + "mode": "100644", + "gitBlob": "9fb40d4a2f2c8d1045b991d639359c00d4a1adae", + "rawBytes": 7753, + "rawSHA256": "b015b94a0b2e130b6e6abbb44415868b824ad5242148d614355e580efa5d8159" + }, + { + "path": "RMQ/Core/Window.lean", + "mode": "100644", + "gitBlob": "d8cfc10c688f5193eb862f900103c5335cd0658d", + "rawBytes": 4323, + "rawSHA256": "c135e68a11af7ff52623a7ccd8439330a93d5758b2e548330889bbf04b08432c" + }, + { + "path": "RMQ/Core/WordRAM.lean", + "mode": "100644", + "gitBlob": "611e796270c9413f36f1ed40842118b5641f5d1a", + "rawBytes": 53644, + "rawSHA256": "7a47ced349d84c379135918115e3a0424b1de2d9f4dda0bb774ff42a94a174a9" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/AccessExecution.lean", + "mode": "100644", + "gitBlob": "e2069d581b36fbf2393dc27f75ba14df24b40df9", + "rawBytes": 2350, + "rawSHA256": "966e88f15b6ced25c337f4614b774fe85aaa0358e44f7efdebfb5be0a0087300" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/AccessProof.lean", + "mode": "100644", + "gitBlob": "6152250b759c657f138216585a314614e3ee289b", + "rawBytes": 15716, + "rawSHA256": "0077fe19d2e693d7f02936fdb4a9592d68b9e67ac1fb9a1e905d361f1db30de2" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/Allocation.lean", + "mode": "100644", + "gitBlob": "e51fcf76f8884a8ccf440e199b8d30d1cc8218a7", + "rawBytes": 3101, + "rawSHA256": "b4de6c3b923589a2aa890399d7d0b8236e3c46e1608ade74f8cefe65b60f392b" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/AllocationFacts.lean", + "mode": "100644", + "gitBlob": "56b5fb206f1faf1eb5014a9f24d3fc6ef896ca0b", + "rawBytes": 5997, + "rawSHA256": "f189969208b13333219ee460db8581d43babb88f18480c68a37f47c070801623" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/AllocationLayout.lean", + "mode": "100644", + "gitBlob": "b8d3e4fd9a544e7e50ba8ac7aa7d8b36da6c203d", + "rawBytes": 9104, + "rawSHA256": "ede611982080f8600ce5f59be89d8d331dc7920855f55b969a66f39c60e99acf" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/CanonicalLimits.lean", + "mode": "100644", + "gitBlob": "7e8242cc21cc1b621bfbd990c5f7f4900fb714d0", + "rawBytes": 4764, + "rawSHA256": "1b0b761c9a42d0ce4c3ef3972b3eb43e3fe02bf56b9d3b7d501d23067c4d5a1f" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/CanonicalMemoryBounds.lean", + "mode": "100644", + "gitBlob": "364db7641887acb7b5170996dae16aeeaa3219fb", + "rawBytes": 24957, + "rawSHA256": "182406e5bcad21c8ef5ee236b92f3ebb63441b8deecb15b9e46019cb8a97aa21" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/CanonicalRankAccessSafety.lean", + "mode": "100644", + "gitBlob": "ecb32418258e80e9ab11fa8e4e76c37e22b70557", + "rawBytes": 12856, + "rawSHA256": "1c39e9d0a2637c45b7306dbd5077dd2319ba2f6c2af7ca43d0de189f9bbac03c" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/CanonicalSelectSafety.lean", + "mode": "100644", + "gitBlob": "4864b9eaf10566dfceb4bb5921cab056281bbe44", + "rawBytes": 12395, + "rawSHA256": "fcbc3b363e47bc16298dedbde693921ec4ca45672753ad564161807d6ce7d753" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/CanonicalStoreBounds.lean", + "mode": "100644", + "gitBlob": "51cf5724de9260ab9009443a697b05bea3d6a549", + "rawBytes": 6254, + "rawSHA256": "1209d9a14b0b92d5ccd6455197c57189903cf65c1502bb049df25ca4472038ba" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/Capstone.lean", + "mode": "100644", + "gitBlob": "8184759bbac7eb8b54cfe5acea62c9b86cb8211b", + "rawBytes": 11412, + "rawSHA256": "1c6cd0a85b77fba7706c77da87de358808a24fa661d5635a3c4b3bbf96005d69" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/ChargedSetup.lean", + "mode": "100644", + "gitBlob": "35117138a48053376485d68acede42d8d6d2d96d", + "rawBytes": 13339, + "rawSHA256": "21440d54c844202f5af6816c5bfd1dfbe07efa18ed23a7c546f8bf29948476e9" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/CompleteLayout.lean", + "mode": "100644", + "gitBlob": "19ac167e084b45596766e61a49d2f8197f882ce4", + "rawBytes": 8778, + "rawSHA256": "e2c61b99e504e99940b3d63645f62cbe805ff21ff4b28473c1de7646e08803dd" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/CompleteReadStore.lean", + "mode": "100644", + "gitBlob": "052c94c46807ae43f0863d75055c1799f732f768", + "rawBytes": 3348, + "rawSHA256": "3a8a6f6f57ce5c7368c8115d4a95521dbc92ff25934bf9b5cd8d8a31ab92fd46" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/CompleteReader.lean", + "mode": "100644", + "gitBlob": "21731c25e9198d0e3c786d24a85acdfebede937f", + "rawBytes": 6971, + "rawSHA256": "53926e3596e4c98a76d939e14cfbb26bfc939950e7a25cb774fbdb0617f73055" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/ControllerInterface.lean", + "mode": "100644", + "gitBlob": "2a665f4fac1fd416ef2212bd006ffbe86a8ad469", + "rawBytes": 3906, + "rawSHA256": "14f14b5a78fc77db768536bf78da47cb60922364538859535198c1e440b30981" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/DescriptorReader.lean", + "mode": "100644", + "gitBlob": "6fd93bc362f340f31f2ba08bfe8e886c2df197dc", + "rawBytes": 3796, + "rawSHA256": "a85c55e8962f8f9f78e0fb00edd81ed9dff7e870792f62830db6cadb54f45108" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/GenericRankProof.lean", + "mode": "100644", + "gitBlob": "aaf46b982c21755434366b0b05a410e74f7c2727", + "rawBytes": 45313, + "rawSHA256": "01544e3b71ebcb90b7abf34f8c241ba6ed6f7954027c3e22443ad9ac65192f94" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/GenericRankSafety.lean", + "mode": "100644", + "gitBlob": "cef3ac8de0fc6addc06a24a662a44073649ee1f0", + "rawBytes": 50086, + "rawSHA256": "46d1c897f34ba42a3da76b5b9876d3c7ce46d05a63950fe9e1f2f9e513d3b4a5" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/GenericSelectProof.lean", + "mode": "100644", + "gitBlob": "be500e482a5ba36a7d4f851987805547695b3a95", + "rawBytes": 96314, + "rawSHA256": "07d1090314e454341ccecbefb74009600c9afb40a812dc218c6810c450790ea0" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/GenericSelectSafety.lean", + "mode": "100644", + "gitBlob": "ee7dcf3531c1f4107818aae0c84c5844402f47f2", + "rawBytes": 105343, + "rawSHA256": "de8c9b1cd5c13c0b4d630839872de55542116046ebdb4cc9b823c53b59c5b678" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/InterfaceProof.lean", + "mode": "100644", + "gitBlob": "1d24385ecf3d73b29084a6be08380c36a757ddba", + "rawBytes": 3974, + "rawSHA256": "9b04897f77ef88a00b85f71bd7a43119572157f9266e74dacefb726856d431cf" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/MemoryLayout.lean", + "mode": "100644", + "gitBlob": "3918218d1ae2dc3be48f1a99f6d8803294635e05", + "rawBytes": 15097, + "rawSHA256": "2cb94877358664bdc93234128fe2115b626c10442aec87c9429a89395b0d6a24" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/Metadata.lean", + "mode": "100644", + "gitBlob": "2d3462a49e9f2899c5ee46b44f9d7d702a11ce3c", + "rawBytes": 4117, + "rawSHA256": "cba9b8cc9b574ec9d66fa4ccf8e4ce277be6aa864b68bcfe6b9aaab7ae955720" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/Normalization.lean", + "mode": "100644", + "gitBlob": "17c5b788d2cf3c8019439bc73d7df303680bdfa9", + "rawBytes": 7993, + "rawSHA256": "ba10a82917c9914e0bb11f619a15a51cfc65e2c0842c066f372339c77ff5f9d4" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/NumericReader.lean", + "mode": "100644", + "gitBlob": "82acb93da4d1fce444286f3a07f5e01f09e6c848", + "rawBytes": 20770, + "rawSHA256": "7e2cc443f2de7351112460b7c2b0699c2879b51e760dec3261b055790133897d" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/NumericSafety.lean", + "mode": "100644", + "gitBlob": "9e70908570f1ead32aa97ccda0395c03ebe11a63", + "rawBytes": 23639, + "rawSHA256": "621fc88a3fd86c8188a3074608cb254fa1d507cc4482f21c9ea13f8888a02c92" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/Observations.lean", + "mode": "100644", + "gitBlob": "a408a2f1c45f508ce1446c24c686f68ca5a1d246", + "rawBytes": 2369, + "rawSHA256": "76b7cae29f31addedd6a90d0fd80ba52fb62f26a6fef02d94ba41fd731ce880b" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/RankExecution.lean", + "mode": "100644", + "gitBlob": "40d01f3f91ea03cb75cd8bdee49b0d9f2a6c89ca", + "rawBytes": 7591, + "rawSHA256": "bd4bdcde4443e60e624dceb0cc87673cf51321ad277dade3a33dc898559a3b7f" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/RankLayout.lean", + "mode": "100644", + "gitBlob": "a456427bafe46356e63fead72ed0be7f191ca13b", + "rawBytes": 9815, + "rawSHA256": "7a5756940175bd775a0f4f0928ebb01f222c7c8db0461cb12c74770a6f8d629b" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/RankSemantics.lean", + "mode": "100644", + "gitBlob": "bed0b99b8f005b63887a1f8a09a37367bfec998b", + "rawBytes": 6212, + "rawSHA256": "9ac0b86bc1630635eaa63a3dc3c3889206a0fdfb0205dd86c36ecf7f5516ab7c" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/ReaderGeometry.lean", + "mode": "100644", + "gitBlob": "b7c518be92f7ed1283500a8bffe98f08e64ef680", + "rawBytes": 4774, + "rawSHA256": "f8ff6c3b35b86208e3c56b09ffa5ca1113fe17650f98ee51e8ea5d9515394133" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/ReaderInterface.lean", + "mode": "100644", + "gitBlob": "143ce2d70af8c7016a83c216a7b037a3fa37c129", + "rawBytes": 4462, + "rawSHA256": "ecd8043060aae4a3f753b81adcfe47f9e22b2914744db6686abbfb18a218a210" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/ReaderProof.lean", + "mode": "100644", + "gitBlob": "55242103f2a899c21839f90ad71e212f20481cf3", + "rawBytes": 5436, + "rawSHA256": "99773e1ba134e76c19a774433d54e1c26a281421ecaba099f7f019ec4a083921" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/RegularLayout.lean", + "mode": "100644", + "gitBlob": "e8d03a2b9a35f9897b9fef3280ce9261d6707eb7", + "rawBytes": 10776, + "rawSHA256": "172ed0f83f0d8e63136f7a3063f8edc009f71d57c4bf8b1d311067f1ac53638c" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/SafetyInterface.lean", + "mode": "100644", + "gitBlob": "9cb438ac74ec077fe7a2a852c5ab08f0ffd20fb6", + "rawBytes": 6230, + "rawSHA256": "9bd0732d2863e80f4311d92c75366a0f280b7ebb250d51c32f66da4540766cd5" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/ScratchFrame.lean", + "mode": "100644", + "gitBlob": "d54970423e9f276e955835c299895dfef93e159f", + "rawBytes": 4640, + "rawSHA256": "0eb35b270f66d55c250d9ef6dc46d897f7afd1aa8e07d5ea40a6eb2d7784905a" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/SegmentMap.lean", + "mode": "100644", + "gitBlob": "8b4ebc1d1ed74b2da293dac729a1feb0c5446e7b", + "rawBytes": 7460, + "rawSHA256": "8f9454fd730b9b857a99bbc33530daf23e2f185ac66e21cc0845f29742c55b41" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/SelectExecution.lean", + "mode": "100644", + "gitBlob": "c46372d8a9a31d28740d4726e6f54fdf07884725", + "rawBytes": 6519, + "rawSHA256": "580db81fde442c341332a1185fd524c2925e45744f1b6918447d915e1e3fd4d0" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/SelectExperiment.lean", + "mode": "100644", + "gitBlob": "5a65069626ce5b7547792f31cfe8a123a1cceaeb", + "rawBytes": 6301, + "rawSHA256": "156744cbe4dec77c874114e10408820f7b107b86d5635068d6b855b8363af0e8" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/SelectSemantics.lean", + "mode": "100644", + "gitBlob": "29d6bb1f9682d8819ed84536100a9f1af47ca418", + "rawBytes": 21230, + "rawSHA256": "d950323b3de006f320335f68af96be9f8a7d50a425eddb35b493efa2ab8dd3a2" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/Source.lean", + "mode": "100644", + "gitBlob": "612b69d1f71358b78578cc7b96199810446564c7", + "rawBytes": 3605, + "rawSHA256": "8277f15d876437bd6c35835c57c9332e839aaa94ea63ec8a9f10b8bc661d1074" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/Space.lean", + "mode": "100644", + "gitBlob": "0895c7a92874e4059d8a2447916f28720fada803", + "rawBytes": 5575, + "rawSHA256": "dbf34f5508ac1a1fc57f722def6a4724b6b495b5416ae2a9970179e5780befc1" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/Width.lean", + "mode": "100644", + "gitBlob": "9e45fbe78a222bbb7eb2b966d571d2fe35adbfea", + "rawBytes": 1589, + "rawSHA256": "873fe2e55102beeb0e5b0450e86bf83cef569303ef76c93d9b8afc7a26860556" + }, + { + "path": "RMQ/Core/WordRAM/Bitvector/WordBounds.lean", + "mode": "100644", + "gitBlob": "6ff6d508b93db01d2bfea818c49ce0e12cd22b24", + "rawBytes": 4605, + "rawSHA256": "756ad2cf263e310966cee28f214b0190b3f748365c9d5b6e808d1bd994956ab0" + }, + { + "path": "RMQ/Core/WordRAM/Construction/ArrayRun.lean", + "mode": "100644", + "gitBlob": "505dbf020aea20a8bf4dc7f02f1722b07debbe89", + "rawBytes": 24346, + "rawSHA256": "def5837d2c7462cdf5a331b4cea13ec27c65af128316a7092567744fef4a610c" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Access.lean", + "mode": "100644", + "gitBlob": "145f909dc08d08b555e1e499f55149b0f23ef058", + "rawBytes": 12186, + "rawSHA256": "a62c60c1031dd01ad496e42765963a8c69cc1ff6c7734e828201afd03261e4ab" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Cartesian.lean", + "mode": "100644", + "gitBlob": "16cf799f4c650787fec347ca899349e390f592ea", + "rawBytes": 3335, + "rawSHA256": "ee2eec58420de15782a7dee29f66f90484232dfcbb9f99a3e08973e6253813c9" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Emit.lean", + "mode": "100644", + "gitBlob": "fbeb1c355f39a903580efa19f4b83ac12c17b23e", + "rawBytes": 3220, + "rawSHA256": "dfb36f53c9f3744e56fea7a8d34d23680f834cf795250d5756bb1a1fe51240ba" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Finish.lean", + "mode": "100644", + "gitBlob": "0d5575362987f6425f727854759eb467ec795023", + "rawBytes": 3658, + "rawSHA256": "b65120bb381931c47fc42fcbc40627f487f61f8ece7f99a8d459e83d52b5b3c1" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Geometry.lean", + "mode": "100644", + "gitBlob": "3e3851b52e0b643f2ecf52dc97b983b0c7634513", + "rawBytes": 6708, + "rawSHA256": "99422e111c8a1cccf692a246adf20a8cef0dd88dd6889dc583592ec14891d088" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Interior.lean", + "mode": "100644", + "gitBlob": "17cbd5c3a9f7556f05165065bbfad8581638234f", + "rawBytes": 8981, + "rawSHA256": "43c7d5815cd3c71e94debbb35c8b1f8a71e83df944f5f130b008b708a161fdc5" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Micro.lean", + "mode": "100644", + "gitBlob": "d39904de90bc94dea340d874afea7ccc07fecec2", + "rawBytes": 5052, + "rawSHA256": "88afa5c11c4706a392ed51edd517571b6888650d20ba4063b84c200594950703" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Output.lean", + "mode": "100644", + "gitBlob": "4a8f9d1dc8b6335a28782fa658d2a910d0dd991c", + "rawBytes": 11449, + "rawSHA256": "f7c2890c942159edccad5d7d12d2a4a00f87492ddaa8870b00e2107ce8bf5d23" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Program.lean", + "mode": "100644", + "gitBlob": "019a5da76784d78a0298872da1e377ee8131f663", + "rawBytes": 3408, + "rawSHA256": "451ae09fa62d30b89b0cff174e977259fba58fd3d96d535caa4d59129caf436c" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Builder/Registers.lean", + "mode": "100644", + "gitBlob": "8500679c3f9a3da2ab373dae74d332dfc2d99dae", + "rawBytes": 10675, + "rawSHA256": "995f80dfee6ad0a9844b0aa752ff84873bbf79d064d96db2840772790a645684" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Calculus.lean", + "mode": "100644", + "gitBlob": "8257561b1a47bd49fe64a4c2d560b83a65f28f5a", + "rawBytes": 34685, + "rawSHA256": "88296c2ac88169d656a07c254df0f2f79c67e8ccc8a7809f66669cc6a4ab3fa6" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Capstone.lean", + "mode": "100644", + "gitBlob": "13f6615354b75df44312ef078d2d09c6914a4bd5", + "rawBytes": 8479, + "rawSHA256": "3b794806dba32d3b59950705185ca8d3c57f470dfbf4d3adda5564746d857833" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Compiler.lean", + "mode": "100644", + "gitBlob": "895f2975970ae1258554358413955f82936ee6aa", + "rawBytes": 31031, + "rawSHA256": "a3a98226a10866b775ab45e6be9f50ac016826f4b9565f9e8926be3e35a2e65d" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Conservative.lean", + "mode": "100644", + "gitBlob": "001346d022f7acbd204e247937449bca0b3bf911", + "rawBytes": 7706, + "rawSHA256": "3c2ed59f22c42ca83774bcd96f92fa8eeff604db2a6b5f338ad4615bf8f54b9a" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Contract.lean", + "mode": "100644", + "gitBlob": "ff5e08816a561f3667bacf057ff1a89e1f66de06", + "rawBytes": 2872, + "rawSHA256": "93e6c1a264c2be7f5de3d9cfccb5b7aaf10c28dc3f6f6c51385dcdaddecc6fd6" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Controls.lean", + "mode": "100644", + "gitBlob": "8ea487ac1a97b3af7f9b08b457cb74f39b551746", + "rawBytes": 5475, + "rawSHA256": "580fecac1c2fea11ab8ee0939082aa69981017e3225cb630b1937431d5a768ca" + }, + { + "path": "RMQ/Core/WordRAM/Construction/HeaderUse.lean", + "mode": "100644", + "gitBlob": "13ca961f29518163ce004905b6f32ef3b829ad96", + "rawBytes": 8270, + "rawSHA256": "2645ac2122f304b26de7630c1e441346f1e6d8659c8d5f4dab47c356a01cd8a5" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Input.lean", + "mode": "100644", + "gitBlob": "53afec2a48fbd6ce18622153c468926591b53d82", + "rawBytes": 7558, + "rawSHA256": "b8311f6583d9a108324a952ca01b23c701682e6c16a83b908cf0932bdd6d78e0" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Loop.lean", + "mode": "100644", + "gitBlob": "ca054024193bbcf5c932b632cf74305257cb20de", + "rawBytes": 6376, + "rawSHA256": "4eba2279f29b509fbedbe7e668d236a2a9f61c0ade5d7e604915b4fefd5aa6da" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Model.lean", + "mode": "100644", + "gitBlob": "d1687b7cebe1278482801cd8c390bbb77bd8b3a9", + "rawBytes": 4743, + "rawSHA256": "601630664b80c2eb0c26778a1ad2982bc4e0d3b59c43b5e349321998cb11da7a" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Primitive.lean", + "mode": "100644", + "gitBlob": "7f44d513249a2e4650a8af799e87cc32238741ff", + "rawBytes": 7450, + "rawSHA256": "9d296ef6a7d08cbcbcad7e262430f466fb9bf41021c55cd1997d2e8f92b77a69" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Program.lean", + "mode": "100644", + "gitBlob": "6cc79066cfbc9e2b5e80b98a49dc044abb9fcba1", + "rawBytes": 6741, + "rawSHA256": "5817bb879d48ffba924d8662df22fa5f6a3dc62e0b0bbf884cba79aa0316de0e" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/AccessEntries.lean", + "mode": "100644", + "gitBlob": "01837bd03186249cb9953c317a2cd605c511f3fc", + "rawBytes": 51749, + "rawSHA256": "362e9beccbb7a11ba120dfa4134ca2a4bcff322c068596ea48751d7775dc19f6" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/AccessFlags.lean", + "mode": "100644", + "gitBlob": "0480e6b7a635f7d0b59a87e32d4efbc71bb74b03", + "rawBytes": 62054, + "rawSHA256": "0c24aa03601cd4e30f5552ef508975effa245a2fbd576ceaf1abd55277016c38" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/AccessHalf.lean", + "mode": "100644", + "gitBlob": "074f691965cc5a3c6cb39c871c2b9b671fdd7c6d", + "rawBytes": 31042, + "rawSHA256": "8d75996b1003644986b12d33328c99111b95dfe55c78fc8083fece2aaaa027be" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/AccessRelative.lean", + "mode": "100644", + "gitBlob": "e8e16e4d116f3aa3c152a36f0e89fa32210d4fd1", + "rawBytes": 48917, + "rawSHA256": "5c1170974b6cd0bdda27732f448402d7abf9a548406970b713434f2b36e6fd8a" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/AccessTables.lean", + "mode": "100644", + "gitBlob": "ba471626d5bf304ba5a09b2308320686bc7bde31", + "rawBytes": 57158, + "rawSHA256": "096b78f02198d730be642e4e916ba74eeeb2252c3fdf9134ccf47e73cbf5b22b" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/BPEmit.lean", + "mode": "100644", + "gitBlob": "db372f4f5b39785e8f863b39cdf8fdfe7fefe652", + "rawBytes": 17329, + "rawSHA256": "aac79854ccd58562096257ee5b3bf4879f90da21e05b79125e4a13a6cc940ff1" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Base.lean", + "mode": "100644", + "gitBlob": "06c668b98b6404ebb71579461aabc5f44c8ef03d", + "rawBytes": 13701, + "rawSHA256": "53d1ea39e9880101f8a681cd21dc8766c6c384b92f1e7feaa1f239b17ba5510a" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/BlockStats.lean", + "mode": "100644", + "gitBlob": "f8c826088c09bf35b321f06be1742383c9de9907", + "rawBytes": 45115, + "rawSHA256": "1f8d540f1bbdae16d6e5471366e16e872ce6e26f7d3f13168d82d40c6fa68584" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Buffer.lean", + "mode": "100644", + "gitBlob": "986f07cc7788b5f493e5f9a3c8e7e4cfa3777531", + "rawBytes": 42894, + "rawSHA256": "53c4afcffce034d40c1aff30cdc2f43a9f52d82f7954c15b800088555ba83041" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Cartesian.lean", + "mode": "100644", + "gitBlob": "05f980c7f3513fd5768a096ce2bae804388ac52f", + "rawBytes": 42201, + "rawSHA256": "800dec258f93a73e47239f40b8616620bf2db82c03fb690e340f2e248cf67af1" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Constants.lean", + "mode": "100644", + "gitBlob": "8c642c6672752183e00b0a9806f0e6e612e0ef64", + "rawBytes": 6561, + "rawSHA256": "c88beb478a7dfd290f74e498b5571600f0a951a4fb43d7d523e3c5a21174c0ca" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Emit.lean", + "mode": "100644", + "gitBlob": "5f89a0f3118d7a6fc8cbb49fb9a5ff47cf113bbc", + "rawBytes": 32918, + "rawSHA256": "00035a07f35101cec056dda45a45ee1986e91615ad81b0beb4269c8ff0fd3971" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Exact.lean", + "mode": "100644", + "gitBlob": "4840b7ead4b2abdf9531648f49ef4384b3ec4a4d", + "rawBytes": 14919, + "rawSHA256": "e643891ec57618cb046b81ba332750091a9407a466427946ee48b06b99e138da" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Finish.lean", + "mode": "100644", + "gitBlob": "3d62e6a32cc3cd3f3b31e6eb2adccb49619816df", + "rawBytes": 22409, + "rawSHA256": "cc9997df8ac50f00557e500b5db5d09a14442163b0e32488f1a3cf201bddf497" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Flow.lean", + "mode": "100644", + "gitBlob": "5b8b1e08a88ee7bd583c40ff5792c37b34b51caa", + "rawBytes": 13046, + "rawSHA256": "4ca5c92d0df1c65e92d241a083cdad3ab0ecbed50cae1cff904c20c42eb91830" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/FlowFacts.lean", + "mode": "100644", + "gitBlob": "3d92bd8c5eef589d94a2e38ab83bae2452f0b1ec", + "rawBytes": 27076, + "rawSHA256": "3da76a721a7c033d2db86879acc53a5738f8cd6b60d8a8743e1af8f3e5d5e5c4" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Frames.lean", + "mode": "100644", + "gitBlob": "ffcfb45e9fd1b5441cd8dd05d29c760d7937eac3", + "rawBytes": 56185, + "rawSHA256": "0f9a820bf49f974d802c4222212a5fb571a859825a285ce2f9c2bc16aed30e80" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Geometry.lean", + "mode": "100644", + "gitBlob": "a74cd94e6d049ed9b12fc4fac1535131c4529339", + "rawBytes": 23265, + "rawSHA256": "3fa714fb27852a50d19011dec0efa377f88bbc74cd251034fdae1b6dd46b1439" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/GeometryBank.lean", + "mode": "100644", + "gitBlob": "48b76d907ee3eeb605855f1940e13ccc9e9e5208", + "rawBytes": 72212, + "rawSHA256": "81a4e60a32563a6fc29b48fb090fe28dce989234fde270af1cd80017787a9613" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Interior.lean", + "mode": "100644", + "gitBlob": "c0c71cb5f624edbd0607da0e8e550315c89deb82", + "rawBytes": 9298, + "rawSHA256": "c21d32bd43eb0b8d12711a74032c44274ae18f5f5a7cc017a9439f1705e2e208" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/InteriorClose.lean", + "mode": "100644", + "gitBlob": "1f633a2344e545dc723a6ffa4b0855a763e6c58d", + "rawBytes": 32686, + "rawSHA256": "9c5ef1100271195f71e0786cd9bb6e07affdf4fcca0d47ad340484302d55d72f" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Leaf.lean", + "mode": "100644", + "gitBlob": "e917618efae25460f79263037ca9ceed34144d5c", + "rawBytes": 2716, + "rawSHA256": "ad992b6f2e15387555b6718457e335dfed1bceddd9206b9ea249cf91479c8c76" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Leaves.lean", + "mode": "100644", + "gitBlob": "d599e95e8b939db0c5f9efe7be22337ae3d2475b", + "rawBytes": 10981, + "rawSHA256": "7d41252dda2325ae1336459d2c14cd21b1a46ec3705e9457c7e244e6033e4ed9" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Lift.lean", + "mode": "100644", + "gitBlob": "7e2963703b3b912f6bf4ce3a20e6019f0ead7d92", + "rawBytes": 5822, + "rawSHA256": "327ffda34fc73c4812141188719e79285294defab6ecefaea56835de332295f6" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Loops.lean", + "mode": "100644", + "gitBlob": "c247da9e5cde757bc27ac8bc5b14f6db55a18732", + "rawBytes": 22381, + "rawSHA256": "628cf71605058acb3af40c134f0eacf70e7a25bae890f3aa6604c2708423b5ec" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/MetaBounds.lean", + "mode": "100644", + "gitBlob": "b76ca524951c026fc5b9a5027d5cdd3840bd51d5", + "rawBytes": 19752, + "rawSHA256": "c4461877876e35b3f594305df1fa7a7c8e04737ecf851dd63e9235ee87121407" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/MetaChain.lean", + "mode": "100644", + "gitBlob": "2bead3b749b076a551b28989a2fd578ab50783f1", + "rawBytes": 78471, + "rawSHA256": "37467f7d8f8fbe88a33a9551f14cd9181865b42ab3e41fa53c1f5ed443fbcd1c" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/MetaSteps.lean", + "mode": "100644", + "gitBlob": "e251fec241f0c34334a989cd9d2611baf54d7fc0", + "rawBytes": 70136, + "rawSHA256": "9046f2772c770052805852fac57f154c99a0977a25697ed85805123c8670c59d" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Micro.lean", + "mode": "100644", + "gitBlob": "1afb5d412836eaa7ff10c909e2705fe13120cc6f", + "rawBytes": 37006, + "rawSHA256": "dccbd07c037f2141225602aecf74756982a3e042de3e49dfcf6d59b31a472c07" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Output.lean", + "mode": "100644", + "gitBlob": "83f3ba46e1003b126802a9ee173a70ba79754685", + "rawBytes": 58277, + "rawSHA256": "463d5728da4f7c03bcc7a6a2825fde0e16e0244c11badea3fca68afd2df82a32" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Ownership.lean", + "mode": "100644", + "gitBlob": "2946170192705db1d2860979c0aa45ab7d7e5a25", + "rawBytes": 12181, + "rawSHA256": "7bb0860def0136514c44b8f1c4b9fff0e75f7ab14bb92e47c47b3827702af076" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/PosPass.lean", + "mode": "100644", + "gitBlob": "edf6f0279331076d8e2a4b09baf0d515115cedfd", + "rawBytes": 25164, + "rawSHA256": "a88ca1de05f251c2c42d550d2724592b5eb36bd419e94926dad671a8fd46eba0" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Query.lean", + "mode": "100644", + "gitBlob": "553a37df6d2a2ed7617a5c5d550cc41bae33b962", + "rawBytes": 10360, + "rawSHA256": "85a8c7daf88a6e35f08cee29ec4a97ebd629e333db6a2a9b946df1dc48bfb9b5" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/RegSpec.lean", + "mode": "100644", + "gitBlob": "82298d167f2b91f9ffa7220e5d369feafb428e59", + "rawBytes": 25592, + "rawSHA256": "e0bd0d62203fbd53df6d18c54d00a47ffb873b7d1474fe88ed7db20f6c848a99" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/RunFacts.lean", + "mode": "100644", + "gitBlob": "4ab983a5e85dc16ea0176ff2bdc365d7759917bb", + "rawBytes": 19676, + "rawSHA256": "57b4cc8feab8c65c65841d0b05264ab388211e52be2fd39c90016d04d02a16cc" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/SparseMemo.lean", + "mode": "100644", + "gitBlob": "62dafd9df10f0b3f4c82a8d8acc827f13b50005e", + "rawBytes": 67449, + "rawSHA256": "1e0a5082591ce57ef93c8fccd2735d4e253fde7703f41ca734be255341e31759" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/SparseTables.lean", + "mode": "100644", + "gitBlob": "ff7510fe81a95dd7f89cab218679608bcf17bd53", + "rawBytes": 26024, + "rawSHA256": "5b0850dbbd889cb89fe506c48a69e16eb723cd829ca00889c480d8467cba9d1d" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/StackPass.lean", + "mode": "100644", + "gitBlob": "3a9a7f7e7e325ee698cd62315efb0c4483272a4f", + "rawBytes": 24176, + "rawSHA256": "fc1b5ac801626d79aa737408b1515ca23e01cdde703fb137ea0c1075cf5558a4" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Stage2.lean", + "mode": "100644", + "gitBlob": "964779c2d2c0494bf9daf618485653527f5daf5e", + "rawBytes": 8256, + "rawSHA256": "c34d6a2a0a28c22ae461b4fa48124a3cfd55d4bb67155ec3d5f62e3a955931a0" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Static.lean", + "mode": "100644", + "gitBlob": "7be4917accfe8859db9f9c2c530fcc2d8b31f457", + "rawBytes": 6949, + "rawSHA256": "775276dca095b9bdb63ae9299c2ae6920dabec05b091e67d8112d5d00a7a765b" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/SummaryTables.lean", + "mode": "100644", + "gitBlob": "3ab485ffe6ae1eda7e6022613d197f13c16eb7de", + "rawBytes": 31255, + "rawSHA256": "3f7e6bf04b9a9cd60193d0101eff0e7b5b8d370ab8df465e0edbf1eddfef65e6" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Proof/Tail.lean", + "mode": "100644", + "gitBlob": "2751f21e327a4ab3a86a79a06d54a49c902323e1", + "rawBytes": 12404, + "rawSHA256": "965fec76aa87bebe5369ecfec58c53064c1ab58c6a6cbf1cee25909226a16137" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Safety.lean", + "mode": "100644", + "gitBlob": "02677487865e12900f10bd8fd6d1dc9dbe8a6b16", + "rawBytes": 8042, + "rawSHA256": "0556bb89b4cd4af1026da3dad249a426ec501b1bf722033637674f6467147c4e" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/Access.lean", + "mode": "100644", + "gitBlob": "4eba41aaed31d816ae787a9f82702fadb7c26284", + "rawBytes": 3307, + "rawSHA256": "a9577e0a6beb788443e1a9a2cd862980cce8dfdc69d6242e7e4a1d4475fa8161" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/ArgMinSplit.lean", + "mode": "100644", + "gitBlob": "8447814b228abeef4546292cc974f6896d2797d8", + "rawBytes": 7000, + "rawSHA256": "00738f5e8ce9e6eba0f191d20089818f102021bbec71e5513cee35d8cf8739fe" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/BlockStats.lean", + "mode": "100644", + "gitBlob": "0658f9d2f306c2373b93149cfbdc6c2efef081f2", + "rawBytes": 4724, + "rawSHA256": "dc47a17fa33ee8680c088580c5e0e0bb1768a64f7eff470259c2e1a914ed8ce5" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/Dyck.lean", + "mode": "100644", + "gitBlob": "48d1cee1e3665a1dc2f938de06682ea3aa4f9b4a", + "rawBytes": 6347, + "rawSHA256": "75ac54d8a2d8471a41ddee045d6537f44324d2663e279c571e9ff10c2a861844" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/Envelope.lean", + "mode": "100644", + "gitBlob": "829953667c58e03d16bdb8d5239572de8de87b2f", + "rawBytes": 22168, + "rawSHA256": "863fb13879921efe8923330ae85382d347c709322044549a787ed4483d61093c" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/Metadata.lean", + "mode": "100644", + "gitBlob": "a9edd97d631a2e0f5412e6f56cb63af757e097cc", + "rawBytes": 54701, + "rawSHA256": "37483440b657030e28c811d6c2cf0c410c06216c70cc6dc3388858b929167fc9" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/Micro.lean", + "mode": "100644", + "gitBlob": "aa36996fec60c578fba967d9e8c53f997474b83b", + "rawBytes": 8030, + "rawSHA256": "72e352c14f60080f631b390fc5ed1ed4bb7e1d8eb6ae9513096c51072fb20632" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/OpenCounts.lean", + "mode": "100644", + "gitBlob": "67c90271e4315863aa98b0fbc902f6fb7a5147b2", + "rawBytes": 7099, + "rawSHA256": "91ba567ee52fde9385a3cbe9e1679695eaa57de7fe71fce84303416f7b7f08dc" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/Plan.lean", + "mode": "100644", + "gitBlob": "43c659e113f08d7ec7598965039a952d4ee127d1", + "rawBytes": 26900, + "rawSHA256": "747c3a77dd71c36a8d354258d8b47939013c4d37e906a896bf1ddd918a4dba42" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/Positions.lean", + "mode": "100644", + "gitBlob": "fe3fd6e9b1d1dc133c535103dfbe4533a7354692", + "rawBytes": 16672, + "rawSHA256": "6a9e1d83f2fd0978fc3d4153cf211447fd6e7098a79a4842f50f6eb364f05473" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/SparseMemo.lean", + "mode": "100644", + "gitBlob": "01bf5e7b085b92c61a29ba7581e095b4f2f8b45f", + "rawBytes": 4880, + "rawSHA256": "128cce8eefb880b81d90afbcd971f97c47945cabbc859f155072d874cce46440" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Spec/Spine.lean", + "mode": "100644", + "gitBlob": "8d99a071326a006d5e614a539e4dc8813109ca88", + "rawBytes": 10132, + "rawSHA256": "f6dca9cc8aad0ed8d0ff345964144902072bb854b32be7798a9d4e3fea39e9c9" + }, + { + "path": "RMQ/Core/WordRAM/Construction/Structured.lean", + "mode": "100644", + "gitBlob": "207462d7005a94286da399da474dec168f8d71d0", + "rawBytes": 16947, + "rawSHA256": "d6321be4381e84895cc6dab6919503951def71c8a153307b1575694ff61c73b3" + }, + { + "path": "RMQ/Core/WordRAM/E1DenseSelectBlock.lean", + "mode": "100644", + "gitBlob": "41ca260240960f10d902cedfbbec99d29e0b918f", + "rawBytes": 73585, + "rawSHA256": "9f032fe04340fa74f3abd0c3fe0587e38fe7c70872feb8639127bf3dd2be2b59" + }, + { + "path": "RMQ/Core/WordRAM/E1FringeArmBlock.lean", + "mode": "100644", + "gitBlob": "0532dcf528d161b1269ac5efdb6135eb03ce2a1a", + "rawBytes": 47124, + "rawSHA256": "99c40c4dc753cb0c2baf2fc85aec1d823c62ab7f465123478f5f6c68c53ea9a7" + }, + { + "path": "RMQ/Core/WordRAM/E1FringeBridge.lean", + "mode": "100644", + "gitBlob": "c8a3dee6bed0831fcbb463c5f25a6d1992d7d3db", + "rawBytes": 17269, + "rawSHA256": "b0287f964144901282a2949dc7fdce9b682506efb34f0bec15f9098a5c8351df" + }, + { + "path": "RMQ/Core/WordRAM/E1FringeFoldBlock.lean", + "mode": "100644", + "gitBlob": "f03253656cbc4aa162005e69b0491d0ee0720ad7", + "rawBytes": 58055, + "rawSHA256": "40764e78eb45b27f4f297d5c737689f5064b01f203ccc6dc98f61d9008cf36be" + }, + { + "path": "RMQ/Core/WordRAM/E1Machine.lean", + "mode": "100644", + "gitBlob": "5646ccb1d9d21fb561b5e624f5e451d00819fa38", + "rawBytes": 23725, + "rawSHA256": "69cc3ddefd185f7b6e9b09b64e8b2fb0fefbe0669210e3d17d96ca707f3e1f94" + }, + { + "path": "RMQ/Core/WordRAM/E1MachineCalculus.lean", + "mode": "100644", + "gitBlob": "18e794f2a79e78a2186c579fc0eeed0f23dc52db", + "rawBytes": 17864, + "rawSHA256": "15138768c905f6b462b52c2a128801b94e57a70411aae7439cbe36183446fe66" + }, + { + "path": "RMQ/Core/WordRAM/E1QueryBridge.lean", + "mode": "100644", + "gitBlob": "5b1bcb4b7e80bc0b7432365a6218adfa78d186c1", + "rawBytes": 5666, + "rawSHA256": "d2581fe4a89435853e1fcf873cb3fbbc527d3b995c2ebe44d6c299e137d937ce" + }, + { + "path": "RMQ/Core/WordRAM/E1QueryProgram.lean", + "mode": "100644", + "gitBlob": "d116a384d1b0de706d680cea95cf145f76e9a31c", + "rawBytes": 24472, + "rawSHA256": "7aa365a2546ac3bf03940c922be6d047aae803b1a72e85e96c2a592442ba1f47" + }, + { + "path": "RMQ/Core/WordRAM/E1RankAtBlock.lean", + "mode": "100644", + "gitBlob": "00830758e171b88ac77530c2a93b526f7edadb23", + "rawBytes": 22104, + "rawSHA256": "b28cb35b0a8c39ffbe287b221caad7c4a860cd1b630228915e72ad381bf58aaa" + }, + { + "path": "RMQ/Core/WordRAM/E1RankBlock.lean", + "mode": "100644", + "gitBlob": "85187e40713589b82268b047441f10775724d783", + "rawBytes": 43362, + "rawSHA256": "8fd21d490a4652f799e3428aa2cdeec28b8eb7df14890d999b29c3f05f410ada" + }, + { + "path": "RMQ/Core/WordRAM/E1RankBridge.lean", + "mode": "100644", + "gitBlob": "6e1eec24542ffb497076e9c497846d2906416207", + "rawBytes": 17770, + "rawSHA256": "40754a0d37317f48f88125e66e6ce207683f639bb4ddbedda4669d80bf1b4ed0" + }, + { + "path": "RMQ/Core/WordRAM/E1RankCanonical.lean", + "mode": "100644", + "gitBlob": "1cd734c77ca27ffe678389b575c1570a41e2a78f", + "rawBytes": 17704, + "rawSHA256": "0a056927249262fb06917370ba3bc89dadb4ce3676b37cc8275409d1164fc9fc" + }, + { + "path": "RMQ/Core/WordRAM/E1RankTrueBlock.lean", + "mode": "100644", + "gitBlob": "f27d8640fd9f6e62b5854e5b22e70273d309dcce", + "rawBytes": 37429, + "rawSHA256": "eee41e50eeffdb5215412f1cc70bbb0b31bc8c5b21c875b52590463303e79053" + }, + { + "path": "RMQ/Core/WordRAM/E1RouteDecomposition.lean", + "mode": "100644", + "gitBlob": "71c261dc0e05f32855566b9fb124b5ae1f351e41", + "rawBytes": 8367, + "rawSHA256": "5f3ad98afa01b98398316b5a027907d3b6715557e83843ac0fb6d3bd0bd7bd58" + }, + { + "path": "RMQ/Core/WordRAM/E1SameBlockArm.lean", + "mode": "100644", + "gitBlob": "2bd5e5784e9d4e9fd09cb5ef059cc57363e2f003", + "rawBytes": 26223, + "rawSHA256": "8724ad3cb2a17affa4148c5506e2c233eb049758ed4a66d4d6b8727268fe2064" + }, + { + "path": "RMQ/Core/WordRAM/E1SameBlockLeg.lean", + "mode": "100644", + "gitBlob": "5b7082fc4756627bb019098bddb89c0059504f1b", + "rawBytes": 27439, + "rawSHA256": "1001bd1bb66be8c612a178179fee50d3070619617b01ffd9841e95aaa302ec9c" + }, + { + "path": "RMQ/Core/WordRAM/E1SelectBlock.lean", + "mode": "100644", + "gitBlob": "bdc243642440376d5236147633d266928129c3f4", + "rawBytes": 33317, + "rawSHA256": "e0a00ba45005bc2b83bc18fb776839cd4fc3058ce22e1d9118df93395f65160d" + }, + { + "path": "RMQ/Core/WordRAM/E1SelectBridge.lean", + "mode": "100644", + "gitBlob": "e1299f1a9e3fb389596f3be2510b77234abb21f4", + "rawBytes": 24487, + "rawSHA256": "20101739899d2939691506fc3b453653c999a7a490899dd9805d42cdf584b602" + }, + { + "path": "RMQ/Core/WordRAM/E1SelectCanonical.lean", + "mode": "100644", + "gitBlob": "ca8fdd96a25cc68f0c9de790a276a2961520fa7e", + "rawBytes": 13074, + "rawSHA256": "5374f6652fbd35c22c98e523d71a64e02a0e6d1f26894eb5b92ce668cfaa890a" + }, + { + "path": "RMQ/Core/WordRAM/E1SelectDispatch.lean", + "mode": "100644", + "gitBlob": "8f866a3cd6043092835b6c04947c6a1337a7f12e", + "rawBytes": 96358, + "rawSHA256": "80d39b97653be2f30988fc9bbd5bc2fea8588fbae952c9db8e917a5459c7588e" + }, + { + "path": "RMQ/Core/WordRAM/E1SelectLegBlocks.lean", + "mode": "100644", + "gitBlob": "90e02d52a97f46e7e8bb9d8735f856b5483efdbb", + "rawBytes": 28145, + "rawSHA256": "33bb4c588cb7508e1fe9f1c5f2f2bee635ae5d02c10e0a48ccb8d3def6c5a8a4" + }, + { + "path": "RMQ/Core/WordRAM/E1StraightLine.lean", + "mode": "100644", + "gitBlob": "4a4d841111aeab1968dca60d5fedae10d31b894e", + "rawBytes": 10359, + "rawSHA256": "cb35abc7263ca27f93f702e0a5c110d2d6f31f1fdabac21aa7e840e0cecac2a2" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Accounting.lean", + "mode": "100644", + "gitBlob": "ff3d382804d84885409f7c072270bbf9a4929968", + "rawBytes": 3507, + "rawSHA256": "f57e0758f80ebe6820648e1bf71a1f810fe1d65e9814b7351713d8d00e6a0d94" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Agreement.lean", + "mode": "100644", + "gitBlob": "d6f7a480c8e604911d06ac611bb39b98b520fb2a", + "rawBytes": 20605, + "rawSHA256": "64ec32e23f112847053dccfa29503d6889cf8f757abee1076915c1eafc245146" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/ArrayRun.lean", + "mode": "100644", + "gitBlob": "58e7f35043be168daadb0230fbf8447df9e84a28", + "rawBytes": 34169, + "rawSHA256": "e9342577949ec6af15ece43ebaa742d30142f7b6769c8036b9e95f22d59dd0c7" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/BoundarySafety.lean", + "mode": "100644", + "gitBlob": "558706446150cab142e76a563b0fd8caaa2ffb64", + "rawBytes": 5959, + "rawSHA256": "ddd3151ae95f579bd8531df8c8b5d5e94f8f48501e4020e85565f1daa3fce49c" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Builder.lean", + "mode": "100644", + "gitBlob": "54bde55b848d829e9d30dfb9ccfb1fbfc765c193", + "rawBytes": 13873, + "rawSHA256": "95e14947a06c81c42439666d59d5959b387e75ca38b8157b717e8caf6cd55383" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/BuilderProvenance.lean", + "mode": "100644", + "gitBlob": "c81d6a1dbd4c2117caa4a7c9634dbd93bb5deefe", + "rawBytes": 13651, + "rawSHA256": "4290eda7e8eec442e1d823fc50a74f06ac85e6bf2c25b34e5815724c6cf81b93" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Calculus.lean", + "mode": "100644", + "gitBlob": "6fc1e652a2c20fe2393fdae68fbb580fb7703b8d", + "rawBytes": 10079, + "rawSHA256": "e962506395c90eeba73b070a18365449f93c27cd5719a37e1d679d64fd3df9b3" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Capstone.lean", + "mode": "100644", + "gitBlob": "9cb036d133da1bbebdfb93943dc6c9ccec62d310", + "rawBytes": 13580, + "rawSHA256": "da6402bfbbd286831fe18237686bc01a535dba8a35abe92290194d15f20c3e3d" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/CodeFetch.lean", + "mode": "100644", + "gitBlob": "1b4d2c82b171845216f1cbe58ef462d11ae32ad4", + "rawBytes": 3157, + "rawSHA256": "748474489f06988205a567f63474122bb0fe1d3dc59cb51fdecf75c2b95440c5" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Construction.lean", + "mode": "100644", + "gitBlob": "bb8788cfb3ce643bfb1bd542445a1f91d6a4021f", + "rawBytes": 15250, + "rawSHA256": "bfff5ea62f452ff86ed80c0b22b781e3d538b8511fec9c54239a41dadb28bb76" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Continuous.lean", + "mode": "100644", + "gitBlob": "c75d2790f3c9336a9bdf8cf632ee8ac3314051cc", + "rawBytes": 12794, + "rawSHA256": "dc52ea63307898e7d00511b1ce6ffde89641237bc94db0f0ca207b851a933207" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Controls.lean", + "mode": "100644", + "gitBlob": "59f3749798a51b19adcc55cfae596d61b375c64a", + "rawBytes": 13170, + "rawSHA256": "207f4d5ccaca1c33143c6e457c90129ad876672bdc0786e29face52f434e8828" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Descriptor.lean", + "mode": "100644", + "gitBlob": "22db7d7e11e469c46f09a2032849529b8e92d6da", + "rawBytes": 15700, + "rawSHA256": "789b974b76e89264eed035defd97559d1e823031a19fa990ee35085436bcfd64" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Executable.lean", + "mode": "100644", + "gitBlob": "5aea1c1267ec5c3d5e7cb12f56b17f797516b417", + "rawBytes": 43297, + "rawSHA256": "7ed53fd5715a4ea1d6628ae52f626b1573b2f20bb4e6b9b983c0a2c32de41baf" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Finalization.lean", + "mode": "100644", + "gitBlob": "49e18b6e158ecfcd0c7247402a3502a4097a8630", + "rawBytes": 29881, + "rawSHA256": "8288249ec0341d280b3b78a23a73a34bddae36b2dfa345d0fe097e0e15085865" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Finalizer.lean", + "mode": "100644", + "gitBlob": "69ee3460aacba441914d77c1433eafd6ebfcd6c2", + "rawBytes": 43977, + "rawSHA256": "0ae34dd1731d0d51af30fbaa0d26e27abb0fb63c2f8e5d19c5543c765812354b" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Input.lean", + "mode": "100644", + "gitBlob": "2df3df361dee8c9556de50a792de6d8ca903169d", + "rawBytes": 6850, + "rawSHA256": "3b54bfba5e08abef39f3c50991f2224debaad792418b329c8c6cf90b8a3f21d9" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Machine.lean", + "mode": "100644", + "gitBlob": "f4dca3838293d7f94d663045d2c13c4c44fd55f4", + "rawBytes": 7428, + "rawSHA256": "bbc0e439fb2fa55ae75e440ac3a6c77e6203fc6f7b39b2cae8b95e1ed2b8d57b" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Ownership.lean", + "mode": "100644", + "gitBlob": "adbcae8fc33a4fa670f421e7198e5f421dcea345", + "rawBytes": 6211, + "rawSHA256": "094fd2aeb50dbf66c209fe9c52ed1352e8d413205c281246ff983dd4dff7197b" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Physical.lean", + "mode": "100644", + "gitBlob": "e6aa6e48bde045042b857da4a7c9383af37254c0", + "rawBytes": 36552, + "rawSHA256": "22dcd8903f457a75c581d771c4804ca2e5375bc1f5d1afd539227494d6240c5e" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Profile.lean", + "mode": "100644", + "gitBlob": "7f876238f299df195f564015ade9a4b6fb91de86", + "rawBytes": 5061, + "rawSHA256": "9b2d904d9a585bc134e0d74e89e91f6fbc4b6f20f880d0ad718d9e86c7d5800b" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Program.lean", + "mode": "100644", + "gitBlob": "02f4dc48ca2a2b7e6c053d3742ac4d0e2331f820", + "rawBytes": 8412, + "rawSHA256": "bb40b5ab3b7532ea4f907bf1d174dd2de14013c5e022454cb7c3b99cc2707dfc" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Provenance.lean", + "mode": "100644", + "gitBlob": "4c878fa3cbe5818bff3941de3f47f195e51bb7cb", + "rawBytes": 13708, + "rawSHA256": "c5aa67539106246d4461dac3d5617c01b24730f7348b44a95f046dc031fe3308" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/QueryBridge.lean", + "mode": "100644", + "gitBlob": "54b8e510b3417e75ac20a6b3a39cc2af8e8b6c28", + "rawBytes": 8004, + "rawSHA256": "df9ab7e58c853fc33a047b0f01baafcc2bc40d359657cdd1fc824da6c0e78265" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/QueryEntry.lean", + "mode": "100644", + "gitBlob": "d385098fbb0938f83c7d6f37226b2569c8ecd856", + "rawBytes": 25120, + "rawSHA256": "5fe765c5ed664e87a9ffc43a4c00b9dc294ce6d2dd75fd6aeec51dbd469fe25e" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/QuerySafetyBridge.lean", + "mode": "100644", + "gitBlob": "245e77ea37749b542b2a2db99ff9de33818fbd8c", + "rawBytes": 24516, + "rawSHA256": "b0324d42d7309664380842c74fbbab479b0f20146ac32c07cf78583c96d96043" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Resources.lean", + "mode": "100644", + "gitBlob": "a23a9004547c96deb5e8384a3bc80da172177823", + "rawBytes": 5950, + "rawSHA256": "bd931d49482d8af1bbec8e8dd78bb7d9dcdf6fa1f65e814856a099964055ec62" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Retained.lean", + "mode": "100644", + "gitBlob": "154cedad80ea3feb1c53210581db8e5dab086fb7", + "rawBytes": 4593, + "rawSHA256": "ff6ada49c394e940e68ece8bdc52dc39c436ca6299837bfd9ff639ef7ee95301" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Retirement.lean", + "mode": "100644", + "gitBlob": "08495761452e2dfbec9450c6041901eaa698861f", + "rawBytes": 23754, + "rawSHA256": "248106288060c2b3316a3fc133093385e498e3775c91bc73c005136db879fb4b" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Reusable.lean", + "mode": "100644", + "gitBlob": "2d0de18da29bab15beb0a5e8a1b18b1aa0ae60ca", + "rawBytes": 26810, + "rawSHA256": "087d46afb3b9da6cfd7373cf8b3c7752fb7b538b4c20942775180b1957c8ff67" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Safety.lean", + "mode": "100644", + "gitBlob": "38b82010e24f51fce11681ebc95680e92d20c97f", + "rawBytes": 5960, + "rawSHA256": "1c0f972965596dfbb631b7bd44aaea00b1178ee9b6c40ddb7d2bd45d95f4c490" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/Service.lean", + "mode": "100644", + "gitBlob": "2591a4f4b65519301bd05b9e2568a1b53bd4ff45", + "rawBytes": 8157, + "rawSHA256": "f4157493517f232a6a83bb52c87b751f6a0c2c1f9ca9c98fb6cae036542a34e0" + }, + { + "path": "RMQ/Core/WordRAM/Lifecycle/ServiceSafety.lean", + "mode": "100644", + "gitBlob": "891afe0e832c8e22493afb3c882c3aa569a12c18", + "rawBytes": 20576, + "rawSHA256": "121a2bce2ed5bde35bfce6a8fe7180814531ca3c1487cc77f768993d5beb3a31" + }, + { + "path": "RMQ/Core/WordRAM/Native/.gitattributes", + "mode": "100644", + "gitBlob": "6ed29baa59dbd6707dfd833d6fba125f605a0a68", + "rawBytes": 94, + "rawSHA256": "b551b88139a88afd228e5532b8d82f6df705a9b82ece640523e3543c9b089e0b" + }, + { + "path": "RMQ/Core/WordRAM/Native/AxiomChecks.lean", + "mode": "100644", + "gitBlob": "54229006f8805c07ddadd1a13c7cca2b6a90e257", + "rawBytes": 4353, + "rawSHA256": "013d4c738e37228f323ecdd606ced8ab0b5d7e5d515225a3cfe6a8d1a2aaf379" + }, + { + "path": "RMQ/Core/WordRAM/Native/Binary.lean", + "mode": "100644", + "gitBlob": "54687742f4641fc517329a10e97575ec03fe7a0d", + "rawBytes": 25637, + "rawSHA256": "c50741d0a9aed1797919f405e8f7440410c0cd13dd2b9f299d0e6ab5e959ae16" + }, + { + "path": "RMQ/Core/WordRAM/Native/Binary/Bounds.lean", + "mode": "100644", + "gitBlob": "08c99b2453cf801c8586e792142d099342eec086", + "rawBytes": 6807, + "rawSHA256": "1adf9be737ad6c86aac6e5fba75ed3384876aa029ccefbbd76cda03df70c339e" + }, + { + "path": "RMQ/Core/WordRAM/Native/Binary/Checks.lean", + "mode": "100644", + "gitBlob": "5e060cf492707eb7062963eab9fb649c74cb00a0", + "rawBytes": 12340, + "rawSHA256": "03b4786f8ab00028b09ab6270efe3b9cf9e178e7db4ca4d98c98d0eebc255cad" + }, + { + "path": "RMQ/Core/WordRAM/Native/Binary/Codec.lean", + "mode": "100644", + "gitBlob": "1ba71e9c2c9fbf454268eb21b8c4907bd8612ae6", + "rawBytes": 16260, + "rawSHA256": "e46f05148bb2f4d1d25c848ec804b0e2e0881efb536f988a90ab9cb7371c11f7" + }, + { + "path": "RMQ/Core/WordRAM/Native/Binary/Cursor.lean", + "mode": "100644", + "gitBlob": "46b3370b0116fc071f9102c48205fdeaf151e69f", + "rawBytes": 10733, + "rawSHA256": "fa032a73e3caab84a874d736d26ca8b833cecc526bbc880bdf09ac8647e68f45" + }, + { + "path": "RMQ/Core/WordRAM/Native/Binary/Cursor/Checks.lean", + "mode": "100644", + "gitBlob": "6bcaf6c3ae76f7d413e7eba37f177b3c12d2e69f", + "rawBytes": 7833, + "rawSHA256": "f7b081ba8bb3a4e11faa1ab75660d7f24613fad1e4745fe7edc7ea2a07f1a0a2" + }, + { + "path": "RMQ/Core/WordRAM/Native/Binary/Cursor/Core.lean", + "mode": "100644", + "gitBlob": "a8f6d49eed485b7036ab8f06c2c2e71cc6e04581", + "rawBytes": 24281, + "rawSHA256": "18f42acee5d218da5cb6b787e7df25c69c572c72551e3008d1106a6cfa660e28" + }, + { + "path": "RMQ/Core/WordRAM/Native/Canonical.lean", + "mode": "100644", + "gitBlob": "cf5aca6ff7b7554bd3d89c93c1b317015a2fd237", + "rawBytes": 6847, + "rawSHA256": "d61c7c1aa6c5fb521995a96f5ec0ebdfe8bdbe4a58cb1f6e159080e365ab857d" + }, + { + "path": "RMQ/Core/WordRAM/Native/CanonicalImage.lean", + "mode": "100644", + "gitBlob": "b3a3245bef846330952f8bd4628625ef8e1c285e", + "rawBytes": 4727, + "rawSHA256": "2a8469798f8a7700f22da9f01aa157bfde5f5bf7fe7282132dd53675fd74ee75" + }, + { + "path": "RMQ/Core/WordRAM/Native/Capstone.lean", + "mode": "100644", + "gitBlob": "7fe78d055cdec2f8a4bd91d068ee1a6db93220ba", + "rawBytes": 17145, + "rawSHA256": "e2b2fb55223a271b3383aacb70361d85126abeb3c252acb0e314467729c6fa0d" + }, + { + "path": "RMQ/Core/WordRAM/Native/Contract.lean", + "mode": "100644", + "gitBlob": "878e44a24c63ce9fb1f0712e6b9245191308a394", + "rawBytes": 13766, + "rawSHA256": "a8db1eaac6445f2f8490a6c344a3f573fd169d3fd7b82e6637c4947159e306ae" + }, + { + "path": "RMQ/Core/WordRAM/Native/Entry.lean", + "mode": "100644", + "gitBlob": "85c45b3d794212d40b7bdf0de43246e23c891c9a", + "rawBytes": 2266, + "rawSHA256": "add666450d8cf6b724f1467cc2cd4182e8b5eefc50ae1bf369aefc5a2a4b7832" + }, + { + "path": "RMQ/Core/WordRAM/Native/Execution.lean", + "mode": "100644", + "gitBlob": "a229ae59c36c222cedf433c8211d725cd2e7df16", + "rawBytes": 8989, + "rawSHA256": "1367785e02684c7a81c93df9815d8b736a3490f32046619c75a1838baf469c06" + }, + { + "path": "RMQ/Core/WordRAM/Native/Finite.lean", + "mode": "100644", + "gitBlob": "987577f5e33326093ecb0903ee5ae332e5f60a9b", + "rawBytes": 11537, + "rawSHA256": "8edc747f2f0bbb7d4e6f6849b63869016969c4f7535d62e99a6e4d01901223df" + }, + { + "path": "RMQ/Core/WordRAM/Native/Host.lean", + "mode": "100644", + "gitBlob": "ef898ee5cdc78ee2b4732ebe1fb0a9e52d2b3405", + "rawBytes": 2820, + "rawSHA256": "290f2dab5985363fd2994ee3f96a21924f3ebd63f3a79a9f2e7df476173001f0" + }, + { + "path": "RMQ/Core/WordRAM/Native/Limbs.lean", + "mode": "100644", + "gitBlob": "fc5ac5b4cac019a10c8c604c2d8216aede5faa97", + "rawBytes": 15313, + "rawSHA256": "06d057d0de50e263e701d2d5fea1a4b0e1f6c3dd9a6bfdb6f2f9ede71a7803f1" + }, + { + "path": "RMQ/Core/WordRAM/Native/Limbs/Checks.lean", + "mode": "100644", + "gitBlob": "6b7b6bf5cd189e7bffa50eb3d282e1f5cf8ca964", + "rawBytes": 5602, + "rawSHA256": "c78560dbeb2076f12a5efbbb3e9cf9389387caccf7ab9a3f8c6b3b16ea3e643a" + }, + { + "path": "RMQ/Core/WordRAM/Native/Machine.lean", + "mode": "100644", + "gitBlob": "7808441654336fecb7dbc00d3c960e512f6dcba6", + "rawBytes": 38858, + "rawSHA256": "f5286e6b52a5c5a73571bbf831e7ca9c5d731f7f5998f3aba724e17f7ab94b3d" + }, + { + "path": "RMQ/Core/WordRAM/Native/Machine/Checks.lean", + "mode": "100644", + "gitBlob": "74dcd3d152f7aaaa5ab16ebe36a3759185822f74", + "rawBytes": 7330, + "rawSHA256": "f8b62700dffcf1bf1948ee63be1ffcbe5a9e10757a569e3df8a7eec8f27614c2" + }, + { + "path": "RMQ/Core/WordRAM/Native/Machine/CodeFacts.lean", + "mode": "100644", + "gitBlob": "25413782c337fb100dfa2c8f4b0fd3d488b98a4e", + "rawBytes": 7126, + "rawSHA256": "94aa115ea137c32f0d11e3714a0e6c0add87165ed1306cdbbc22ecc4c0030c00" + }, + { + "path": "RMQ/Core/WordRAM/Native/Machine/CodeFactsChecks.lean", + "mode": "100644", + "gitBlob": "42fc709b74722a236fdaa6ded2ec08f758575905", + "rawBytes": 1432, + "rawSHA256": "a3aac86ce95af7b8f477b499d8dfd6ad8a304ede8ceb20461054a2e0a6151ece" + }, + { + "path": "RMQ/Core/WordRAM/Native/Observations.lean", + "mode": "100644", + "gitBlob": "b02321cd8584c6c9c0bb85f413f2349854685f85", + "rawBytes": 3164, + "rawSHA256": "bc3c825ab7598810f9506b36d0ec9f34031df7d9715f2ab68fedb823009679b6" + }, + { + "path": "RMQ/Core/WordRAM/Native/Route.lean", + "mode": "100644", + "gitBlob": "ed34016488095d90560f26a6fa6a91ec6d569452", + "rawBytes": 7462, + "rawSHA256": "c00240a5a2e994dd1a996c79a52ff54780a0b5a87010b3dbcf4ed3a61244a5c5" + }, + { + "path": "RMQ/Core/WordRAM/Native/Runtime.lean", + "mode": "100644", + "gitBlob": "886d698777ec9acce552a8459683cb3dfcb3dbd5", + "rawBytes": 6120, + "rawSHA256": "23ef158fcc87169566cc443401bd6842197f9373e39cf5df172165b765fea847" + }, + { + "path": "RMQ/Core/WordRAM/Native/Thin.lean", + "mode": "100644", + "gitBlob": "7fd0365ff4bc40be2e95386c428a1ee6e3ab3ede", + "rawBytes": 4498, + "rawSHA256": "26d984386eea21cccc49ebf6217cd824b7896cf98785f8f843c6ad9e2eb69845" + }, + { + "path": "RMQ/Core/WordRAM/Native/WitnessExport.lean", + "mode": "100644", + "gitBlob": "cd5a1e59c85fbb2afcb0df4c55c9455928e70e51", + "rawBytes": 13585, + "rawSHA256": "4cf5c928fcd784df112115a8bdff87a8ca3ffc85af04b679e320402106466f70" + }, + { + "path": "RMQ/Core/WordRAM/Native/Witnesses.lean", + "mode": "100644", + "gitBlob": "2192ef86e5d8abdee7c7e5d8c5f3a0971bb6cbb7", + "rawBytes": 10501, + "rawSHA256": "8e732e615a9e69646ad6b6d2fda5f632df9826d2a22ca1b2dd71c98ff016b642" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/BranchBound.lean", + "mode": "100644", + "gitBlob": "48157b1318258ad86649efed70af04471f1f8e5b", + "rawBytes": 17543, + "rawSHA256": "64f539c5e8f0247a630b5099e6f9a0d4e8bd00f6dfc8f0073e8179cb870b66d0" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/Capstone.lean", + "mode": "100644", + "gitBlob": "7eeebe68bbd2ea3077fe825a5b01462e1b8f09a4", + "rawBytes": 7574, + "rawSHA256": "6f960b2c3d01676e2a5fe29509622b901dfa97072e2529d6d6befe70b3158a63" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/Certificate.lean", + "mode": "100644", + "gitBlob": "9d47713c26a491934ab17526750b08761c6afa87", + "rawBytes": 9238, + "rawSHA256": "4750350391bbca77af33f4952afcd091142fa62a788841a58f03b9ed2dc40430" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/Compact.lean", + "mode": "100644", + "gitBlob": "42259f79f94c26bc4e06e89ca5c4ed4588bcbfb2", + "rawBytes": 3208, + "rawSHA256": "7bde1173b5661a8c68acfd13f5e9911d176cf8e55f7fbd635e8a5e5819c8de17" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/CompactProof.lean", + "mode": "100644", + "gitBlob": "c349a1ad48cdc85169623acbe7647d43cf292925", + "rawBytes": 31141, + "rawSHA256": "54bf190ddfaa28aa410583942daeb219937e8db061ac4ce6ca8cf1ba201cb5b4" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/CompactSafety.lean", + "mode": "100644", + "gitBlob": "11a777f9b21b4c946b5c8d01df3aa2e953bc81db", + "rawBytes": 34678, + "rawSHA256": "6b84a73fcf1d9ddc6d5c7117ea5b55d4fcd840b6676cbaab717fbbdd7476563e" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/CompactStatic.lean", + "mode": "100644", + "gitBlob": "b0164a73b49c8407267ff30c779fca3d39025843", + "rawBytes": 17274, + "rawSHA256": "5c5f1ab987abe38d7bb41b93dc67ba6dcdf15c6ed805f4eb1c95037a338875a2" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/Consumers.lean", + "mode": "100644", + "gitBlob": "7a78c403e548df7ba7e7782ab081f08c4f4ad32b", + "rawBytes": 25172, + "rawSHA256": "47a1c35ec6ea7db27a16abe4cb282a1043ef315f54485806bf4f986e7f5d5597" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/Query.lean", + "mode": "100644", + "gitBlob": "3f1829809423696c204372ae2056348c4a7ff2f7", + "rawBytes": 9432, + "rawSHA256": "1fe89cf2b3f2833c330c91db9c93ea35b6c37a3f98bc85a4b241d6aa63c36c05" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/QueryProof.lean", + "mode": "100644", + "gitBlob": "aeaf3b8ab78f7c316d1e6fc267447e72bf8d1daf", + "rawBytes": 6442, + "rawSHA256": "f5520f3b203a20eb8ebfacd2c0381c4ec2503dc9a975e4876b361d16d40ceb58" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/QuerySafety.lean", + "mode": "100644", + "gitBlob": "c414eb89274fd85807fcd6fe070ebfefb1a362d1", + "rawBytes": 2379, + "rawSHA256": "e546204b1380775f78a82f45bdb07616b86bacf55dd73d06faabfe60e7da41d5" + }, + { + "path": "RMQ/Core/WordRAM/Optimization/SourceRelations.lean", + "mode": "100644", + "gitBlob": "089d6b1a3e9768bca1be2c60510e5570b8b0b255", + "rawBytes": 17566, + "rawSHA256": "b6cc636bfd691d18f4bde989afe188365d12007b68565cac98cc3cc394e3a0db" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Accounting.lean", + "mode": "100644", + "gitBlob": "986ef250b8dfaf17ef712c559bae6c3fce61ac5f", + "rawBytes": 2876, + "rawSHA256": "9429c3d715b22d587d4cad41bc5f288987d1a27d51da345ed6c6eec85333e2cb" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Allocation.lean", + "mode": "100644", + "gitBlob": "39d65f0bc8a19dfc8467d16263bfc631e99c6551", + "rawBytes": 9520, + "rawSHA256": "7fdc39400ff3ab877becd63d2e367e24ace0c71f373c7f54017039ee578e7d49" + }, + { + "path": "RMQ/Core/WordRAM/Packed/AllocationLowerBound.lean", + "mode": "100644", + "gitBlob": "8806fc00da8501ed57de269a32f6f3135450f591", + "rawBytes": 26743, + "rawSHA256": "d571b5f875ec5c34be3056841dbf90cfaf00cfb3ff4fcacea19e1d83253d6d06" + }, + { + "path": "RMQ/Core/WordRAM/Packed/ArrayRun.lean", + "mode": "100644", + "gitBlob": "0e6484f9a5238cd7805ed31a8e406fbc9081e844", + "rawBytes": 2050, + "rawSHA256": "cd45c07c1f822c1ba57b65acca2f5ce916fa735b33269afb7ceb17f4e3b9c82f" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Calculus.lean", + "mode": "100644", + "gitBlob": "1a4908d33997a2f6222a64a080d772f37ccc6a81", + "rawBytes": 17807, + "rawSHA256": "2ba830ca4ad97fe7a51a6561c5f18eaff7d2bc4084edd0d124fe47c41d955a45" + }, + { + "path": "RMQ/Core/WordRAM/Packed/CandidateProof.lean", + "mode": "100644", + "gitBlob": "c0d507aa3126cf91b8d4b752e0d25b4ae838e1d6", + "rawBytes": 5101, + "rawSHA256": "122efd67e9a359275f949a85185cc45d406b6648211091a6704805c5cb3033a2" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Capstone.lean", + "mode": "100644", + "gitBlob": "4bdf1fda17b0eceee714c7719175e8357bcd3ced", + "rawBytes": 11554, + "rawSHA256": "d9c7bb7d158d54c9f221080453c58f7da6960497d287b7accc39bebb3f931a2c" + }, + { + "path": "RMQ/Core/WordRAM/Packed/ChunkArithmetic.lean", + "mode": "100644", + "gitBlob": "824723043427fc36a9a6e5c0a4ce8ca47b13bc9f", + "rawBytes": 10439, + "rawSHA256": "0f1b3de7e3cf3dc37036335da47fea5f4a859e06bfbdf47314f23c6312a982fe" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Compiler.lean", + "mode": "100644", + "gitBlob": "2cd06337d200b1c778145a286d7a08146bcef910", + "rawBytes": 29873, + "rawSHA256": "c7aaa88dfb6a24099f8e7b22d7ac77942043476a47874a414bdab58c77ee5505" + }, + { + "path": "RMQ/Core/WordRAM/Packed/DensePacking.lean", + "mode": "100644", + "gitBlob": "fc07693b13a3362e22ccb4b2b6e239d55cdf4a7a", + "rawBytes": 8009, + "rawSHA256": "75487722a3dbb6bcb3d445b0c242e8380f7b9f77a0762354d83f692cbc956913" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Frame.lean", + "mode": "100644", + "gitBlob": "da57356278dbd5a6cb1febf3d3e1cada43857a80", + "rawBytes": 3216, + "rawSHA256": "480ea8df315b6dee0f2048eeeac03131368fd27ef09e0aafa21da2a676929939" + }, + { + "path": "RMQ/Core/WordRAM/Packed/FringeProof.lean", + "mode": "100644", + "gitBlob": "884ca054aaaaf20b33aec0afcfb4fbfd32cb8cb0", + "rawBytes": 49982, + "rawSHA256": "80e9dcc3c7410d60ed99ebebd7f2a40d8faf54f634bd5310f326319ebe589fbb" + }, + { + "path": "RMQ/Core/WordRAM/Packed/FringeSafety.lean", + "mode": "100644", + "gitBlob": "1bd86ca09a2d07f86886d3667bd79a9f68cc3652", + "rawBytes": 56146, + "rawSHA256": "9d582e04a68534074a62f4494969e60264102e87a554dc4c0a9328327b841f2a" + }, + { + "path": "RMQ/Core/WordRAM/Packed/FringeSource.lean", + "mode": "100644", + "gitBlob": "7865a9671d9453dc9ac8bf66af2c8642e4360f10", + "rawBytes": 8756, + "rawSHA256": "bc779a746a938c7b10fdb4b93c84003e9ca91d27fb3a3813abdf5944920b96c2" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Guard.lean", + "mode": "100644", + "gitBlob": "8cfeba2892f8321956d799eb3514c7522bf46a7b", + "rawBytes": 5782, + "rawSHA256": "b911e50388fbdcdcd82a8e3adedd754473b6e5ab162a0d5d25b5c009a9160ffc" + }, + { + "path": "RMQ/Core/WordRAM/Packed/InteriorCandidateProof.lean", + "mode": "100644", + "gitBlob": "536c476bcebca4833366a5f3f0be3d5d19d4a09e", + "rawBytes": 131852, + "rawSHA256": "ce6073be51d918b221216b6dfad4cb913d2372e3d2f5ea66a3f09233589c4987" + }, + { + "path": "RMQ/Core/WordRAM/Packed/InteriorLocate.lean", + "mode": "100644", + "gitBlob": "2b76d6235136a8bb9afc1daac7fe67df6ce34012", + "rawBytes": 7310, + "rawSHA256": "e570243d505d2498085a4ca289deb74e7ccc98985f08aff7bfb9d9d3151600e7" + }, + { + "path": "RMQ/Core/WordRAM/Packed/InteriorReadProof.lean", + "mode": "100644", + "gitBlob": "e59f716c11e9cdc0b323265220e0e5633e87789f", + "rawBytes": 38897, + "rawSHA256": "922e483a25d0bb212358c7df4285fff17f98acf057e6d15207796306f185a605" + }, + { + "path": "RMQ/Core/WordRAM/Packed/InteriorSafety.lean", + "mode": "100644", + "gitBlob": "9af0ede08be43082e459e6b97a578f008b5ff551", + "rawBytes": 135916, + "rawSHA256": "5d38792a31319f871c6bb9fdde4374df51588a78905b65e1036dc702e9b0d631" + }, + { + "path": "RMQ/Core/WordRAM/Packed/InteriorSource.lean", + "mode": "100644", + "gitBlob": "920906f499c5b95eb3c9dd5b87927924ceca09cf", + "rawBytes": 11666, + "rawSHA256": "656c25cffd3d7bec326ca03c9e068250b9287402aaf6091e71e5a234c0879949" + }, + { + "path": "RMQ/Core/WordRAM/Packed/LCAProof.lean", + "mode": "100644", + "gitBlob": "76f4ee5df246d48cbaebb4e7a640e4304dd4a244", + "rawBytes": 43679, + "rawSHA256": "281f6c63fda95699292eb9eed87dcf362d3ec549d99cbcb5a0a0cffe0cfff058" + }, + { + "path": "RMQ/Core/WordRAM/Packed/LCASafety.lean", + "mode": "100644", + "gitBlob": "04eb3caad4c2e088e7bea13142bd6d4174d4080e", + "rawBytes": 27935, + "rawSHA256": "e0ea8687c328aefc33ce385a53d8bbe9bb6ffeb1c974756ffaef80e3e562047f" + }, + { + "path": "RMQ/Core/WordRAM/Packed/LoadSafety.lean", + "mode": "100644", + "gitBlob": "d072778216d7d44539636bfcb766e74213ccc57b", + "rawBytes": 42584, + "rawSHA256": "aa7f502022e29c3d10a808e68ca0c9bb1481a0032659fa3c05bbb6d860850369" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Locate.lean", + "mode": "100644", + "gitBlob": "a610d7777cb91a176575c41bc722b1bea7dc17a6", + "rawBytes": 61614, + "rawSHA256": "3220feece22baef77ab8466675b8bde65bd3fef3a3c3832aeb176adb4af81578" + }, + { + "path": "RMQ/Core/WordRAM/Packed/LogicalSpan.lean", + "mode": "100644", + "gitBlob": "e23de1a5946d8a55c17dce7d382369dd18e54c34", + "rawBytes": 28689, + "rawSHA256": "3a3bf287e8221fd1825d2205260fd7e5f02ed75ff930cebf603fba67420b1573" + }, + { + "path": "RMQ/Core/WordRAM/Packed/PhysicalRead.lean", + "mode": "100644", + "gitBlob": "6efea650e46a7d4b1ed36adc6483e030b4332ec3", + "rawBytes": 15311, + "rawSHA256": "49c9ce18f81b0b7a00e96c0e32f12121ee27401412146752db845ce22581558f" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Primitive.lean", + "mode": "100644", + "gitBlob": "9ee7a8069c8e55407e4199dc620e5b8551e3093d", + "rawBytes": 7448, + "rawSHA256": "4c73250df41ae328f6a9c6cd33fcea48190a8a77ac81f09f1731b789d79b05c4" + }, + { + "path": "RMQ/Core/WordRAM/Packed/QueryCertificate.lean", + "mode": "100644", + "gitBlob": "23d6a4c6f83832eb2ebe83e8779f29f77df60496", + "rawBytes": 10150, + "rawSHA256": "363eef84524d4942d755bb84176ccc843fe2169f87c8b503d52a227f1249ddb3" + }, + { + "path": "RMQ/Core/WordRAM/Packed/QueryCorrect.lean", + "mode": "100644", + "gitBlob": "c5eb674a2bbe8f2e6d600fb0f85766386d6eca04", + "rawBytes": 4565, + "rawSHA256": "f6f8066e4d71db8298f1bd902f6ed1e98e5cb3aecf572b5996b63926b925125d" + }, + { + "path": "RMQ/Core/WordRAM/Packed/QueryObservations.lean", + "mode": "100644", + "gitBlob": "a42907e59bd5f1a9280c44a814b45cd4bae6a3eb", + "rawBytes": 4588, + "rawSHA256": "a51a79c3d201495a4538c7d04a7a35d9b3beac350c1ba01fc0f4c540891b4c05" + }, + { + "path": "RMQ/Core/WordRAM/Packed/QueryProof.lean", + "mode": "100644", + "gitBlob": "6bc4493a814eee485dfb7cf36da2d1c006e41779", + "rawBytes": 34048, + "rawSHA256": "868d310396b232719b24b706709c9feecf7cf0672e1ada87fa26578367bd9399" + }, + { + "path": "RMQ/Core/WordRAM/Packed/QueryReference.lean", + "mode": "100644", + "gitBlob": "afe47b8a32832e53701e28dc3b008f1d6d32b8f7", + "rawBytes": 5808, + "rawSHA256": "be9c1eca68416bf8df4844ded3cc8d243fc2480e6d2a4834dbcbc0a276e3fbd6" + }, + { + "path": "RMQ/Core/WordRAM/Packed/QuerySafety.lean", + "mode": "100644", + "gitBlob": "64eb0bc513349545f81cbac2475f92895930a4c7", + "rawBytes": 36470, + "rawSHA256": "b2139f2396502e4e01d7f666f5b7d2eeb68c03bcbb61390ab23e2a77de716e33" + }, + { + "path": "RMQ/Core/WordRAM/Packed/QuerySource.lean", + "mode": "100644", + "gitBlob": "077f3b3803468dd60f58736caf979b4c879a827b", + "rawBytes": 6040, + "rawSHA256": "dfcb57325902a1eebafabcf24fc5437aed88a2ea32df416b5cb2bbce98f51415" + }, + { + "path": "RMQ/Core/WordRAM/Packed/QueryStatic.lean", + "mode": "100644", + "gitBlob": "a6a6c8af4ca92fedc10bab730056c3a6d2d03513", + "rawBytes": 5433, + "rawSHA256": "f8724bbe814a5a752eeef4c1e192698fe8e6941e776d604c10a92d65a43b3d2e" + }, + { + "path": "RMQ/Core/WordRAM/Packed/RaggedWindow.lean", + "mode": "100644", + "gitBlob": "c25aa9a82983f898417ecb1b5d9849e7713c7605", + "rawBytes": 6002, + "rawSHA256": "5520399e6da36ed822f7f8f95505168acb673779521a95bbf402cb7d5805bbd4" + }, + { + "path": "RMQ/Core/WordRAM/Packed/RankProof.lean", + "mode": "100644", + "gitBlob": "57d719c4b0015fa534dc2340a1c194b36861a0ad", + "rawBytes": 83941, + "rawSHA256": "52106920b98f295c699008619de132d320a3f97258074c8027fd8f6b2d5231bc" + }, + { + "path": "RMQ/Core/WordRAM/Packed/RankSafety.lean", + "mode": "100644", + "gitBlob": "2932df9d0b444aab14914558f7425c8948c2eed2", + "rawBytes": 87035, + "rawSHA256": "bff7f9cb3bc558ec41b0b1bc4b73c08f4f8f2acc5df9eb734e7ff20d9974d4f4" + }, + { + "path": "RMQ/Core/WordRAM/Packed/RankSource.lean", + "mode": "100644", + "gitBlob": "b5f57f94ce458a38dfcf83801c89333029704414", + "rawBytes": 5803, + "rawSHA256": "b10ba599d21313ac0e5fc7d837d1fe1b999d270280959ca1ae30b8690ab4f6fb" + }, + { + "path": "RMQ/Core/WordRAM/Packed/ReadInterface.lean", + "mode": "100644", + "gitBlob": "0a68f62355dfd798bab3f2579e43135b8fcdb588", + "rawBytes": 5106, + "rawSHA256": "75509f98331eb79e87809851b1bfb340bc3157e4482405f9f47d1d49a7c1ea87" + }, + { + "path": "RMQ/Core/WordRAM/Packed/ReaderSafety.lean", + "mode": "100644", + "gitBlob": "37b534eac23885a9e17856adafb111c766eb5db9", + "rawBytes": 50353, + "rawSHA256": "ae8aa18eae3c6639ae66843efca0a4a4e4ca9f52ed974756f092214408baea44" + }, + { + "path": "RMQ/Core/WordRAM/Packed/RegularLocate.lean", + "mode": "100644", + "gitBlob": "26e636e0cd038f1783541ab60545d6c0bf025bb5", + "rawBytes": 5670, + "rawSHA256": "047ecf38990bd410085689fde702417c035785c59c738ba6e1d66b248709d360" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Safety.lean", + "mode": "100644", + "gitBlob": "a2aa663ac41075c94a9f973c7c6c83dd53a35328", + "rawBytes": 43628, + "rawSHA256": "ef0273d4b16f5876a949cad219ec421864d7533fddd5bb492bff360c0134cc1c" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Scalar.lean", + "mode": "100644", + "gitBlob": "ba905d2a82b6e5947fa62baf346ba3ae2c380e4c", + "rawBytes": 3522, + "rawSHA256": "5d25c758d77f5523df8ae1c1136ae85fae12bd9b11bcb6e472dbfabf97506493" + }, + { + "path": "RMQ/Core/WordRAM/Packed/ScalarSafety.lean", + "mode": "100644", + "gitBlob": "9490454d58fb0c531469f12934f5cc04370954f4", + "rawBytes": 11712, + "rawSHA256": "e7afb1fb9e238ad9f051dfc5236e3e095ef259b4d0cfd875e4a757c10af858bc" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Scratch.lean", + "mode": "100644", + "gitBlob": "ad08e91a31b1323abdcb3c7b8d4c50be3971bc92", + "rawBytes": 4433, + "rawSHA256": "320ddd6c1f6549902951b99ccf99c66b231d2a0106487a710d8638372ef32e64" + }, + { + "path": "RMQ/Core/WordRAM/Packed/SelectProof.lean", + "mode": "100644", + "gitBlob": "1a1d2bfe44a2bb29ed46b6cc2266617d1db3ae9c", + "rawBytes": 162352, + "rawSHA256": "292ad12dc2879b2f523b29300db2e5251aea57bbacc5ad2154b2660daf8946fb" + }, + { + "path": "RMQ/Core/WordRAM/Packed/SelectSafety.lean", + "mode": "100644", + "gitBlob": "42e973fa4096490518fabbd098ff960ce49a1624", + "rawBytes": 121690, + "rawSHA256": "43c6c183a6b08b38b58521c42320f56a7ac87c27d23dc7aaf0dd5f73eefc13e3" + }, + { + "path": "RMQ/Core/WordRAM/Packed/SelectSource.lean", + "mode": "100644", + "gitBlob": "893b7deee585ac83ed3121312d476b695574233f", + "rawBytes": 9735, + "rawSHA256": "9c41270fe301b417ca622e523f6546e1eb4cb707fdf68d38f64f2975a97c9a5d" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Setup.lean", + "mode": "100644", + "gitBlob": "9fc02c520da4b841a3a519d833e251c6d90e5d62", + "rawBytes": 20542, + "rawSHA256": "b1bef6d6859a63c33e8abd31387697012c002209503d3e13f79b2c8145e6a918" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Span.lean", + "mode": "100644", + "gitBlob": "2631671b135a4400597b4b266a1430f23b8be00c", + "rawBytes": 15105, + "rawSHA256": "54e1a81bdde51e0c460c9ba5adfd57a04254fe5d14ca6a77259f4108a64584b7" + }, + { + "path": "RMQ/Core/WordRAM/Packed/SpanAssembly.lean", + "mode": "100644", + "gitBlob": "0e8cd2d15968d0425355049571dbe484fa4d118f", + "rawBytes": 26016, + "rawSHA256": "ea0b7ca706c9750a6e0cdf6220f5f8b411a54cec33cfaddded4f010020239106" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Structured.lean", + "mode": "100644", + "gitBlob": "680f1585b4d833318b86b67b5f511c258a66d563", + "rawBytes": 4052, + "rawSHA256": "f7f580a6a5e7be2bed61f3c126ac83720046fe3a3d18c07286cf6b5aef81a887" + }, + { + "path": "RMQ/Core/WordRAM/Packed/Width.lean", + "mode": "100644", + "gitBlob": "a776d3e2ba49ab867683dff49deb7956b6a0cc02", + "rawBytes": 25342, + "rawSHA256": "6fb1d7dfe053e4a415b861819e46e448750ee056f8a0a6cab8ed904277f9f9e5" + }, + { + "path": "RMQ/Core/WordRAM/Packed/WindowProof.lean", + "mode": "100644", + "gitBlob": "0b65303bb54e5e30b5ca1f09b58540979407854e", + "rawBytes": 20240, + "rawSHA256": "b0923835a5b9039d6041c15de61d2fd02ae3bea82ad79b83b7726fcdcc9d8408" + }, + { + "path": "RMQ/Core/WordRAM/Packed/WindowSafety.lean", + "mode": "100644", + "gitBlob": "42cea2741f64970b5819e52974db7335d53d20a8", + "rawBytes": 19064, + "rawSHA256": "21c514e1a3cd6e90b8fa31fcac2bb71d147d5baf66e0ec3b47cbdc7fcf394fa4" + }, + { + "path": "RMQ/Core/WordRAM/ReadStoreEval.lean", + "mode": "100644", + "gitBlob": "35435e9d3b9e224b458f8fbf898d7736757a3d8d", + "rawBytes": 29601, + "rawSHA256": "862496d886be52077fd0b6f9a8ad6d4e49ee0c39234dcd3213c3df33300397d2" + }, + { + "path": "RMQ/Core/WordRAM/Register.lean", + "mode": "100644", + "gitBlob": "eca2029a512cdbae6596467ccb0898139b45af13", + "rawBytes": 39440, + "rawSHA256": "93284e2a6dcacf9c3b425c3267eb8a0568e38cb2cdb083d21ec93fcdb32b783d" + }, + { + "path": "RMQ/Headlines.lean", + "mode": "100644", + "gitBlob": "b6072633607106b0d20372f551f5f5c92f10865b", + "rawBytes": 7201, + "rawSHA256": "fb71fd41fd5a395a725a9500023fd3f46363cc599eaacba7ac0624bd9474cfd1" + }, + { + "path": "RMQ/Headlines/Lifecycle.lean", + "mode": "100644", + "gitBlob": "0ad61bd2b279519a254e2b4b412366eca6e5b7d1", + "rawBytes": 687, + "rawSHA256": "989b80022d6286e66033a99462c28ac346312d4454a41fd1360f11a6ed269ae4" + }, + { + "path": "RMQ/Headlines/RMQ.lean", + "mode": "100644", + "gitBlob": "4411ba0c8c555efa181a19ead7ff28751dcd0e3e", + "rawBytes": 44746, + "rawSHA256": "1b0703827da6802b22649df8cea6c49bfd66e5f3f3e6f24eecbea4658761e3fc" + }, + { + "path": "RMQ/Headlines/RMQCompatibility.lean", + "mode": "100644", + "gitBlob": "2ab3a1a46b8f7f7d2325564bcd402648ab794913", + "rawBytes": 9464, + "rawSHA256": "22e197be5cc074b088460cdd19148e4283304c755ddd4e0c692467a156582546" + }, + { + "path": "RMQ/Impl/Equivalence.lean", + "mode": "100644", + "gitBlob": "fdeab7d65d2f6310cdf9a0f4f766e28731e8ede2", + "rawBytes": 8235, + "rawSHA256": "cced314e3758108d9023d6927a58b6cf49dcc5c727e2b78aa2a05c5afad0ac36" + }, + { + "path": "RMQ/Impl/FischerHeun.lean", + "mode": "100644", + "gitBlob": "6ae0c496a2c200a6fd74c6b285ed0c9a422f5343", + "rawBytes": 82108, + "rawSHA256": "52b3ddaed6feb9982affec6fdca9cee0d73c57fbe388ab670d98f00db45df4a3" + }, + { + "path": "RMQ/Impl/FischerHeunCost.lean", + "mode": "100644", + "gitBlob": "b0875b2474683f5a96a1a03aeb2892040b37e311", + "rawBytes": 20541, + "rawSHA256": "1c4108a5b4d2e12d5f70dd00aeeedbb1701fae2c5063ff24c7556b639f5fa7f4" + }, + { + "path": "RMQ/Impl/HybridBlock.lean", + "mode": "100644", + "gitBlob": "8f627f319efb9253d42f2d5289a47c542f94ff9b", + "rawBytes": 21313, + "rawSHA256": "6e2b60c9912e30dbca95dcbf6d91687a155b55c0417ac5b002ba54e1f32a4072" + }, + { + "path": "RMQ/Impl/LCACost.lean", + "mode": "100644", + "gitBlob": "f1667aa132ecc4a3e0d2eb4be51b3c1bcbe2f156", + "rawBytes": 58796, + "rawSHA256": "e9550c8cd1acb63f1a11bff7d5b440ebfdf2d5736c32dbf706e3ae2f50c63618" + }, + { + "path": "RMQ/Impl/LCAFischerHeun.lean", + "mode": "100644", + "gitBlob": "72098e48cafc01af47c07ea1ea815e0c5ec0a88b", + "rawBytes": 34730, + "rawSHA256": "bcac2c38f5473504c5f42cc991e57caae682740bf43b904cecbb077dba47b3a3" + }, + { + "path": "RMQ/Impl/LinearScan.lean", + "mode": "100644", + "gitBlob": "2b4132443e230e922c3e563d7cdd9034da262bba", + "rawBytes": 2878, + "rawSHA256": "45c4a2b92ff08dc802571aa726381dfe3930d861a769fd3529e0a45a50bcb208" + }, + { + "path": "RMQ/Impl/PlusMinusOne.lean", + "mode": "100644", + "gitBlob": "9d5d1336208da32e6a8ed5f8cc8b164426ee4bad", + "rawBytes": 3658, + "rawSHA256": "0f410278b15eaf10d160b9d8504d247579fc674a47f424ff2e1c8fcf7357309c" + }, + { + "path": "RMQ/Impl/RecursiveHybrid.lean", + "mode": "100644", + "gitBlob": "f8620ecf0e7e89bb3864901bb0e4e8eb25141baf", + "rawBytes": 9144, + "rawSHA256": "3b389a2e68278a919dbb2d470a259b67d375f607e004ddc8f804da442d6da931" + }, + { + "path": "RMQ/Impl/RecursiveHybridCost.lean", + "mode": "100644", + "gitBlob": "2e0a0697173eaace00fc9f5780f3d25e9a14644a", + "rawBytes": 10711, + "rawSHA256": "e03f0ed4a547ff9d3a6f8e45d6447394d179b23ecba61096c79ea1f997ddd229" + }, + { + "path": "RMQ/Impl/SparseTable.lean", + "mode": "100644", + "gitBlob": "ca40d0a916ac41b7e6d9ef324ecf112f2bcdf459", + "rawBytes": 11287, + "rawSHA256": "9384fbac678f74fd7e8b1b0c646ae55c42ee0ca78557c770b5c93099817fe69c" + }, + { + "path": "RMQ/Impl/SparseTableInstrumented.lean", + "mode": "100644", + "gitBlob": "f5838d5e2ee6d1e8bbdb59ecfdf235e09e3ec923", + "rawBytes": 33186, + "rawSHA256": "bee384f2f29e57bcd71e1b9dc77c85f6b9de36ffc40552513ae1cf835367be76" + }, + { + "path": "RMQ/Impl/SparseTableMemoCost.lean", + "mode": "100644", + "gitBlob": "7ab7db7d6b690b1bba46def1ba026762bcfeba71", + "rawBytes": 16091, + "rawSHA256": "ef2e212c2391e7312df93925eb3618f9f22357b4eeef6eae3274b31b00e46ff6" + }, + { + "path": "RMQ/Validation/.gitattributes", + "mode": "100644", + "gitBlob": "26dabad73bbdf2a327967dad24c74389970ba652", + "rawBytes": 107, + "rawSHA256": "ac74ec4be7080e08e819ba40ff241a4a351cea1efe44997c5f722345a2ff51e7" + }, + { + "path": "RMQ/Validation/EGCPFinalFalsification.lean", + "mode": "100644", + "gitBlob": "e761c7f4b7abdd38e84448e09991ea336c2ef212", + "rawBytes": 152858, + "rawSHA256": "8ed9529db28ee3a5e964b4305a32bb3e776aa9ec9766673adf6e4a6bffdf7afc" + }, + { + "path": "RMQ/Validation/EGCPStageA.lean", + "mode": "100644", + "gitBlob": "bb94d1b7c5accfb982027e5175fcd3bf1a064067", + "rawBytes": 37004, + "rawSHA256": "96e5f6a0efc5c87738b1570dece59d2ca0c81331a2e7b57f79b1cbefacc70773" + }, + { + "path": "RMQ/Validation/LifecycleContract.lean", + "mode": "100644", + "gitBlob": "cb87275bec76845642e33406c1c6496fc0379192", + "rawBytes": 12403, + "rawSHA256": "f7022ac916813779745b9847b43d9091a90f4f2356615bdbf3b560f2861ad9ec" + }, + { + "path": "RMQ/Validation/PackedBitvector.lean", + "mode": "100644", + "gitBlob": "702061d81a8595ad940019bb5ec572e768eb78e7", + "rawBytes": 9387, + "rawSHA256": "333b0a6bd8fb3082051845d2f1bd333668b9d33758a9030a68b25695cfee068e" + }, + { + "path": "RMQ/Validation/PackedLifecycle.lean", + "mode": "100644", + "gitBlob": "69d6ade9d2ec84521c208b559af1912561b80316", + "rawBytes": 14971, + "rawSHA256": "624236001fc72817441cc3dc536da9c299ccb1dc9c050687b09896b7f1679c14" + }, + { + "path": "RMQ/Validation/PackedNative.lean", + "mode": "100644", + "gitBlob": "a759468a851ab432eebfa22d315f70d6e74945e0", + "rawBytes": 13565, + "rawSHA256": "437808a44fa6aaa92422b544b2036ad2f6cdfad79297df8bf94bfb402e081ef7" + }, + { + "path": "RMQ/Validation/PackedOptimized.lean", + "mode": "100644", + "gitBlob": "dfc6b3639a7224ec900c05736f512d28cfd21088", + "rawBytes": 12485, + "rawSHA256": "894a4048230e1ed095eab24bf78e8ee594251579c5bda1163185722ac821eeed" + }, + { + "path": "RMQ/Validation/PackedQueryContract.lean", + "mode": "100644", + "gitBlob": "1862749764fbacf3460faae49a7392b9aa98f73f", + "rawBytes": 21736, + "rawSHA256": "01f6a3f2b77f86d2c647d963eed8b6e79188f7c2d381eadcf96b128e2b52b1bd" + }, + { + "path": "RMQ/Validation/PackedQueryRuntime.lean", + "mode": "100644", + "gitBlob": "46399d6ed85585e4d2b2e061b0a89a0b15553c96", + "rawBytes": 12838, + "rawSHA256": "2f84a5e5b5c4470a07e9455b1292d8967239bc170d9d75fc0555be9f8ff14fe4" + }, + { + "path": "RMQ/Validation/Preprocessing.lean", + "mode": "100644", + "gitBlob": "357d646ec8d701a93609657bf187f4db72a0e085", + "rawBytes": 11578, + "rawSHA256": "12fdf7fbeb1e40ca038cacb97f100e2ed5319471522d0bfa6e115f4de04a98e8" + }, + { + "path": "RMQ/Validation/PreprocessingContract.lean", + "mode": "100644", + "gitBlob": "edcfca8e096f62db1eee312826f43c112932b22e", + "rawBytes": 88557, + "rawSHA256": "5893c423560ddccf5fc63f8e7ba58c6334f90f70e1d6af3c9e1735c1fbfeeb2e" + }, + { + "path": "RMQ/Validation/SuccinctClassic.lean", + "mode": "100644", + "gitBlob": "42658ef96a3f28283d3812b95596d7cd4db3a8a1", + "rawBytes": 18280, + "rawSHA256": "48883dc1c7ffee53c69425f81560f72467f39f2d5b70e075b66c8c2b75d3ddc6" + }, + { + "path": "RMQ/Validation/SuccinctClassicCostHarness.lean", + "mode": "100644", + "gitBlob": "3f362837f206559783edd4b7ec616ad87af247ad", + "rawBytes": 27425, + "rawSHA256": "95abcb4d3302ceff84f14bbfa88d65d425867bf408c4c8bcb7e026080b6d33d8" + }, + { + "path": "RMQ/Validation/VariablePayloadLowerBound.lean", + "mode": "100644", + "gitBlob": "9dbf530287981149d5c8ae099b7cac34d9ea5c86", + "rawBytes": 29145, + "rawSHA256": "dfcebf64749a43348ff7786c7305d01152093f469c6cf817405cfe8c90814598" + }, + { + "path": "RMQArchive.lean", + "mode": "100644", + "gitBlob": "2a75e345b97a0471346159db82425bfca499c32f", + "rawBytes": 217, + "rawSHA256": "e2e8cbdf62b8af143ab21d2e31f5ead8e2299c904311fef8dc979bff9df9e704" + }, + { + "path": "RMQBPNavigation.lean", + "mode": "100644", + "gitBlob": "13d99a09bff63c97392a2e6de62b1d75b4688193", + "rawBytes": 2022, + "rawSHA256": "74d883c55e5492a73c5afb9123d62dc24067e23521eab0695c684766d8e1f167" + }, + { + "path": "RMQExamples.lean", + "mode": "100644", + "gitBlob": "ead80ae7ed6bf6be72066e7bcb5aa269f22bfc6d", + "rawBytes": 353, + "rawSHA256": "8156ebd4d3f50075f710f912307312676fa8e9593f8206114569a945852c3b28" + }, + { + "path": "RMQExamples/BPNavigationImport.lean", + "mode": "100644", + "gitBlob": "1fa4c62a9dab4c8e1eb6f471841fde5db05672a4", + "rawBytes": 1956, + "rawSHA256": "c3baedc76ee811fcb28080061e93494dd7a87876bfade213bc5d57d6e37a8509" + }, + { + "path": "RMQExamples/Concrete.lean", + "mode": "100644", + "gitBlob": "82c72907f49bed98eb069c2865dad5a8c540377b", + "rawBytes": 11051, + "rawSHA256": "999523d23318ca959f8c9eb5c3bb4005995f15d59c8513638233183cae5f6d52" + }, + { + "path": "RMQExamples/LowerBoundImport.lean", + "mode": "100644", + "gitBlob": "7a91da9876659eb2196c434b6d203d967e40aef4", + "rawBytes": 440, + "rawSHA256": "12052183c19045768fa576ba54e744cd0ccfa208c5fdbfe3342509da59cacbeb" + }, + { + "path": "RMQExamples/RMQHeadlines.lean", + "mode": "100644", + "gitBlob": "5a17994899922772a2ad4d120d514ef91a253729", + "rawBytes": 1426, + "rawSHA256": "8ce6b0a60eb512fa98a322ccb109ec5f3b57544ff00e4f8779f154d3c7244936" + }, + { + "path": "RMQExamples/RankSelectImport.lean", + "mode": "100644", + "gitBlob": "8a7071f6bc781a65454f8ea63ea85758357b01ec", + "rawBytes": 1613, + "rawSHA256": "81325ea75d985130b35313185e6ae0a7cc2b6896ad5f6af240dae5da4b4bbf42" + }, + { + "path": "RMQExamples/UnionFindImport.lean", + "mode": "100644", + "gitBlob": "47aa1bb122f510fabb0924934a36d8ff52ffa44b", + "rawBytes": 812, + "rawSHA256": "2dd1afdef4a2040c332ee244020e5b33ef9304631fd1657c48bdb79562274504" + }, + { + "path": "RMQHub.lean", + "mode": "100644", + "gitBlob": "519416922e5c33415a687e53f45bd867fd231b4b", + "rawBytes": 297, + "rawSHA256": "d56a4db9ede4ff8e34b20a3d3f4a4d4b7693482392f68c3fae570ff317200544" + }, + { + "path": "RMQPaper.lean", + "mode": "100644", + "gitBlob": "14f3f66c82c0a340e67af42f0411c1bc67ecbdc6", + "rawBytes": 787, + "rawSHA256": "7583544715df9f29f6747a327ca38a48f448ab329173916f430bc6c3ab93faf0" + }, + { + "path": "RMQRankSelect.lean", + "mode": "100644", + "gitBlob": "91ddd891416da473b234c2f3c10dc6e24ab40a5a", + "rawBytes": 2854, + "rawSHA256": "f1cef44e3e309373f5e125b40897c315f72f2a8b07bcad05f2f13988d21d2be0" + }, + { + "path": "RMQUnionFind.lean", + "mode": "100644", + "gitBlob": "2a5a9bd133c39b02118dedefcdec7c5241601a30", + "rawBytes": 13745, + "rawSHA256": "c15ba8e45198c46c8c5e31b4a571d6351995e1b4784ce61383bc6f93d613709a" + }, + { + "path": "VerifiedDS.lean", + "mode": "100644", + "gitBlob": "04e59c51cc5da1502b9fdf66e8926d1c23ae234c", + "rawBytes": 799, + "rawSHA256": "b5a0f4ebcdbd59135cfebc03ecfaab57286448fa067bfb20d20b116cee60f63c" + }, + { + "path": "VerifiedDS/BPNavigation.lean", + "mode": "100644", + "gitBlob": "433cf90a05fdddc0fe57963861f87d50f2ffe78c", + "rawBytes": 279, + "rawSHA256": "3851302587cfeaaba9aec1c0a652967b6d6ff94e08a0aa2e740580c7965738a3" + }, + { + "path": "VerifiedDS/Hub.lean", + "mode": "100644", + "gitBlob": "f0a84d6c204590a8b64fba456e8fa1af96ddd403", + "rawBytes": 394, + "rawSHA256": "137df45fe00021f19f9aba0d1c170aea7bbf0f06ddfa1a978d5d56e7cdaa67e5" + }, + { + "path": "VerifiedDS/RMQ.lean", + "mode": "100644", + "gitBlob": "3411da19f09add718ce43641cc5fc04f5304fcec", + "rawBytes": 326, + "rawSHA256": "26e398a29c91e875fcb48aaab46fa603e491ea5f250e5812dac425f74a36639c" + }, + { + "path": "VerifiedDS/RankSelect.lean", + "mode": "100644", + "gitBlob": "5b55b874edb8f62686fca54705602a9a57e2a834", + "rawBytes": 328, + "rawSHA256": "26702bcf437f2dcc02599d0ff8753805ee5c45c7bee0996e99636b6d7dbafaae" + }, + { + "path": "VerifiedDS/UnionFind.lean", + "mode": "100644", + "gitBlob": "f169bad9c58158536d63a726c1c3513fa3449ec8", + "rawBytes": 21800, + "rawSHA256": "6e79cc628aebd259c25ebcc799a220fa65d55ae557c111551213f369cc609bd8" + }, + { + "path": "VerifiedDS/UnionFind/Forest.lean", + "mode": "100644", + "gitBlob": "3713c97ba25bca8a33c5eec8356facf873e6ea48", + "rawBytes": 796, + "rawSHA256": "ffaf07ed86fcdbb4f1887c440082010efb7f3012b0c5bfd5e906459ccb1c5d13" + }, + { + "path": "VerifiedDS/UnionFind/Forest/Amortized.lean", + "mode": "100644", + "gitBlob": "39fc20f1610f7618f411992321064bc17059fa51", + "rawBytes": 30429, + "rawSHA256": "01fbbb2309e1a85857b2a8da30bfb282a9198430387c25e17ec3f7172c937228" + }, + { + "path": "VerifiedDS/UnionFind/Forest/BackendOps.lean", + "mode": "100644", + "gitBlob": "f6b89fc8a0e36475478e677ce438119d154a5780", + "rawBytes": 52287, + "rawSHA256": "457622b148b1c5016f1e834b985ac63723ad503adb4072f718d9dc784f5a53f9" + }, + { + "path": "VerifiedDS/UnionFind/Forest/Base.lean", + "mode": "100644", + "gitBlob": "3f2183c884b9af563ac10a28bb9a8f99d6dc28e5", + "rawBytes": 122271, + "rawSHA256": "20d06974e67c14e6330f79dea290ea8b780326f16144021fb3691ddbd5423cdc" + }, + { + "path": "VerifiedDS/UnionFind/Forest/NoCompression.lean", + "mode": "100644", + "gitBlob": "f0e446f4e9d300ea252b94ca44e6b5aee402dbdc", + "rawBytes": 25086, + "rawSHA256": "dc247f6594551f78149f93777e719a006bf631fd97ec3de83ea9ca1eaeff1e57" + }, + { + "path": "VerifiedDS/UnionFind/Forest/PotentialProofs.lean", + "mode": "100644", + "gitBlob": "0520c04917567f4194be50ed6079d06d7d1323f8", + "rawBytes": 75885, + "rawSHA256": "9b5cd389ac103abd0898b369d7fe64feeaa2288450969e51824a72bf47199a89" + }, + { + "path": "VerifiedDS/UnionFind/Forest/Potentials.lean", + "mode": "100644", + "gitBlob": "b38697b9c2e098d3ce194a2462910ac609054d9a", + "rawBytes": 25740, + "rawSHA256": "72080d765e29016da66d9ae84d4bdb3aa3c9e79a036f0a40f97b699a6a134b92" + }, + { + "path": "VerifiedDS/UnionFind/Forest/Reference.lean", + "mode": "100644", + "gitBlob": "bfb6f36c8052cb406a7f64a6f7ec00461491404f", + "rawBytes": 9008, + "rawSHA256": "03906c94d5ea14c0c783c00603e5bf687e99879628b0fe6eb97090a84e83273c" + }, + { + "path": "VerifiedDS/UnionFind/Sequence.lean", + "mode": "100644", + "gitBlob": "f3118eb08d02d6cf70fc37e6cc17002cb358e7f2", + "rawBytes": 25608, + "rawSHA256": "05a15ccc89f74c88ec8718faedf91c0a5c58d583221864f7996c2872e1ad386d" + }, + { + "path": "VerifiedDS/UnionFind/TarjanEvents.lean", + "mode": "100644", + "gitBlob": "822d8fe65571515e1daafd53bce50b752818b1f5", + "rawBytes": 106912, + "rawSHA256": "5f8c7e692d500c8d00bdf135e9e329729c2058bfd05d6198f43ad213fb5265b1" + }, + { + "path": "artifact/CLAIMS.md", + "mode": "100644", + "gitBlob": "3bfc6fc7fe905b123608539752bd97d1a4593103", + "rawBytes": 22134, + "rawSHA256": "7c0220c36e0c57ce60c3772d79254ea3a709583965d00ceb9ef07872ad02b697" + }, + { + "path": "artifact/README.md", + "mode": "100644", + "gitBlob": "235975868c8a484c5cc1a7c9b6a1a37f60b1ae37", + "rawBytes": 9868, + "rawSHA256": "0786161a511128dfb4be3730cc657d19bb2590b3d6150c81153eed215faa99fc" + }, + { + "path": "docs/ADD_PROVENANCE.md", + "mode": "100644", + "gitBlob": "a09581e68eebfed57e370be40bb7ca0d28064708", + "rawBytes": 14398, + "rawSHA256": "7f044dda48dd6020b0757f79d7fd1b98bbb74aa349e2ca10d670c5cbec09aa76" + }, + { + "path": "docs/AI_ASSISTED_DEVELOPMENT_NOTE.md", + "mode": "100644", + "gitBlob": "02b9280a175a8a687122ae5ffcf3a657aa452fab", + "rawBytes": 1786, + "rawSHA256": "96fafe668251bcb9a9d5f47ca4695c360e675aa9a966e107c0ec4a356de0a4de" + }, + { + "path": "docs/ARTIFACT_REPRODUCIBILITY.md", + "mode": "100644", + "gitBlob": "cede178ff2a119fcdcad436481b73e25a3e0a238", + "rawBytes": 4351, + "rawSHA256": "f586e566f540b619f563a064a9be4fc8b24a618fd6820b5b942ded619f4ff1d1" + }, + { + "path": "docs/BP_NAVIGATION_FRONTIER.md", + "mode": "100644", + "gitBlob": "588080a108a7887822a09adf2d910a008a780f0f", + "rawBytes": 15495, + "rawSHA256": "755d40bd8e1dc0051f04a808fb6b91468775b1be07f8044574878b0863a53043" + }, + { + "path": "docs/CLEANUP_AND_ROADMAP.md", + "mode": "100644", + "gitBlob": "eaf4da5f1d2281ba9e369727de1ded452b77ea11", + "rawBytes": 25004, + "rawSHA256": "f9c55919f49edf095c41529bcd638535c0b67936f18bc22f1799184d0df1f9de" + }, + { + "path": "docs/CODE_MAP.md", + "mode": "100644", + "gitBlob": "46d96a75efad3b38f4a097dbb9cdfc7bb82b9d5e", + "rawBytes": 10970, + "rawSHA256": "d4e3ceb5c6ef18f077f6c0ea19847a9c0d12345e5adb621cda9fd359760bae07" + }, + { + "path": "docs/DESIGN_FRONTIER_OBSTRUCTIONS.md", + "mode": "100644", + "gitBlob": "76949015c11f53e0c178aa9b85ca5390318b08e7", + "rawBytes": 12517, + "rawSHA256": "237558da1df3cdc7510da60305b339cd505626d321a5a447446e51bed818dde9" + }, + { + "path": "docs/DIGESTION_LOG.md", + "mode": "100644", + "gitBlob": "29732fa9f124cc2b2f41c747f2d50e9fb535cdd2", + "rawBytes": 135043, + "rawSHA256": "4413955ed2e267822d64ddb3746f3bbe51e072d096988fbe81656d6e1ea28c87" + }, + { + "path": "docs/FAMILY_SUMMARY.md", + "mode": "100644", + "gitBlob": "ccdb4872c96306b16acc7592373e2a586b4998ef", + "rawBytes": 261642, + "rawSHA256": "0f2ff10bb63ddd88cd2ccbb8fc36d8a0b2195d9492a3619e10a1c98dda47ed47" + }, + { + "path": "docs/GENERIC_SELECT_REFACTOR_SCOPE.md", + "mode": "100644", + "gitBlob": "b5d866fd91d2a89b84dea8e2232b9b17cd14a41e", + "rawBytes": 7392, + "rawSHA256": "f5514b395d486956b8e331526a01b1e5ac5ec6dd72c250f79339b7cce910a637" + }, + { + "path": "docs/HUB.md", + "mode": "100644", + "gitBlob": "2d76742cd8343b838a0e79c0dfe494747a5cada4", + "rawBytes": 3333, + "rawSHA256": "4dd923fc85d9afaa33cbac9c40f89ad2e907fc8240998248937a408590898006" + }, + { + "path": "docs/INDEPENDENT_CHECK.md", + "mode": "100644", + "gitBlob": "a7a088158e7d24733a5f72cb128cef01591051ad", + "rawBytes": 3800, + "rawSHA256": "3ec0c4d14eb3f71010cd3cf18a90683e0a5bb9173514ff17ac8bc148bec228f0" + }, + { + "path": "docs/PAPER_CLAIM_CORRESPONDENCE.md", + "mode": "100644", + "gitBlob": "1d7fdffc49820a5452133eec6f0431df938cf651", + "rawBytes": 28735, + "rawSHA256": "0c20cb3092758e8363bfa8190e767f74486ac452c5a85c48c4b732fe5f2e89a6" + }, + { + "path": "docs/PAPER_MAIN_THEOREM.md", + "mode": "100644", + "gitBlob": "ace4407ddaa578db16a2d64f19cd70effcf64dc5", + "rawBytes": 9786, + "rawSHA256": "1733f0e1c8c97eb4c077fd279a3e94b30764880dd6b684f837fdbee820a20b4c" + }, + { + "path": "docs/PAPER_MODEL_ADEQUACY.md", + "mode": "100644", + "gitBlob": "dfda528a280b220d02c5f56f1dac1ae84e64b999", + "rawBytes": 27210, + "rawSHA256": "3e7c1e71c91e1e0cee656b2aee05423b2fb16cc1831f19c671b204cb67bba2bb" + }, + { + "path": "docs/PAPER_RELATED_WORK.md", + "mode": "100644", + "gitBlob": "89bc05f09002541702f23e943e9966f2765b4a73", + "rawBytes": 8688, + "rawSHA256": "63dec791cda51c6be5ea157e3210cbce3c064b48db0bc4a2c0e6ae996a770a20" + }, + { + "path": "docs/PAPER_THEOREM_MAP.md", + "mode": "100644", + "gitBlob": "55dad2e14ac9157899d48820c02744df73e8d4cc", + "rawBytes": 15517, + "rawSHA256": "6a65ec3c44c6b82b9f7be5aacc248f5a2bdb71fad4a69e2836c646eec275341f" + }, + { + "path": "docs/PUBLICATION_STRATEGY.md", + "mode": "100644", + "gitBlob": "788593c1a2620ae62ea5d1a0dc436d6a39c76b63", + "rawBytes": 15320, + "rawSHA256": "7c030d2a663f32b78a19803fce6d231acc3e96b71d24a98a331fa66bfddc7462" + }, + { + "path": "docs/RANK_SELECT_FRONTIER.md", + "mode": "100644", + "gitBlob": "19ea58cfdc2163a4f67636aeb295e839b2702dc8", + "rawBytes": 56713, + "rawSHA256": "f90e27a9f0247ec2e4ec9ec43a3747947337062b51c21a02ea69f59dba30196b" + }, + { + "path": "docs/README.md", + "mode": "100644", + "gitBlob": "6a6479c2bcf8d664039d467a9dc61288329645ac", + "rawBytes": 5354, + "rawSHA256": "3c89ad41d454b5ba47857455b1451476757277d4627961eadd3a474024495f86" + }, + { + "path": "docs/RELATED_WORK_AND_LIMITATIONS.md", + "mode": "100644", + "gitBlob": "7c2e614c596174e4bb27ab79c448b36ea8f4566f", + "rawBytes": 4470, + "rawSHA256": "deb52f76c995e2bc519f564e91b5e0712e01d3adb02b1f5a1616b87709567c5f" + }, + { + "path": "docs/REPOSITORY_STRATEGY.md", + "mode": "100644", + "gitBlob": "24ec5930892f8d2e79545121214c48024c86625f", + "rawBytes": 4740, + "rawSHA256": "6827392394c750523a1e96cd6ea6ee82371e73f98af489e21ede126a9e098776" + }, + { + "path": "docs/RMQ_EXTRACTION_FRONTIER.md", + "mode": "100644", + "gitBlob": "7697a757bc3d0de5a8bb9e475b98ba7566483506", + "rawBytes": 4113, + "rawSHA256": "96760b9360b7d5ca0b679453672ef7864eb00745a7f1acbfe6ecd0ca230e36db" + }, + { + "path": "docs/RMQ_IMPORT_CLOSURE.md", + "mode": "100644", + "gitBlob": "0db19bd5c87e5fa92b9d57955dd08071182a816d", + "rawBytes": 6260, + "rawSHA256": "aded17637f124a674a7c11c2263b7f1f4afa56da45da42ceefa7ce3cb2ca3584" + }, + { + "path": "docs/ROADMAP.md", + "mode": "100644", + "gitBlob": "d3d421f88644ece0f2d834e1c0189e457b66d582", + "rawBytes": 44671, + "rawSHA256": "f1e9d5b0475188f3f67a2dded5c7aa87730ad5df04a84b24ee064c5fbc44a59f" + }, + { + "path": "docs/TRUST_AUDIT_PACKET.md", + "mode": "100644", + "gitBlob": "a6b0f8b9c84fdd120f9af3a33ca46ef9b65a2b5f", + "rawBytes": 9958, + "rawSHA256": "2fafa5d1e4cf5d51b5947280f26644b90e155a8ef1d1155bcdaf976e93be7432" + }, + { + "path": "docs/TRUST_BASE.md", + "mode": "100644", + "gitBlob": "ae2574658093410c16b143c91ab3ce565b0f1ada", + "rawBytes": 3755, + "rawSHA256": "7ecf5b8ab4055505efb2fbc04e3edba5f99c4095d49563da3eaeb5425947c84f" + }, + { + "path": "docs/UNION_FIND_FRONTIER.md", + "mode": "100644", + "gitBlob": "2f51367d588989ec81050fcfb1ba2a26c10d4d5d", + "rawBytes": 59337, + "rawSHA256": "9ee00a4e7b0d903b6ab86182f11430dc61822619349d8d38c6de83181876b1fa" + }, + { + "path": "docs/WHAT_IS_PROVED.md", + "mode": "100644", + "gitBlob": "fcb8d780d8f8a41d88b8c67d4157b80098ef8760", + "rawBytes": 56552, + "rawSHA256": "81dad0bd1d323b37622ef28a139684c8048925fa2285a3be02b3460d67c0e3ba" + }, + { + "path": "docs/WORD_RAM_REVIEW_PACKET.md", + "mode": "100644", + "gitBlob": "49461932ce3dbb908c99c6a8fc0441027957c98c", + "rawBytes": 13498, + "rawSHA256": "3db4397de2b733029e38609008a69818a8bf7093e22431350cfe858be43cf288" + }, + { + "path": "docs/digests/COORDINATOR_COMPLETION_LOG.md", + "mode": "100644", + "gitBlob": "c181568cd483f6c792d71ea94f9fa491b497e7f6", + "rawBytes": 6721, + "rawSHA256": "0c2ff3b85806131013f4dcdc557b4e6c859edd1b792352629aac26595b497feb" + }, + { + "path": "docs/digests/DEEP_PROJECT_DIGESTION_2026_06_28.md", + "mode": "100644", + "gitBlob": "0987ec0e5470ce977f640849e8f564eb7d3d2543", + "rawBytes": 40254, + "rawSHA256": "bab09eed7b25890f595da25c48979acfb0c5d8bfd7e0f47d6bc225316269a801" + }, + { + "path": "docs/digests/LIFECYCLE_PROOF_GUIDE.md", + "mode": "100644", + "gitBlob": "e343d1c9b575ed2edc0e873bc348c888ff2fd864", + "rawBytes": 9262, + "rawSHA256": "9c43098acf0d96ba74ea6a9d6e2ca5382277568e3e326de46307b2f4cde44c2f" + }, + { + "path": "docs/digests/PROJECT_DIGESTION_CURRENT.md", + "mode": "100644", + "gitBlob": "c7623b0d37e8406b71481dbdfec1eb2e370f2e07", + "rawBytes": 13370, + "rawSHA256": "26d32d8761d94e25d408dc210656d30af250ef180ee6df35c65879c36e7ed424" + }, + { + "path": "docs/digests/PROJECT_STATE_2026_06_28.md", + "mode": "100644", + "gitBlob": "109c282d8bdabfcd5418c5220e126e0f840f2941", + "rawBytes": 15749, + "rawSHA256": "7e7749709d9e1d5a729cb2b0a83592678b121acb330383e5bd83fae27a0e4ea9" + }, + { + "path": "docs/digests/RANK_SELECT_COMPRESSED_FID_2026_06_29.md", + "mode": "100644", + "gitBlob": "6bde4e2cacc1cc1452cb42a8c198e284cb87b611", + "rawBytes": 11378, + "rawSHA256": "d9d31c8bfeffc2c89bb0b259f04c090f3a05e4d09324258a9d3b0e89c4b4b3a7" + }, + { + "path": "docs/digests/RANK_SELECT_FID_FRONTIER.md", + "mode": "100644", + "gitBlob": "47a0e4c6b3675efd73d634e29a1cb6521083b86c", + "rawBytes": 9546, + "rawSHA256": "c70f9937e59f71b4a18647d9b231ff4ff0f9772af23a162f9e1393776300be0e" + }, + { + "path": "docs/digests/RMQ_CAPSTONE.md", + "mode": "100644", + "gitBlob": "28a69dbad66bedc65e2fb7caac3672b42d8f9fe7", + "rawBytes": 4860, + "rawSHA256": "9cb8669a7a728b1668956a40b7f671dddf1fa579a89683ff483c5d5f2b6acac9" + }, + { + "path": "docs/digests/RMQ_PROOF_MAP.md", + "mode": "100644", + "gitBlob": "5dd011ee673e8605085eb1259785f3582e008bb5", + "rawBytes": 3338, + "rawSHA256": "63bac42ccacc6ff0b64f2c1c646487d87944783ab9e1767d26898178f2abcaa9" + }, + { + "path": "docs/digests/SUCCINCT_RMQ_COST_COMPATIBILITY_HISTORY.md", + "mode": "100644", + "gitBlob": "a2435ade2189ae5c20db0f1b561a294fcd3d6f63", + "rawBytes": 4000, + "rawSHA256": "5d8063a67a3d26038205392c32809d4a22670e47b39ca721fcc85aa67e98ac26" + }, + { + "path": "docs/digests/UNION_FIND_AMORTIZATION_FRONTIER.md", + "mode": "100644", + "gitBlob": "2344588e1bada681ac20630f6c84213f54cd9329", + "rawBytes": 18119, + "rawSHA256": "6751cb73d96aa3ecd1acea14d31dc066a63ba1caba143c24bd2c2a35bd5fb127" + }, + { + "path": "docs/digests/UNION_FIND_TARJAN_ARCHITECTURE.md", + "mode": "100644", + "gitBlob": "e76d0aed69d29dac397ccda288f8765c3de67a9d", + "rawBytes": 10566, + "rawSHA256": "7bd1635e4927dfe2e820276d48ac277770bcc14a23632b912e52aaffbd37276a" + }, + { + "path": "docs/internal/ADD_WORKFLOW_TOOLING_PLAN.md", + "mode": "100644", + "gitBlob": "9d2ddd852d0629ce88bc568cf01d0ae8ad1d91b5", + "rawBytes": 5220, + "rawSHA256": "153797b759671e5a3e229335b8134654482840960b9d8e823b51a9c8777dbfc9" + }, + { + "path": "docs/internal/AUDIT_2026-06-18_FH_MIGRATION.md", + "mode": "100644", + "gitBlob": "d5941c311e5c84507d13c5362c41e5cec017de8a", + "rawBytes": 5017, + "rawSHA256": "29455612c7f8e4972bf467f97f0e65ea72ebd9b912576e0e8690bba0ef0510b2" + }, + { + "path": "docs/internal/AUDIT_AND_A_DESIGN.md", + "mode": "100644", + "gitBlob": "83ca4fc67e1d871f3a2eff3881e97b70b1bb1eeb", + "rawBytes": 63623, + "rawSHA256": "55cdf774dd05380b7a679bf01309575b8c7c2037f681cd6a6e8fed0ad0c36824" + }, + { + "path": "docs/internal/AUDIT_PROTOCOL.md", + "mode": "100644", + "gitBlob": "63b32de746ba9c893ac8e3327b0d355904a846f6", + "rawBytes": 8758, + "rawSHA256": "1a651f51812d9b67eff15e6e5a3b94b026512d13afc0da128f762ada0e1c5719" + }, + { + "path": "docs/internal/B2_CHARGED_FRINGE_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "3ff455634ed07fcd22dc623b022fa469e93503d9", + "rawBytes": 137221, + "rawSHA256": "d27a19ebd471d12f564c9e3def634d5437708b41f17367cf866517ad75597ca3" + }, + { + "path": "docs/internal/B2_WORKLOG.md", + "mode": "100644", + "gitBlob": "5a80aea77f6ac5611adbeb2d08fae563d2508e86", + "rawBytes": 18783, + "rawSHA256": "07a74a0a074b0d58ef2b88333f6c43e3efab88e383aa867efcc66d1029d7a08b" + }, + { + "path": "docs/internal/B3_WORKLOG.md", + "mode": "100644", + "gitBlob": "2d152ca701ae3132670f43d3b3f13b9b3b22929e", + "rawBytes": 40020, + "rawSHA256": "66530edbddf3a8f8c9d46fe10dcb464ad7dab07c65923d1f359c35abca79d51a" + }, + { + "path": "docs/internal/B4_WORKLOG.md", + "mode": "100644", + "gitBlob": "c828ae8f60388acdd5c324c831db0b6411a12881", + "rawBytes": 14427, + "rawSHA256": "930c90cc55adb3dca2f8aba572f311962759d3b92fbaaf77f8fc2b79c0fb70a4" + }, + { + "path": "docs/internal/B6_SAMEBLOCK_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "8779db9d2f4914353a42aabde281207533be49ae", + "rawBytes": 34904, + "rawSHA256": "1985363e41d62044beb29cd24446df1620147835acc81096a194c274e2a4e5e4" + }, + { + "path": "docs/internal/B6_WORKLOG.md", + "mode": "100644", + "gitBlob": "03a6008d7a1d930217f630cd2a747e9da9769452", + "rawBytes": 28274, + "rawSHA256": "054566e0441dec87ff258ab97c32a4a8df2fdc85a8325f0d21ec84f503af0824" + }, + { + "path": "docs/internal/B7_SPARSE_LEVEL_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "b33aa1482393b379b532b5ede2f77171c27f5afd", + "rawBytes": 129119, + "rawSHA256": "be80b57364e51bbff1fe68406504d0ca57e493529751d97e06b138fd4bc99533" + }, + { + "path": "docs/internal/B7_STEP2_WIP.patch", + "mode": "100644", + "gitBlob": "765199018b6ca6cd896bb8d018a80f3b1c4441dd", + "rawBytes": 101242, + "rawSHA256": "d5910658df43f1ecb435bede1846f43ed351ab0ca30a51872e6ba9c1caeca791" + }, + { + "path": "docs/internal/B7_WORKLOG.md", + "mode": "100644", + "gitBlob": "088e2f3aa1973c5b9aee2f8e705001adbc2ef1ce", + "rawBytes": 163862, + "rawSHA256": "23d8774ebe2083d610297fdc1d3cf6b9c4d05121b3e9be58f3e56333659c4519" + }, + { + "path": "docs/internal/CLAIM_DRIFT_POLICY.json", + "mode": "100644", + "gitBlob": "491791898dca137d2a7d94126b87402545ccaa9d", + "rawBytes": 21046, + "rawSHA256": "4096c7a708df686f0ac7b62d935b22c13c1f1212494a3b39fd2add127ad43cd9" + }, + { + "path": "docs/internal/CLAIM_DRIFT_POLICY.md", + "mode": "100644", + "gitBlob": "2cbf8cb57c7ab1c73c8018a2274d4e6106412f39", + "rawBytes": 18325, + "rawSHA256": "f12148db46880580d2879ea4f8adcd75cebf2c8bdd0d31312524fae1de48384f" + }, + { + "path": "docs/internal/CODEX_AUTONOMY.md", + "mode": "100644", + "gitBlob": "b2c785e62e0f36141be8af69ac92bf85df63c016", + "rawBytes": 2305, + "rawSHA256": "2ab7188abb78f1f0a7ae415eecf9392e17da3ab9af4e6781cf79e70dde42f0c2" + }, + { + "path": "docs/internal/CODEX_ORCHESTRATION.md", + "mode": "100644", + "gitBlob": "ab26a72e9ce269c0eb7198b7a6866e5b3e947fcf", + "rawBytes": 2233, + "rawSHA256": "72aea81dcdb221ba822cdb89a51358ef616b19ffb8cdaff5b23ada2eeed17eb0" + }, + { + "path": "docs/internal/COMPACT_EXCEPTION_LOCATOR_AUDIT.md", + "mode": "100644", + "gitBlob": "9192e995984b6d78d697c985e8ee54e20a84f08e", + "rawBytes": 14788, + "rawSHA256": "7e328a3a96072238ade0421be83293e67ed7c170adb2508ed22baa03630e6a6a" + }, + { + "path": "docs/internal/COORDINATOR_RECORD_STAGEA_TO_V1RC.md", + "mode": "100644", + "gitBlob": "a3483dc722cebb401b0cf298dca34238fe05d3a2", + "rawBytes": 18944, + "rawSHA256": "2a496d10ffa3143626775fec5510a98d034c07f9cc5f943e12788a430c82943f" + }, + { + "path": "docs/internal/DESIGN_DECISIONS.md", + "mode": "100644", + "gitBlob": "c8a36f7d912fddc4a4523d4a7b5fbef7502ba0e3", + "rawBytes": 835682, + "rawSHA256": "99de0bacefc9a69a0c20962a5d8911e26133d0926ce8c2fef64552ca1b282956" + }, + { + "path": "docs/internal/E1_AMENDED_MACHINE_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "05b4b693c18ed12fc39ad722614d601e605cc039", + "rawBytes": 26223, + "rawSHA256": "52900e7ce1df7a9899d0e6c750b2a1645a906d864577a980fa0e6e8dbc00ef51" + }, + { + "path": "docs/internal/E1_ARCH2_B3ROUTE_R1_WORKER_TERMINAL_REPORT.md", + "mode": "100644", + "gitBlob": "f31b68c0880398515b58217f5dc707bfff74c577", + "rawBytes": 5782, + "rawSHA256": "2f3e4eda6953393275da48ad12229a83dac2e8b25f3398e3425f10513eb02b7f" + }, + { + "path": "docs/internal/E1_ARCH2_CONTRACT_REPAIR_PREP.md", + "mode": "100644", + "gitBlob": "69a92ddaea704f63294d821d59b90fce6b2ad8d1", + "rawBytes": 23913, + "rawSHA256": "b871b94ec8f3449451248467d8fcf8e0ed9ea2d590f41c6ec40cebae4df2485b" + }, + { + "path": "docs/internal/E1_ARCHITECTURE_COORDINATOR_HANDOFF.md", + "mode": "100644", + "gitBlob": "d8ff6358929fb6b5fbc40ca92de434a7b1939297", + "rawBytes": 28486, + "rawSHA256": "b7f35b50957c3e73bfe6d871f9364ff8f3ecdac1b8427f1345515eab8f93ca63" + }, + { + "path": "docs/internal/E1_ARCH_ADDENDUM_C05_2026_07_23.md", + "mode": "100644", + "gitBlob": "cf4c612e6c993f02c04e18cecd82e4fdb51ea22d", + "rawBytes": 16230, + "rawSHA256": "1f7e0c29db1b0971ed7541c30d98397517bf22a369adad3ba8f142849d7da0b6" + }, + { + "path": "docs/internal/E1_ARCH_HANDOFF_INDEX.md", + "mode": "100644", + "gitBlob": "220d60692865fed77f7e6cbb4f865d4ebfe83949", + "rawBytes": 4412, + "rawSHA256": "5ae23feb08250669473efb32d1a25d13d69afd86d4d629bc1a68a7f562276ae7" + }, + { + "path": "docs/internal/E1_ENDGAME_F03_CLOSURE_RESULT.md", + "mode": "100644", + "gitBlob": "ccbec11854a93a5aca7b14f679555d95752d1a88", + "rawBytes": 11277, + "rawSHA256": "7a93b99cc1a28aca330d7ccb44c6e4ab0e6cb10fa53d188072e95ce9c26fc259" + }, + { + "path": "docs/internal/E1_ENDGAME_F03_GEOMETRY_CLOSURE_CAMPAIGN.md", + "mode": "100644", + "gitBlob": "db91f904ae93bd50fe1e6703a8b46cd0b52d7f24", + "rawBytes": 19995, + "rawSHA256": "970739b783e4ce2c53e7ed09edb2e0eb2bc8f4466818f145eb22c6bcb4e9e55e" + }, + { + "path": "docs/internal/E1_ENDGAME_T1_SELECT_LEAF_RESULT.md", + "mode": "100644", + "gitBlob": "2ade44b1ab2970d1168a222f4394f6122ba7b1fe", + "rawBytes": 7854, + "rawSHA256": "dceeadb6250270ec472a33d96c8977242e37736f982982b05ef21ae56cf403d4" + }, + { + "path": "docs/internal/E1_WORKLOG.md", + "mode": "100644", + "gitBlob": "5d4c16907ab2acd838910f290f477bb866174a50", + "rawBytes": 157184, + "rawSHA256": "beda07a9c3fae6d4e2c1b31d3b1036a4f0980209fe62b590bada8da8f8273c7c" + }, + { + "path": "docs/internal/EG_CP_FINAL_FALSIFICATION_MATRIX.md", + "mode": "100644", + "gitBlob": "46be6c10c5cc05cbab7e8838ec059b78bff9fa54", + "rawBytes": 152998, + "rawSHA256": "94ca97260f83248445736efdc87f6d05d34bbc36f65ab5e12e943a78a6e6af6e" + }, + { + "path": "docs/internal/EG_CP_FINAL_FALSIFICATION_RESULT.md", + "mode": "100644", + "gitBlob": "0bd5c6d7fe7ba2e4efa811a84bd38c8e11867caf", + "rawBytes": 57615, + "rawSHA256": "ee8d63daced9661e8f3bf13cc18fb2e23247a6611ab7701142b1236fd1aed58a" + }, + { + "path": "docs/internal/EG_CP_STAGEA_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "69e32a5da5d5e26b25f87638d8914ffea49b1370", + "rawBytes": 72266, + "rawSHA256": "353754ba798d26a7b483cfd985f98652bcca3d6694b11fa3ca73c9f1542e8bf9" + }, + { + "path": "docs/internal/EG_CP_STAGEA_RESULT.md", + "mode": "100644", + "gitBlob": "088a57b8d0d54a9279b04fb9d1545d511a0e321b", + "rawBytes": 48199, + "rawSHA256": "a0edaa9f6cfc08df0f0f9197a193e3e288c2ff2b6b655069e4307c90474e57b7" + }, + { + "path": "docs/internal/EG_CP_STAGEA_WORKLOG.md", + "mode": "100644", + "gitBlob": "107e22baf6a5e4138fca06a7b50f1d7caf893e62", + "rawBytes": 8338, + "rawSHA256": "4b6397862117f4d90b69c8f81e2aa1e411250fe9ef0df5366d6021da365e2719" + }, + { + "path": "docs/internal/INTERIOR_NAVIGATOR_DESIGN.md", + "mode": "100644", + "gitBlob": "44350df412d5989b20991e22ee97bcf602341f2d", + "rawBytes": 7968, + "rawSHA256": "796b3e353a15f8d89d6c0260344ba5b3cd0e74347a8578aab8737951864304ca" + }, + { + "path": "docs/internal/LOCAL_BP_DECODER_PATH.md", + "mode": "100644", + "gitBlob": "e13aa53b847ab48bb6b431b14a1bb4789e179325", + "rawBytes": 11243, + "rawSHA256": "c5062983aa244162cae7988793c4afc280d7a8ac87092381e9a05fd22a8bf1ce" + }, + { + "path": "docs/internal/M1_REVIEWER_NATIVE_ADEQUACY_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "21b42ee8babefe6d96234a92c3f3e12b34cb1451", + "rawBytes": 213412, + "rawSHA256": "194f2e9562d2394dc5724d85414228cb8df2db36e5233b642cdc85132688f7fc" + }, + { + "path": "docs/internal/OPTION_B_CHARGED_FRINGE_DESIGN.md", + "mode": "100644", + "gitBlob": "a9c47741422d4e2066daa8e71cdc63b8e2dfda98", + "rawBytes": 7311, + "rawSHA256": "efd64a2c1d21e9ae72ac1866f34c0fbd1b61bb20d53785bcba6bd6f316ebf670" + }, + { + "path": "docs/internal/P1_POLICY_HARDENING_WORKLOG.md", + "mode": "100644", + "gitBlob": "d63e93d0fe563f66b14bdb21d36e6d4cd0c94f5e", + "rawBytes": 55440, + "rawSHA256": "32bd7ef286cd43867c39e51a3c00dd430a014c719c16ad9112bac5f776f0ecd1" + }, + { + "path": "docs/internal/PLAN_AUDIT_DISPOSITION.md", + "mode": "100644", + "gitBlob": "af4b6f015a5690bbd9980e6a9422b31cbdfe8ff6", + "rawBytes": 19313, + "rawSHA256": "d25d29ad74a5274fb25e3405c406442269a0ee702814b541d9cc10c3eb5cd949" + }, + { + "path": "docs/internal/PLAN_AUDIT_DISPOSITION_v14.md", + "mode": "100644", + "gitBlob": "fba5c499de4f098bfc340aa9de4e8b2c49381b3c", + "rawBytes": 2740, + "rawSHA256": "633a9d49d0cc9050aa0a3b198e2783726686ab46621a82d4361f3a5a02f77b39" + }, + { + "path": "docs/internal/PLAN_AUDIT_PROMPT.md", + "mode": "100644", + "gitBlob": "5f44abc94c224b996430dbbd01d240a9e8e113fc", + "rawBytes": 5308, + "rawSHA256": "1db8e3239315498ae5dcb8def2fa543bbdddab937d3b787aed6ba52c7c5aab52" + }, + { + "path": "docs/internal/PLAN_LINEAGE.md", + "mode": "100644", + "gitBlob": "6946a670f3dbadd1a3f39219ccc30ca4803dfb10", + "rawBytes": 5914, + "rawSHA256": "6da92669c550c57db3b8339ac1799b695c397a5a7dc4282a7e1b0deccaa2c12e" + }, + { + "path": "docs/internal/R1_WORKLOG.md", + "mode": "100644", + "gitBlob": "7f1fcd286dfdd23bb17b12735b8a31ee922ea2ae", + "rawBytes": 154831, + "rawSHA256": "04cc6278d24b5667ad0146e84f9d4db089ef305ab1cd56749a62d98f9c375842" + }, + { + "path": "docs/internal/R2_ALLSIZE_WORKLOG.md", + "mode": "100644", + "gitBlob": "e7a186aa514e628c89f00f1e14c49806d5a5726c", + "rawBytes": 7922, + "rawSHA256": "680ae226fab901e12f6160f6dcf9b593a8c07bb00413fbec660796b7f3760541" + }, + { + "path": "docs/internal/RC1_CORRECTION_HANDOFF.md", + "mode": "100644", + "gitBlob": "a10679e4644342042aab6b0f6e604133ad5ab1f5", + "rawBytes": 12088, + "rawSHA256": "4c641ada92b59d5d112aa6ef8c73ab5d203e487cb64d7f3917e64080b40bc187" + }, + { + "path": "docs/internal/RC2_CORRECTION_HANDOFF.md", + "mode": "100644", + "gitBlob": "b58efba8c2e711fc1d26385f5004039d02f4355f", + "rawBytes": 4073, + "rawSHA256": "6fff3d4bb100477766ecf2180ec422e823c69c1b7999bdb2c29d0cd36d115373" + }, + { + "path": "docs/internal/RC3_DISPOSITION.md", + "mode": "100644", + "gitBlob": "3865ca3628cc2993e14c5aca752c102646db0179", + "rawBytes": 14779, + "rawSHA256": "143510da80f7ede92503f57e8953c49b3e25c0974993428edb0ca6918169ba34" + }, + { + "path": "docs/internal/README.md", + "mode": "100644", + "gitBlob": "b64fa2654f86ccb99997291839f05379b0750b50", + "rawBytes": 2621, + "rawSHA256": "88db538d661d063f3f39dc77a3b7e71d0e4a35f3b9006a443e771a4817521654" + }, + { + "path": "docs/internal/RELATIVE_RMM_LAYOUT_DESIGN.md", + "mode": "100644", + "gitBlob": "8dee2aa4be55c63b261fd967f96524f46c84f0ae", + "rawBytes": 11442, + "rawSHA256": "526089e3fa0cf23ddeed2a6c880f580c3b444979031daff8a91b4b37e0396369" + }, + { + "path": "docs/internal/RETROSPECTIVE_CERTIFICATIONS.md", + "mode": "100644", + "gitBlob": "5a8d1a9ca909e92a597c98913f6fa8b48fced8d6", + "rawBytes": 6942, + "rawSHA256": "c8a21045ea24da6dde9f24c352bcb14b20412b18582b02b76b47f2c6fa3052fb" + }, + { + "path": "docs/internal/RMQ_DECLARATION_CLOSURE_2026_07_10.md", + "mode": "100644", + "gitBlob": "56457fecc6acc34f3ff226355c036ddd5cce5ddd", + "rawBytes": 5760, + "rawSHA256": "03f0e045829df97963f532c8872e79dfe50eb87edfc4564119e57271118c7e4b" + }, + { + "path": "docs/internal/RMQ_ENDGAME_ROADMAP.md", + "mode": "100644", + "gitBlob": "12f84ba455d4bb8f19385575a7d5a74e95753953", + "rawBytes": 52798, + "rawSHA256": "d3c05249e0bf43ecaf527a3168b14d28f8398abc530cc3260101ac6d05ab1c47" + }, + { + "path": "docs/internal/RMQ_FINAL_ROADMAP.md", + "mode": "100644", + "gitBlob": "73f67afb0e98c7358640a2a791d319b7b0679875", + "rawBytes": 32220, + "rawSHA256": "e8a69418d01424eb4c3772a6e4c673145d2443ffb4b88d2c94d6805c42054efa" + }, + { + "path": "docs/internal/RMQ_PROGRAM_PLAN.md", + "mode": "100644", + "gitBlob": "37eaaae37a884cd15369393df5bf6f1cd44b2793", + "rawBytes": 44761, + "rawSHA256": "e66111a9545da6c8e9f472bbafcf81c3752ad734961853c9612ef8f07b113b86" + }, + { + "path": "docs/internal/RMQ_PROGRAM_PLAN_2026-08-13.md", + "mode": "100644", + "gitBlob": "b14cd7ccc5232bfbd3f53e8d46be5e417f4f53bf", + "rawBytes": 25557, + "rawSHA256": "98c1ff8029cac4065c174588423f87d5778490c60395ed39aea0d0e29cf54e6a" + }, + { + "path": "docs/internal/SUCCINCT_FINAL_PATH.md", + "mode": "100644", + "gitBlob": "bfd1aded8b9c1328b94f8c5d9388fb9006a2cc21", + "rawBytes": 46398, + "rawSHA256": "d0e06a2a3bf75adff0755bc6559b9051a8da12bdcf12ee5f1df94a9267443f0e" + }, + { + "path": "docs/internal/SUCCINCT_RESEARCH_AND_PLAN.md", + "mode": "100644", + "gitBlob": "2547359289338442007831917d13b57ab6f25464", + "rawBytes": 10217, + "rawSHA256": "4be951cc893bcbb7c71ee38c55b5e1c9db0803a575a3f8eef359e93889bdf9f2" + }, + { + "path": "docs/internal/SUCCINCT_SELECT_LOCATOR_ARCHITECTURE.md", + "mode": "100644", + "gitBlob": "7cc2c626a6142ef7e0d6f7d01b2c29c878011218", + "rawBytes": 14339, + "rawSHA256": "92e0ea286726ac054b17ffb8fa1322d2b3a6ee0bc19b3a3f1acfcbcefc03f77b" + }, + { + "path": "docs/internal/V1_RELEASE_CANDIDATE_AUDIT_PROMPT.md", + "mode": "100644", + "gitBlob": "48335dec906409193ab4f4d02c2c53b1f45a0fda", + "rawBytes": 19322, + "rawSHA256": "b176e0f704e03c201114166bf9494d5a3ae7656bf1db73bb965f184c4eb3a524" + }, + { + "path": "docs/internal/W15_U2_CANONICAL_PAYLOAD_WHOLE_MACHINE_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "054c97db8f3d6877df3af3149575149834eec13c", + "rawBytes": 114378, + "rawSHA256": "8453fce1283460ff01df74a7817dc8383c4812a4fcac0cd845af1a5484e44aa6" + }, + { + "path": "docs/internal/W21_U3_PRINCIPLED_ALLSIZE_COST_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "e2adac84f4d7267e01ed5ce90509d8c0b4d411b2", + "rawBytes": 27110, + "rawSHA256": "bc47d95743947a88aaeae202e94a2254c785374c8da003e3526e8aff1652d283" + }, + { + "path": "docs/internal/WORD_RAM_INTERPRETER_REFINEMENT_PLAN.md", + "mode": "100644", + "gitBlob": "b59c6fa60709c2b9b2bffe70780f835a8cd941c9", + "rawBytes": 27836, + "rawSHA256": "fceace7a313c65cb64ff7e37e40ce109a06281c70f4274a35678e9f5c0ef1a0e" + }, + { + "path": "docs/internal/WORD_RAM_REGISTER_CONTROL_PLAN.md", + "mode": "100644", + "gitBlob": "cc8a0fe7be50bea0740c47d6f50e5cbe81244e04", + "rawBytes": 14505, + "rawSHA256": "93201a03d35cdb422e76438f6bdce9aa33337782b6daa2beefee99337fbb40c9" + }, + { + "path": "docs/internal/WORKER_INTEGRATION_CHECKLIST.md", + "mode": "100644", + "gitBlob": "89ce88aedd0947308ef8c2cdbd619a9f2b85ea3a", + "rawBytes": 5552, + "rawSHA256": "4b9dff882c4936e8e65f8f01d97940941468f3fc5f39456752780ae5d51fdb4e" + }, + { + "path": "docs/internal/WORKER_LIFECYCLE.md", + "mode": "100644", + "gitBlob": "fc58b9d056aae55007fde2ecdac6a31cd7fbbbad", + "rawBytes": 6149, + "rawSHA256": "1a2cce5d2b9ed935295d34be45e4b7a3d7f88e6a48c2e67030dd56019fa00bc5" + }, + { + "path": "docs/internal/WORKFLOW_DESIGN_DECISIONS.md", + "mode": "100644", + "gitBlob": "f530ec37431e4d555d5dd427921c2e7547d3b985", + "rawBytes": 948524, + "rawSHA256": "21cfd4829bcb582f8878d219a6a5477a917afead1200eed4e70602d85eba8bcc" + }, + { + "path": "docs/internal/audit_packets/EG_CP_STAGEA_AUD1_PACKET.md", + "mode": "100644", + "gitBlob": "f992d829411e729398996986ac7681d194e78b8c", + "rawBytes": 10784, + "rawSHA256": "0f10a17e4dfaa9c8bb71d633c70a23476066d944903cd58c5e3b12b16979c034" + }, + { + "path": "docs/internal/audit_reports/2026-07-09_A01_rmq_frontier_audit.md", + "mode": "100644", + "gitBlob": "43b21e3fe52aa4f0be36be81814c96437f6108b4", + "rawBytes": 4389, + "rawSHA256": "1eb28b6a2c14756210645e99de970418728d148c3dd93a5e37a197c3503db27d" + }, + { + "path": "docs/internal/audit_reports/2026-07-09_A02_rmq_pre_w10_frontier_audit.md", + "mode": "100644", + "gitBlob": "83bf5c84d81f3d8ffb5a7f9cff6580ed99750f85", + "rawBytes": 20026, + "rawSHA256": "4fd892636ad6096e143a7fe802835a97565c089d156a1e7dd1ced1d51530ae39" + }, + { + "path": "docs/internal/audit_reports/2026-07-10_A03_u1_total_layout_audit.md", + "mode": "100644", + "gitBlob": "0f46e151df3cb03183ae6844c81c1556d18d3f98", + "rawBytes": 20349, + "rawSHA256": "23c3bbc662c0b0b1aaba6d8b7de5ddd5513e61ae27320993bc6d3fe538236562" + }, + { + "path": "docs/internal/audit_reports/2026-07-14_A04_u2_blind_acceptance_audit.md", + "mode": "100644", + "gitBlob": "176fb015c8613505ee76ddfbe3235e617ee5a123", + "rawBytes": 29411, + "rawSHA256": "13706df623b47ac1b8060c4ad1a49a66be4deb9cf408cab0b78cbb2e19e79e8b" + }, + { + "path": "docs/internal/audit_reports/2026-07-19_A08_b7_charged_sparse_level_audit.md", + "mode": "100644", + "gitBlob": "642f057c9b947c9c041bc5aff1a648efcae461a3", + "rawBytes": 29641, + "rawSHA256": "119d0065712d8c9de3225f000ecd89c2a1f126824a72b9dca4f8db76ee31d961" + }, + { + "path": "docs/internal/audit_reports/2026-07-22_M1_R5_R9_fresh_blind.md", + "mode": "100644", + "gitBlob": "bc5144abff8d4974799ae285782b67b0669bbb90", + "rawBytes": 42457, + "rawSHA256": "bb4849e925543cc3027c0b62b29731be9d156c97958826af4c0609caa613d34d" + }, + { + "path": "docs/internal/audit_reports/2026-07-24_C06_e1_arch_handoff_package.md", + "mode": "100644", + "gitBlob": "98d7d07a93b1e778d5760df8814f1deaa034a7d0", + "rawBytes": 10975, + "rawSHA256": "00454bf5240e58a5b37f8e83ae379563e8260d0aadbdae5efe995045421b0cdb" + }, + { + "path": "docs/internal/audit_reports/2026-07-25_A09_endgame_plan_audit.md", + "mode": "100644", + "gitBlob": "836c11307aa2ad3ccf87db5594b609d47b168314", + "rawBytes": 38964, + "rawSHA256": "7270b33b0c9d73d6b03ef78a94b112506cd8590bdfde5e4efb5e2bc680621502" + }, + { + "path": "docs/internal/audit_reports/2026-07-25_C06_e1_arch2_b3route_r2.md", + "mode": "100644", + "gitBlob": "9132abe7256bb4f5789d620649717fbda5c39c26", + "rawBytes": 11171, + "rawSHA256": "cdde31471d572737670e8aaf9acb7dbab429408ec8c060f5212ade37b449db74" + }, + { + "path": "docs/internal/audit_reports/2026-07-25_C06_e1_arch2_b3route_r3.md", + "mode": "100644", + "gitBlob": "dc394bf9f1476b7aa042dcef77606364b976e2fa", + "rawBytes": 10976, + "rawSHA256": "1e3bc6b60ead54cae11cff5d938d2cda05a71bcd31a700d75028f265bb5fb0d0" + }, + { + "path": "docs/internal/audit_reports/2026-07-25_C06_endgame_adjudication.md", + "mode": "100644", + "gitBlob": "69108651015651c9e9672bbde68a7acd5c2ffa32", + "rawBytes": 7483, + "rawSHA256": "a0a59fd93018da7d585003ae38551df32dc307bfa224ff367bb8488bfc5d79ad" + }, + { + "path": "docs/internal/audit_reports/2026-07-26_A10_f03_geometry_closure.md", + "mode": "100644", + "gitBlob": "a1e168cba058e6dd0aac4e8207c49a266775196a", + "rawBytes": 19446, + "rawSHA256": "004b070a1a27f9112cb9c59720c9b898e483b8ad5df6d4dcffdd1133d3e779da" + }, + { + "path": "docs/internal/audit_reports/2026-08-05_EG_CP_ALLSIZE_R2_fresh_blind.md", + "mode": "100644", + "gitBlob": "d42272ee1d0c3adebabcbaabd280cd97c5db8f14", + "rawBytes": 18981, + "rawSHA256": "d4b511134ac09190eac0db6513f891d15208bbe941b259d92123c3caedc4b783" + }, + { + "path": "docs/internal/audit_reports/2026-08-06_EG_CP_STAGEA_CLOSE_R1_fresh_blind.md", + "mode": "100644", + "gitBlob": "fbcf778a1c22ce6a56a8de1b94d69a8f2f8f7ce1", + "rawBytes": 59918, + "rawSHA256": "d6d0ff08f971efb3a94f2fcae244e586b56242c61069356b4333b569c2cc9cc2" + }, + { + "path": "docs/internal/audit_reports/2026-08-06_EG_CP_STAGEF_CLOSE_R2_fresh_blind.md", + "mode": "100644", + "gitBlob": "2c24bdb5a70248591bc32d563683c06cdd59c113", + "rawBytes": 39645, + "rawSHA256": "11a671e3bf9006e49f38b52ec97f521041f28760ecca137b34bcdd723e0c2326" + }, + { + "path": "docs/internal/audit_reports/PQ1_FRESH_BLIND_4c89378.md", + "mode": "100644", + "gitBlob": "55c1b95b4fc1440687dca94337449c7c600006f7", + "rawBytes": 45505, + "rawSHA256": "d14773ac45b93d75e03ea19b7d2b5b3263aa46980e65d87a0955759529b97e02" + }, + { + "path": "docs/internal/audit_reports/PQ1_MERGE_READINESS_20260912.md", + "mode": "100644", + "gitBlob": "c594f8e49ed5ce7a85813c23a48ec179ecb51514", + "rawBytes": 5403, + "rawSHA256": "002ad25f67054da39a92de63c88f5f6b359107eada801935801b39dd8d4430f3" + }, + { + "path": "docs/internal/audit_reports/README.md", + "mode": "100644", + "gitBlob": "c7dc3b458fc6c1210f1136959cd8390bd60f34fb", + "rawBytes": 986, + "rawSHA256": "3e9cc023afc4bfa4bec3c4cdd999caea8e872f8b9b5ba86f2c13c55f848f1b30" + }, + { + "path": "docs/internal/e1_arch_prompts/A10_F03_GEOMETRY_CLOSURE_AUDIT_PROMPT.md", + "mode": "100644", + "gitBlob": "0a07cd8f284d4fcee7090213078e515b84fe3c25", + "rawBytes": 11877, + "rawSHA256": "037e044ca5c912f65ad45742a0f8691bc640a22dbd0dd79f1cbf9751039411fc" + }, + { + "path": "docs/internal/e1_arch_prompts/A11_F03_AMENDED_ROW_AUDIT_PROMPT.md", + "mode": "100644", + "gitBlob": "39304aadfbd4794e9cc55cfc656be0621400f1fd", + "rawBytes": 10078, + "rawSHA256": "848a175dce1923ec974286f5281c61b50aebfcacb0f978dedc4e9e05a00b9c1b" + }, + { + "path": "docs/internal/e1_arch_prompts/E1_ARCH2_B2DESC_R4_PROMPT.md", + "mode": "100644", + "gitBlob": "0479b7c62bf911cb741625a0b8113f6a67cf5b2c", + "rawBytes": 18623, + "rawSHA256": "a3ec3c3077fee9a34d34fbd745d393ed2df9bab92da081cfdb79f5f6091a47cf" + }, + { + "path": "docs/internal/e1_arch_prompts/E1_ARCH2_B3ROUTE_R1_PROMPT.md", + "mode": "100644", + "gitBlob": "0941ab7a97dc319513c023833983366bff59a76e", + "rawBytes": 22058, + "rawSHA256": "ef0112772907e0005bf5b6a978ef7903957cfa0def948cf1fabb3f064165d320" + }, + { + "path": "docs/internal/e1_arch_prompts/E1_ARCH2_B3ROUTE_R2_PROMPT.md", + "mode": "100644", + "gitBlob": "e74a01f7150366776bfbe3e5eba728d2977684c7", + "rawBytes": 32547, + "rawSHA256": "24c9466dfa3f58cd76a9578e71a2131ab21db9d012f2373fa4bd8882bf0bf4b1" + }, + { + "path": "docs/internal/e1_arch_prompts/E1_ARCH2_B3ROUTE_R3_PROMPT.md", + "mode": "100644", + "gitBlob": "6b065ae8f143d00c64e454a05564ed86ba879cad", + "rawBytes": 28154, + "rawSHA256": "e23313d7aa7c62cecfdf08d059bd0730213b987d3b9c5485a73b69257a0caa7b" + }, + { + "path": "docs/internal/extensions/bv1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "d91d42d39bad8f1ed37e3ec5d31af119d9e8ee5f", + "rawBytes": 29096, + "rawSHA256": "80bd59a314fd33d37076802954444da24f65c87a2a91de23bc668b6af9cceb24" + }, + { + "path": "docs/internal/extensions/bv1/ACCESS_PROOF.md", + "mode": "100644", + "gitBlob": "68e4e7e569063951f0e91652b3eef0396b9672b3", + "rawBytes": 12485, + "rawSHA256": "5406a336bc4e4c2b82355fa32c6fa91d4a74f6d5548619974eccc4c605445a09" + }, + { + "path": "docs/internal/extensions/bv1/ALLOCATION_FACTS.md", + "mode": "100644", + "gitBlob": "1f0821f98776b638be4c8b61f5a3fbe9df36b2b5", + "rawBytes": 14852, + "rawSHA256": "772e12f6d8b484500c9f8ddb3a2156c750cd7a5d824d2297d04522c351164935" + }, + { + "path": "docs/internal/extensions/bv1/ALLOCATION_READER_PROOFS.md", + "mode": "100644", + "gitBlob": "aadfa6d496896c348265dca699e0d0f5932c1c39", + "rawBytes": 15449, + "rawSHA256": "418a6c7840c1d3a7607803596b05f67727ea1b51325a8f570d2ddb5fa9b300c2" + }, + { + "path": "docs/internal/extensions/bv1/CANONICAL_MEMORY_BOUNDS.md", + "mode": "100644", + "gitBlob": "707444d9f5c4f1873d2bb3b8c35fb93d4561d0af", + "rawBytes": 14017, + "rawSHA256": "ccfb35d6c2ad82e0d0182c1c963f5635670863cc8d3c384b34526a7046a94324" + }, + { + "path": "docs/internal/extensions/bv1/CANONICAL_RANK_ACCESS_SAFETY.md", + "mode": "100644", + "gitBlob": "10ae75797d11de63753b0e26de722510402bfe93", + "rawBytes": 13931, + "rawSHA256": "625fc059c257f6b427a76b3168f391e7be3db8e978897ef98f0f819e5175328c" + }, + { + "path": "docs/internal/extensions/bv1/CANONICAL_SELECT_SAFETY.md", + "mode": "100644", + "gitBlob": "3611d7ea4131c96126a2d13982024e8e3ea5de98", + "rawBytes": 11616, + "rawSHA256": "25be7079bcfb495e451458d54c54d9736d53344d8d6ebba9d3260fad03410067" + }, + { + "path": "docs/internal/extensions/bv1/CAPSTONE_COMPOSITION.md", + "mode": "100644", + "gitBlob": "2d38d6e273a47c2dcc7c411c24b7d518d9ecb33d", + "rawBytes": 18510, + "rawSHA256": "54e865cab745c9e04988f3097024704678cddec3776b39c573984851799d0646" + }, + { + "path": "docs/internal/extensions/bv1/CAPSTONE_SCHEMA.md", + "mode": "100644", + "gitBlob": "f21a76e3014ef96b5542fd95401b361ae632ab1b", + "rawBytes": 5697, + "rawSHA256": "89b40df3c68cf7fb50903984cc37d519d0a6ec567e4b6ff29e155c302cf927c4" + }, + { + "path": "docs/internal/extensions/bv1/CHARGED_SETUP.md", + "mode": "100644", + "gitBlob": "586b27fcbb4ca359e0afd6fee1a751e91749f303", + "rawBytes": 13047, + "rawSHA256": "02b99abb531178c17602acf8a5329deab47a621f9dc9c0f16fabea0735524614" + }, + { + "path": "docs/internal/extensions/bv1/CHECKOUT_BYTES.md", + "mode": "100644", + "gitBlob": "b8a442c0ce14a3eb517d5ad59669a13f0c301103", + "rawBytes": 7745, + "rawSHA256": "11ad1f389569cbfb7c9a8fd05811278b828f45b066cb21c92164307d013b22fb" + }, + { + "path": "docs/internal/extensions/bv1/CHECKOUT_BYTES_DISPOSITION.md", + "mode": "100644", + "gitBlob": "503190799f369fd809cfd73321eb87794e42a6e0", + "rawBytes": 1725, + "rawSHA256": "7f8810e67213ee3071044dfe1e72f354b52d3c6c2d90d1d1a56462b9e2926396" + }, + { + "path": "docs/internal/extensions/bv1/CHECKOUT_BYTES_LAKEFILE_DISPOSITION.md", + "mode": "100644", + "gitBlob": "21bcc4371b2777f04af0c58c30d7ad39bd0b76a9", + "rawBytes": 3028, + "rawSHA256": "f43488628bcdbded05bc7139719f6e9ccff3b5272bb138b14b14eb316101f512" + }, + { + "path": "docs/internal/extensions/bv1/CHECKOUT_BYTES_LAKEFILE_PATCH.diff", + "mode": "100644", + "gitBlob": "59bf1a16cb8caa7035c5519ac26c6a889980d287", + "rawBytes": 363, + "rawSHA256": "a6d7771daeeeb3618e55a9fca3302e88a8d402455425b66616eedfa6511e1cc6" + }, + { + "path": "docs/internal/extensions/bv1/CHECKOUT_BYTES_PATCH.diff", + "mode": "100644", + "gitBlob": "f8b4240fc07d93dbc03c2e6021fa23371ca7d28f", + "rawBytes": 679, + "rawSHA256": "22681770c2d5b2a42389e00bc00080a79b75acdf968c27320fb0a90f2224e40b" + }, + { + "path": "docs/internal/extensions/bv1/CHECKOUT_WHITESPACE_DISPOSITION.md.gz", + "mode": "100644", + "gitBlob": "99cf52e863c580fa5aca2eef4c1e0ce5fa375947", + "rawBytes": 1854, + "rawSHA256": "1e5b6c40e1d751154de9be02201fb0b26054a2df69cff54cf426c178ecf7d011" + }, + { + "path": "docs/internal/extensions/bv1/CHECKOUT_WHITESPACE_PATCH.diff", + "mode": "100644", + "gitBlob": "ee97a7188cc5e75808f140f4604bf19c97ff4b39", + "rawBytes": 1927, + "rawSHA256": "8addbdb7b260aceb3712ce30d59e066a2144c01013164f4e52352f1d464b057e" + }, + { + "path": "docs/internal/extensions/bv1/COMMANDS.md", + "mode": "100644", + "gitBlob": "48f4278afd76ad2de82e8926238ff0905af95e95", + "rawBytes": 15024, + "rawSHA256": "9f3c35c92863ecad365dea7ef89006164db87ec6741adabd60ef5609c6633122" + }, + { + "path": "docs/internal/extensions/bv1/CONTINUATION.md", + "mode": "100644", + "gitBlob": "6f5eb3acb81bc8ac86ac0fa41cb77d46c5395a3f", + "rawBytes": 4689, + "rawSHA256": "265264be0ee49d12b258089efb1c74eba213b6db8115e2311cc88750694eb18d" + }, + { + "path": "docs/internal/extensions/bv1/CONTRACT.md", + "mode": "100644", + "gitBlob": "cf852503874fffe3ffd7a3f7aa1c2ab183d01789", + "rawBytes": 10151, + "rawSHA256": "1f8fd493db9896e66288db850a9ea456a0cdaa05d55b6fe9686ccfc766fd4a00" + }, + { + "path": "docs/internal/extensions/bv1/CONTROLLER_PROOFS.md", + "mode": "100644", + "gitBlob": "95ecfc9cb0578a7debd235899f9c6e67813948da", + "rawBytes": 27322, + "rawSHA256": "a065c80bfe3c29b898d31587eb643d148ed7f662e18bd5df19f7ddd0d7e7622a" + }, + { + "path": "docs/internal/extensions/bv1/COORDINATOR_ROUTE_DISPOSITION.md", + "mode": "100644", + "gitBlob": "d1dd25457982a7a90bcf5d63656be04afb7c7f00", + "rawBytes": 6169, + "rawSHA256": "ba1f222d4904290527417b951489b54f9833999de3d0f1060a0e6e060002cab3" + }, + { + "path": "docs/internal/extensions/bv1/EVIDENCE_MATRIX.md", + "mode": "100644", + "gitBlob": "1dc49c8954db1192a6a2200635bcd40eb157eebf", + "rawBytes": 22376, + "rawSHA256": "e6f34b2de09fb86c0adfcd5527c3f7944fb4f24a9d940ea153e60e83d7803fa4" + }, + { + "path": "docs/internal/extensions/bv1/EXCEPTION_CONTROLS.md", + "mode": "100644", + "gitBlob": "565928e6f5288c6655700a70042f88f2d966c6d2", + "rawBytes": 13721, + "rawSHA256": "f676ed4a5f4cbdc25b2b868eb081288d73a65c05762a1c7022a77a55692981a6" + }, + { + "path": "docs/internal/extensions/bv1/GENERIC_SELECT_SAFETY.md", + "mode": "100644", + "gitBlob": "e01643735009b999eb9414eb215eaa80c820cd3a", + "rawBytes": 16708, + "rawSHA256": "258b27bbb14229787f19b2391110f4044312df2d3fae42112fc106f7e9fa6c38" + }, + { + "path": "docs/internal/extensions/bv1/LEAF_CONSUMER_REPLAY.md", + "mode": "100644", + "gitBlob": "12bfa7976c58ae75277d809bcea611538c0477f6", + "rawBytes": 10324, + "rawSHA256": "af80e6176efd1715ee1a30cfc009258135fd1f0d94aff79a1b07b1aaf0206de7" + }, + { + "path": "docs/internal/extensions/bv1/MACHINE_CONTROLS.md", + "mode": "100644", + "gitBlob": "999d63f08f3fd0ea560d7576fdb1078be41c94ca", + "rawBytes": 20162, + "rawSHA256": "ef319fa374972399caf190e3c1c3f0afc9e1b6fc6ca98ddc57c2caeb398c8190" + }, + { + "path": "docs/internal/extensions/bv1/NORMALIZATION.md", + "mode": "100644", + "gitBlob": "78f9f12db749b9783924758c92bc73b1510aca32", + "rawBytes": 14640, + "rawSHA256": "519753d23f9bc91bfe97f3120fca21815328fa361e1e6494a9c60a4f7cfeddc8" + }, + { + "path": "docs/internal/extensions/bv1/NUMERIC_READER.md", + "mode": "100644", + "gitBlob": "c898fdb857250e9cbf32a95b5909eb72a67ff8a5", + "rawBytes": 10280, + "rawSHA256": "d2bc1e797619a434f7b3b24140d776af2203ac4b774eb7a55659fcb977c0446a" + }, + { + "path": "docs/internal/extensions/bv1/NUMERIC_SAFETY.md", + "mode": "100644", + "gitBlob": "9ffc6562256cf30dc027902e9808515e3cd63c05", + "rawBytes": 15029, + "rawSHA256": "48d2c5a4b30c3d501fed52f54c036d8b05e86e9564b8d7d3b9c4b4eeb5547690" + }, + { + "path": "docs/internal/extensions/bv1/PREFINAL_COMPOSITION_REVIEW.md", + "mode": "100644", + "gitBlob": "6621f00e3c9c6a059b75e8216cbf9eaaf18018fd", + "rawBytes": 15579, + "rawSHA256": "6795a463a9f640df504b140652c633eab0a6d15ee13a93ca7fdeed8235403b93" + }, + { + "path": "docs/internal/extensions/bv1/PUBLIC_MUTATION_CONTROLS.md", + "mode": "100644", + "gitBlob": "069b7e6715fa5164a28f5d4ab38c4449c8710f9e", + "rawBytes": 29772, + "rawSHA256": "00b9c435b65b5f5c5516d255b67dcfe558e243aa4537d358db734c511d1d8c59" + }, + { + "path": "docs/internal/extensions/bv1/RANK_LAYOUT.md", + "mode": "100644", + "gitBlob": "16b536a7773e8428d93deeb2d3d87899301b3d42", + "rawBytes": 11351, + "rawSHA256": "01edd5e631d3cd73e4d508b6c47a45083380bc52e432ffe20fe522f0b18d2304" + }, + { + "path": "docs/internal/extensions/bv1/RANK_SEMANTICS.md", + "mode": "100644", + "gitBlob": "2f090c860adfb708d908b9f2946cfbcfe8dbb4f2", + "rawBytes": 16494, + "rawSHA256": "be503531c70f68a9afac08dc1a301729a9ca645cd1f6efd9fa6a457ad8e1c8e7" + }, + { + "path": "docs/internal/extensions/bv1/REGULAR_LAYOUT.md", + "mode": "100644", + "gitBlob": "7c1792c56640296b01c4813a9593bbf82a5bb962", + "rawBytes": 17776, + "rawSHA256": "5e620e761b9d41fedb6849354322a7f5882316e1fe1c13de1cc4bf8023ba43fa" + }, + { + "path": "docs/internal/extensions/bv1/REPLAY.md", + "mode": "100644", + "gitBlob": "74c438e509841f719a3855dba945e7f475a241af", + "rawBytes": 5316, + "rawSHA256": "1387ee95a1c281a7aff6c7ba959bafd28f59c573d0868480ff6c9ecedecf87dd" + }, + { + "path": "docs/internal/extensions/bv1/REPORT.md", + "mode": "100644", + "gitBlob": "d1eef7b4031bb23bb08e0c99024b9e37b869d9e3", + "rawBytes": 11579, + "rawSHA256": "5b3d640ed84691a596ee3dff087d8ac589b41649d83ac9d6b5fcf0d8cfe30381" + }, + { + "path": "docs/internal/extensions/bv1/ROUTE_REVIEW.md", + "mode": "100644", + "gitBlob": "edac5b71a31dc37e3551be094c02256b460f08cb", + "rawBytes": 3091, + "rawSHA256": "24daf17f573c3c45b17fe73ab21f5f04d2037f61ef8d9565367e990c37f12e29" + }, + { + "path": "docs/internal/extensions/bv1/SCRATCH_FRAME.md", + "mode": "100644", + "gitBlob": "022a95d51ad9a8273bd5a60e04232d519c17118f", + "rawBytes": 8079, + "rawSHA256": "8726f87b832549c0dd5132a163d4059b64e22d68579952517bca1e122d9b031e" + }, + { + "path": "docs/internal/extensions/bv1/SELECT_SEMANTICS.md", + "mode": "100644", + "gitBlob": "df24efaebfe9bc9bb1a610513e662b82da794c58", + "rawBytes": 14847, + "rawSHA256": "07759680fc451fc55dd89dd99f8ca35b5ac2cf6a65d9dc18bd489cbaaa2aa46a" + }, + { + "path": "docs/internal/extensions/bv1/SOURCE_FACTS.md", + "mode": "100644", + "gitBlob": "715ea00f2c322dd95fb3dffcd0bb745bd5ab367c", + "rawBytes": 5764, + "rawSHA256": "1ee1f6908b5efe8a139b0fbd197b9a0933b39dcbcd6b1fda5e0df6c98d098dbd" + }, + { + "path": "docs/internal/extensions/bv1/VALIDATION_CONTROLS.md", + "mode": "100644", + "gitBlob": "d5736de37d7416b6278ca72ade8dbdd74a8c8e5a", + "rawBytes": 18381, + "rawSHA256": "df1268c6147d15d9c2a72aef90a2c2c169544e3e9cb24fe609b609e6af9f9ffc" + }, + { + "path": "docs/internal/extensions/bv1/access_expected_type.lean", + "mode": "100644", + "gitBlob": "0b9d6153194b473b2fdf895b2d9b01a6fa973974", + "rawBytes": 1344, + "rawSHA256": "af77f97fef74247bfc45061d2078ef8d4709d22ef5a77c00f7f11a9bb018fb54" + }, + { + "path": "docs/internal/extensions/bv1/canonical_rank_access_safety_expected_type.lean", + "mode": "100644", + "gitBlob": "de9465d826161dd834ca8254522f690f29fb4d2f", + "rawBytes": 3471, + "rawSHA256": "09503edc196b297b331c3addcc938d863d2568aa85c161d34a2ee7bb84221e71" + }, + { + "path": "docs/internal/extensions/bv1/charged_setup_expected_type.lean", + "mode": "100644", + "gitBlob": "e0bb8975f68a2ba334bfda8d620120dcf4972119", + "rawBytes": 2428, + "rawSHA256": "5ccc0d63d945734387f6e8ddb4a9ad6d10f39a2eedbd285da48c46d5acd2fb86" + }, + { + "path": "docs/internal/extensions/bv1/check_build_manifest.py", + "mode": "100644", + "gitBlob": "e2c92216c88873a169458d5230ba741f71e17a1f", + "rawBytes": 2232, + "rawSHA256": "b4424a7cf836c3e44b929d8ab77fff7f04562e586a9e334c112d1424e229093e" + }, + { + "path": "docs/internal/extensions/bv1/check_checkout_bytes.ps1", + "mode": "100644", + "gitBlob": "0c7f548313c55209d3572b01a390c47755271f1b", + "rawBytes": 10854, + "rawSHA256": "c2689d8b37f7bbf6ede527295e1dad543132e00ff847d9d654fbe2c5290a0807" + }, + { + "path": "docs/internal/extensions/bv1/check_frozen_rows.ps1", + "mode": "100644", + "gitBlob": "2d4fdff09ff1673af8ebc479b626be43747e8fce", + "rawBytes": 4714, + "rawSHA256": "8487d2f0f9b5906802f44b305a866f0df652acac31e0329803fe562d4b292af9" + }, + { + "path": "docs/internal/extensions/bv1/claude/canonical_scalar_payload.json", + "mode": "100644", + "gitBlob": "1744925ad30252125b009a9b7deac0a2c7b8e37d", + "rawBytes": 2273, + "rawSHA256": "1013e7050cefe6236962ef40cc87a427d2f4ada890648befe3d8f9b3c1da486f" + }, + { + "path": "docs/internal/extensions/bv1/claude/canonical_scalar_scoped_start.json", + "mode": "100644", + "gitBlob": "61bb3f8feb441460f15b78bc7213922fcb5a50ed", + "rawBytes": 8432, + "rawSHA256": "e862d492d924221ec3240b8949afc4bc908dbce4459038b5789352b30faf3e06" + }, + { + "path": "docs/internal/extensions/bv1/claude/canonical_select_bounds_start.json", + "mode": "100644", + "gitBlob": "d478b7ae0e564e2860f124c1cbc52a48b928f54b", + "rawBytes": 4131, + "rawSHA256": "2e60b940238c0b9426006d65fca25757e30368f6849215b537f311421fef51d2" + }, + { + "path": "docs/internal/extensions/bv1/commands/access-proof-build-final.json", + "mode": "100644", + "gitBlob": "1c7801f4a3af0bdb4f4d7ed88a32a0a2b0685728", + "rawBytes": 227889, + "rawSHA256": "2e1100897cfdf434ddaf542bf075c59cc7ef9151e5dde07922dd16c2a5c5f5a0" + }, + { + "path": "docs/internal/extensions/bv1/commands/access-proof-build-v1.json", + "mode": "100644", + "gitBlob": "b5c2c8fe70abdbafaf9e69c06c27de75cd0aaa67", + "rawBytes": 250137, + "rawSHA256": "d9cf58b18f8ac9375cf7558f6d64dec123dc51e1a5468a9a586333dd553e1c0a" + }, + { + "path": "docs/internal/extensions/bv1/commands/access-proof-build-v2.json", + "mode": "100644", + "gitBlob": "e90afdb4a9890b92f020a8d50725cd8c535f1e8a", + "rawBytes": 246898, + "rawSHA256": "6ce84a2406cae1769affcfb90ecb38fec0d1ee0134bcb2d0021caad10ae7ff3b" + }, + { + "path": "docs/internal/extensions/bv1/commands/access-proof-build-v3.json", + "mode": "100644", + "gitBlob": "bf2ffdb82261a03e0a513397e8ced9febcba1406", + "rawBytes": 251357, + "rawSHA256": "d07c26cde8b9d891807f7bd8fba0c2855af6ea8610e61711df1c00ce2e6333e3" + }, + { + "path": "docs/internal/extensions/bv1/commands/access-proof-build-v4.json", + "mode": "100644", + "gitBlob": "60e3015cb5cb4c6d7e876db4f32a0c0df5d9df22", + "rawBytes": 250333, + "rawSHA256": "0d4c132acc0a77cdaca5ca56df571038217b6152cbffe6fe8d817b3293a35bb7" + }, + { + "path": "docs/internal/extensions/bv1/commands/access-proof-build-v5.json", + "mode": "100644", + "gitBlob": "3e466e10618733363fa12fd031ce83c1b3d88e33", + "rawBytes": 242163, + "rawSHA256": "9f3ac7beada117bec09f9f7b3554ec2f47062a01ef115b7e33a86fdfec8d459c" + }, + { + "path": "docs/internal/extensions/bv1/commands/access-proof-consumer-final.json", + "mode": "100644", + "gitBlob": "60a2d61e1ed6c7cb3595a4420fccbdb500a42a3c", + "rawBytes": 20819, + "rawSHA256": "c49930f05884d6c8468995d7fe152d83eb2f79149da6e6852d88b5d77d5e350b" + }, + { + "path": "docs/internal/extensions/bv1/commands/allocation-facts-axioms.json", + "mode": "100644", + "gitBlob": "c6a57ff53b6524ce4f8eb8e71d222747cd451032", + "rawBytes": 3977, + "rawSHA256": "41a36c0a915f3781786bc69961e0d95dc32e3b1e5d1c4b7974446ecd35565bed" + }, + { + "path": "docs/internal/extensions/bv1/commands/allocation-facts-repair-1.json", + "mode": "100644", + "gitBlob": "0e1a8a40839dc12df84ba1db0c055709bcde5019", + "rawBytes": 2450, + "rawSHA256": "ff46dd9e2ff614e2fc4e589fd9a2715e9fb7d39f165339342d6c0883bed43717" + }, + { + "path": "docs/internal/extensions/bv1/commands/allocation-facts.json", + "mode": "100644", + "gitBlob": "c4cf81f868cc3366001597132f8426d457c0e175", + "rawBytes": 5442, + "rawSHA256": "6c357989dbd4eb1868295f728bb20b392c3a24f409fc1eb4845219812c2fcad4" + }, + { + "path": "docs/internal/extensions/bv1/commands/baseline-span-assembly.json", + "mode": "100644", + "gitBlob": "72609b03a5cc929c20603c68ca00e9bd1e9c542e", + "rawBytes": 17480, + "rawSHA256": "ad4c9b82bad324c9a35dd2340c9e70d08f7f881001503fe53c271358950cde44" + }, + { + "path": "docs/internal/extensions/bv1/commands/candidate-checkout-bytes-v1.json", + "mode": "100644", + "gitBlob": "59b13536c3ef6e516db00467681fecfd75484b66", + "rawBytes": 1220877, + "rawSHA256": "1e7944dde24967717e629e632025b45e6df7a7d6a6da9a08a2fff8425d30ee0b" + }, + { + "path": "docs/internal/extensions/bv1/commands/candidate-postcommit-policy-v1-output.json.gz", + "mode": "100644", + "gitBlob": "91c19ea59fef4ece6a4cbc7d770bfe7119ce18da", + "rawBytes": 576, + "rawSHA256": "24ec2a88c88de6ac4f14d4264dcef25ef6f7d7de818fea7a882879b34d50f7f3" + }, + { + "path": "docs/internal/extensions/bv1/commands/candidate-postcommit-policy-v1.json", + "mode": "100644", + "gitBlob": "483cae7e7ea35f34b62bfbfe5440228194d98beb", + "rawBytes": 1047, + "rawSHA256": "fcc5cfd8f90c85f3e78a74e7d6e54eaf37e8e2b4b66e43e1d36613ba4daa6155" + }, + { + "path": "docs/internal/extensions/bv1/commands/canonical-rank-access-safety-build-final.json", + "mode": "100644", + "gitBlob": "893a8b3011dd25b6434d604913fd2205379c54d4", + "rawBytes": 235734, + "rawSHA256": "5347984506cdff0c3cabfca354daa01acc37c3a1847b15536be72db8edb35af7" + }, + { + "path": "docs/internal/extensions/bv1/commands/canonical-rank-access-safety-build-v1.json", + "mode": "100644", + "gitBlob": "77507292a152fa82dccb16c3718b5adf0c59dcfd", + "rawBytes": 243569, + "rawSHA256": "847bb8fea147863856ce31b8022ae092300a110bd5c6f85b28d36e3d8d185de4" + }, + { + "path": "docs/internal/extensions/bv1/commands/canonical-rank-access-safety-build-v2.json", + "mode": "100644", + "gitBlob": "ade853ca238651b361065a041b1c0fac380ef260", + "rawBytes": 239165, + "rawSHA256": "332ad83d70ecd64a3ddf02ba089616949011c3a62c397be0824838f5552565ed" + }, + { + "path": "docs/internal/extensions/bv1/commands/canonical-rank-access-safety-consumer-final.json", + "mode": "100644", + "gitBlob": "b36908468e339f0f0ea565b18e409321eaf8f6e3", + "rawBytes": 24627, + "rawSHA256": "b720ab8236895ea7fa00541f973de25a29aeca78f4d4091242bd4f5f46f5871d" + }, + { + "path": "docs/internal/extensions/bv1/commands/canonical-rank-access-safety-static-final.json", + "mode": "100644", + "gitBlob": "0c2f9dcf5e2f028f59801aea3e57cb90b246f3d3", + "rawBytes": 800, + "rawSHA256": "180840c62d7e92e228702f347085b558dfb2919ae042de211c7666e10de1c91c" + }, + { + "path": "docs/internal/extensions/bv1/commands/canonical-select-safety-1.json", + "mode": "100644", + "gitBlob": "9ab590d57278b087834a7bc59c00951c2bbd7e81", + "rawBytes": 244296, + "rawSHA256": "1e95bd3ea3d8d331362dce7e9ccd6c591d4bf7417bb3f2887c13beace48f35ff" + }, + { + "path": "docs/internal/extensions/bv1/commands/canonical-select-safety-2.json", + "mode": "100644", + "gitBlob": "a0f54876c81a993995d035752285f031baefd2a8", + "rawBytes": 232084, + "rawSHA256": "22bb586a3afd4626ffff7180bed167ad7808ac2e9f0bc9f1ccf1103dae3327c2" + }, + { + "path": "docs/internal/extensions/bv1/commands/canonical-select-safety-consumer-1.json", + "mode": "100644", + "gitBlob": "558eae3221c9670a92daf4ff309b358b35c9df7f", + "rawBytes": 24780, + "rawSHA256": "b059995c121c7002e704e99117e25f4c47bfb7e8728d2ead6bea7566ed620d92" + }, + { + "path": "docs/internal/extensions/bv1/commands/canonical-select-safety-consumer-2.json", + "mode": "100644", + "gitBlob": "ac2b06864ef92c079de174aaef511dde91e4c77c", + "rawBytes": 24237, + "rawSHA256": "61cfec7df405152d480e58d10ce1fd1384eb162a7fc26027e5290e121fe27785" + }, + { + "path": "docs/internal/extensions/bv1/commands/capstone-allocation-reader-consumer-v1.json", + "mode": "100644", + "gitBlob": "5a83a4d06d1cd1bcb3ebb9159c94caab6ccc5415", + "rawBytes": 29844, + "rawSHA256": "875e393de82148ef9ba60eb0fb6de83000a4e16c8211e1699eb9c4f66059038c" + }, + { + "path": "docs/internal/extensions/bv1/commands/capstone-build-v1.json", + "mode": "100644", + "gitBlob": "097fed3967f82e7e348fa63fbdb2e99993e8159e", + "rawBytes": 239614, + "rawSHA256": "c4498f08add230f1540b50e8de665bce41e6b78547aa061eed9d3407b810bde8" + }, + { + "path": "docs/internal/extensions/bv1/commands/capstone-public-consumer-v1.json", + "mode": "100644", + "gitBlob": "5718ef8df097da7b2946057f09f0d1546115aa07", + "rawBytes": 37322, + "rawSHA256": "d90182df1d0a7137ba6a095fb6ea7e2500de82410ab41a6e1ac2031659f9fe0c" + }, + { + "path": "docs/internal/extensions/bv1/commands/capstone-public-consumer-v2.json", + "mode": "100644", + "gitBlob": "ef61a0e10eab4308f1bb53b6938a1168a3b6f2bb", + "rawBytes": 34377, + "rawSHA256": "136f18b21a308caf06b28a5d6449a9763a74b9786b01fd1470ffe39be889204c" + }, + { + "path": "docs/internal/extensions/bv1/commands/capstone-static-final.json", + "mode": "100644", + "gitBlob": "9cc5b93d473e93a3a99f0d6a7dff95adfd3a23a9", + "rawBytes": 548, + "rawSHA256": "07a61e7e16f87b2df7d276702bc53d34c59098be5d94e458422d46e3ab44f556" + }, + { + "path": "docs/internal/extensions/bv1/commands/charged-setup-build-final.json", + "mode": "100644", + "gitBlob": "5443c2669c03c6924bf729eb6d1a582cb9ff88fc", + "rawBytes": 221825, + "rawSHA256": "5aae919523725a57d2aa18a2221e3620668e755c11e4806810a357f7d17668ca" + }, + { + "path": "docs/internal/extensions/bv1/commands/charged-setup-build-v1.json", + "mode": "100644", + "gitBlob": "9cd5d58378023e67ee1dff263ea8fdf27ac42d6d", + "rawBytes": 20570, + "rawSHA256": "a2f95db09e1c3a3a500e75ea2ad58a102a1a37174053fd741e085fce89701730" + }, + { + "path": "docs/internal/extensions/bv1/commands/charged-setup-build-v2.json", + "mode": "100644", + "gitBlob": "47651df9d2b919996d188a677213a41563d3d27a", + "rawBytes": 1022951, + "rawSHA256": "3b6a902fc15c2e620295a0b688e0a55ac5d8015072d2bd23b2dc257f0d4d5001" + }, + { + "path": "docs/internal/extensions/bv1/commands/charged-setup-build-v3.json", + "mode": "100644", + "gitBlob": "6799a479ce801bb9a188a416275d4d1d2c62b6b7", + "rawBytes": 229697, + "rawSHA256": "9450eea3e4784071ce7a9a8e6856d7e13f9ab26ef66c71f7e63436d07c0a680e" + }, + { + "path": "docs/internal/extensions/bv1/commands/charged-setup-build-v4.json", + "mode": "100644", + "gitBlob": "e24a71a455738c6a2f2f5f5d7dfdd2e5a5f0290a", + "rawBytes": 222342, + "rawSHA256": "aa1509516c658000069225f5e2cc53f95468ca8368c2d156350cfb67ad3dd3ce" + }, + { + "path": "docs/internal/extensions/bv1/commands/charged-setup-consumer-final.json", + "mode": "100644", + "gitBlob": "58db6ce468e7327bfc9701c6322097cb43d6dead", + "rawBytes": 16555, + "rawSHA256": "83a4d989a92326221b66e676e6612647bc8ac2fab4f29a9ed8b3f43c9c1d0f8d" + }, + { + "path": "docs/internal/extensions/bv1/commands/checkout-lakefile-observation.json", + "mode": "100644", + "gitBlob": "e123b3d734c4b64ed66c83a09e43dd03b24aee07", + "rawBytes": 855, + "rawSHA256": "ed856de5aa0475d6b95677a71e927839543ff4d60c9d54f6831e3a09a2d7aa2d" + }, + { + "path": "docs/internal/extensions/bv1/commands/complete-layout-11.json", + "mode": "100644", + "gitBlob": "d3599091f73218d28970105eb1d2bbafe93db32e", + "rawBytes": 223463, + "rawSHA256": "0855abee6c4811a99b862d8d26bf79e445030aabd4687f07482d7f9bf5d68bd0" + }, + { + "path": "docs/internal/extensions/bv1/commands/complete-reader-12.json", + "mode": "100644", + "gitBlob": "bbb354a37a47c500e5f08694471b13cbc4827e70", + "rawBytes": 233313, + "rawSHA256": "3c95147e3f37848c125bce040b7e228316974fc73cff67ead53bd53ee3dc970c" + }, + { + "path": "docs/internal/extensions/bv1/commands/complete-reader-limits-13.json", + "mode": "100644", + "gitBlob": "239a13a0c4f3391c6f788fbee9e1b3c8ed82f8cd", + "rawBytes": 229651, + "rawSHA256": "65d9b24cafeb1f9c98e4b3a1aaba26ded0459f549992a3907e8fb915952d4644" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-generic-rank-r3.json", + "mode": "100644", + "gitBlob": "241d9695933fc19c9de1e0d1cd9a75dc43fa801d", + "rawBytes": 217176, + "rawSHA256": "b8f2878f1d3919156e60b21002013627de2ffef2e8b5fd3ad3d9641dee4b77c2" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-generic-rank-r4.json", + "mode": "100644", + "gitBlob": "b0f26f876ed9463409ded81143d52ea763000be1", + "rawBytes": 218791, + "rawSHA256": "eb3c01df188e217f979fb8518e902903c5be3d3e4904729e62d41e6990c9660a" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-generic-rank-r5.json", + "mode": "100644", + "gitBlob": "b180ea95fbaae0b74b6f138b8d92292601345cf1", + "rawBytes": 214203, + "rawSHA256": "2cbb14b1c57de4cbd0d2fdaff4010bcb80436305094989d0d785a2ce588bf726" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-generic-select-r6.json", + "mode": "100644", + "gitBlob": "2c4cdf202355ec45b8c4cf9fbe012a1e2ab565cf", + "rawBytes": 221006, + "rawSHA256": "00136c2bd049ba567c02e0e42f509a32eb22aa7f44b8058a1c5f989cf2796303" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-machine-known-r17.json", + "mode": "100644", + "gitBlob": "f247765216bf3d31fa287f11118d74419bdbea63", + "rawBytes": 27014, + "rawSHA256": "1b2d79a1b8d52aba452e154f0dc65b45ff108efd9f5c437aa4b636ae871fbe93" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-machine-selectors-r18.json", + "mode": "100644", + "gitBlob": "cde8e50a269f8ad04aa65ca0d18671e068344271", + "rawBytes": 26247, + "rawSHA256": "6d22d44af537072771a3392544c3934eaabf117c6565e0f7918056a90e5e54a3" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-machine-startup-r16.json", + "mode": "100644", + "gitBlob": "d3a54675bf2e394e203957cb72ab5f38b4495a11", + "rawBytes": 24348, + "rawSHA256": "2c2d0d42022800e613da9b74939371ad907414bc1c1a97b7d1f932283b8e3cd8" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-machine-static-r20.json", + "mode": "100644", + "gitBlob": "eb661e2ccfc6259527bb777a8a5fb7188cae7c9a", + "rawBytes": 42482, + "rawSHA256": "17e1dc942b1fb86eda0cc7da407a1becf876c32216c0219b2a39d19bf76057fa" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-memory-consumer-r15.json", + "mode": "100644", + "gitBlob": "41d8d90a7e48ab5f0c046b67b1cc24db3d3a3221", + "rawBytes": 27010, + "rawSHA256": "b4dfc1911a842b9af973b0b1cf36d0de6affdd116394326d196694d027dac454" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-memory-r11.json", + "mode": "100644", + "gitBlob": "810b862525f734d2d42a95bf5d9bccdf00bd791f", + "rawBytes": 229780, + "rawSHA256": "f47a0c1b86a54231e27e8650cb827908ce2bb4e283b9e01fb84f3edfe8931a5e" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-memory-r12.json", + "mode": "100644", + "gitBlob": "dc35b4682d58bbc41e4bd3428d334dadcdf36aeb", + "rawBytes": 226332, + "rawSHA256": "1342f5964633c4f77fb9bbd68db85e8ef98267aee67c80b361fdadf23e736c03" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-memory-r13.json", + "mode": "100644", + "gitBlob": "804543422acf385e0c5d01f23ac206da14f99d9c", + "rawBytes": 232507, + "rawSHA256": "88391794ed5640f5382b6f5c614708751ff27c914a605621d23948863dcd319e" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-memory-r14.json", + "mode": "100644", + "gitBlob": "f65b10013a1ea5a430ff8e6cf6f97e13df21ef01", + "rawBytes": 229048, + "rawSHA256": "de1d61ff8ed4049b1ba21179bda03877cc3969443bec6893d55d267a3542d682" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-rank-prerequisite-r2.json", + "mode": "100644", + "gitBlob": "c72f7d95c08f8ba1cbeaafd49b8b015cb458043e", + "rawBytes": 213772, + "rawSHA256": "4ac098274b138dd83a2f1c2f3a017623cd72ae6403a111e73ec147f6ed91b20c" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-rank-r1.json", + "mode": "100644", + "gitBlob": "3b5cbb41be0931cd8c942f13f4ca396404d82d56", + "rawBytes": 177860, + "rawSHA256": "81ad5cc2b6a88853e024186cbc219df39ee4542e56deaed558792f6db899e4e9" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-rank-safety-r9.json", + "mode": "100644", + "gitBlob": "3c11b83294edd56fd0be547fa120119cd7f9af7a", + "rawBytes": 218295, + "rawSHA256": "0562ebaf4f7ed430cef43e8ffc1c7dd5e404707e4ceec6f3cf8322e5dcc4b1ea" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-safety-consumer-r10.json", + "mode": "100644", + "gitBlob": "3733a0b28fb6545669d55edb495b6bb1de9ed6cd", + "rawBytes": 18863, + "rawSHA256": "e5f7147b0d66b3ea1a4891bcbe6c1f10e62c81395a66556e4a2a519bee0d3152" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-select-interface-r7.json", + "mode": "100644", + "gitBlob": "4e4b0f26a2550eae0b5ac58994d4a3ca533e82e9", + "rawBytes": 216983, + "rawSHA256": "8ad42a4f414b9f3f2e822d88214040c6c9be0c3089cb4670c2afda7f0ac23688" + }, + { + "path": "docs/internal/extensions/bv1/commands/controller-source-consumer-r8.json", + "mode": "100644", + "gitBlob": "b0b7e385882b6e1a35049d795b49d04a89587277", + "rawBytes": 15652, + "rawSHA256": "0461b4472fa13f4f5239f02f7282ec132533ef667a2ea493bcea11c1aed1b39d" + }, + { + "path": "docs/internal/extensions/bv1/commands/crossing-known-case.json", + "mode": "100644", + "gitBlob": "f3d8497fb24ba1ec972dd649336bd0f32427a7f2", + "rawBytes": 3346, + "rawSHA256": "107b024045569970d416f968d0b68b9e5c467aeed4c3560f2c95a382e3a3b7b2" + }, + { + "path": "docs/internal/extensions/bv1/commands/crossing-startup.json", + "mode": "100644", + "gitBlob": "4fd441d66e48f23adf973c6d7c647861f86463d6", + "rawBytes": 2554, + "rawSHA256": "7dd909f870de9b660097e37b5c4eb3e7e39211b0eb0975e33f6528d846eb3ff6" + }, + { + "path": "docs/internal/extensions/bv1/commands/crossing-v2-known-case.json", + "mode": "100644", + "gitBlob": "f7dce17e3b381e8c851f3fdde8b7187151b4e0b4", + "rawBytes": 3667, + "rawSHA256": "fc96b072493c6b7c9b746156203f77e582fe28d28becaa9320d69b97a0303204" + }, + { + "path": "docs/internal/extensions/bv1/commands/crossing-v2-startup.json", + "mode": "100644", + "gitBlob": "3e98f1fb820dab2305ce3ac2f233f84210a04933", + "rawBytes": 3419, + "rawSHA256": "b1ebfabd762c9ffcb6193f1a4c27a589ac0e274547d973ee28c6186df3e09799" + }, + { + "path": "docs/internal/extensions/bv1/commands/evidence-design-correction-v1.json", + "mode": "100644", + "gitBlob": "9b5735c02316af730a3815f0e4949ad3df454085", + "rawBytes": 713, + "rawSHA256": "43bfbc62162d0a650f1e6658d9eb9a391f4933a8d7df33a8048a03e3acbe1f51" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-known-v1.json", + "mode": "100644", + "gitBlob": "2239cef887031ff52282c59354c8ce07baed950c", + "rawBytes": 61727, + "rawSHA256": "cf68372361f73c40d5a281b80003a482a42c30b3e520ae8d9e0f085fba93fac4" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-replay-v1-omitted.json", + "mode": "100644", + "gitBlob": "faf7ff06b11c4f93b8c67d6f51dfc2172845a721", + "rawBytes": 64111, + "rawSHA256": "f53e60aee1ed2de4d4ddef95ac5eb9801107fc39a3bb623836cac1872aeb99bb" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-replay-v1-route-accept-after.json", + "mode": "100644", + "gitBlob": "7dc4edb1729429dd43d1a3177316e90a56ebcab9", + "rawBytes": 62934, + "rawSHA256": "d6a6a614f1d2e5a262739a0f0fd371d0e947439304029454eabe1fc9c69bdaae" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-replay-v1-route-accept-before.json", + "mode": "100644", + "gitBlob": "a3165fa5698d0176401856db698c46cdc13c4dc0", + "rawBytes": 62742, + "rawSHA256": "8fed62f8546109ce6c9194327f555a7dffae44818234e9c37f000af2e9c92fd8" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-replay-v1-route-reject.json", + "mode": "100644", + "gitBlob": "f843de2da00247226860dbd881001adc4ab6531c", + "rawBytes": 62798, + "rawSHA256": "8c346bb716311c1a313a0e185cd7e7fcc56f0a1a5141a601fb4c8c5394e5cbd2" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-replay-v1-valid.json", + "mode": "100644", + "gitBlob": "809271bbf0af5286e161dc73ff65d3ada620f434", + "rawBytes": 62555, + "rawSHA256": "77605bb5447fb564c2422ad59dc3b32e46e5e0b477bb10f688cdc780f54a0018" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-replay-v1.json", + "mode": "100644", + "gitBlob": "25696570b45a29fc74b54c1dea07a46dc606aed9", + "rawBytes": 84679, + "rawSHA256": "4bd36879a9c95006d943a2dc7d0a6abb285954759b8ed0147697f5d97e51b64b" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-startup-v1.json", + "mode": "100644", + "gitBlob": "cd0e482f990dd30aca6fe67f0f547fc266ee94aa", + "rawBytes": 109465, + "rawSHA256": "086c4c43eab8c703a88fd4e2ae0b893811e8383f379a7f10a7b46155cebf0584" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-startup-v2.json", + "mode": "100644", + "gitBlob": "30b87560a78c5b855dcc2aecc660010e802152be", + "rawBytes": 62975, + "rawSHA256": "7ef191f1dc401a7ba573ae5a7fb5b51145fe7d50c4ee7288cf6421255b3ab791" + }, + { + "path": "docs/internal/extensions/bv1/commands/exception-controls-startup-v3.json", + "mode": "100644", + "gitBlob": "6c6459f2e99f832c028c3ffe2527a79b4756501b", + "rawBytes": 60950, + "rawSHA256": "c122e720b82056894069ad050acd39a35031d1a6e25c3a8380a719602e0c2367" + }, + { + "path": "docs/internal/extensions/bv1/commands/final-report-claims-v1-output.json.gz", + "mode": "100644", + "gitBlob": "3cd9f82831b5399997204fa895ceb27ca134ca62", + "rawBytes": 31557, + "rawSHA256": "e3215c620f71942e895536119117f17831c1f7061272d4b5ab31121d41b34839" + }, + { + "path": "docs/internal/extensions/bv1/commands/final-report-claims-v1.json", + "mode": "100644", + "gitBlob": "9ad61183cd77e1baa4cfca4c9badf242352626f3", + "rawBytes": 799, + "rawSHA256": "bd863f1ba5984e24b4d445ac67c0be4609824cdb7bb8144917a60fc3f87282e7" + }, + { + "path": "docs/internal/extensions/bv1/commands/frozen-rows-final-policy-v1.json", + "mode": "100644", + "gitBlob": "0c9f60b7e5cbc67cd70bc0ec24706176b5d661db", + "rawBytes": 10146, + "rawSHA256": "cd4357f022324752a0eb66d97a59b1e846139061483c38a81e075b365806f824" + }, + { + "path": "docs/internal/extensions/bv1/commands/frozen-rows-implementation.json", + "mode": "100644", + "gitBlob": "cc0e2effa5d7d9d29288f9d1a9dab57a88cec790", + "rawBytes": 10145, + "rawSHA256": "c5f23ae4fb9d86f72ac83727b05415d1553ababc929c7f2b898d454b7575a186" + }, + { + "path": "docs/internal/extensions/bv1/commands/frozen-rows-pre-replay-repair.json", + "mode": "100644", + "gitBlob": "eff0d7703f4a7e1842f809c80d88826900acad4d", + "rawBytes": 10148, + "rawSHA256": "943ba6d806b9ac8c4a49c707a0d1935c532d87555f4e235e4a3dce6d6bfb94c8" + }, + { + "path": "docs/internal/extensions/bv1/commands/generic-select-safety-1.json", + "mode": "100644", + "gitBlob": "58993f3a4094b1fee533cd4ea334dca109e6c887", + "rawBytes": 227111, + "rawSHA256": "69de0dc7b6f832bb3be3630c14c2e3ff64789e70c089e898506388eca2d1bbb3" + }, + { + "path": "docs/internal/extensions/bv1/commands/generic-select-safety-2.json", + "mode": "100644", + "gitBlob": "1f134e5e5bd16ec7e616cd678a4a0ef733285e2e", + "rawBytes": 223496, + "rawSHA256": "d4f0fc074429485bf62638d52a5344a6c2e35f61b115a3c2587c7cd5d20ff9f5" + }, + { + "path": "docs/internal/extensions/bv1/commands/generic-select-safety-consumer-1.json", + "mode": "100644", + "gitBlob": "5d5e4a3955deab9247afe1a2b4ce9fb6900544a0", + "rawBytes": 19411, + "rawSHA256": "072f87eccac657bbdf46083797677b22e57d6bc10a7bb32996e8fe772069962d" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-final-policy-v1-claims.json.gz", + "mode": "100644", + "gitBlob": "3458e3f047c34a19e59ff17b8490465ddd0aa00f", + "rawBytes": 1198634, + "rawSHA256": "c80d9e825fd18a7f974138295add19245e286c4ffcbaaff7b668118f6b2336f6" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-final-policy-v1-design.json.gz", + "mode": "100644", + "gitBlob": "f23d5dc6caeac20dced49f2e9fe17230834db162", + "rawBytes": 279, + "rawSHA256": "23f0243c259ed54a450630688d909e61444d0f01e09dd538d425547c4588cfdd" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-final-policy-v1-native-trust.json.gz", + "mode": "100644", + "gitBlob": "1559476b22a5c124bb3615e19e842e0a8cbfcfbd", + "rawBytes": 216, + "rawSHA256": "cf8320c46a07d78091bd847a1b5d0d681e3e8cb99e3e762d105000b6bbedc576" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-final-policy-v1-range-diff.json.gz", + "mode": "100644", + "gitBlob": "3324b2c6c23067a936638a93d3945b7fc7a546b8", + "rawBytes": 216, + "rawSHA256": "9ded06c4403978c0c54091287fda10b4e6c617afa34623e9aa0815eef3b08446" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-final-policy-v1-staged-diff.json.gz", + "mode": "100644", + "gitBlob": "6040be92a1f479e13083119efab6758a5a2f520b", + "rawBytes": 281, + "rawSHA256": "202c1ed84a83095ad7b52145f088ce42c70221acd0c5c440ed1cab03be70326e" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-final-policy-v1-trust.json.gz", + "mode": "100644", + "gitBlob": "acf324fe2cefb446f8bb83208a65b902c6b323cf", + "rawBytes": 209, + "rawSHA256": "5565c3124076b9d6413b814cb9ed803ced1bfd7628b5f13859e67ad1323d2924" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-final-policy-v1-working-diff.json.gz", + "mode": "100644", + "gitBlob": "1e6c3cb4456fe828c920c54397b88c73718dcf6d", + "rawBytes": 216, + "rawSHA256": "7dd79014e0d19958e001cfc1ee1de101dfddadb88de3c8533fa52249fe35227d" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-final-policy-v1.json", + "mode": "100644", + "gitBlob": "91f71ab740946de70475454bdd471c40e8accd50", + "rawBytes": 5851, + "rawSHA256": "2ed077b782c67adbb7ecdf84e85287f38075123c287d39d5fc4a3a0d1970f352" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-precertification-claims.json.gz", + "mode": "100644", + "gitBlob": "b7d20ec4bcc0a86baae618cfeeb4e2aa6eed7b0b", + "rawBytes": 1188985, + "rawSHA256": "24698f2b225cd0574316514cdd4b1910c70b1674e43943c72d98e32676d05ac6" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-precertification-design.json.gz", + "mode": "100644", + "gitBlob": "9400e0b0fdeb9a145d6db0ef05de26b1d1cb74c1", + "rawBytes": 274, + "rawSHA256": "e457741cf1809d9576208ed01ff5ef13fc993dea98e81335f6db40ad91739305" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-precertification-native-trust.json.gz", + "mode": "100644", + "gitBlob": "6d04ad56dd8b69d7bfde6344066d1e22af2c15c0", + "rawBytes": 212, + "rawSHA256": "05a3bcf86170144acccf79626736792d3d8a195a5f45897782a05af1356ab33a" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-precertification-range-diff.json.gz", + "mode": "100644", + "gitBlob": "e0fe46c801dd6f95e37462d2bce8cd38dd637ae7", + "rawBytes": 211, + "rawSHA256": "9323a76d487ec99fc1769db47f432676a00d2d37ed45e44ac1f6668f6ad7e489" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-precertification-trust.json.gz", + "mode": "100644", + "gitBlob": "7593c2628e1ef421d67ae1d789ef46d3f85cdb7d", + "rawBytes": 207, + "rawSHA256": "3e7cd96bfddb6a2c1b13d01979d4c96766c07da38b32b79d4548de4be11a88e0" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-precertification-working-diff.json.gz", + "mode": "100644", + "gitBlob": "aacdbce67c4e75b2aa80bcc6ef17f094f58921a8", + "rawBytes": 485, + "rawSHA256": "ee28adfda9282557955164cd9da62fa69b44f2ea9f0e8b3639ead012851757a3" + }, + { + "path": "docs/internal/extensions/bv1/commands/implementation-precertification.json", + "mode": "100644", + "gitBlob": "e2df599d80c36ddf420aea835de4f278c2876d21", + "rawBytes": 5420, + "rawSHA256": "319d1e77ec69984ef8447459689532a7ea9c3d535b0edd292d7c038f25fdc265" + }, + { + "path": "docs/internal/extensions/bv1/commands/index-byte-final-v1.json", + "mode": "100644", + "gitBlob": "37b360668df697f544cdc21ae136203cb7b38709", + "rawBytes": 287230, + "rawSHA256": "692121a53fc12712dfc64e0a1ae611bc88a449ae6624c45f6c527598b9cbf6f6" + }, + { + "path": "docs/internal/extensions/bv1/commands/index-byte-preflight-v1.json", + "mode": "100644", + "gitBlob": "3bd41399a3e7cd06118d0b71d489dd2a1a689aff", + "rawBytes": 10557, + "rawSHA256": "eefa2a706ba1616c8898536318b4f472e3338b111c4415ac4b42c7e30c25ce25" + }, + { + "path": "docs/internal/extensions/bv1/commands/index-historical-eol-v1.json", + "mode": "100644", + "gitBlob": "f22fb2438356b038cf4e2202134891f5d3505b56", + "rawBytes": 8868, + "rawSHA256": "ab7cd75359f43bab5a3fb302a2dd0b6c46e40915bd047c164685ca9be2be6861" + }, + { + "path": "docs/internal/extensions/bv1/commands/leaf-replay-20260912130101742-canonical-select-safety.json", + "mode": "100644", + "gitBlob": "49bfc225cb86e3b9429b4cce912d497fd455272f", + "rawBytes": 33671, + "rawSHA256": "cdeb96061245ba59f592dc827288a0ec041fed5dd40057053bc40315a134bd5a" + }, + { + "path": "docs/internal/extensions/bv1/commands/leaf-replay-20260912130101742-generic-select-safety.json", + "mode": "100644", + "gitBlob": "3161c2bba3d0a5a8dd5324c37b4da1e3ba26e1e1", + "rawBytes": 33627, + "rawSHA256": "71412f83a9780b15afadc835b7cc955e938f415015c62ddb0eeea0fc6903c024" + }, + { + "path": "docs/internal/extensions/bv1/commands/leaf-replay-20260912130101742-rank-layout.json", + "mode": "100644", + "gitBlob": "d5933e58ddd4dd43429b72a368b1aa3b9568f6bb", + "rawBytes": 34025, + "rawSHA256": "8e1b2f9e875cad259cea07c8a065d9c04cf8e16d41d349551f0ca9451f7b6a20" + }, + { + "path": "docs/internal/extensions/bv1/commands/leaf-replay-20260912130101742-rank-semantics.json", + "mode": "100644", + "gitBlob": "3f994a65b48211159cb61871014e444a53c63308", + "rawBytes": 32293, + "rawSHA256": "608d67251a2e366cd44d26b2fb6100fbe13121dfd87b83724abffb0fd910fbd5" + }, + { + "path": "docs/internal/extensions/bv1/commands/leaf-replay-20260912130101742-regular-layout-axioms.json", + "mode": "100644", + "gitBlob": "13611dd697d0768912cfacf89b89367f230e60c5", + "rawBytes": 32062, + "rawSHA256": "05c7019250a1087e44981111dfb9cb8d4e1017c0cf40c1d622f833689da79fd5" + }, + { + "path": "docs/internal/extensions/bv1/commands/leaf-replay-20260912130101742-regular-layout-types.json", + "mode": "100644", + "gitBlob": "e61066772bc9b3836916de8013ace1c55643ff24", + "rawBytes": 33849, + "rawSHA256": "b56a4907aa7b8baec6106ed24696134f055a2dba8a574f8409e1f934a8905598" + }, + { + "path": "docs/internal/extensions/bv1/commands/leaf-replay-20260912130101742-scratch-frame.json", + "mode": "100644", + "gitBlob": "43c65303a72a18f2ae6f33a4552cc8d82ff73829", + "rawBytes": 32945, + "rawSHA256": "06fa7f9769edd48c758933f457d88b40144da0cb882f261810104176b8b8063a" + }, + { + "path": "docs/internal/extensions/bv1/commands/leaf-replay-20260912130101742-select-semantics.json", + "mode": "100644", + "gitBlob": "a3779286f93976686658b0b498f877d2108a26f1", + "rawBytes": 32926, + "rawSHA256": "9ee21f88a484cb7e5d203998436b3f026b1e0813a5a578c058169794d09ed71e" + }, + { + "path": "docs/internal/extensions/bv1/commands/leaf-replay-20260912130101742-summary.json", + "mode": "100644", + "gitBlob": "262e1e8df6ef68b88276b750272578e8292a2b8e", + "rawBytes": 13668, + "rawSHA256": "e1a6fcf86b0f856dc1abb486836a13e42ca31240fe458248230f6d81402c2c30" + }, + { + "path": "docs/internal/extensions/bv1/commands/machine-controls-v1-20260912111911796-bcf37cc6.json", + "mode": "100644", + "gitBlob": "88bb6e70fbc73a273a76f51c758a58d068a1c5c1", + "rawBytes": 60033, + "rawSHA256": "cace30f722697d762e31ec2814d28af89ffb2b45da789ffd841991a4b266407d" + }, + { + "path": "docs/internal/extensions/bv1/commands/machine-controls-v1-20260912111955043-999b380b-omitted.json", + "mode": "100644", + "gitBlob": "a1816068efe33d11f90fbe0b72290158f4464bf2", + "rawBytes": 67995, + "rawSHA256": "95f84fd158c4e46a9a0490272dd99a2e3d283f173ee9045939b93693b6350e2d" + }, + { + "path": "docs/internal/extensions/bv1/commands/machine-controls-v1-20260912111955043-999b380b-valid.json", + "mode": "100644", + "gitBlob": "4c70a9387caf4ecf8ec2172a0889d2af53e753b2", + "rawBytes": 61089, + "rawSHA256": "b2c64da938e9c3c120d78c49cf6a44ae6b0776f2ac1be1d063e88792cf8a373b" + }, + { + "path": "docs/internal/extensions/bv1/commands/machine-controls-v1-20260912111955043-999b380b.json", + "mode": "100644", + "gitBlob": "3079c79d4fcd0f4680c7d6de19c5c689c93f0fd7", + "rawBytes": 77385, + "rawSHA256": "109aab4b6e6ffd90b6da496b6c1a46f104a68138c7d8031c1c5c5f67d403b086" + }, + { + "path": "docs/internal/extensions/bv1/commands/manifest-raw-staging-v1.json", + "mode": "100644", + "gitBlob": "7b84b3fb690bbcc17ccaf6b8c6fd6e497f39efc0", + "rawBytes": 510, + "rawSHA256": "4be7c5b09af0824ecc8f28aa0454c7d69ede5085a06b8d40edb81a76b555b890" + }, + { + "path": "docs/internal/extensions/bv1/commands/manifest-semantics-v1.json", + "mode": "100644", + "gitBlob": "2db43595677687c846b6b480ad96b39604bdc6cb", + "rawBytes": 770, + "rawSHA256": "b78a8150f50cc0d80541feaba2ec32a04b6c834f88d7d03c04ee6ec17875c44c" + }, + { + "path": "docs/internal/extensions/bv1/commands/memory-layout-1.json", + "mode": "100644", + "gitBlob": "54bcbfaaea209c6758b2bafc29f890327239d004", + "rawBytes": 8119, + "rawSHA256": "0b3ced500236dcbeb8bc43b89089a70053cfe733d0b89f0fa90f2e299fe625ab" + }, + { + "path": "docs/internal/extensions/bv1/commands/memory-layout-2.json", + "mode": "100644", + "gitBlob": "3916fa31fe824189baf2f8494174db1b00124627", + "rawBytes": 4037, + "rawSHA256": "8f4bc4c1b1dccc13d565057e6bc505ebcf7a9c6101d58c94820452744e12dfef" + }, + { + "path": "docs/internal/extensions/bv1/commands/memory-layout-3.json", + "mode": "100644", + "gitBlob": "daff23e0e115e621a38e8e16b7f071869f2f4e6e", + "rawBytes": 18941, + "rawSHA256": "dc0ff4c4546996a45814c697bf9c3b6fef94a57da455f4de8f5c967acf7390ca" + }, + { + "path": "docs/internal/extensions/bv1/commands/memory-layout-4.json", + "mode": "100644", + "gitBlob": "f2a26643409cbdc8f822afaf1dc2f90aa1db0408", + "rawBytes": 33124, + "rawSHA256": "251b09244b5c3c2433b608071a3d33e9dadf5826e587fac23905dca188b7ade4" + }, + { + "path": "docs/internal/extensions/bv1/commands/memory-layout-5.json", + "mode": "100644", + "gitBlob": "f1bd1b8bb44380eff44db77dd7f808c7b0332112", + "rawBytes": 15728, + "rawSHA256": "485ecbf4803e634ad95e3a7b734ed7b8247db13d709540d6cedd25c7c258d005" + }, + { + "path": "docs/internal/extensions/bv1/commands/memory-layout-6.json", + "mode": "100644", + "gitBlob": "3ea7e8b6a9c90eb54332e232ee4f17049535a5cc", + "rawBytes": 13176, + "rawSHA256": "04a7ada5d6573d7c6b1f310b0310d5e548973a0bcfef0f83aefb2ef96c022012" + }, + { + "path": "docs/internal/extensions/bv1/commands/memory-layout-7.json", + "mode": "100644", + "gitBlob": "a09894ca8ef39b4a18925d145e781ef8bcea3757", + "rawBytes": 111350, + "rawSHA256": "0b72cb3b2b115a5c8feba3bbdc6c5a77b0f3bd2b4871e3028c1fe68183ee8695" + }, + { + "path": "docs/internal/extensions/bv1/commands/normalization-axioms.json", + "mode": "100644", + "gitBlob": "65e7898d575f389c123a1dc6c18ff35fe22a20a4", + "rawBytes": 2674, + "rawSHA256": "5a396ea974d67bdab45f3b26bf37bfef7124712925d9f1c4e8ab67758cc5c7fb" + }, + { + "path": "docs/internal/extensions/bv1/commands/normalization-final.json", + "mode": "100644", + "gitBlob": "a2cd0b172c58c4a2f29dff73820e13700b3d0071", + "rawBytes": 1077, + "rawSHA256": "ffab97e0c967554b6d5202c71a928911faa14decc913502485382ec987757d62" + }, + { + "path": "docs/internal/extensions/bv1/commands/normalization.json", + "mode": "100644", + "gitBlob": "1faee7b38c0da895e822989bb514bced7156d145", + "rawBytes": 2327, + "rawSHA256": "ab3de5f3277a7f22bb8892ccbceb606208062f5f441540829c25ce4b5d46b2cd" + }, + { + "path": "docs/internal/extensions/bv1/commands/numeric-reader-build-final.json", + "mode": "100644", + "gitBlob": "956d3e7e3b3aa6ba3bcc947d8ec81caee6d349e6", + "rawBytes": 11276, + "rawSHA256": "4d1e351b22cf9f1719db7499bdb5fd56fee5d878f95c48f876bb69ce56b4fa93" + }, + { + "path": "docs/internal/extensions/bv1/commands/numeric-reader-build-v3.json", + "mode": "100644", + "gitBlob": "5158d4b38791caaa6fb5c0db2cabd6a6b69ae79d", + "rawBytes": 19376, + "rawSHA256": "700ae87d2c708c737044c52829d17d71171cbbf8b4327fd71e29edd36b3f3fe3" + }, + { + "path": "docs/internal/extensions/bv1/commands/numeric-reader-compile-v1.json", + "mode": "100644", + "gitBlob": "2e77d83bbff18e080f23713df4f83554af00f653", + "rawBytes": 179644, + "rawSHA256": "3c233da69003757fe9033d8f079d0a324ba10b5a11c0582074880097f8fa8bfa" + }, + { + "path": "docs/internal/extensions/bv1/commands/numeric-reader-compile-v2.json", + "mode": "100644", + "gitBlob": "a238778aabe2b5dac12f36b1fc2eae53a570c0c3", + "rawBytes": 110529, + "rawSHA256": "c65ec384aae9b489859c218f3fd8f57f35179dc76d428623e179aeed79cd7f55" + }, + { + "path": "docs/internal/extensions/bv1/commands/numeric-safety-build-v1.json", + "mode": "100644", + "gitBlob": "7271f25b043026c0ad21939e35a3dbc8b7a5a1ca", + "rawBytes": 284233, + "rawSHA256": "c256ed07c731f93739ad917e3d182dcd2d1790a1e90a147d9050660a5a3e2f03" + }, + { + "path": "docs/internal/extensions/bv1/commands/numeric-safety-build-v2.json", + "mode": "100644", + "gitBlob": "ed7e447e26e6a1d4fedb2b2c2a659301ea9bdcfd", + "rawBytes": 280144, + "rawSHA256": "72ccd651ee1259a9cf27477c2210ef22637c75ab0adee8cf9fae860d71f3ae53" + }, + { + "path": "docs/internal/extensions/bv1/commands/numeric-safety-build-v3.json", + "mode": "100644", + "gitBlob": "6987e6ce78a7946b585ae69cb0bd540117815f40", + "rawBytes": 220931, + "rawSHA256": "5a7ba4f2caf4d9acefcc9f42525bb00c08b7e12adbf89b4b928122dd4f007a3e" + }, + { + "path": "docs/internal/extensions/bv1/commands/numeric-safety-prerequisite-v1.json", + "mode": "100644", + "gitBlob": "f77ec5cc85892bbd9266259b809bada10a600307", + "rawBytes": 216014, + "rawSHA256": "cc17c6ea8763fcd36c1a26c212fb029a427d93441dd96421d062db292d3b1857" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-14.json", + "mode": "100644", + "gitBlob": "8e9f0bd6198fea645d72f01fc50433d863de565e", + "rawBytes": 241595, + "rawSHA256": "3c34ce19b0ab0350bba52dbd952bdab74cd9758488d66e4b204d42d52a325bc0" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-15.json", + "mode": "100644", + "gitBlob": "3d56532248940fb80da3eca90b705049cdaf193e", + "rawBytes": 228977, + "rawSHA256": "1ee190588bf5ae4af023f53b27609aef80ed1fdc339ca0b1ff18c0bef50e698e" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-16.json", + "mode": "100644", + "gitBlob": "524b49c8e356660b003990157dee89be3dfc4330", + "rawBytes": 237399, + "rawSHA256": "92c924674719c11df4eddd153b76ae76db79c6e7677f2ea2ecb6161d8ae5ad38" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-17.json", + "mode": "100644", + "gitBlob": "37fd623828aa03c3561e79e91aec985b90685b4d", + "rawBytes": 23725, + "rawSHA256": "c6799edd33be6994da943ad4f1f0d640de64b03cefdfa015b1e3ccd3d328df86" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-18.json", + "mode": "100644", + "gitBlob": "ef4cb6d0ecd4db75cceec3a89f3162aa1139c790", + "rawBytes": 235181, + "rawSHA256": "3cbae330e9d31141ae546950e9cb773a32165bd545908fe6ac729d15bff5e353" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-19.json", + "mode": "100644", + "gitBlob": "fc02b6c30d34f8e404ed195f155545972c5ccc8e", + "rawBytes": 236878, + "rawSHA256": "8bebee33c93b34d4dcd967b45b3cb98b9a01a0ba8b58204be275b4b3fbb2d8d3" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-20.json", + "mode": "100644", + "gitBlob": "2bd071817760a4e4615ac8c3787ceddf852ed24f", + "rawBytes": 240813, + "rawSHA256": "117f6b72e0ad9bff652a29775d362bb409552bc8f6d18b1701f06d5c45d979cd" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-21.json", + "mode": "100644", + "gitBlob": "e7099c0ffaa0ef6dd70b42a5fec05171f9bc8786", + "rawBytes": 241344, + "rawSHA256": "1b22a8ac734b7c9ae0ecd56784fcc0c8e0f67c4a0b4d04112a481b217f804a44" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-22.json", + "mode": "100644", + "gitBlob": "1e1edc8d31f14dd8d8ec5e231c220a92cefecc79", + "rawBytes": 243818, + "rawSHA256": "ce7df6c3641842b57cf287199cb2df8591939a2262c1c3b357da89cd7b755469" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-23.json", + "mode": "100644", + "gitBlob": "9937545cb1f67bc6b1bcd0e0c13f0b08ad2c7c75", + "rawBytes": 238075, + "rawSHA256": "d6de55faf1e3fa977251a7e3cfefeec3f4abd9008647ece1d9d8bedc0502c2dd" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-24.json", + "mode": "100644", + "gitBlob": "a528935d34b6f81d03b4e2f97666dd5257e5f88a", + "rawBytes": 251683, + "rawSHA256": "af9b7575b97df5c5f6fd1836a54ea35c5eff107af6d4d47974053ea035e80f70" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-25.json", + "mode": "100644", + "gitBlob": "a231fb5685fe7c90003b56324515fb67b1b6e771", + "rawBytes": 269368, + "rawSHA256": "15b294ed5b2ac1ee5c4d2104a4c75cdee51eedee886c1914527a8fcda0e2a9c1" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-26.json", + "mode": "100644", + "gitBlob": "5a0730dd4ea5b3f9d0a6151cb700ea516a4fc57e", + "rawBytes": 285902, + "rawSHA256": "8a92c0876ca1e64fe8af6e6ebab63232279d199d2f8c4062868cd9bb8d2e65a4" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-27.json", + "mode": "100644", + "gitBlob": "0c6e87eecf6588a7c0342a32d03d3645da2732fa", + "rawBytes": 498706, + "rawSHA256": "bab8667ce6d220683f33fbcb708e73808c3bf9fcf65d6f09bc06abf337bb7b81" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-28.json", + "mode": "100644", + "gitBlob": "4d626b3047a3246897fa58277fe4da0152da1cbb", + "rawBytes": 269113, + "rawSHA256": "0823f9b639a6cabdffcb47601d28c00adc098be0d76b8d15ccc449b1cd73f01e" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-29.json", + "mode": "100644", + "gitBlob": "d47c09392b9564ed7ac9b932d5a103cd3f40651c", + "rawBytes": 242550, + "rawSHA256": "dccf072c0bee703486c53774581610e86087d645d4b116d7785eac6f2ee434e4" + }, + { + "path": "docs/internal/extensions/bv1/commands/operation-joins-30.json", + "mode": "100644", + "gitBlob": "3e449dd5de06f0373163a4802acc92254294c37e", + "rawBytes": 236329, + "rawSHA256": "53b5a876c863e8755af4fbef997a7d12a25b82c966fcfb4d5034c1f448d15d59" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-postcommit-claims.json.gz", + "mode": "100644", + "gitBlob": "e54977658cc9d98b96604c175136fec49b10ff49", + "rawBytes": 1169364, + "rawSHA256": "2b00b67d50bc0dabd6a090b6cac08b3fc3f5d34036a76363b9bc7a3dd84a210a" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-postcommit-design.json.gz", + "mode": "100644", + "gitBlob": "352cc6be08c69be6527daca763114ba8c0718f79", + "rawBytes": 267, + "rawSHA256": "e418d4b3534d507734fc121531c8c98e925872a78a0b918029b095bf1c1f0f9f" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-postcommit-native-trust.json.gz", + "mode": "100644", + "gitBlob": "b4b3d0ec8a31e079820f0b6a25cd9024838ad4ee", + "rawBytes": 200, + "rawSHA256": "e064a06aa3bf0e51da32f9d274c96827979495491f3368fc4ec3dd0721b12311" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-postcommit-range-diff.json.gz", + "mode": "100644", + "gitBlob": "2f68097dc24fe33d8815eee20b968bcb7ab4778b", + "rawBytes": 203, + "rawSHA256": "a56c74df68e9facf093e30bc7e9a3749249c7429f688e95fe0635360f4b153dc" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-postcommit-trust.json.gz", + "mode": "100644", + "gitBlob": "843b3578ec4c3c53cd38fdc72d9c920491187e5b", + "rawBytes": 197, + "rawSHA256": "1b2754223ee3c894871ae071bd549eece417285bf24e0f03e21d51ec6d06c629" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-postcommit-working-diff.json.gz", + "mode": "100644", + "gitBlob": "a3ff3bc7a56fb757eb08a6647a0f66c06d4fd177", + "rawBytes": 341, + "rawSHA256": "76ff7e8c1feb573509a09e9a03cddfc2b03515ee83214a6c143e84860d0cc2d9" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-postcommit.json", + "mode": "100644", + "gitBlob": "aa1e570784914100d6a8b04cafb12bde350f6a53", + "rawBytes": 5306, + "rawSHA256": "1e3ad9ee5c0850bdf2fc38d5f93d9043a05eeeb16db11381b3f2c3d7062ad4c9" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-claims.json.gz", + "mode": "100644", + "gitBlob": "f442ebd3be0bde366c6ccafae68783d6548d4b2a", + "rawBytes": 6330702, + "rawSHA256": "1c81df3849ff0498e1316aa317616cb7fde17c92b04b41ed47056ea1c7545c5f" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-design.json.gz", + "mode": "100644", + "gitBlob": "1e0c61fcbc12b6154cd3982e9f5b5d67a2f37f30", + "rawBytes": 266, + "rawSHA256": "872999de12b7f7d0a5a8aa37f88b78088bcf70c0f59713ebc14926a88e7cb472" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-native-trust.json.gz", + "mode": "100644", + "gitBlob": "9eec55a615f0aec1e19f8c3869142f4e95ed4486", + "rawBytes": 199, + "rawSHA256": "42905804016161ceb5b0b4252a2ec0c9d8fea31b907400fa7a10a624cc70e63c" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-r2-claims.json.gz", + "mode": "100644", + "gitBlob": "042aa05aea2b25c960be59d40e21ac754270e195", + "rawBytes": 1166740, + "rawSHA256": "6690dd4f178c64cb249fd1a84b6987ceacde4a56414133b79168ed5ed8d0eadc" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-r2-design.json.gz", + "mode": "100644", + "gitBlob": "cb7b7a98b593bceb4b70eed1c79636b71e63aed4", + "rawBytes": 269, + "rawSHA256": "571136ff0b2a2b23036182e65437a6cefde9770491c5aa93e072b6c6722df632" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-r2-native-trust.json.gz", + "mode": "100644", + "gitBlob": "9fae177fb666127d55428cfea55a7e7ed4b7db41", + "rawBytes": 205, + "rawSHA256": "993abf75d1371778197a7d16d13a6ef860d21386c2db42a5f95988419a295a82" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-r2-range-diff.json.gz", + "mode": "100644", + "gitBlob": "c4f0de2d2a654626829dc35cbdded15a1ac7d695", + "rawBytes": 205, + "rawSHA256": "807cc5071bcabd70147c2622d4f812d9aae3853466811a1121e32b071c5fcb86" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-r2-trust.json.gz", + "mode": "100644", + "gitBlob": "78b999c3300ea3324bac89a5b32716b8554d424d", + "rawBytes": 198, + "rawSHA256": "e7985c7cd3bf688ddd343b6436d66a23f4648c99f65604a7fdc7940d24c514e8" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-r2-working-diff.json.gz", + "mode": "100644", + "gitBlob": "7cc4424b29afb44dac54adf3a6852b2da4f79839", + "rawBytes": 340, + "rawSHA256": "d89861c04b553dfc878e51963933634646b993e3c36e709b56fdb8907da0eb39" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-r2.json", + "mode": "100644", + "gitBlob": "4fa8c8c1bf79fb8c232f44314a2a547529e6a6ee", + "rawBytes": 5294, + "rawSHA256": "23fdddb8ff6e71877c1252fb1b1a2edcf1ba8142e7550ba394a2d905256d1b9b" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-range-diff.json.gz", + "mode": "100644", + "gitBlob": "bbc7179392ae9c441151f27fceceaf853c545cd2", + "rawBytes": 203, + "rawSHA256": "7cfad20856e23b7b578dacc15a1c4d5cb26de74f26503c1307189df94916ff9e" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-trust.json.gz", + "mode": "100644", + "gitBlob": "8b00e7b8c2a107fce34c31e117e75492e48316b3", + "rawBytes": 198, + "rawSHA256": "eb7eeee7dca17fd5fc09dc43dedfc0767d94e635639ac6e553010072a10ff585" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit-working-diff.json.gz", + "mode": "100644", + "gitBlob": "9741b0b5200877c755af4df26734489d8961ead3", + "rawBytes": 335, + "rawSHA256": "85730978d93fcc33c8eac2ff93b9d7aa3f6d50df1a0eaf86fa6b958ddc3486b6" + }, + { + "path": "docs/internal/extensions/bv1/commands/phase-precommit.json", + "mode": "100644", + "gitBlob": "b3d72ba9464faaea4a7b092faf2fdd1655afd49e", + "rawBytes": 5278, + "rawSHA256": "fbb6f49b8a0b6d7f819db4f6af97fe7c68c142893b9f6674dc918e1fa8f2968e" + }, + { + "path": "docs/internal/extensions/bv1/commands/provisional-evidence-design-failure-v1.json", + "mode": "100644", + "gitBlob": "43ca2e497649464c552f2b9a79c085f30ce10322", + "rawBytes": 1068, + "rawSHA256": "ac6784565e14d08144e063fe9ffb019fae0a44177a8be58b23c67e6ff08fecf7" + }, + { + "path": "docs/internal/extensions/bv1/commands/rank-layout-1.json", + "mode": "100644", + "gitBlob": "a454a331514f0a5ebfa2da49e663ecc17daf39af", + "rawBytes": 13865, + "rawSHA256": "980f203778be1e513b1ad9536231ad8bcb0ec93f81ca3267c7adc3cf871be44a" + }, + { + "path": "docs/internal/extensions/bv1/commands/rank-layout-2.json", + "mode": "100644", + "gitBlob": "0bb0222b0ea260b9355d0a2e6b993c38b344d0f6", + "rawBytes": 13644, + "rawSHA256": "22accd5ab23dde3d05bc7afa07f9d2bc4ad07031e6db25e7f06a7a5d48d13116" + }, + { + "path": "docs/internal/extensions/bv1/commands/rank-layout-consumer.json", + "mode": "100644", + "gitBlob": "a53c64c246bb626259ad1f38b6fb0256e10ba9b6", + "rawBytes": 16312, + "rawSHA256": "60056965796acf009363dab4f86cf5b08ffebef98960673fe8c2941afe155256" + }, + { + "path": "docs/internal/extensions/bv1/commands/rank-semantics-1.json", + "mode": "100644", + "gitBlob": "e32249b49c5968551edc0bae05c7eff0a4172093", + "rawBytes": 29218, + "rawSHA256": "1b2a87914d3550fa7c2b8b76bce143a0369e2fbb0c779c2b841aee7283199e8a" + }, + { + "path": "docs/internal/extensions/bv1/commands/rank-semantics-2.json", + "mode": "100644", + "gitBlob": "82e96d5ec6b2dc1917e5da6c4a814d659488ecc7", + "rawBytes": 21528, + "rawSHA256": "9650366e79e29f7edf98a0140ccde3f879d69a9bea6ecfcfec7ef942aba29234" + }, + { + "path": "docs/internal/extensions/bv1/commands/rank-semantics-consumer-2.json", + "mode": "100644", + "gitBlob": "905e1ccf8815baa06849b9fc758fc6e94db7f89b", + "rawBytes": 12308, + "rawSHA256": "2f6566e97767d9bd2ec7d3748592efa0c668df2a1bf75291a2bacbabc4c5d301" + }, + { + "path": "docs/internal/extensions/bv1/commands/rank-semantics-consumer.json", + "mode": "100644", + "gitBlob": "ba2e521a614491f51dac2497988c5c2bbc937f3e", + "rawBytes": 13804, + "rawSHA256": "40be56de7d32a3ff5434f58228afd49a083803579a3e5a2bf27ffc8fcde3fc02" + }, + { + "path": "docs/internal/extensions/bv1/commands/reader-geometry-9.json", + "mode": "100644", + "gitBlob": "4b4b146c7cac460bf125fd08eb4fc6402fabd0f8", + "rawBytes": 223997, + "rawSHA256": "e731c733040f2b68754b51e15c5d19363349a4cdcc0e613c86a6f9b3202c890e" + }, + { + "path": "docs/internal/extensions/bv1/commands/reader-space-10.json", + "mode": "100644", + "gitBlob": "8880fb4d686abce2119f891463dcc6a58cc64404", + "rawBytes": 232365, + "rawSHA256": "30fd3e8fc6baf88ac38949d5f64719b689bbaf7f3f4617259424122f79f9ece0" + }, + { + "path": "docs/internal/extensions/bv1/commands/reader-support-8.json", + "mode": "100644", + "gitBlob": "185bccae6fd776a5176e4c341297c4765a9354fd", + "rawBytes": 14000, + "rawSHA256": "05c98df23e912ceb165ad4ba7a888ea23c73e5a8dc117c6cfc8215c183d51053" + }, + { + "path": "docs/internal/extensions/bv1/commands/reader-typed-axioms.json", + "mode": "100644", + "gitBlob": "2cc623dfdc2c8d713dc6110b92c2fc70d2b66cef", + "rawBytes": 3642, + "rawSHA256": "030ce603aeb22900875bd950d695b69dd4b78b5b9f5e023eba1ef38850def1d1" + }, + { + "path": "docs/internal/extensions/bv1/commands/receipt-report-claims-v1-output.json.gz", + "mode": "100644", + "gitBlob": "ac929cac455b65808ed5fb9167a2a3ac448d51c6", + "rawBytes": 5742, + "rawSHA256": "b476d2b78b3a6a0a1d2db89ce4a2fa94a0e354820f0f2c085a4d917374d16c93" + }, + { + "path": "docs/internal/extensions/bv1/commands/receipt-report-claims-v1.json", + "mode": "100644", + "gitBlob": "f73f0a5be1b62385f42ee5f8ff1f18e45228ac1b", + "rawBytes": 1017, + "rawSHA256": "0b7b3f309bcffa3e82cc634e6010cc6c2f91689e05a71227a446ab23793c2dc8" + }, + { + "path": "docs/internal/extensions/bv1/commands/regular-layout-1.json", + "mode": "100644", + "gitBlob": "523fbfa0cf48dcb72e2cb0e207b8d94bb43660f0", + "rawBytes": 17427, + "rawSHA256": "576bb8609c564d2b248415eff83c42f602a598a32d01379f3272afab9c63c8ed" + }, + { + "path": "docs/internal/extensions/bv1/commands/regular-layout-2.json", + "mode": "100644", + "gitBlob": "f9c859595da0030396b58cb7de015f117481acfa", + "rawBytes": 8858, + "rawSHA256": "8b6f9776b7463da434077995efbed54da8af5e1d0f90beceb717c9dc97038adc" + }, + { + "path": "docs/internal/extensions/bv1/commands/regular-layout-3.json", + "mode": "100644", + "gitBlob": "323ba6c5649532bd4f6c51303d9de6254e74e489", + "rawBytes": 5972, + "rawSHA256": "438a8be409a500a6fb503c568c73cd95c3edc503d19387c0e08962081d134f6f" + }, + { + "path": "docs/internal/extensions/bv1/commands/regular-layout-axiom-source.json", + "mode": "100644", + "gitBlob": "a64ee11026ac2b1687cf3a4a83e5c6f1969401e3", + "rawBytes": 7040, + "rawSHA256": "de8754edca0c6e67df9e74becf74160100fca5e9ded29e7288800cb05b95c209" + }, + { + "path": "docs/internal/extensions/bv1/commands/regular-layout-axioms.json", + "mode": "100644", + "gitBlob": "ccf91b61c0a73de55ebfbd8db5531fb0782875c1", + "rawBytes": 8846, + "rawSHA256": "b59c60e80dcbce5a41cda7cff5d87633e883e48a59aafdd41f26e9d9de97e079" + }, + { + "path": "docs/internal/extensions/bv1/commands/scratch-frame-consumer-1.json", + "mode": "100644", + "gitBlob": "2254024d06e215768e88cfe006dff29d688e32f7", + "rawBytes": 23491, + "rawSHA256": "8e5db3407733f593d9b5d027908be4f49a9e18482fc822b13486be0c7787d8fc" + }, + { + "path": "docs/internal/extensions/bv1/commands/select-experiment-compile.json", + "mode": "100644", + "gitBlob": "17fe04b8891d2c19072413e44e1810d30d739e41", + "rawBytes": 4192, + "rawSHA256": "8497256a6218e97d3642041669bfbd15c12af56de826e07873985536f1f74962" + }, + { + "path": "docs/internal/extensions/bv1/commands/select-known-case.json", + "mode": "100644", + "gitBlob": "e6faef7593a7dc2debc4f7090f0416f9c6e5ddf7", + "rawBytes": 2397, + "rawSHA256": "eff5e47aaa2b941a7f9274622968d8c8ddf749e7afbe0b7ea60e9c10c367e18e" + }, + { + "path": "docs/internal/extensions/bv1/commands/select-reader-compile-r2.json", + "mode": "100644", + "gitBlob": "5a4d5fef7f573198d732ab83d1d925a1b618f409", + "rawBytes": 1258, + "rawSHA256": "105bd8bb6bb420d28f1cc2124533220f7c9d0b0568881f632a500d445b0ec24d" + }, + { + "path": "docs/internal/extensions/bv1/commands/select-registry-v1.json", + "mode": "100644", + "gitBlob": "429613884ea30d28d314176c6b5c18e871820ead", + "rawBytes": 6761, + "rawSHA256": "c7827d26a18c302f09ce6902e03b9d90429d6fbe358f9d370e915427c29dd142" + }, + { + "path": "docs/internal/extensions/bv1/commands/select-semantics-1.json", + "mode": "100644", + "gitBlob": "d06f3db059afae7610c941882d02b5cdc77c576c", + "rawBytes": 36028, + "rawSHA256": "fdcf3f46b691d093b9827eb47c62481623d6ea02affc13a5c46488b2ae585fd9" + }, + { + "path": "docs/internal/extensions/bv1/commands/select-semantics-2.json", + "mode": "100644", + "gitBlob": "d19a70aaf4b9cf6d5cf4ced877b11b56967118c4", + "rawBytes": 80670, + "rawSHA256": "adab4d5d52d975d2d3f3c21f5881f6320bd743f55c690bf4d37bdba7e2019196" + }, + { + "path": "docs/internal/extensions/bv1/commands/select-semantics-3.json", + "mode": "100644", + "gitBlob": "e94d5e77698eb2fb419f11afe53d92eeb7bac038", + "rawBytes": 19631, + "rawSHA256": "1d39b0f0e2581e036dce49968818d3f65f7ee9988ba429d4c57d4e3d9074aa2a" + }, + { + "path": "docs/internal/extensions/bv1/commands/select-semantics-consumer.json", + "mode": "100644", + "gitBlob": "87d144c1ea65ed1458f3eb7df5747fce36ab2503", + "rawBytes": 10802, + "rawSHA256": "65d2d19b62700511d7953a7250759b85b4f0d9d63486db7bf4486c920f20471f" + }, + { + "path": "docs/internal/extensions/bv1/commands/select-startup.json", + "mode": "100644", + "gitBlob": "f755bec316d90ac15f3aa198fdae3562bc514057", + "rawBytes": 2074, + "rawSHA256": "f4d75585761602dd84631eb71be4c50eb7aef43efc12dd7ea5bddd52ddf0ecdf" + }, + { + "path": "docs/internal/extensions/bv1/commands/selector-controls-main-v2-final.json", + "mode": "100644", + "gitBlob": "972d9bd6a56cc65e00705e346fb9cdba8ac7d3ae", + "rawBytes": 51445, + "rawSHA256": "9dedd1345b46d867ed735419cf795b59cc3505ba5d3af98d6e17d241c2543c9a" + }, + { + "path": "docs/internal/extensions/bv1/commands/selector-controls-v1.json", + "mode": "100644", + "gitBlob": "c8bb3e170085a28b2fa4dcf427f98b9ab82863e8", + "rawBytes": 21521, + "rawSHA256": "5d2a9f16e0c9ff1f85958943774d32207d0d69c8e637cebdb5f2f382f9a2c3e4" + }, + { + "path": "docs/internal/extensions/bv1/commands/selector-controls-validation-v1-final.json", + "mode": "100644", + "gitBlob": "01737b36f214d59c191da9ee4198aecab3512159", + "rawBytes": 10909, + "rawSHA256": "e5e424e5121c5a3b809f29f45ae17636c381450e8ec685ad8cb6ea5c2b4c5018" + }, + { + "path": "docs/internal/extensions/bv1/commands/selector-omitted-main-v2-final.json", + "mode": "100644", + "gitBlob": "23b9288a4950ca41fce4afc58b815efac2917578", + "rawBytes": 48945, + "rawSHA256": "8bcdbe202527191fd84501c27e02c894d987cacf1f272dc4ee0a68c1e6e6d293" + }, + { + "path": "docs/internal/extensions/bv1/commands/selector-omitted-v1.json", + "mode": "100644", + "gitBlob": "31003b3d1a0dad3cfd0cf13480af319dd586b51f", + "rawBytes": 7081, + "rawSHA256": "8b98d984c817016b4f683fd4c047e3b431906f2fa92fd13104bb84c5b5df39ae" + }, + { + "path": "docs/internal/extensions/bv1/commands/selector-valid-main-v2-final.json", + "mode": "100644", + "gitBlob": "10bbe1c0e967e238581a392d4c2b43eebd0191c7", + "rawBytes": 31182, + "rawSHA256": "1eb13d7156e15b5915b152adce2ef888417eeb774eb3b7d04a08785c7b0b64fe" + }, + { + "path": "docs/internal/extensions/bv1/commands/selector-valid-v1.json", + "mode": "100644", + "gitBlob": "a0e2ecb1faaea365ce77ead6520f7cba09feb529", + "rawBytes": 2814, + "rawSHA256": "203e389b086c46eaa2b11ff495cc9d6e15d3ee9f672525684b8623b9ff64ef46" + }, + { + "path": "docs/internal/extensions/bv1/commands/staged-whitespace-diagnostic-v1.json", + "mode": "100644", + "gitBlob": "2a41f2fa768f6941eb6b177fa066e3e4fd8833bc", + "rawBytes": 11126, + "rawSHA256": "1bb86b5d38173e8a4187e0eac85fb876498414aa404d1e4197c85eedccbae11b" + }, + { + "path": "docs/internal/extensions/bv1/commands/validation-controls-selector-omitted-validation-v1-final.json", + "mode": "100644", + "gitBlob": "dc60529314be2af96681ce3f2a2624415d08d7fa", + "rawBytes": 16207, + "rawSHA256": "83e9deb9562cf9a9384da68c55c8be3175d84d34bec02449f3cd2c2bd8317e7a" + }, + { + "path": "docs/internal/extensions/bv1/commands/validation-controls-selector-valid-validation-v1-final.json", + "mode": "100644", + "gitBlob": "191b9f009294d014317f3be09a9d8fb8f1d699a6", + "rawBytes": 8957, + "rawSHA256": "4c406a2572dfb0f857d454ceed5eb19e40d822c78542ce8a9965b057d5551188" + }, + { + "path": "docs/internal/extensions/bv1/commands/validation-crossing-v3-first.json", + "mode": "100644", + "gitBlob": "707b648b8c8077261689c0507344bede967cced8", + "rawBytes": 29084, + "rawSHA256": "361d4712d4c15bb91ce9a42e92781a7c506de820be8a2562c46096b3b36266ec" + }, + { + "path": "docs/internal/extensions/bv1/commands/validation-final-static.json", + "mode": "100644", + "gitBlob": "b411cd3c443a64e67375760a30bf80f4e0c0041b", + "rawBytes": 4534, + "rawSHA256": "c965bcb4060be0e6e5787d61313568d5675e9ba6ce245fd89d4ae9c4f2edcd36" + }, + { + "path": "docs/internal/extensions/bv1/commands/validation-v2-known.json", + "mode": "100644", + "gitBlob": "83929e134685b52726fd365b61a2e4297858e583", + "rawBytes": 28475, + "rawSHA256": "1b636540b73eb9cefac6aae64e76241d2c4dc703366da95e80989876aff925bc" + }, + { + "path": "docs/internal/extensions/bv1/commands/validation-v2-startup.json", + "mode": "100644", + "gitBlob": "614d2743eb1db61dd267d190c65595f93ebee65c", + "rawBytes": 27935, + "rawSHA256": "7eb7ff55ac5337368eb207f67e9b5969769711997e2e7f2a6108cac66231d0e6" + }, + { + "path": "docs/internal/extensions/bv1/commands/whitespace-attributes-v1.json", + "mode": "100644", + "gitBlob": "6faa7c2cf6713d0d1aec48addd5b695de813fedd", + "rawBytes": 44028, + "rawSHA256": "c7aa69ecdc79d64de7698c0b142650954ca6fba15c17c6b4003577705e9ed67f" + }, + { + "path": "docs/internal/extensions/bv1/controls/allocation_reader_expected_type.lean", + "mode": "100644", + "gitBlob": "b8d5b2048b4097587cc54be27e7060c66ce3c36d", + "rawBytes": 4290, + "rawSHA256": "dd09511ed00d8753c97164eee06cc0e58c066cb0bfe33c0a37ca04d2c6d8f7ed" + }, + { + "path": "docs/internal/extensions/bv1/controls/controller_axioms.lean", + "mode": "100644", + "gitBlob": "d30198a229102f569172a4699f7a0f7d7fbd5a73", + "rawBytes": 10008, + "rawSHA256": "10705ae00918bfd709027b1dd3936867c8c0ef0502d5c84e630c7b9fc755b957" + }, + { + "path": "docs/internal/extensions/bv1/controls/crossing_v1_expected_fail.lean", + "mode": "100644", + "gitBlob": "ca27842b6cc81eefcbc73f123bb6689ee4e8019c", + "rawBytes": 1405, + "rawSHA256": "f9201fe1970244d968af47eb884d42e6bc2055984ed4a853985afb64351ed758" + }, + { + "path": "docs/internal/extensions/bv1/controls/leaf_consumers/bv1-canonical-select-safety-consumer.lean", + "mode": "100644", + "gitBlob": "1a1e8cfdc6d4e9d31ad637a068222acd69138bc8", + "rawBytes": 3741, + "rawSHA256": "6eb1741ec157b37904dce556cdbc16ba9730dfd28269217c16feea0ee9b44c50" + }, + { + "path": "docs/internal/extensions/bv1/controls/leaf_consumers/bv1-generic-select-safety-consumer.lean", + "mode": "100644", + "gitBlob": "01c0de4061a9943662290e6b6aa1094ff3f01e58", + "rawBytes": 4382, + "rawSHA256": "297c96db48830938a8236c5d02cda3de35e87afd4ccd75e17785814b5f53d8b7" + }, + { + "path": "docs/internal/extensions/bv1/controls/leaf_consumers/bv1-rank-layout-consumer.lean", + "mode": "100644", + "gitBlob": "c796a04648b75c4a8dd76a331de1f2a72ebcaf41", + "rawBytes": 2044, + "rawSHA256": "283ce0b7e52e49f63108bbdbcbb66e916c6086c0e821f49c1f6b8b5d6a071e7f" + }, + { + "path": "docs/internal/extensions/bv1/controls/leaf_consumers/bv1-rank-semantics-consumer.lean", + "mode": "100644", + "gitBlob": "2367efceefca82d879bb3c6a1850a0f8e412cef6", + "rawBytes": 3117, + "rawSHA256": "2f4d7a5b4ff532c80ccd162519c8a989f5b78b44b249cd9a159f122e7eeea2c0" + }, + { + "path": "docs/internal/extensions/bv1/controls/leaf_consumers/bv1-regular-layout-axiom-source.lean", + "mode": "100644", + "gitBlob": "e5b1344fd89fd497141c2a11b12eecfa7279d6dc", + "rawBytes": 363, + "rawSHA256": "67012ccc16e31764979aded20ba08c462e1cc207da389839737219cd98e7627d" + }, + { + "path": "docs/internal/extensions/bv1/controls/leaf_consumers/bv1-regular-layout-exact-types.lean", + "mode": "100644", + "gitBlob": "f4f08493067048bbc3ceee869b8561a079115ad9", + "rawBytes": 3415, + "rawSHA256": "f59ccbb23fd0074b8e769d98dc16ed263c16a7dbc3939e6f76ff20cc1586e337" + }, + { + "path": "docs/internal/extensions/bv1/controls/leaf_consumers/bv1-scratch-frame-consumer.lean", + "mode": "100644", + "gitBlob": "f190e7b03cb27d76edd7108c76bf1e3122c4334e", + "rawBytes": 1684, + "rawSHA256": "c40d8f1b3d776c84e2594ffc6605e51ad347f9abba1b5a83e1788cb214ac6712" + }, + { + "path": "docs/internal/extensions/bv1/controls/leaf_consumers/bv1-select-semantics-consumer.lean", + "mode": "100644", + "gitBlob": "b572118f9f808ee63248feb00705ae8755596516", + "rawBytes": 2874, + "rawSHA256": "35a9feb285aa5cd883f9ab0fbecc693ee7de9271242eb63e8f45ea07b27026a0" + }, + { + "path": "docs/internal/extensions/bv1/controls/leaf_consumers/replay-list-v1.json", + "mode": "100644", + "gitBlob": "e928d2382b1a1081c3494e5b77febffea332f248", + "rawBytes": 10079, + "rawSHA256": "fca3d67ad0b3b13ae65416431f73a209fbe8cecde1c08e790fa7dadb2dfbedec" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_expected_type.lean", + "mode": "100644", + "gitBlob": "77799af6f8a981de81e5e91e85929247d66013c8", + "rawBytes": 13417, + "rawSHA256": "fea8d045ef0a9cb9679949ed8825f2e04a4542c01e8f056a778bb0b474bf7a9e" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/capacity-without-code.constructor.lean", + "mode": "100644", + "gitBlob": "dcff956498a94d9e36ac789b581d5e334de287cd", + "rawBytes": 11829, + "rawSHA256": "648a6a344cfd1d95b1384aff1d805a7f66d8a6abf72c13a36c49b70f00b5b55f" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/capacity-without-code.consumer.lean", + "mode": "100644", + "gitBlob": "9f8c2d3f12b04a6c74443c4141155fb120dce4fc", + "rawBytes": 25204, + "rawSHA256": "0551357ab6fdeca16921cbc2e38131462338188c72bcf697886139a68b356abd" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/capacity-without-scratch.constructor.lean", + "mode": "100644", + "gitBlob": "ce5f16c77e0e43beca7cb141e1e5bdcd0e8ffc82", + "rawBytes": 12171, + "rawSHA256": "7bf69aadcdd603d3dae0fd3a4194c2151bb94f7b51e90d1abc5ca0c81d446ea5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/capacity-without-scratch.consumer.lean", + "mode": "100644", + "gitBlob": "482507db97b824eb46600deeefd326d8c2f508e2", + "rawBytes": 25546, + "rawSHA256": "4854d99d124b5b7ab5e0c07ab4448499c8ff6e1a5d3cba3b3ccd02797b1f0872" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/delete-accessCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "4e700258a22c22b183c3c94899b83b06f35ab634", + "rawBytes": 11313, + "rawSHA256": "e107cdba1fd835c7cd236aa6ee5cb28b632b4bc79821a5607b4ae0070d24d0a9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/delete-accessCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "8e79188fde15e57d13709c5294cf6acb87b65d98", + "rawBytes": 24688, + "rawSHA256": "623c809616b6935f1ab462afe46940f9def46bcfb105d4efc002b4b05530a930" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/harmless-comment.constructor.lean", + "mode": "100644", + "gitBlob": "2d9c01574473366581c1683657f4c2e3e002d0c4", + "rawBytes": 11638, + "rawSHA256": "b98a0874f9314eec8601ea885726d66f17847062a29f444f2f92309152b1e937" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/harmless-comment.consumer.lean", + "mode": "100644", + "gitBlob": "ffe24e322ebf7452d2b8b403ad483a38e185ea84", + "rawBytes": 25013, + "rawSHA256": "6b4d647b5cc0fb377cb4f2aca1de30ab1bb0d84e1c810ac5e1f8f3de42a1aba8" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/public-proposition-True.constructor.lean", + "mode": "100644", + "gitBlob": "6b97ac13a445ceeade28acd38230c89f8d8cf13f", + "rawBytes": 8464, + "rawSHA256": "c0795054b92747d206166b629dcb8ad43a25c0bab8a289f8bd6fba2ebb959f4e" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/public-proposition-True.consumer.lean", + "mode": "100644", + "gitBlob": "131a1e6f871572821ae2bdbfe571ec171b0eabae", + "rawBytes": 21839, + "rawSHA256": "5fe7e7c2cd8f5ef82956b103c12cf1b1a28f88e43974bea4afe13e88f3ca0d61" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/sibling-completeCapacity.constructor.lean", + "mode": "100644", + "gitBlob": "dc30237ad3df8354203d66859211dc92e3879dc3", + "rawBytes": 12334, + "rawSHA256": "d7a40fd7f8cca01ddab064d1258459145cdb263207ccab7e003a62463ed07438" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/sibling-completeCapacity.consumer.lean", + "mode": "100644", + "gitBlob": "36d0c84fc9d182e1b40f26dbaef522110b47a66d", + "rawBytes": 25709, + "rawSHA256": "b515c27bbc7c7445e64563c2e91c476813186742fbcbef4b0c40f6de9d7cc29f" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/sibling-readerCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "72172a15eda02c88eda38acda10de449f7163560", + "rawBytes": 11090, + "rawSHA256": "d5a0136709d05ae4dd09bf7033b1691370225221997dfa87f144f0bfb7c29236" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/sibling-readerCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "007a00bdd8503f1b9271a62399cea60532a4599f", + "rawBytes": 24465, + "rawSHA256": "5c359574d244e725dee232e852c94516ea06ae455fb8c2659aa053789bf9b565" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/sibling-selectSafety.constructor.lean", + "mode": "100644", + "gitBlob": "673be9ec6c646a824895efc99fc03a5ae01fca6d", + "rawBytes": 11615, + "rawSHA256": "c25b0530845c1b02f0a01bae596d5b7a8dfed8af5337f9f8ac33664d8f1ea66a" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/sibling-selectSafety.consumer.lean", + "mode": "100644", + "gitBlob": "11ee0e684491a3ea02ed557cf5b89be41117daa7", + "rawBytes": 24990, + "rawSHA256": "35924fbc0c83e6a97b0825490d9c97bbd650318ca84de27c928c55d18d539e3a" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/unchanged.constructor.lean", + "mode": "100644", + "gitBlob": "c52bf5ddd24b34224533f8090b12de44bab236fc", + "rawBytes": 11567, + "rawSHA256": "051e5472bb3aa2f8f22b6a1c392e68ef2cce2f0744f2f1657b58cc45f18eafae" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/unchanged.consumer.lean", + "mode": "100644", + "gitBlob": "8d0d2b8d1b0f69a6f6b0868a2075736a8ae49dbd", + "rawBytes": 24942, + "rawSHA256": "07320bba0dbfce2862cf737ca2549371e50c85ed31062c2c73740ef03bec8b32" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-accessCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "78098a5fe2d36fa36702a5423d4dbcbd4169ec38", + "rawBytes": 11502, + "rawSHA256": "ba8855f6a16ef8f8ae7216da53aae1c2f5f4a68571c98f9e8b0b31c816c1bf64" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-accessCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "6260bc3868c380f7cea8d5f87ab0e2fe6ed73f84", + "rawBytes": 24877, + "rawSHA256": "10e69147fb2a58ba4a63a6a949ebd72050866172d53f2227dba829723670c7c4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-accessExecution.constructor.lean", + "mode": "100644", + "gitBlob": "c052a7f899a4aeb9753df979bb0f1510cdcd92a5", + "rawBytes": 11122, + "rawSHA256": "6582d802f511e7636f238db3f91f51834625f31875d68d97480eb41b724da79d" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-accessExecution.consumer.lean", + "mode": "100644", + "gitBlob": "e2d88a57d841a00ea4979d84ba021b048b18b598", + "rawBytes": 24497, + "rawSHA256": "6c3a572fee66f47158c9564bffc4734fb1d6cfee8ebd4ffbd071ad73ec2a58d9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-accessSafety.constructor.lean", + "mode": "100644", + "gitBlob": "b002788a5f9881c404fe347d129bb3c0b260b6f9", + "rawBytes": 11293, + "rawSHA256": "e91610f2212f81f1a3d09fe4727ca187cc24239ef1bb56565a39357a2b4de554" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-accessSafety.consumer.lean", + "mode": "100644", + "gitBlob": "9078c5ddd5fb92b54955869232c3c7e80ff1f340", + "rawBytes": 24668, + "rawSHA256": "34c2327113e1356622de8ab2dff3cf42326ef2528a3bd40cd38fb74f93ad1c37" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-categoryBounds.constructor.lean", + "mode": "100644", + "gitBlob": "ba144a6d9753d0979c18d17c0d8b7ce3781f5724", + "rawBytes": 11352, + "rawSHA256": "6949e46511d90a5f2f4becf310e5016b1e98a3b6b1bd7d67e349b86eb127f66a" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-categoryBounds.consumer.lean", + "mode": "100644", + "gitBlob": "681a3f1ed6166242e01fb1dfcd7d64462d841cdf", + "rawBytes": 24727, + "rawSHA256": "0609f1c9021faf43b3bc5a9a02e45d3ccf950b42c03a8476e249420fc0790aa4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-categoryPartition.constructor.lean", + "mode": "100644", + "gitBlob": "f5efbf2b0597a46fb9bbafd0255847f6e45fae34", + "rawBytes": 11186, + "rawSHA256": "7c19221f37f3fd07387c8999b5fd1d1ee683955f983c248951f489e5f3a9ea9b" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-categoryPartition.consumer.lean", + "mode": "100644", + "gitBlob": "72ab8829e9529368a519d793a0518fefdea10ebb", + "rawBytes": 24561, + "rawSHA256": "aa1e55e48f0a618c1b96dab1937a0dd24f3005e51f163ab3d3227ed2afef0eb5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-completeCapacity.constructor.lean", + "mode": "100644", + "gitBlob": "25bb9b1c3dbae9bc3ffea1f8e9faf5c0fbf544de", + "rawBytes": 11203, + "rawSHA256": "f17a26d72b7c0a9a9ca79a0e9d99879c56ff0739cd5f5780349d77c7acaeb4d9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-completeCapacity.consumer.lean", + "mode": "100644", + "gitBlob": "9c5eeae1da9a3b5a2fcd71e2fcb4833e56e32d3b", + "rawBytes": 24578, + "rawSHA256": "0d5c916242818400e43f59a1f7a59e415e84e9fcfbb57b36b83b9c9d9b2042c5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-finiteScratch.constructor.lean", + "mode": "100644", + "gitBlob": "4f3f765f217b3089983f6f411b53c65daa088855", + "rawBytes": 11359, + "rawSHA256": "1132be4d82415b8e0eded57f266a11bf296a081fecdf96b06f2cd587d5e69193" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-finiteScratch.consumer.lean", + "mode": "100644", + "gitBlob": "564ab30914cc3d7e7c2fbd6216c4966325366c6f", + "rawBytes": 24734, + "rawSHA256": "6430d5ee21f8f5b04dd6c427cf2c23ce2765c9f2474198d1a044344999e80875" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-memoryWordsFit.constructor.lean", + "mode": "100644", + "gitBlob": "fe027f44908da00299a0851bdb6afd0c1af4fe80", + "rawBytes": 11438, + "rawSHA256": "4309d769aa3b95540ab4bee346ca264a51fb0e5b8e1b2e650a6048c3305d6728" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-memoryWordsFit.consumer.lean", + "mode": "100644", + "gitBlob": "635611625f4ed77ae6c3dbcb36246da1a16ad365", + "rawBytes": 24813, + "rawSHA256": "86f30a1e37ea8e53aae7cac29b5d2c1a5142e30d62f79ebcaec9047807870d27" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-overheadLittleO.constructor.lean", + "mode": "100644", + "gitBlob": "fc06d1549b41e7801096c034b7b03ce0791b0266", + "rawBytes": 11537, + "rawSHA256": "35ed2361481ce3409f0f0200eb6b41d894b409db8c1191325ba8bb1805eef4a4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-overheadLittleO.consumer.lean", + "mode": "100644", + "gitBlob": "b30b8465e7cbb1caf91ce4469b1f549a1165b19d", + "rawBytes": 24912, + "rawSHA256": "f28b855d9ae3a3792462f4199eedc6f164286479dd168cc6d790a952a1403937" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-programLengths.constructor.lean", + "mode": "100644", + "gitBlob": "2104f1c20ad96331c8b02f2897a228d4e032a8d2", + "rawBytes": 11394, + "rawSHA256": "73edd80d3493862acfaac033c720f70de216e2984c6e274b0fac5e12444268c1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-programLengths.consumer.lean", + "mode": "100644", + "gitBlob": "f058f1a487c1e897b8eab2a1141ff31d1bb2448f", + "rawBytes": 24769, + "rawSHA256": "2d2efb3ed01ba27749498a2a29208a7792a699f5988e3d2e009465da6dc8eb6e" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-rankCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "19a50698edc8b37de94f43771b41f3e34fc6449d", + "rawBytes": 11397, + "rawSHA256": "0b5ec9d0fdb6b003fa4a5e5129cb38abf77e8fef64717b0768f0d24c6b2e69ab" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-rankCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "6c05d2c293cdebd77eb0a8ec8cf8cded9e08448d", + "rawBytes": 24772, + "rawSHA256": "c918e25b84c82860f2f9a69ad33e27ba11981ce7e9ab7302e0c4300da9ee0a46" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-rankExecution.constructor.lean", + "mode": "100644", + "gitBlob": "b8d6416c2e9835e4df68f8ef82df4eacec4d6c86", + "rawBytes": 11096, + "rawSHA256": "929124cb2d24a019614a6951e0f651f4ac8d88e1477e4f76d66a39835ef2602e" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-rankExecution.consumer.lean", + "mode": "100644", + "gitBlob": "24d05da2a5ff95a47a4b96cb178d8c3a020b8692", + "rawBytes": 24471, + "rawSHA256": "a18e055613be6b35aef2d73124a3939a5e763a18f15685354751b7256e28b43e" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-rankSafety.constructor.lean", + "mode": "100644", + "gitBlob": "99ec78f302d6ecde363464abcaf78d33ff00be5e", + "rawBytes": 11284, + "rawSHA256": "b4cf3ea1e6c9e9665495e8efc3725c0d4828879242a0b4b0ae0dcc7b92ca1623" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-rankSafety.consumer.lean", + "mode": "100644", + "gitBlob": "9a1772c02264836346f77c58ae9959d6e6bbfca3", + "rawBytes": 24659, + "rawSHA256": "04e66eb52c517f09cb1b68152553c8d907edf348cc110931e1e78bc9b1cb7c21" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-readerCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "1773ba48f0938a26591f3d7147c7e131264b6e95", + "rawBytes": 10894, + "rawSHA256": "ef9fd42a99bc7fc9e30ec36860547697fd1066dceb5b2c8f037df9c84c8e6442" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-readerCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "397f570cee1e92a37e8d04aeb7daeb2c92b77cc0", + "rawBytes": 24269, + "rawSHA256": "8fb7ab2dd365b1a2cf50ec646e9b8b20f254d16607ff8a82eb12ab46af2cdc5c" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-readerGeometry.constructor.lean", + "mode": "100644", + "gitBlob": "aa377eb52f10c53a2f0eb8298e387c97ad5edd1d", + "rawBytes": 11268, + "rawSHA256": "a17c94536127915c823b65826c136acee50c7f09a8d67698604105b894496f22" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-readerGeometry.consumer.lean", + "mode": "100644", + "gitBlob": "33158e890193ce150c1ed68bc04f9fc554f251a4", + "rawBytes": 24643, + "rawSHA256": "ffe06e2491a7d86fcd28e5951c5697231f90a7da7b4d8518da94bed1ac72e13a" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-selectCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "4ebb063d892d661bf6b09251c6f114f4d6d3ad33", + "rawBytes": 11439, + "rawSHA256": "c1aa1b79b631ea5943cdc4736c179b4e6041ccc574be7f88e0917bf942511bc2" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-selectCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "e1c435b99150b16a82309ca14254682ebc8ddd75", + "rawBytes": 24814, + "rawSHA256": "10846343307642cec627ed4c9fea917f1112f358086579ded3353708a23eef84" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-selectExecution.constructor.lean", + "mode": "100644", + "gitBlob": "6fb95585bd9b74b8fc4f2145c990410a36794d8b", + "rawBytes": 11066, + "rawSHA256": "2cb005b1d063b78c95aee13e431f352156ee44f3f7ac08a49190253c04eeab88" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-selectExecution.consumer.lean", + "mode": "100644", + "gitBlob": "60b71251d4195a13c0398eec4879bd6af7ebdbc2", + "rawBytes": 24441, + "rawSHA256": "5f0ef38fcc7fbf843612b39e0948429dea7d76b34c01e5b26d426d75b4f9800e" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-selectSafety.constructor.lean", + "mode": "100644", + "gitBlob": "05af4d81ac49a623222512a79db8024e135481df", + "rawBytes": 11276, + "rawSHA256": "9ac67af9f57d88e5be80a609f61a630ce67522ca0e3aeea9453d7f51bf36a3af" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-selectSafety.consumer.lean", + "mode": "100644", + "gitBlob": "5f6ac7d185f402c0e4c940c5869b5015e30d9fa8", + "rawBytes": 24651, + "rawSHA256": "886ce818099f531c25b1d7d59da8e82e04027d0731048948d6fdb2c4d5ceb2e8" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-sourceBudgets.constructor.lean", + "mode": "100644", + "gitBlob": "1c09abeea72531de4a339f2809c62ec6d7598423", + "rawBytes": 11394, + "rawSHA256": "826d9211d0ae37384d09e5c931341577b3dc2e23a091ca10e049505df9ea7a74" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-sourceBudgets.consumer.lean", + "mode": "100644", + "gitBlob": "1a212c7045ae7378a85cfcbad1470ed6ebeccc01", + "rawBytes": 24769, + "rawSHA256": "3b1b57a79fa8ae065aab959b78864bf2617d8ed74079bc96a53bc2ee7425319e" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-stepsBound.constructor.lean", + "mode": "100644", + "gitBlob": "afcb0b556d8fe5126db2bc1a3d56e5c870f429a4", + "rawBytes": 11400, + "rawSHA256": "d9f4b4c9791037a3c5760b743ce3c4606e126b59fc63c5ee47e37513f55e5f73" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-stepsBound.consumer.lean", + "mode": "100644", + "gitBlob": "8fa556cdee818cfbaa122c151d5e5f79edfb3d33", + "rawBytes": 24775, + "rawSHA256": "16421cda6cb337fdba04de4727cf19744dcbd5350246ebfe32761517cafba63e" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-suppliedMemoryAgreement.constructor.lean", + "mode": "100644", + "gitBlob": "e7043541fa1e13a9a757c268e68311d4cabf16a8", + "rawBytes": 11152, + "rawSHA256": "61bfa2e0e489d2bab4a64d155b1f0b224388e1578ec7dec01a59509b636858da" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-suppliedMemoryAgreement.consumer.lean", + "mode": "100644", + "gitBlob": "8d2d4db56cf811f71d517122d76dafb9c4e99178", + "rawBytes": 24527, + "rawSHA256": "813cfdf046c30c83fa2506747be016de1e9699760bfa3b76a3f2fe40a7e85767" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-validArgumentFits.constructor.lean", + "mode": "100644", + "gitBlob": "3478c531356f46808333b9a545e7e2b14aada19e", + "rawBytes": 11486, + "rawSHA256": "4e70b1e0541ecd469f9fd28e4d4a0ff9bbc1712d9960000701745ea7daa89e65" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-validArgumentFits.consumer.lean", + "mode": "100644", + "gitBlob": "b02eea3df85b222cf7dbbb7bb7f5b21f48672a0f", + "rawBytes": 24861, + "rawSHA256": "7816db0f5b2be3b00746de43af9de3a2894dc0118176c9d5479834172b5b91a8" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-widthBounds.constructor.lean", + "mode": "100644", + "gitBlob": "9d1e010b095eb94779ad664881baad06a0d557a7", + "rawBytes": 11448, + "rawSHA256": "8c77d786737fad5efd287ad46b889bc72cfe6a2d74b6a4be2bdd0098aadc9fb3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A/weaken-widthBounds.consumer.lean", + "mode": "100644", + "gitBlob": "e4cbb00d512f907823054f15d3c75a2aa9665fcb", + "rawBytes": 24823, + "rawSHA256": "879657296dc3615a02661b33a7913920f6ef7e2befa199093d465f12bb377d41" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/capacity-without-code.constructor.lean", + "mode": "100644", + "gitBlob": "650fdb6c82509ea5f282ab3e79ebbcf4b0acfb81", + "rawBytes": 11904, + "rawSHA256": "7c09b74d503bf7f673a834d9b1cb2f092bba8a17b41f5160bee3c10679c1ac04" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/capacity-without-code.consumer.lean", + "mode": "100644", + "gitBlob": "62cf44bfb72b6240679b5af65035d4350574d056", + "rawBytes": 25279, + "rawSHA256": "7849671da72d77e6ecf49f4adec7cc0608cd4dc6f9054b9823fbfbd09715735f" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/capacity-without-scratch.constructor.lean", + "mode": "100644", + "gitBlob": "6ad1c635ee7e84334333ac773db46aa43f479cfa", + "rawBytes": 12246, + "rawSHA256": "904825c2c5a5f96040bffb84135d504a417174ef5d7a2d46b9691dc9f73b75eb" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/capacity-without-scratch.consumer.lean", + "mode": "100644", + "gitBlob": "ad28d7ff656ef44fef14c56fa7e1af99bc0fe399", + "rawBytes": 25621, + "rawSHA256": "b679c671e706c9f9f3fb042e9913c900a3388752186d28dd016962f343e411d1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/delete-accessCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "e49773659d34d7ad4e74a3a1c1428007e4d123fd", + "rawBytes": 11388, + "rawSHA256": "0f0406739ef1c369e2cfc38541a4fb51b22a4e3c6d0259e538061ac58a6ac3af" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/delete-accessCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "78fb908f580e744119e62135cbecb718aafcdada", + "rawBytes": 24763, + "rawSHA256": "0f0d99598825d9946b77913aa886e69c4648af272f46b90ebcfb0071e9f80a5a" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/harmless-comment.constructor.lean", + "mode": "100644", + "gitBlob": "c8f5f25dc5bec852f867009b448a28d435b7ffc5", + "rawBytes": 11713, + "rawSHA256": "a4ab5e4587bcd8f59fb11ceb44efb47be70c216bc864aad1794f8fc24fa96a87" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/harmless-comment.consumer.lean", + "mode": "100644", + "gitBlob": "857410a8f3cdec32c8ce203e2bf2bbbc347cd108", + "rawBytes": 25088, + "rawSHA256": "b4e84042625f412b9a5ec0ee94172ea685f43390fa7d1686cf171e198a31a874" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/public-proposition-True.constructor.lean", + "mode": "100644", + "gitBlob": "d8519f2571453cbc71d22b62508640e07d9cc8c3", + "rawBytes": 8539, + "rawSHA256": "32e8c382c78fade4ca06bf78228fe1b8a7e59d5f8d929c5f61b1f0dc81fcd3ef" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/public-proposition-True.consumer.lean", + "mode": "100644", + "gitBlob": "0356a311fbeb986e295b4ded1c2774c4d5b8f013", + "rawBytes": 21914, + "rawSHA256": "cc86c2519bc28f797afa57832a4a480de69d814ad747f4fa62df3bd72c34cf58" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/sibling-completeCapacity.constructor.lean", + "mode": "100644", + "gitBlob": "c3b2862d4ebd3844724a7c28054879154d84a895", + "rawBytes": 12409, + "rawSHA256": "e97fc11f28a067d0fc4ca0b2bfab0b68fe6889acd89fb08e589c25e523d45b3a" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/sibling-completeCapacity.consumer.lean", + "mode": "100644", + "gitBlob": "34ae8110584f219d4a4a0023f30c2659870d0e0f", + "rawBytes": 25784, + "rawSHA256": "277c6ffdc862520b9bd3c16d95622a727338363154530122e1464727b1f65606" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/sibling-readerCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "5b2c7a1ed3d2076ab2e767ef65cd35a4959c1ca3", + "rawBytes": 11165, + "rawSHA256": "2ad7e7c62d2346d57a9ecb9d415c67ed6d4c5bddc4236a840f193f2fb7d59bd1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/sibling-readerCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "3ee17763ed0a649ebf5a34d96423f2789f207c04", + "rawBytes": 24540, + "rawSHA256": "731b15131915cf739754c250405f1f897fbdce48cfd3d5c9853295ab9fd7290a" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/sibling-selectSafety.constructor.lean", + "mode": "100644", + "gitBlob": "20bc459a1e4fe32babb434e271c29b8b1eb260a3", + "rawBytes": 11690, + "rawSHA256": "1cc63491001f357b5c76799177a79c1aed57b3d7fd79cb18dfab80edf028b74d" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/sibling-selectSafety.consumer.lean", + "mode": "100644", + "gitBlob": "ea9b95634a17d299afd967f839cc264e347a8917", + "rawBytes": 25065, + "rawSHA256": "040bce96780fb16a9fe681ce8a5b9aec1cc099b467e1203e42b894a0f29a6b58" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/unchanged.constructor.lean", + "mode": "100644", + "gitBlob": "dcab715171e9e3414a8ecffe3a50e73ca1e16764", + "rawBytes": 11642, + "rawSHA256": "7f7b7ec00bfa68887243ad12b3d0d87147d37ec457e2025ae99359b8a47e2c12" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/unchanged.consumer.lean", + "mode": "100644", + "gitBlob": "98dbb8532c03342401e1f721014cdfda273ed5ed", + "rawBytes": 25017, + "rawSHA256": "bb8983ea0a13e5b50163522effd007f2af98e563c3d0681f2e0c3db941e9b6a3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-accessCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "beaf3608671da3dfc23f9d380bddde81536e1d8b", + "rawBytes": 11577, + "rawSHA256": "03446601c88a0f8d4ee1e69ec635ff62995f9a1efbc5923165783510b80fabae" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-accessCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "ef6779b38f15dac71abab7ee0475fec118fbccce", + "rawBytes": 24952, + "rawSHA256": "a9122ccf5714fd08d5dfcf813995dae0c2e37fffdcfdac078b8c6aaaef2d613d" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-accessExecution.constructor.lean", + "mode": "100644", + "gitBlob": "8235da8f7b07d293edb687f7fa030ef71a92ce67", + "rawBytes": 11197, + "rawSHA256": "4ebdb3f8fe1dd35d563fb0315380292bdc9bff48dee55dcc45e4fdeb0166ecce" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-accessExecution.consumer.lean", + "mode": "100644", + "gitBlob": "346dd1ee2b3a2c99f5ca720d538d7234ae8419bf", + "rawBytes": 24572, + "rawSHA256": "a6ec15e8bf0b17e4da01e968ce8f3df496f191fae3d207e89c9850ec9e3eade9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-accessSafety.constructor.lean", + "mode": "100644", + "gitBlob": "998cfd32c4124c6ed7c8168407ade71d1991577a", + "rawBytes": 11368, + "rawSHA256": "d4236db17f212d0bad7778440138fb61954163905fa0e2797e03d779c0ba1b1c" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-accessSafety.consumer.lean", + "mode": "100644", + "gitBlob": "492ac5bbf07883c7dd02b9aa48287387a278dda2", + "rawBytes": 24743, + "rawSHA256": "47fc99ad80104b2a3aae5da7bc471e85f81eb884d7a91a7830f5caaeda0497c6" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-categoryBounds.constructor.lean", + "mode": "100644", + "gitBlob": "7e6882c326deec45a4af0db4d2722dc06f0da0dc", + "rawBytes": 11427, + "rawSHA256": "f09305959c7be02eb358d1df577f7f0df2b59e776ad41fbe1283b98643759781" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-categoryBounds.consumer.lean", + "mode": "100644", + "gitBlob": "50479bc32abab4ab0835b12dd138dd73e807ce73", + "rawBytes": 24802, + "rawSHA256": "a996c5da62acb6f95bef10b5e950ab6fc2a9123fdc6effa15a4c63851130bb48" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-categoryPartition.constructor.lean", + "mode": "100644", + "gitBlob": "b6096adffc84868b405f490f194a6db792e67445", + "rawBytes": 11261, + "rawSHA256": "01e8dcd4f40fb210dc78bd3b2ccceb8ba08252f82e27b02ba22407da8438f41b" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-categoryPartition.consumer.lean", + "mode": "100644", + "gitBlob": "04f593d2be17f2a5c21edc3c632ae198ee8c717f", + "rawBytes": 24636, + "rawSHA256": "38676dbaf807cfe09ef8b6474dc67ea5fc560521e8944f6d828096e964ea4eb0" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-completeCapacity.constructor.lean", + "mode": "100644", + "gitBlob": "27e9711bc8ca5714d0660c53ff975aab177b6822", + "rawBytes": 11278, + "rawSHA256": "c2cc22b5a53391cf69c3d68bde36b8b9a096cf9e88b57cd91b81fc5e80fdd661" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-completeCapacity.consumer.lean", + "mode": "100644", + "gitBlob": "b2ddea77b83e66663e6ef573bb4a515543040361", + "rawBytes": 24653, + "rawSHA256": "ff5f485929e3aef036422e1ce658c7febdfeb59d2dfd24d91bf43d917fd994e4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-finiteScratch.constructor.lean", + "mode": "100644", + "gitBlob": "a6cb7603dd41057f96f5013083ab7c61f0d40d0c", + "rawBytes": 11434, + "rawSHA256": "d21a76992f4ee54f58aea7b9e6332b44268f1e4349f682918eefd57191f5a080" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-finiteScratch.consumer.lean", + "mode": "100644", + "gitBlob": "29a038946035f29e94c39afc9a6032dcbe569bc4", + "rawBytes": 24809, + "rawSHA256": "f6532543b8b0444dcb13f6acb46ed30e05d83ecfa0bfa56953079e9d848e88c1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-memoryWordsFit.constructor.lean", + "mode": "100644", + "gitBlob": "9afb789d8902e7d054dcfc212ccb0771e92ad479", + "rawBytes": 11513, + "rawSHA256": "328063870767754d95ee7b2192d4263ae37335289c5a90c81f413e3e0f8fa99c" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-memoryWordsFit.consumer.lean", + "mode": "100644", + "gitBlob": "ee77b1673b18cc6b41bf1f2a892d0d3c2d03572e", + "rawBytes": 24888, + "rawSHA256": "e4c525aa498bf0f609182ba82d0d4aaf661b4ef2a79cbf929d286a96b45c101d" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-overheadLittleO.constructor.lean", + "mode": "100644", + "gitBlob": "26546cd85a407f868198cabf6a3ae1b7fdec200b", + "rawBytes": 11612, + "rawSHA256": "dfb67100f9e512f9eaa7270d650949491193cce5d504aeba5e54dc46aa9c5d95" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-overheadLittleO.consumer.lean", + "mode": "100644", + "gitBlob": "1a1ca7c7ace49beed6c79b5046486e4cbf73ee19", + "rawBytes": 24987, + "rawSHA256": "8517d6b5f604e384ac9ce2ff68908c028a06df5ba0174f40a0879f663965f405" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-programLengths.constructor.lean", + "mode": "100644", + "gitBlob": "b9446ad827a93f33a9c14387e01227019ea2c657", + "rawBytes": 11469, + "rawSHA256": "284691291d50277eb8ab79f917cdf6691939cd5e2940d1bc61756db3acff8f61" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-programLengths.consumer.lean", + "mode": "100644", + "gitBlob": "3f70eb7c86a344a8707d6d407696d8a53ba36aba", + "rawBytes": 24844, + "rawSHA256": "f02584e3b4fde6e7f8d0be7c11240e2dacc8436ea627f4fcc2f45b8da57e4a27" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-rankCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "fe16fad50765acdd31e3cdb83cf7a2040a99cafe", + "rawBytes": 11472, + "rawSHA256": "04c3f219060f67b66423ab9cc9a73dc0f114521655187419f1c865d4fa559446" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-rankCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "0f3e16210a2c6254b768ba4a79059a21df72dac7", + "rawBytes": 24847, + "rawSHA256": "7bd0479e0fe44fc476753fd1578c27c25c7b4286dd5bb2e87d0bd3ba2137d537" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-rankExecution.constructor.lean", + "mode": "100644", + "gitBlob": "9c70a510ee7ec140d37d62c1b6359a8ca4fcba30", + "rawBytes": 11171, + "rawSHA256": "483f2074d1abe6a72364afb6654300a0d2ae7038363bc46a440865adc004f9d9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-rankExecution.consumer.lean", + "mode": "100644", + "gitBlob": "8901dcaa2cb240f140c04c8dba1f454d696a39a7", + "rawBytes": 24546, + "rawSHA256": "fdac29abbf3a0dee84eb673bfc9cce83049c0147d619d92b10d288abd94e65bf" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-rankSafety.constructor.lean", + "mode": "100644", + "gitBlob": "e23ac973c2e54860595b2a1fdbe730c64ef2d2f8", + "rawBytes": 11359, + "rawSHA256": "fa0e57b48ffc2b3ee1aa02ebbafad39a81fdc6add2d8899b831ae05d41291654" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-rankSafety.consumer.lean", + "mode": "100644", + "gitBlob": "ebbd07e33170a896440bf6e3dd9e941b4405e3ae", + "rawBytes": 24734, + "rawSHA256": "edf9308c83eb831ec444c5e8393f263e845396d583715692f6f43030aa13fd95" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-readerCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "b9d2dfe94a0bcda7c117c2faa943168f6135b09a", + "rawBytes": 10969, + "rawSHA256": "70f29691a7a81238d8287ad1204cb42580b3bde1def21c11b43bbcec91769d21" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-readerCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "4640a5dcf616d71cb3451bf7d1d74fdfdf88e722", + "rawBytes": 24344, + "rawSHA256": "a686e61143d39e595c3544b523fa06086acc6e5b5d0623096b90b9989853c522" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-readerGeometry.constructor.lean", + "mode": "100644", + "gitBlob": "4010f6f99838441aa26d04f245f1ceeedec2a5f3", + "rawBytes": 11343, + "rawSHA256": "7ec5d47eb0c8d6260fd30ecf2f2791333caade175e7283c52008da24a5986663" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-readerGeometry.consumer.lean", + "mode": "100644", + "gitBlob": "fb8df43159baba23b466d17cef00d5720ba6e093", + "rawBytes": 24718, + "rawSHA256": "9ef134d70a370c8f5e6c63cf239a3621af529d6e4ec2d0488db8518b0f73ed55" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-selectCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "58cbdb875cae56c3fe638e7d25f5b7ee6e0fc908", + "rawBytes": 11514, + "rawSHA256": "129467d512207044d15388ae05fc3cc0edafa81b50ec98c071924aebdf1c0adb" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-selectCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "bfdf5c998a503ceff1cd9b877e7457fcfb0ea9a9", + "rawBytes": 24889, + "rawSHA256": "0131fd5b04e6194df51fa1e04c447254ac43698761b7c4a563635de8c0afbe04" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-selectExecution.constructor.lean", + "mode": "100644", + "gitBlob": "6aadeb5a8414a87b5a0da931ed31b625f64a4d44", + "rawBytes": 11141, + "rawSHA256": "256145addfcb7a2b746c28d61f2001aa200cb7f1bff24eb21c8a22762d5d001d" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-selectExecution.consumer.lean", + "mode": "100644", + "gitBlob": "0f3498f5646f136b78f52bcf79462e014b8a3053", + "rawBytes": 24516, + "rawSHA256": "6c6dfac4d59c02176f2883c103261edb0a549ea3b2bd460918ccacd2bdac6626" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-selectSafety.constructor.lean", + "mode": "100644", + "gitBlob": "cba231e230c468700f5016166a1e9a7f5b09c040", + "rawBytes": 11351, + "rawSHA256": "1a2e66c5af4ad393cccad4e9c087c51410c9785ddfcb25f2b36d382157ba3f91" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-selectSafety.consumer.lean", + "mode": "100644", + "gitBlob": "e65cd6d0aa3dbbf3be13c0c3c827e5260a3e229a", + "rawBytes": 24726, + "rawSHA256": "31d27bd8c8b62f39b4bbf24445e0869a71a9eea01a07e8dd032106f4dcacc1bd" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-sourceBudgets.constructor.lean", + "mode": "100644", + "gitBlob": "0ac22a00b23fe5f123bf1908ac24872c64df17a5", + "rawBytes": 11469, + "rawSHA256": "c0abbb5591ba2198028dfc2c3306b78eba3bb50b0c35957df850a87eed198a9d" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-sourceBudgets.consumer.lean", + "mode": "100644", + "gitBlob": "8ebcf380ba46fdfa2383d950a44113a2e47c05be", + "rawBytes": 24844, + "rawSHA256": "637aabf5e10408764016d9d972cbdd3f74d2a56a9a96c932b0d80d717495dc32" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-stepsBound.constructor.lean", + "mode": "100644", + "gitBlob": "7a19a9b09769e13388889e85b7f8b9e4d8987d71", + "rawBytes": 11475, + "rawSHA256": "9cae3c200b773ea6a3a9e6df07b1e1678c3536c365fc90ac504f5441e65d1e70" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-stepsBound.consumer.lean", + "mode": "100644", + "gitBlob": "e9d39d29a3aefc9dcc09e6fdaf917c05863dd3d2", + "rawBytes": 24850, + "rawSHA256": "a8041a49032744e7aad19a522bdb826264bce7129e7002b912cdaeb99e9578e1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-suppliedMemoryAgreement.constructor.lean", + "mode": "100644", + "gitBlob": "caba8e0eecda659baf87bae8ebd28f7c4d758488", + "rawBytes": 11227, + "rawSHA256": "3b57be9502209f2e102938c3914b8e6e2071c78d7803eeaec6a9f1d181aa665b" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-suppliedMemoryAgreement.consumer.lean", + "mode": "100644", + "gitBlob": "eea90d0e57135df9c25ecfa3029804155f9f9fa5", + "rawBytes": 24602, + "rawSHA256": "3ec6f253e26664ab9bd7542514ecd75ae2c63250f483b940d6e36d2091bf4824" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-validArgumentFits.constructor.lean", + "mode": "100644", + "gitBlob": "98bacbd30fcd7a17be2d69a55eefac4ff1ef90b3", + "rawBytes": 11561, + "rawSHA256": "6312c19e40daeecb8166e82f6d609f0d0f94a04f5cfdf7fb5aaae129500b2c44" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-validArgumentFits.consumer.lean", + "mode": "100644", + "gitBlob": "e06e4a8830a652e59876dda41f17c79df29b332a", + "rawBytes": 24936, + "rawSHA256": "472f158ce31d7c0f1aa63e1f00506005e19ebd11e2651b1f2cb311bb61a5fd91" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-widthBounds.constructor.lean", + "mode": "100644", + "gitBlob": "15dfa1443eef6538c14e53f3f66b2dfc3c618d17", + "rawBytes": 11523, + "rawSHA256": "7a76e88c776843c55677298b903b0cb051580d56eef772981987a4f47ffc778c" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821/weaken-widthBounds.consumer.lean", + "mode": "100644", + "gitBlob": "97414c714081d0c1d549dc34881a8290a14c427e", + "rawBytes": 24898, + "rawSHA256": "3b2dfff51a9959f39c12f25c50b6aab67f6ff74b721a70a28070468066808ec5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/capacity-without-code.constructor.lean", + "mode": "100644", + "gitBlob": "515b663f92b6833ae30a68ad22e6cef3f4d94015", + "rawBytes": 11823, + "rawSHA256": "b1498ed33ec8656803133ccc32f6560a3ef2d9a345e6f8c2fb70dddac670fec9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/capacity-without-code.consumer.lean", + "mode": "100644", + "gitBlob": "4f75bc2e2bcc97a81ca986573a5185219cb43a18", + "rawBytes": 25198, + "rawSHA256": "3c92a1a989eee049bb61a36cd138b6d834e622ea4706c96ea428cf955d3aca51" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/capacity-without-scratch.constructor.lean", + "mode": "100644", + "gitBlob": "b8645a5b221a47202280b0fdd4a1eef917426c2c", + "rawBytes": 12165, + "rawSHA256": "9bd68c775dd930400a88a320855be4d66c3a91daba162f8b556745f53061cb16" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/capacity-without-scratch.consumer.lean", + "mode": "100644", + "gitBlob": "79afbbe4e723e6f8835eff5fbbc2bbe23363be39", + "rawBytes": 25540, + "rawSHA256": "a3ab73e68543f636b03efcd85e345b43c0537ac0754ed0609f92d0a64f5ee9e1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/delete-accessCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "d501900856a222f63ebcef52caa1b431e77f7c79", + "rawBytes": 11307, + "rawSHA256": "d5a999cfdb2fea2598efc0999d10d15002d67b6d2090cf8ea1117cdf8beeb343" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/delete-accessCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "e3bd6e4aa10e552ba48943ebe7dbc952bffd1d5c", + "rawBytes": 24682, + "rawSHA256": "50ce522db5671b9da3fa9bceef71d38a05d4f2a8be41c9b5f7c182ce4329b25c" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/harmless-comment.constructor.lean", + "mode": "100644", + "gitBlob": "58dff7038e0ab087dca4a2bd0850ed8b4952f839", + "rawBytes": 11632, + "rawSHA256": "fec9e7c7ba1299c60e8d3eb6e3dcf06bb51029d9cf66509f2049cb4c55d900c9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/harmless-comment.consumer.lean", + "mode": "100644", + "gitBlob": "e51ed9b2437b8aad0e2fd1a5198ab6fffe32551e", + "rawBytes": 25007, + "rawSHA256": "2d37f54478ddbad26e5ea0132323739a6b5d33ca4ebacb4cd45ba920e468cdd3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/public-proposition-True.constructor.lean", + "mode": "100644", + "gitBlob": "5f70b6920e9c57f1c32e5b1f54e4183291133cd7", + "rawBytes": 8458, + "rawSHA256": "67676f9278028407c5d50e0b0db3858fd63526659468285912f27c09a29fd155" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/public-proposition-True.consumer.lean", + "mode": "100644", + "gitBlob": "b7da322ba2a93b49714f5fad9774268302e23c09", + "rawBytes": 21833, + "rawSHA256": "18c8d76bdf639fef1b55c052a30ca6beb80980a7b5aa9edee421c6c4ca47a62d" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/sibling-completeCapacity.constructor.lean", + "mode": "100644", + "gitBlob": "9a06c60f325da387900ad316512610689efaab74", + "rawBytes": 12328, + "rawSHA256": "12e410d3f19c1ba5288d506549f8ba4a1fd5142d4fe776db7fb11d1ed4fd3e40" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/sibling-completeCapacity.consumer.lean", + "mode": "100644", + "gitBlob": "2e14e749704d99bd1fef73396b2674b4d49e337a", + "rawBytes": 25703, + "rawSHA256": "e3619a833e72a70b5030d0043b4e4963dafbaf78d40bc3690195d56bb8de7bfc" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/sibling-readerCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "da2b175bfb46284ad94bf79785737b4ac171189b", + "rawBytes": 11084, + "rawSHA256": "61d16c948ddbb3825ba19c7f780af94c108aea700cf4330548ec2bb5953ebaab" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/sibling-readerCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "eb574d4c9080473160a7d868b2c2885df6c804b4", + "rawBytes": 24459, + "rawSHA256": "9ac0fe972cfe6825f48781b502086434f421da86255aaa04fc978bbcf2efeced" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/sibling-selectSafety.constructor.lean", + "mode": "100644", + "gitBlob": "d4e0416fbd11df6deac3aefeb7e0599c1f2c2e3b", + "rawBytes": 11609, + "rawSHA256": "feb06585e104da3c4b665b4af9b1baebe0642f39cd15ae472fddd0aad0f49809" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/sibling-selectSafety.consumer.lean", + "mode": "100644", + "gitBlob": "20cc96dea023dc04ec142900afac47eb277d401d", + "rawBytes": 24984, + "rawSHA256": "2ac4c251760bf877e382109d55996eaa1387881c3e4d6e90d0c7bcc8d5b65ec2" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/unchanged.constructor.lean", + "mode": "100644", + "gitBlob": "52e9cc5c2e2352a99b7d6a6345131f4734294d27", + "rawBytes": 11561, + "rawSHA256": "3e6163098f25f0a698a33a9e3cc9f5bf230a56451dd1570cc571d5df4510ed77" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/unchanged.consumer.lean", + "mode": "100644", + "gitBlob": "91924d7091871bf4773b0dc1d647090bfd291941", + "rawBytes": 24936, + "rawSHA256": "0214f8540456ad97cdd60a19431cb9ea14dd162370c2cd63902a4f916c6c868d" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-accessCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "09d9abd90fe91d005611ff27a1e2b65514466e5d", + "rawBytes": 11496, + "rawSHA256": "a91b8ec7bf919de89e97d36030aa10a45a1c260ece541520f20b0a6901b4a61f" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-accessCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "a96606fed7422fbc3e4d50bdea26ee9b15e48b08", + "rawBytes": 24871, + "rawSHA256": "3edade56cadb4067c7467710b3fd61ba5d2c6537e0fe414611f04057dc9850a4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-accessExecution.constructor.lean", + "mode": "100644", + "gitBlob": "72c4e00479ecd92130a70c869e55789f2505f824", + "rawBytes": 11116, + "rawSHA256": "8ca893fa74512aac3e84e6825524a1140a90198c09d8cd02242dd1bdda78a2bf" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-accessExecution.consumer.lean", + "mode": "100644", + "gitBlob": "3922ba3699912d7a69def89eed1673f3b8754b26", + "rawBytes": 24491, + "rawSHA256": "d5c5545945ab8540bb5f05b72634c3be1b30b8c05e339d2fa8ac55327b127c53" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-accessSafety.constructor.lean", + "mode": "100644", + "gitBlob": "5910a7d5bccef71fc0072355a0de5d7679f12256", + "rawBytes": 11287, + "rawSHA256": "ac2f6b6ff76ffd51b8b37f2b738aca1049b78f07c4e1c10b38dd2a6380c7e33e" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-accessSafety.consumer.lean", + "mode": "100644", + "gitBlob": "dc63eec5ea441834743bd378b6b29de423f09332", + "rawBytes": 24662, + "rawSHA256": "a1556436823bb967ce0cf5a30cb1ac530c542f323dd9c3cd7287d25a111dc3d1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-categoryBounds.constructor.lean", + "mode": "100644", + "gitBlob": "69cf1c5ae32e10a36068750f9b28bf33e5510b46", + "rawBytes": 11346, + "rawSHA256": "c869fa9c5559f6365bf73b2d6b2ad3c0395be79e8d6cad015fa3913829e63dc3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-categoryBounds.consumer.lean", + "mode": "100644", + "gitBlob": "c26e9bb04c357988cae6d711599c7a50eb0629d3", + "rawBytes": 24721, + "rawSHA256": "dd1c80fb12a567c40177bb26ac88aaa7159864d45c565e5a5792f79816d1b37c" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-categoryPartition.constructor.lean", + "mode": "100644", + "gitBlob": "17b66c31de1454102ca74d7748d1f811b1000024", + "rawBytes": 11180, + "rawSHA256": "4bc1e2e56bd83331c1f0073e805fb1ed9f4f68e9e52eb590a72ebcb6afebc691" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-categoryPartition.consumer.lean", + "mode": "100644", + "gitBlob": "f4e3b77596a7e1cdfc688c386331c1f39c59bb41", + "rawBytes": 24555, + "rawSHA256": "05b77e9a4682110852e02330eae35008f33689ffab0c95e1c57f379b91ce9aab" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-completeCapacity.constructor.lean", + "mode": "100644", + "gitBlob": "b8aadd31b47e8d6076b0364d4c3eda127ff9d0b6", + "rawBytes": 11197, + "rawSHA256": "a2a79b31028dcbaa990c354ccb6eac4f15e69c015776fa99f5133f09fc120108" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-completeCapacity.consumer.lean", + "mode": "100644", + "gitBlob": "a958edb1b1c58a406fc707c89b413b3ef14438a2", + "rawBytes": 24572, + "rawSHA256": "7974feabd9c67765dc3d10ac6c4aa507645268b47647f42e757bbe167151c25c" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-finiteScratch.constructor.lean", + "mode": "100644", + "gitBlob": "f8754e09c77cbd961e6647b68883b874cc477bb3", + "rawBytes": 11353, + "rawSHA256": "9a14f8d9ba315a63e2794cd9acc62066b09a8cd6ec24f3b4e538f6b352029f66" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-finiteScratch.consumer.lean", + "mode": "100644", + "gitBlob": "3a80ce4867e71c9fabfb518d1c35fe14279e627c", + "rawBytes": 24728, + "rawSHA256": "342682daf21a7c0b94a4e59041084960e09b16110b094c295f3be1d7891777b4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-memoryWordsFit.constructor.lean", + "mode": "100644", + "gitBlob": "97ad82add7d98c3c519596eef8974cf37457e800", + "rawBytes": 11432, + "rawSHA256": "c1d3730d6aac0a1128c823821f17a4a7bce6b20bd88b4785789f9eb232933c1f" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-memoryWordsFit.consumer.lean", + "mode": "100644", + "gitBlob": "20a252518297f672231818d4a3b2e2091857bbc6", + "rawBytes": 24807, + "rawSHA256": "0e1fa937e9d1bf2739ab2be64f15ee0477e0d1f6c578d7cc0e2df5a6b08d42b2" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-overheadLittleO.constructor.lean", + "mode": "100644", + "gitBlob": "691fa976294e420a64b79067318cbdb0c41c5bc5", + "rawBytes": 11531, + "rawSHA256": "c9ca06d84ea8ad65b10c87ec9c2285c70efdab2ea33dad354195e972bc237142" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-overheadLittleO.consumer.lean", + "mode": "100644", + "gitBlob": "507011bfe03ecc82a30739cff384055de9a7782f", + "rawBytes": 24906, + "rawSHA256": "fb1f0ef5acc97b9db6e08b3b39759b2ee0adbd358748ab803bc1e2535cf6fd12" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-programLengths.constructor.lean", + "mode": "100644", + "gitBlob": "55f896818bd82e2d345322f952559ea8b7d33ff9", + "rawBytes": 11388, + "rawSHA256": "0c61e1d4cb45c8147d736b11c33fbd4703fd266af833429d31a3e1f5b5c210a3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-programLengths.consumer.lean", + "mode": "100644", + "gitBlob": "e37318ec4320bd485584a6ba58ef1d35aa663455", + "rawBytes": 24763, + "rawSHA256": "301a49ec9ad804e7dc9e2d3aa2d782f93ecdc30901147da5db42cfe2dcd274d2" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-rankCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "2dc827fe66b158f8ba609fa0b55aceca720dec37", + "rawBytes": 11391, + "rawSHA256": "5e5852b5b5216e9762bf204c9be8bc0f43ced3e9610247665d4f9ecbb081952b" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-rankCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "f557ce56dcaff8f3a35a4ab40fa70fc555a18810", + "rawBytes": 24766, + "rawSHA256": "5060ae513318ac89bba83bac95e4d3d3b62b38388dbe04df4be0a95c7f96bae5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-rankExecution.constructor.lean", + "mode": "100644", + "gitBlob": "f295d8dda841f4f11f8bf1c09c382dc1b58b2d70", + "rawBytes": 11090, + "rawSHA256": "db3c462314d91a669d9ee1d9ffb80f3d4a4ed36c781e9a139e35081a897e9bd9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-rankExecution.consumer.lean", + "mode": "100644", + "gitBlob": "f562ce9d3efecbd4b671a99785475b57daed1f34", + "rawBytes": 24465, + "rawSHA256": "4357f0dfa0dfa23efa153d502b4e960faa7c531329bab18915912e7dc48f754a" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-rankSafety.constructor.lean", + "mode": "100644", + "gitBlob": "2cee78c55ce6c2a745ffe9603c3599b80a0e7395", + "rawBytes": 11278, + "rawSHA256": "a8697e1e9553c7a0cab78b0efe5be5fcf6217c401ba11e781dee489bb214a03a" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-rankSafety.consumer.lean", + "mode": "100644", + "gitBlob": "280b2879f924d6dc2aa67e2bfb7a9cb399f95606", + "rawBytes": 24653, + "rawSHA256": "22f88a61af30638089bcf15b71900c137056c1f8a434cd4eca61746c4dbf30dd" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-readerCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "ae6f258afa82c6f2335da4f71b230e1692054324", + "rawBytes": 10888, + "rawSHA256": "ba1fdbf0aba815c0cfaeccca117ac46c36c0d4bc2eface02aac969fb53385381" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-readerCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "7fd7e0075c31d601fcb2d6ed4159c2ce4a55d5d1", + "rawBytes": 24263, + "rawSHA256": "bef27c49c398627deaad4490f5dac22e4c9dbb55a8e4d0c1f772fd54b83275b6" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-readerGeometry.constructor.lean", + "mode": "100644", + "gitBlob": "b1bfccca365a17ae30ea7742057b4a738478dcdb", + "rawBytes": 11262, + "rawSHA256": "cefe12eb9ad045b3109c60d4e4a839b22588f07ed71c34002766fb0516005962" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-readerGeometry.consumer.lean", + "mode": "100644", + "gitBlob": "bce078189acb11566ce6a73040e370a51b1ef393", + "rawBytes": 24637, + "rawSHA256": "b459c912fa63a869f0353b8e6d1bdeca91d2d61b4a0df4ff6eb1b2dc965aa046" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-selectCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "b4c9d373b78ef027b7cc26e7051cea241f52508e", + "rawBytes": 11433, + "rawSHA256": "5a8b507444f96a5fcd981ac792ec98b1828d68bc9178257846a1c04d6414d24e" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-selectCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "ebdcd922a10abe403ae70b9a1754b5a90bf69301", + "rawBytes": 24808, + "rawSHA256": "7ba9f6e3635b6cf6eace442f5629c8157b562006e6b50118b66d4cbf0f520573" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-selectExecution.constructor.lean", + "mode": "100644", + "gitBlob": "75a116f29d984dd6e0b764db7a15ec882e99c23b", + "rawBytes": 11060, + "rawSHA256": "e2257a7ad3b756e144e142f2b0097ca03a63423307e2d4a0fc24cf92b830968c" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-selectExecution.consumer.lean", + "mode": "100644", + "gitBlob": "f7702035b48c282ad09578d9e6c0b3c3e6079c21", + "rawBytes": 24435, + "rawSHA256": "d6164a4c8b8765eb193bb335e9f4f3cc2a41da4ea924d9c1087bc2a49b526ea4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-selectSafety.constructor.lean", + "mode": "100644", + "gitBlob": "4f4c7b5d9c3ebdb7930012294b64c96b72c32793", + "rawBytes": 11270, + "rawSHA256": "087312e4eabdbce8868fa93b0489beb3129ca756b8f27855bacf4eaf62182e0d" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-selectSafety.consumer.lean", + "mode": "100644", + "gitBlob": "ccc615f20e91256dd2d3de883f7e470d5a8574b5", + "rawBytes": 24645, + "rawSHA256": "c3f5df9af70e24d549d6bafeaae7fc8293bc44c3cef55351210f5bdbb06c7738" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-sourceBudgets.constructor.lean", + "mode": "100644", + "gitBlob": "17a044876c0784059e0540e680dbeb61038bdc18", + "rawBytes": 11388, + "rawSHA256": "5630b8d3eeb6efedbeb00609a9b29e4a5ffcbdb190b133cb88f7e1f7c8d411a4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-sourceBudgets.consumer.lean", + "mode": "100644", + "gitBlob": "086eeaf32be4b9216b2aaff0c86a1df0dc4ff69d", + "rawBytes": 24763, + "rawSHA256": "9dfa351d725d4d6bfbff387ff3cc7e556d433ec0aecbff3f88bbe601520fd7a5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-stepsBound.constructor.lean", + "mode": "100644", + "gitBlob": "3f4af7cf06e35e0847a86f4f537e8161446f748f", + "rawBytes": 11394, + "rawSHA256": "287279111614fa86ace3bfa7b6b0d34ef1d23cc8d4dddd5cb0fa728c6b1c3075" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-stepsBound.consumer.lean", + "mode": "100644", + "gitBlob": "3468e33ad53bfe2bc18c066f0d4d17ed9a0ffdfc", + "rawBytes": 24769, + "rawSHA256": "57e53ca68683c31d4d71f34a8504c4f14c92f09f4ff097b9f7be9973e34e1488" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-suppliedMemoryAgreement.constructor.lean", + "mode": "100644", + "gitBlob": "4ad093d673a1b096cfc2b97039a6e01c0bafea27", + "rawBytes": 11146, + "rawSHA256": "d37d398a33627168dbfa19cd30487f4e6e4f3b7a8fa48f5a1649fd971a99a7e6" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-suppliedMemoryAgreement.consumer.lean", + "mode": "100644", + "gitBlob": "5848525126b6a62946ece6c3b47403ca2ba2025b", + "rawBytes": 24521, + "rawSHA256": "979c4975e4484d66dae9864380269bb37fee0926695dcb61d37fe1a3865593fe" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-validArgumentFits.constructor.lean", + "mode": "100644", + "gitBlob": "bf29c02c26476cecac082dd2a043963f0145e070", + "rawBytes": 11480, + "rawSHA256": "3ed0a28aa01af37dc29a2170acbb0eb14cfec27686efbf156cc9e2e53e1a5f21" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-validArgumentFits.consumer.lean", + "mode": "100644", + "gitBlob": "1fd0b65abe837a19d45fd812584409240a1e677e", + "rawBytes": 24855, + "rawSHA256": "5b2af2ec240642f0cd03c38fe51ec6e51c810e519c9de28bfa6d93ef4ff71b54" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-widthBounds.constructor.lean", + "mode": "100644", + "gitBlob": "1c76722e5df313e661da7ff4d36ce697fcbdcf6a", + "rawBytes": 11442, + "rawSHA256": "e5b7627e6bebe4733adbcef700c3976b6081924fc230d98797b68d085b39bc05" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2/weaken-widthBounds.consumer.lean", + "mode": "100644", + "gitBlob": "04fe4f7190bdfcc9d1c96d4bb31f1d907b4e5fbf", + "rawBytes": 24817, + "rawSHA256": "d9287c6f1e8402a30a66f79d76fd65a05902d67abceedf66ce1f90da6840b10a" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/capacity-without-code.constructor.lean", + "mode": "100644", + "gitBlob": "a09ac4fef7ce4b45f2f3ff9b3c74cd718a55c8d9", + "rawBytes": 11674, + "rawSHA256": "3b8f2b138d8688e6135b810b4dfe542d2e6a541cd0228ee11f3edf7a7a7bc4fb" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/capacity-without-code.consumer.lean", + "mode": "100644", + "gitBlob": "77211266476610042602cf0018555ab8841da42e", + "rawBytes": 25049, + "rawSHA256": "51441d1d50d5306585fb86a5b6e7878a40227ef4496e567482675373b6f55a80" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/capacity-without-scratch.constructor.lean", + "mode": "100644", + "gitBlob": "d96fdb2f0732fbd87f561640c451c26617ff9fee", + "rawBytes": 12016, + "rawSHA256": "a753103b1a5acf77e6c1e99ae347c5737ce5f430be46ac37ff0a6f5fcc33a6c9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/capacity-without-scratch.consumer.lean", + "mode": "100644", + "gitBlob": "cfdb4c8b554b3ab363ae805637de53eea9a57298", + "rawBytes": 25391, + "rawSHA256": "c4f7c8fd7424e1e114fa44146c8264a73db4979b726735dc43c6d7a5f2ca338c" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/delete-accessCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "2476fca2abe7dbaa66da65680a665301d3a5d5c3", + "rawBytes": 11158, + "rawSHA256": "651791c2bace987748195f70eae64b2b7456dad1b64f76d39959113edeffc6e7" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/delete-accessCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "a2e585992498bc3b6be2a163851887449e0fee3b", + "rawBytes": 24533, + "rawSHA256": "1d448f39649be5ca08713ba75e8b198063819bc1de619488de32a3d06145dcea" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/harmless-comment.constructor.lean", + "mode": "100644", + "gitBlob": "ae0a57829e7dcc813a86aa375c821691b2ea3f46", + "rawBytes": 11483, + "rawSHA256": "72fb34aefdd6dd4c5d58160f954ff6f6a251b957438528e4bfe9fe86ccda4daa" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/harmless-comment.consumer.lean", + "mode": "100644", + "gitBlob": "570516f92f378ae3df0ab4d691fb122f3c8b9081", + "rawBytes": 24858, + "rawSHA256": "fd5635974a1ab26f392d5ad314220bc219019acbc066c38d8b4bb1275a3917a8" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/public-proposition-True.constructor.lean", + "mode": "100644", + "gitBlob": "5fd81410e22ed0c9adbc8e8b304fd971e33e1edc", + "rawBytes": 8309, + "rawSHA256": "25f7dfa212ca726bfa0b94d53514f418f636334834e611683c107ddb500198f5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/public-proposition-True.consumer.lean", + "mode": "100644", + "gitBlob": "2b40da833cc40572f755deed688ff3b5ce0752c5", + "rawBytes": 21684, + "rawSHA256": "cd318d4a01d7eb7d85734777d2de9793df29c799af2dbbc66e6e39521cfb8e2a" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/sibling-completeCapacity.constructor.lean", + "mode": "100644", + "gitBlob": "830663d296b3c0671ec8b200e37367e1562b61a9", + "rawBytes": 12178, + "rawSHA256": "383ac71e84d35b513e61fb2d6922511ec707a66d73906edbe059f110bb4ca583" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/sibling-completeCapacity.consumer.lean", + "mode": "100644", + "gitBlob": "7f3fb3d33027495d529f4719e60c1b99c00acb4d", + "rawBytes": 25553, + "rawSHA256": "3d897dbe47103bb5dbab786b2efc7dbb6320edcfedaa5e5f050af8c9b6a321a5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/sibling-readerCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "b9e942b8ac95e8582bd01c2c19e7de3391931f23", + "rawBytes": 10935, + "rawSHA256": "09dd0a40d2e4aa6100f2fcd52327f3f1a899dfd7c18cfa8aa6025d02a56d8a93" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/sibling-readerCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "f8e64748eace4d1a60bcdcdf3df979f9a05ded95", + "rawBytes": 24310, + "rawSHA256": "8bf63b05d98c8f0785ac0684b7f1d960757c792a0a81cef5b98445b5845da11f" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/sibling-selectSafety.constructor.lean", + "mode": "100644", + "gitBlob": "0fe2b2a154a94bc3c6e9c73b75140d1d694b83b1", + "rawBytes": 11460, + "rawSHA256": "e7ec2c585e24141bf454ac9b116f824acba24ede85d58d5cfd33b9670bf7e2a0" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/sibling-selectSafety.consumer.lean", + "mode": "100644", + "gitBlob": "8783cc147547d65d482021fa38f1ef5c4c31848d", + "rawBytes": 24835, + "rawSHA256": "e6c6e5f62feb8b9a903a40606a2fce0c84e467480595bc097b9db2f2949dbf0e" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/unchanged.constructor.lean", + "mode": "100644", + "gitBlob": "8184759bbac7eb8b54cfe5acea62c9b86cb8211b", + "rawBytes": 11412, + "rawSHA256": "1c6cd0a85b77fba7706c77da87de358808a24fa661d5635a3c4b3bbf96005d69" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/unchanged.consumer.lean", + "mode": "100644", + "gitBlob": "333c7f7b9185d5f19e703855126e300f0630b0da", + "rawBytes": 24787, + "rawSHA256": "34030ec06c9424f6692a02e49352d7b58cb67a6f1a874bcf07d980dea0fcb3fb" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-accessCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "1d1566db6c748a2005e9e61c18d92df996201130", + "rawBytes": 11347, + "rawSHA256": "be09f4706f3d5a0b82a0b7a2b3c2f7ec974f39181b7ff6eb82a3c2f0d0905839" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-accessCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "4d2d4efffff52f03062ed28e0d0ce3d1f703fbf2", + "rawBytes": 24722, + "rawSHA256": "3e46a4250093f07453fddd3077b0cd86d24e4f0c7da68e0b7a36614937d1eb8f" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-accessExecution.constructor.lean", + "mode": "100644", + "gitBlob": "3daad8f272f9a29156236becf0a9fe9b8b94c106", + "rawBytes": 10967, + "rawSHA256": "d08cbaff37a5a3cf762a697b7c0b041d91612db39ced86481a29f11d80a9a4f5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-accessExecution.consumer.lean", + "mode": "100644", + "gitBlob": "811a8bbb0b624dc28ccf54f044b142bcd23e3fd4", + "rawBytes": 24342, + "rawSHA256": "233bc572f5947a66bfb47857ca8629e696b691e3399ae6ddb7bef3814129ef9e" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-accessSafety.constructor.lean", + "mode": "100644", + "gitBlob": "8b63d87d332133a7d6cab2b046a4bf1070f7b60e", + "rawBytes": 11138, + "rawSHA256": "89bd8c1d125d764ab8538610a7986b71b4639107b89de60c3b00b012f89127e2" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-accessSafety.consumer.lean", + "mode": "100644", + "gitBlob": "aec90e1e7fe49ab2530abe5e301daf058331420e", + "rawBytes": 24513, + "rawSHA256": "5433d05760d65d9f969d3433834eedabab1a6274f65f951efa5fd0af339e901f" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-categoryBounds.constructor.lean", + "mode": "100644", + "gitBlob": "2b7a998ee82242c228d9e5e4e41a7202f673780e", + "rawBytes": 11197, + "rawSHA256": "7716c9062519f437b242e46328219893b7c9da9fdb4f56c7f7cab92e96a899f5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-categoryBounds.consumer.lean", + "mode": "100644", + "gitBlob": "f73dc29a882e258ffaafe9981bec1f894f9b4da5", + "rawBytes": 24572, + "rawSHA256": "e4311923fff5adb3787056d750814b35477e68419265d522bf46fca8d7ff79a8" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-categoryPartition.constructor.lean", + "mode": "100644", + "gitBlob": "51a91f75c783f1a07a9057b7eefe75d4f02d7255", + "rawBytes": 11031, + "rawSHA256": "04863cc2f81c1f9de7e69f8a8e551af2dc69ae39dd7327ace348fdc7314c0719" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-categoryPartition.consumer.lean", + "mode": "100644", + "gitBlob": "0ad1aff421088743802d92beaaf57937487d1446", + "rawBytes": 24406, + "rawSHA256": "a87cc95187ddeb2e09fb08d0834036c10f434318e32b1631581e80cbdb05106a" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-completeCapacity.constructor.lean", + "mode": "100644", + "gitBlob": "6b9a4ebb43ffb4f9c18513ae7d179d2984737fd0", + "rawBytes": 11048, + "rawSHA256": "4b0706831969c019a3d2783ba58fb40fcf6314aba0324a8fa664f5f8e1486fa7" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-completeCapacity.consumer.lean", + "mode": "100644", + "gitBlob": "9f37df32e743f745c3f3f9eeec94350a16aec239", + "rawBytes": 24423, + "rawSHA256": "6eeac100ad379a0ccf6d0ae1df62aed680db286b4a3aca11a204c23ecffa28e4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-finiteScratch.constructor.lean", + "mode": "100644", + "gitBlob": "6039b399f77492b63f72fe0bcc983203ffa7a6fd", + "rawBytes": 11204, + "rawSHA256": "b152a554e610cd1b71af4febe48ef7de76a07ad1e552bbbb369329f73e753d95" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-finiteScratch.consumer.lean", + "mode": "100644", + "gitBlob": "73d618a553f1bdcf6da6eec731b92e47101e5806", + "rawBytes": 24579, + "rawSHA256": "45a0f90170383aebcc6a26b1f805930c9edd1c7ac7712a4572cb05413b124c07" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-memoryWordsFit.constructor.lean", + "mode": "100644", + "gitBlob": "a281320d581f1d5d54df90d3713b0d8f3245680a", + "rawBytes": 11283, + "rawSHA256": "357895f2a939a21ad32072c92496e332a6a7c0d19b11acd6460bb4777f1365be" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-memoryWordsFit.consumer.lean", + "mode": "100644", + "gitBlob": "5734d69446f18daf6c7e8d5bd85a7acfeb01041a", + "rawBytes": 24658, + "rawSHA256": "7c694af7b9dcb60a38645bef898af307e331504b9234f03c727782ce119fb382" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-overheadLittleO.constructor.lean", + "mode": "100644", + "gitBlob": "8ed06564d248876239944cb3abbb19084b1394bb", + "rawBytes": 11382, + "rawSHA256": "81b4ed9073c48c982cd353d2fc5aea6db93312eaf20e1a5f3b1e59b0f57af1ec" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-overheadLittleO.consumer.lean", + "mode": "100644", + "gitBlob": "b85064500f53df05e1704ed05308611255c7dda5", + "rawBytes": 24757, + "rawSHA256": "4b929237a0a552fb5c0452adc7c67645cc48145df3136145429e914de25a39e3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-programLengths.constructor.lean", + "mode": "100644", + "gitBlob": "550bb409b7ff387703fac09747804da606320944", + "rawBytes": 11239, + "rawSHA256": "218b2e0e75ada30ff7cc020751d13604192493d43bf9dea4a8a38720a1bec884" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-programLengths.consumer.lean", + "mode": "100644", + "gitBlob": "1f345bd3b0750d52ad62a951e9daa2dc34367738", + "rawBytes": 24614, + "rawSHA256": "6504d0887ebeabc94d26ff26ec79cfbb9be8e44e192d1179a9b9a872799e425d" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-rankCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "68d19f16af2b8fd83a3f89e78e4e22c1108511f7", + "rawBytes": 11242, + "rawSHA256": "cb537e5bdf53729456d4cc64d8ed0c587eb0dcb02fc71b0890e0feacfff08aed" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-rankCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "7a8ff28d0acb1cae1b605f33babefa41913aacdd", + "rawBytes": 24617, + "rawSHA256": "70dc8889fb84878be1f28130f289efee45d4a993a1b41af79f989b1b637468e9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-rankExecution.constructor.lean", + "mode": "100644", + "gitBlob": "9454db01084751433eb6831e392789a8801f70bd", + "rawBytes": 10941, + "rawSHA256": "94001d672071d489778fa49426b372fbfbc332370182a6281d7548f5702ca367" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-rankExecution.consumer.lean", + "mode": "100644", + "gitBlob": "1f4be86560bee62a285e994f11d1075e4c3e4ef8", + "rawBytes": 24316, + "rawSHA256": "8560837aa178eaf503503dd786c74ea68e3ad4ca57822877611c460fc5762aff" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-rankSafety.constructor.lean", + "mode": "100644", + "gitBlob": "6697061bf711bb009d330e0f4d95b9107204ea47", + "rawBytes": 11129, + "rawSHA256": "507059533a947ebaf1cedf8bf78f68a90e76904793922602f4efb1bccdbd8641" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-rankSafety.consumer.lean", + "mode": "100644", + "gitBlob": "f96d5476f508ad71411580b2be4c20cec8966025", + "rawBytes": 24504, + "rawSHA256": "5ca82990a028513e0955cfd0d3bb20e97d6b7109a30bf36a3fc8305ca6adc937" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-readerCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "28b673e42454f8a92bac1035abeccbdb9cc8e238", + "rawBytes": 10739, + "rawSHA256": "93e5ed046477366087d233485968f19b015170505d15c2e7745c1ebc54f5c1dc" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-readerCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "1da9913307f9082269bdda156622f96c35e90f8c", + "rawBytes": 24114, + "rawSHA256": "ed39ea38fa85b96952e8c5442e95d3f60bb16147a4995c5cd2256c0f8b6ee0b7" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-readerGeometry.constructor.lean", + "mode": "100644", + "gitBlob": "152181f03342c990eb0b2d862bb00ce5bddd2397", + "rawBytes": 11113, + "rawSHA256": "b83749b6812a69e42e75c286f433bdec4f07b8297b50ec220313c8edacab1029" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-readerGeometry.consumer.lean", + "mode": "100644", + "gitBlob": "13b5db7ea87fe732e5ff633ffaef111f0f18fb01", + "rawBytes": 24488, + "rawSHA256": "94b58cd1d753928b54be64bf9341e3f01ad2ed48ef6ffc1ed915d28d7b18f7ea" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-selectCorrect.constructor.lean", + "mode": "100644", + "gitBlob": "dda8a9e04b53ebabb62afd2318cf1f7824e105da", + "rawBytes": 11284, + "rawSHA256": "cf4d7af5efa1270f66619985da7a42453826fec680c932bf3cd562deda1d4820" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-selectCorrect.consumer.lean", + "mode": "100644", + "gitBlob": "59b4310658fd9852090d5ae1997a7c6a8762a561", + "rawBytes": 24659, + "rawSHA256": "ec2bc5463d39d9511a08403449b9818356db57309e3d0ba6cadc6875b831bb81" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-selectExecution.constructor.lean", + "mode": "100644", + "gitBlob": "895abd72751b7c334c3d5d24e418cd0b1a88b763", + "rawBytes": 10911, + "rawSHA256": "6f840afc5ba6467310e7db225fc8a8d1396f3b01339a8463ccc3ab60716bf122" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-selectExecution.consumer.lean", + "mode": "100644", + "gitBlob": "c19e3fcd6b0eca01d803d05515c82f3dd77450d7", + "rawBytes": 24286, + "rawSHA256": "0507fab74975c9ffa4094fc2644580900a2ae77fd74013f6131e0666d7a326f6" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-selectSafety.constructor.lean", + "mode": "100644", + "gitBlob": "94edf5c2043e7eae01f2ecc634430e2f9f7b7cd6", + "rawBytes": 11121, + "rawSHA256": "2b7d753ec6dfbf5848b7f3e14bd0c6c4ae0e98d0d04876effbe316ed497c5be1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-selectSafety.consumer.lean", + "mode": "100644", + "gitBlob": "eb0a28141277ce7dff35c304f5a5d4d25f872ce4", + "rawBytes": 24496, + "rawSHA256": "a61094fe7ecf898d423e14830d6845942f59e93c24dfa49f10b3559d8cd1b588" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-sourceBudgets.constructor.lean", + "mode": "100644", + "gitBlob": "5649fcbc908b923e244fae25768a16468aada7fe", + "rawBytes": 11239, + "rawSHA256": "005bb35670b2c32fbe85e30ef1718dc644b1234aed677f8754c5659ba5ac2331" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-sourceBudgets.consumer.lean", + "mode": "100644", + "gitBlob": "290f1355401845c41fd468cac840736f6fc758bb", + "rawBytes": 24614, + "rawSHA256": "6c7c268a1034c947b8f8e922e17b4dca6e675f1b40f2fc6962b8227d3db1631e" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-stepsBound.constructor.lean", + "mode": "100644", + "gitBlob": "95d47280ef6088fe846f34b6021d835e9ff9d053", + "rawBytes": 11245, + "rawSHA256": "01046965f0db6e44eb0701dc4d8e77be3a61037132270b41d24b76324384e193" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-stepsBound.consumer.lean", + "mode": "100644", + "gitBlob": "218635533e9b447f5067cfa7ee0866176c6e1da0", + "rawBytes": 24620, + "rawSHA256": "bbdfc89e87897bec6f8cdfe092134ff9d8aa413f0bbed409d832dd7077de9765" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-suppliedMemoryAgreement.constructor.lean", + "mode": "100644", + "gitBlob": "59b8303f4a08710869d4d5ec53edbbe6d8e10cf1", + "rawBytes": 10997, + "rawSHA256": "46b67e7a43110c142844548f3c12f71c6a261e216105a7e98ee0511e909f96fe" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-suppliedMemoryAgreement.consumer.lean", + "mode": "100644", + "gitBlob": "a7f23e23244d36e27c5b68da21a210c5069c5863", + "rawBytes": 24372, + "rawSHA256": "bc23bd30c1c415d25127455ed9c75e7158bab19325cb69f93797032fd9f3e195" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-validArgumentFits.constructor.lean", + "mode": "100644", + "gitBlob": "ca3d46df660efdf67521f9145f327e4db0dfd1cc", + "rawBytes": 11331, + "rawSHA256": "6b9a8f0b135126f6a20839d0ac2e1eda63fae2addb068c2e40ca3fac14c89c35" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-validArgumentFits.consumer.lean", + "mode": "100644", + "gitBlob": "e16b0775c56df82ff5fb46abf8b8a7b9f4547054", + "rawBytes": 24706, + "rawSHA256": "fe300cd5be7a660467ea4c06dd91b6cdde02c5bad63490a5a6c9eee56226af69" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-widthBounds.constructor.lean", + "mode": "100644", + "gitBlob": "acb6e5fc9dc8ea55830cf10d1f648424313aab01", + "rawBytes": 11293, + "rawSHA256": "dcac8f2fe924655589d8a5436cb92a1288a0bdd797f3a20a8e15c2b0bd0f4689" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618/weaken-widthBounds.consumer.lean", + "mode": "100644", + "gitBlob": "eacfe7b1c1aff9543d2d38d9fe2561ab48c9b2c8", + "rawBytes": 24668, + "rawSHA256": "2ecb9d416095dc8adff4067438a5d2fd17d57d5ec63ef29b747c6fe0108380cf" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/fixtures/diagnostics/capacity-without-code-r10.consumer.lean", + "mode": "100644", + "gitBlob": "f714f0ebcafd2f667c93281db823014577b054ab", + "rawBytes": 25232, + "rawSHA256": "46fa2e22e169f04da3348e33986ec96bddda9441f385079f019ce390b91e25ef" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/manifests/177285DBD0DEE89002F8BC59478EF90A4D5B8B227FDFB7F04E6BED14DCB5F16A.json", + "mode": "100644", + "gitBlob": "40df2724ffdc8ee04f59de7f69cf3b1af11251bf", + "rawBytes": 76712, + "rawSHA256": "177285dbd0dee89002f8bc59478ef90a4d5b8b227fdfb7f04e6bed14dcb5f16a" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/manifests/55DAA6A25A1E74050631EAE23A4FDC0F8FA4A467AFE3BF5759291D444350F821.json", + "mode": "100644", + "gitBlob": "138a358f42fbdab9cfdc7a06a3e50b27c9086976", + "rawBytes": 76787, + "rawSHA256": "55daa6a25a1e74050631eae23a4fdc0f8fa4a467afe3bf5759291d444350f821" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/manifests/6E87E80858AAB80AD14C66934009B54BEE070120AAE7BBE038FBD55AFA446BB2.json", + "mode": "100644", + "gitBlob": "8ca13d336f77a2c1eba785344f0b3a3f1afbc971", + "rawBytes": 76706, + "rawSHA256": "6e87e80858aab80ad14c66934009b54bee070120aae7bbe038fbd55afa446bb2" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/manifests/B39CFA73CEAA05B8D0E8E803CACF0696529FDBF7F2BD3BEFB5A8805045127618.json", + "mode": "100644", + "gitBlob": "8ebe97ae0ad7f70c92e219cf9b3352bc7665d2e6", + "rawBytes": 73041, + "rawSHA256": "b39cfa73ceaa05b8d0e8e803cacf0696529fdbf7f2bd3befb5a8805045127618" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/capacity-without-code.json", + "mode": "100644", + "gitBlob": "94f90d2c75b7a26ef5e4652f71b46b4b44671a78", + "rawBytes": 11745, + "rawSHA256": "218b564248cfc043ed72dad7712900703b7fcb3e50526f3f80c2447ab34ff030" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/capacity-without-scratch.json", + "mode": "100644", + "gitBlob": "ace528ae29ec17b4181e7a4ab5be6d6563f3302b", + "rawBytes": 12297, + "rawSHA256": "d9d63ca9d840280c0421fbcaab91c2d22c2d6a3bb9782fc69dc5e782ed7ba54d" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/delete-accessCorrect.json", + "mode": "100644", + "gitBlob": "de3bcf320a1762cc35cb4be51032ee694e89085b", + "rawBytes": 10782, + "rawSHA256": "c63667ecbcbf93ad2b97340459c09c525686ca5f6d771ae0321f3f24670ef9f9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/harmless-comment.json", + "mode": "100644", + "gitBlob": "510fd62159933b170d1cc1d838cc8cd0307911d2", + "rawBytes": 9318, + "rawSHA256": "542ebcd8671a0d75e1a584ee17e7f38dc859862cf5f52bc544c9db758803451a" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/public-proposition-True.json", + "mode": "100644", + "gitBlob": "557cc01b96c9f0fd3635eb4c11577bd437591254", + "rawBytes": 10575, + "rawSHA256": "2d01c5558ee5d5aeb9f469200d079472cc33405090c4abb81a40843d8256722b" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/sibling-completeCapacity.json", + "mode": "100644", + "gitBlob": "eeb031df10e4f2782360c8c00f5969f5b07dc4db", + "rawBytes": 12433, + "rawSHA256": "807cace1b1ba4530e66dd6af6f91f1f42133796be6afd4f460f09efb15128c1d" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/sibling-readerCorrect.json", + "mode": "100644", + "gitBlob": "658fa676ad804416961be0701dac6d6c397dd501", + "rawBytes": 12071, + "rawSHA256": "21c344c900687fcc7685cfd9f0307daf90c5d6c1623b61c439b5e5e24e032498" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/sibling-selectSafety.json", + "mode": "100644", + "gitBlob": "b1a0db5efdedeb10e9cd1ed69bc74558e5433878", + "rawBytes": 15310, + "rawSHA256": "4dd630756b4a4024415bf8a91350a12b7e72e26c408f7738875a26c198e970c9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/summary.json", + "mode": "100644", + "gitBlob": "f20f507aa95f9f8ae4306e00b3d811fb6f63685d", + "rawBytes": 500628, + "rawSHA256": "dc190de58d493133d28d800e73a1ce58fd474d674bf5a9d8f61017987a5016c1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/unchanged.json", + "mode": "100644", + "gitBlob": "69469b1573a2732ff6368a65cbf9106abbc6cf24", + "rawBytes": 9298, + "rawSHA256": "38f7f634e83e047c78db2ab86305b9775c4ad7a41e4435532f399f2afaa3a799" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-accessCorrect.json", + "mode": "100644", + "gitBlob": "f41a320212fd30d11f3adad8d1fd115634f8ae3f", + "rawBytes": 10733, + "rawSHA256": "65afa75ba0fcc50063446d66e15647a713363c86d05bc3ac5b4bc50c68f2caa3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-accessExecution.json", + "mode": "100644", + "gitBlob": "798524091ae9b64ec7ec6521fb36e73fb0dda475", + "rawBytes": 10749, + "rawSHA256": "1e51557748066f4355bc771b9c657a1147527b406e75b1d34ed533954134734f" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-accessSafety.json", + "mode": "100644", + "gitBlob": "04f3c63bbe496b4920747f466bbc183f7b38839d", + "rawBytes": 10722, + "rawSHA256": "68160fddb776b184889af48b76aa4b33eeab4cba8af1deed47599d39de28d597" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-categoryBounds.json", + "mode": "100644", + "gitBlob": "0999ff7643e2ce1642d4e6d337bea4336b290e71", + "rawBytes": 10738, + "rawSHA256": "48c7eac3c35f1a141f800d5cdaa83e022211d1f7a4cbce909141c2869d6a7498" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-categoryPartition.json", + "mode": "100644", + "gitBlob": "2eec79f6e5ea7fe73cfbf15cb47f657e3c13d91b", + "rawBytes": 10762, + "rawSHA256": "4cf07693f65cad28fa3e0f365b592b7679abd414cb2adaaf3d19ddb67e151216" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-completeCapacity.json", + "mode": "100644", + "gitBlob": "723f22b8d1549d688c7f097d25b7c2953faf3019", + "rawBytes": 10753, + "rawSHA256": "794e04dfbadb5742e01d979f9bcf81cc331fb3f8b31b2de061f62311331e710e" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-finiteScratch.json", + "mode": "100644", + "gitBlob": "2f40a4e11f7d1472056e80902025544f4c2852d5", + "rawBytes": 10734, + "rawSHA256": "9a415a1a199e2b557fb73d89313f0ed183d86f3d26dbea6dada25cf374716396" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-memoryWordsFit.json", + "mode": "100644", + "gitBlob": "d0306ef35d9e35d279444295f5eccf93caaae4f7", + "rawBytes": 10738, + "rawSHA256": "73c5b67f305f6832828d5d56ae5aa7aff7222e6cd682d737650fe7f1c9a98916" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-overheadLittleO.json", + "mode": "100644", + "gitBlob": "f85589dea0b5997be9cc2cfadbe716f3761f842e", + "rawBytes": 10669, + "rawSHA256": "cd012e14f23863d28d98cba4d37b0280151415d2f95c6befdad9dc81f9dbbddd" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-programLengths.json", + "mode": "100644", + "gitBlob": "eae71c5737b2a18e670b4a481529e165951dd32c", + "rawBytes": 10923, + "rawSHA256": "77746bc59dd7b5c83c44f4f644146cd339c2f380db080919a7e2302757536e82" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-rankCorrect.json", + "mode": "100644", + "gitBlob": "32ee40a91a50be367557794f029db3edef33ce1c", + "rawBytes": 10714, + "rawSHA256": "88679530b7e56c31e45f03b4f41c07b46a087a9464aee8236db8ff8e600ab015" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-rankExecution.json", + "mode": "100644", + "gitBlob": "e99f3ee1317a9c9ce26665823b58e5ab1b7a3909", + "rawBytes": 10733, + "rawSHA256": "08e32ac6411dce2831c1d8fd1239fbbcb9682101dae866f79409d5464f0c7e87" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-rankSafety.json", + "mode": "100644", + "gitBlob": "4bed602459efb3c22a68e22424e7ea5045d1a250", + "rawBytes": 10706, + "rawSHA256": "7e7c4d7db8cd26f3144a7d1d2d8ae5a649edecc4bd78725f597aad77b2989a8d" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-readerCorrect.json", + "mode": "100644", + "gitBlob": "1137453ade2929421fbb726bc9550b1b3dae2e65", + "rawBytes": 10730, + "rawSHA256": "8ae24729cbb9893b28daa455c5c251db4f0a7fde48c722c302360b1d2243504b" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-readerGeometry.json", + "mode": "100644", + "gitBlob": "6f56ee397d0b78c876c2068280c350df4792e819", + "rawBytes": 10738, + "rawSHA256": "90b282f678a9ce46ccac42807bdf1d6c987c0ac9941c1e3c28c49b503507b75a" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-selectCorrect.json", + "mode": "100644", + "gitBlob": "cbe820781ca4bd64fd0da3d88f299e0a7708f760", + "rawBytes": 10733, + "rawSHA256": "463d8217dd8b67ac7745f09ab30f07db365372c692ef4f714d87feb29d40f510" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-selectExecution.json", + "mode": "100644", + "gitBlob": "c7a6e70ece3761f755886a16ef9e45530e04cd80", + "rawBytes": 12034, + "rawSHA256": "ff92b9b1cc91937758a49e7439f2f3fec5c81438ba8329d084786c0fb6bd0a1f" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-selectSafety.json", + "mode": "100644", + "gitBlob": "597b5956306c25618ea9fdb1e362b6d38ee79adb", + "rawBytes": 10721, + "rawSHA256": "f664d534dc90c38d2db50beab2e245153c9712a8680c0eeb0957e8bf8ba98b2e" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-sourceBudgets.json", + "mode": "100644", + "gitBlob": "a673d2fc87b35ebf18f5646bbfb11c4770f5d866", + "rawBytes": 10891, + "rawSHA256": "ec89931815b8c56f1664a23a1633d9a9e6d527858135a28c3e34384ad8d7ae5c" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-stepsBound.json", + "mode": "100644", + "gitBlob": "2ca9ce8af60e6087a42f33ed9cf00f012f263b94", + "rawBytes": 10706, + "rawSHA256": "cd04b1d72bceed20f8091f9ccaea3f84a845d05d9443913ef29b66c1291e28a5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-suppliedMemoryAgreement.json", + "mode": "100644", + "gitBlob": "97049f434b95813624a57df9b030501217aec459", + "rawBytes": 10810, + "rawSHA256": "e98f669bbbad677c3d64df121410a14ad3354e86d07c86b6473fd0f2fd0fd5bb" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-validArgumentFits.json", + "mode": "100644", + "gitBlob": "106a9729a721ae6041c38cff6e35995eb09b4a08", + "rawBytes": 10756, + "rawSHA256": "6eda749fe36eca43ecd022d178f23dab20cc7bb8951c7cc3adf7b7fba4d055d3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-omitted/weaken-widthBounds.json", + "mode": "100644", + "gitBlob": "64e5936b29664ae5c8bbfc4c5b503b6aadbbecf7", + "rawBytes": 10711, + "rawSHA256": "a1170c4bd6da3c75ac9cfedbc866fcfe15c35bc5b5400e64b32c82590fc2c46b" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-valid/summary.json", + "mode": "100644", + "gitBlob": "b731e304e9b9b9e68e89c3df908bc3a44a4173a6", + "rawBytes": 129729, + "rawSHA256": "94d5c1e8678d63e7f3b1fad31aa829e8da55b1d70be433b04a655b32f5470185" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507-valid/weaken-accessCorrect.json", + "mode": "100644", + "gitBlob": "e44c1d9d7a9c787dd8424ea5102ac36bec42ebbb", + "rawBytes": 10729, + "rawSHA256": "9b2baa4802ca6b2138decee73043265d5267e37eb83d2fd1ccf420c8cf460654" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-final-v1-20260912131342256-3b473507/summary.json", + "mode": "100644", + "gitBlob": "92fbd7ec61c689fa0389690f6b8e2448d35224c9", + "rawBytes": 133847, + "rawSHA256": "176c5d9d041b2791d10f4e635d51dd664367b8a3ac2fa59daf0d6bd95777420d" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/capacity-without-code.json", + "mode": "100644", + "gitBlob": "cbbde7260b2829b8795d5c24e239e4bf459942a8", + "rawBytes": 11174, + "rawSHA256": "789c5a54e7aaf6b957a4a4f76c8ae5637a5f28cab4edb49a7016e30459c2d4aa" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/capacity-without-scratch-consumer-campaign-v1-20260912120258157-2c2c1792-omitted-24a73644b0e14a389023d3d989968e6b.bootstrap.ps1", + "mode": "100644", + "gitBlob": "65cd30d465ee4dbd8dbfac2dc91f5273f49fece5", + "rawBytes": 542, + "rawSHA256": "e66c4be027de2bfdbe634a0af46b0cc346b514788014246ca6482bd416f7dfba" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/capacity-without-scratch-consumer-campaign-v1-20260912120258157-2c2c1792-omitted-24a73644b0e14a389023d3d989968e6b.launch.json", + "mode": "100644", + "gitBlob": "ea4323ee1df72b9ceb4000b057c6ecbe6441fb2e", + "rawBytes": 3478, + "rawSHA256": "6feef544985ae20c47fe3af8b731ba567c0b6fba825cd47502d287396e7828e8" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/capacity-without-scratch-consumer-campaign-v1-20260912120258157-2c2c1792-omitted-24a73644b0e14a389023d3d989968e6b.release", + "mode": "100644", + "gitBlob": "f73a879c57b3b06728c6e7abdf61ad40308199ee", + "rawBytes": 5, + "rawSHA256": "f5e6d024c05c9cc2746a3e127408b91a8b7a7f2a30da0c259bc54265502ddef4" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/capacity-without-scratch-consumer-campaign-v1-20260912120258157-2c2c1792-omitted-24a73644b0e14a389023d3d989968e6b.stderr.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/capacity-without-scratch-consumer-campaign-v1-20260912120258157-2c2c1792-omitted-24a73644b0e14a389023d3d989968e6b.stdout.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/delete-accessCorrect.json", + "mode": "100644", + "gitBlob": "1a2ca4f52ba2ce6c472716cd791386a2882f666c", + "rawBytes": 10770, + "rawSHA256": "8af49b1a6f73cca7dd9fe7a25aa5016b0382f3c9c577eabe182f60cf2d0645fc" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/harmless-comment.json", + "mode": "100644", + "gitBlob": "81bc342e99dd56652b3bdd7eaeb447a608e3d119", + "rawBytes": 9306, + "rawSHA256": "7744f7b3d1706ddedb49a5e0a4feb775cc13f68138ca306f943f1fe80b30f6c5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/public-proposition-True.json", + "mode": "100644", + "gitBlob": "f3f2650747031c8f83f68835582f8237f6e260ae", + "rawBytes": 10564, + "rawSHA256": "3c36b10b05db79b8aa7b356647d32b926701d57bbf3de07ac16d06bae8bcca18" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/sibling-completeCapacity.json", + "mode": "100644", + "gitBlob": "227673fe279fb4b37ccdd862ba34b975120018e7", + "rawBytes": 2328, + "rawSHA256": "20f74544602acc3c307d92328b6e4aea04aabd19a2463660144d7e0397e83e98" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/sibling-readerCorrect.json", + "mode": "100644", + "gitBlob": "a3ee8c754f6468a2a30f9e8a47f61f6e4e285845", + "rawBytes": 12060, + "rawSHA256": "1cba0c3d18735bc4782e8808a4d072ffad26b1cda269d6cc6d570299a6707f71" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/sibling-selectSafety.json", + "mode": "100644", + "gitBlob": "4b62c3701e785bb68a5e5590c368feba321042f5", + "rawBytes": 15300, + "rawSHA256": "680bbe2def3a5c5372030bc53ddf1b4c251374b45bb895552202199a323460ff" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/unchanged.json", + "mode": "100644", + "gitBlob": "388c21f7f456c0230c248ddf97e483f5dbab901f", + "rawBytes": 9286, + "rawSHA256": "79c71f7421481f6c61f68afa5100e737da6e65d55e92f655c70e21ce7a090802" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-accessCorrect.json", + "mode": "100644", + "gitBlob": "a00abc70f2d25f41850389c86b1b9c3ae9c8bbb9", + "rawBytes": 10721, + "rawSHA256": "13025c57dd6ee46504d49a0a2283367ad4f304c610ffd49016ba2e16b970317b" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-accessExecution.json", + "mode": "100644", + "gitBlob": "a058c6244868520a6916822692ae06187b496a9d", + "rawBytes": 10738, + "rawSHA256": "b25e70b2e168089ccabf71f04757a049a7019209f06a9126a8426d0bb7c9ea94" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-accessSafety.json", + "mode": "100644", + "gitBlob": "9c3540c2019b0c658d78fa2ae3f2ae9c9143a6e0", + "rawBytes": 10711, + "rawSHA256": "258010dcb6ce2f2d8d983b642b51a41d6da2986aaee12f5c535ff2c30c3957cf" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-categoryBounds.json", + "mode": "100644", + "gitBlob": "48cba7ccb6e57856bbf7449352868f0a8d650f39", + "rawBytes": 10727, + "rawSHA256": "fd90787ae8d0de8e9b1c836ac210cfc2dd7eab82efe5188b3b88d4f836593c6f" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-categoryPartition.json", + "mode": "100644", + "gitBlob": "0d13effc909e2196b6394214ebec3a6b4445cdcd", + "rawBytes": 10751, + "rawSHA256": "129cfb8c2344698e73cd40935f5c931f183fa336301e4bd033149c83a0e67336" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-completeCapacity.json", + "mode": "100644", + "gitBlob": "787d8e82812e81d788fbe7d15bfeb3d2e275dc2b", + "rawBytes": 10742, + "rawSHA256": "02cacf411343ee091f420e0e931568418ad0db2519725aa172b2223392181826" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-finiteScratch.json", + "mode": "100644", + "gitBlob": "fdbd4ac263667cd522462cd96ca7d04b0f283940", + "rawBytes": 10723, + "rawSHA256": "3332311a14a2ef97437d73cdab65b5eac3a1cd07a3db30ddb624efd248324d9d" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-memoryWordsFit.json", + "mode": "100644", + "gitBlob": "d4e74782793f0fbf310a7576d1f9c677d1b82f73", + "rawBytes": 10725, + "rawSHA256": "b9ae7dd4117f19804ad90558aae64698d7369ea78efa13e10b4f9506965a6e09" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-overheadLittleO.json", + "mode": "100644", + "gitBlob": "2586967d1fbe6c78507d5f2b9862644fe85d96d0", + "rawBytes": 10659, + "rawSHA256": "3004a5a5cc8d091c9247c9db9ed1b715dc5c8abc029bbe0b51b2a11e4d7347be" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-programLengths.json", + "mode": "100644", + "gitBlob": "5dbf80d439ab7eb312a9796fc6e37869df318722", + "rawBytes": 10910, + "rawSHA256": "c1bdc511045c38bcae793ad44abab09a81b27ae8b9c4f63e6da07f5be735768b" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-rankCorrect.json", + "mode": "100644", + "gitBlob": "f3756c6e61fb994bc205c0a6f6cc22e4558f9905", + "rawBytes": 10703, + "rawSHA256": "24de8525cbfc2d2117da6cd3d0d26e71c66ba7a160655c8abafc43baf62189d3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-rankExecution.json", + "mode": "100644", + "gitBlob": "639e20cd1778014d5a3469d3b1c24c8a494b4428", + "rawBytes": 10722, + "rawSHA256": "0bc449a586b4d0d522d67bfc732c5a7c71954709e6e9d82201db2d1f86396542" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-rankSafety.json", + "mode": "100644", + "gitBlob": "8f04c2f9033b8a8fc419bbaf3ebca677f3908638", + "rawBytes": 10695, + "rawSHA256": "52a8b89b236a96af2843501d72e9be2d8b6733ffa2f68cecfa384b0229359dc2" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-readerCorrect.json", + "mode": "100644", + "gitBlob": "f1dd91808320a4cc1fe9d74f4d282ab2c0430ed3", + "rawBytes": 10718, + "rawSHA256": "21c099880974b57eae5f2394b1c633fb2309284eb101e7e7b9b1222ae59da390" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-readerGeometry.json", + "mode": "100644", + "gitBlob": "2ea64297448ef7ad08aff09ee6f6d94a35b8cf4d", + "rawBytes": 10727, + "rawSHA256": "16f295e4f066b2f7b94fb5227359e028fe008769550a0fc94d69ccb885d7b1f9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-selectCorrect.json", + "mode": "100644", + "gitBlob": "8ea8525625944015792eb859fca125ee583c079f", + "rawBytes": 10721, + "rawSHA256": "96b5b4c1bff269cb3abc64e5b2519393d3e63fdc82575ccfbb95d63f0551faae" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-selectExecution.json", + "mode": "100644", + "gitBlob": "98f5951fd20e7c8c93dbed8a8b74e7f83603a02e", + "rawBytes": 12022, + "rawSHA256": "275a26ef8abc4f81eb2c8a50ffa9c0599e830aa3f0b3cc2d616e001e7aeed482" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-selectSafety.json", + "mode": "100644", + "gitBlob": "33cd18ee693ad0852769e062f945687d69b20083", + "rawBytes": 10710, + "rawSHA256": "13bd295ef3584cce4128ddadb803dece9773c1b900c7ab35c332fbda12c1b50d" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-sourceBudgets.json", + "mode": "100644", + "gitBlob": "18193e7e32db1879245df40d8aea036b23fba010", + "rawBytes": 10880, + "rawSHA256": "58fed9ed5e1a7bf453e0ebcb9b9ced144add0aaed0d04e28416fc6eb8e7d7b8e" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-stepsBound.json", + "mode": "100644", + "gitBlob": "c31455461e1281ffca216d55a324a8d64bd05f00", + "rawBytes": 10695, + "rawSHA256": "0ccaa2071e9a6f35e5a9cee0329caf8a0b89151c3fe66b3edefcb6abf0b89a55" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-suppliedMemoryAgreement.json", + "mode": "100644", + "gitBlob": "2f16341d6636e6302820e48452461c1419e69329", + "rawBytes": 10799, + "rawSHA256": "081d4d07d9d824e88a7397a41386e077dccb4d7680d269701542e31686fcabc1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-validArgumentFits.json", + "mode": "100644", + "gitBlob": "eaea1f9510c3a73f271ed4cb7dbdb66f92294ef5", + "rawBytes": 10745, + "rawSHA256": "e5ea6a139e8e65cf1443acf518620fc3261bd5bb5cadb6bf644bdae29d452dc0" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-omitted/weaken-widthBounds.json", + "mode": "100644", + "gitBlob": "f45f4e678b1b9206e378cd4866b5db1b54f6701c", + "rawBytes": 10700, + "rawSHA256": "df2c85e9847fb837581b75f8c21ba0a5d8833cc1f8def8ee310e9409454d0b95" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-valid/summary.json", + "mode": "100644", + "gitBlob": "2ffb0e12a2ca0341f36b47594355260fdd9cb973", + "rawBytes": 127528, + "rawSHA256": "1991b66202a780e3abbc9d448cfeeba73044efaa90d380260c30249bece3c4f5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792-valid/weaken-accessCorrect.json", + "mode": "100644", + "gitBlob": "0538e72c7e07398a77c2eeebbf8a3a529cfba522", + "rawBytes": 10718, + "rawSHA256": "d4a15477f5272d8bc8ebcb448a5bc8f20a1b423bee4ecfd8ccbdef20eb856c27" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/campaign-v1-20260912120258157-2c2c1792/summary.json", + "mode": "100644", + "gitBlob": "379ffb578e61622ae49c527c0e1febdcfaed9898", + "rawBytes": 129539, + "rawSHA256": "65546ae004a15e5b09db583e169803a5c22c5e83a5c927ac5217a9ca6f40c1ec" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-known-r2.json", + "mode": "100644", + "gitBlob": "d9ed7f55ec062eb95e127b8904c7a3d5b79dfdda", + "rawBytes": 2603, + "rawSHA256": "9ed285c82152c828016bf095a9dd4a70c1b2bf7dac2ac64ca28f8ec4311514a0" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-selectors-r15.json", + "mode": "100644", + "gitBlob": "8511e12e527776d5e307b7801a3008664f1d5ca2", + "rawBytes": 3143, + "rawSHA256": "648bfef62d26c2f97765785319f28db321cb289fa5f31f4e9613bdee81035695" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-selectors-r3.json", + "mode": "100644", + "gitBlob": "8e43515ee8d64797e97494a14c1d8bdfdd55be16", + "rawBytes": 3134, + "rawSHA256": "15e9cceaa5bd9b7a6b7a69678c9012da4b9e57cc5779108dcd376edfbbe9c46f" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-sibling-capacity-r14.json", + "mode": "100644", + "gitBlob": "6f67aa1383cec65624ac2dec8e2fd72e0730b47b", + "rawBytes": 2640, + "rawSHA256": "88405a9141edf748f43d970a1828e85b206799de80db95763d6db20788a86d3d" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-startup-r1.json", + "mode": "100644", + "gitBlob": "fe77d19cf780fec4b8996c69163a517f28ea88d3", + "rawBytes": 2665, + "rawSHA256": "68937007517cf24122ea01b03b750a4f324d05af256c426432bb6167ae856fe9" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-startup-r11.json", + "mode": "100644", + "gitBlob": "d1fca654e1690313398791263ad1db20d6e485d8", + "rawBytes": 2646, + "rawSHA256": "08cd3ba113d91285c3326b0a3406ece175c590fac6353efa58064f044a8e2c60" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-startup-r7.json", + "mode": "100644", + "gitBlob": "9610db1cade9d6e7f5ec5eb7a34bf145f0eb7afb", + "rawBytes": 2627, + "rawSHA256": "e6630325a65107e4c596406e25e09691137be3d5f7fc7ea49ad2e949a2bdb56e" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-startup-r8.json", + "mode": "100644", + "gitBlob": "1ba1c152eeb132e52b0cacec19cb15ff4dbce833", + "rawBytes": 2723, + "rawSHA256": "45327f4ce0e73a92e505994cd11b5151a9915b8f407ebc4eb84f9d45480eb309" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-without-code-r12.json", + "mode": "100644", + "gitBlob": "a49d079340ee622610b48a5f5a3b4de3a40f4278", + "rawBytes": 2615, + "rawSHA256": "1af88927e2370b4abc688e7e90e95e6f2d7703289afeb66b601f594796ead6cd" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-without-code-r9.json", + "mode": "100644", + "gitBlob": "b4d9a71d670b98d1626cd51c374db51a5d78b930", + "rawBytes": 2601, + "rawSHA256": "871c0c21bef28913b224439c83f4719af7f0df23892b7c2c4050806c0a40194f" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/driver-without-scratch-r13.json", + "mode": "100644", + "gitBlob": "fa4c7a4375e5f5b893d8a5d3e0597c1363bc55de", + "rawBytes": 2636, + "rawSHA256": "78ac9d40b1ed9d1ef03303914ea60e7095dbe6d030e2ded4e0f4369598e56d98" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/final-static-r16.json", + "mode": "100644", + "gitBlob": "33e20f4d8d406825b27320e11161799f8b3135bf", + "rawBytes": 118993, + "rawSHA256": "3a6b5cadd17a7f4fe7bb7d0d263c33d34a4b8ba10c79290bfb54e2dc902b6180" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/first-campaign-multiline-axioms-r6.json", + "mode": "100644", + "gitBlob": "b0b6d550022c52c22f1ea6e5169266be9b4b65e9", + "rawBytes": 23080, + "rawSHA256": "027b1c9613213338e7f53e55a20b5ddcc6626e0d1a1bb3d2d1dacaed8c92d06f" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/known-v1-20260912120122614-27f1d4e3/summary.json", + "mode": "100644", + "gitBlob": "31c650ab7fc0e9684dd6649ef46b5ef9d26dae66", + "rawBytes": 126194, + "rawSHA256": "9db603032ee96ee9c5d97c6b18da8a36a9d364e7e896148466d3794d1cf64494" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/known-v1-20260912120122614-27f1d4e3/weaken-accessCorrect.json", + "mode": "100644", + "gitBlob": "76e1b0ee799eb8310b045ea3feca468312e32cff", + "rawBytes": 10699, + "rawSHA256": "9803bd6d4745fb61ba011fb59e20ad4dd83292eadf65f2bdbf7a7d5667b8397d" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/preparation-r11-allocation-boundary.json", + "mode": "100644", + "gitBlob": "3ab6d6bad926948de1f8dc971f88ffd1f519f9ce", + "rawBytes": 21268, + "rawSHA256": "b116b00c7e8d02ca6c7750d0b0388ce1ef81353cdd6ab9466ad316bbac864300" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/preparation-r5-amendments.json", + "mode": "100644", + "gitBlob": "c2ef2cf5dab6035ca8d3d28536cf15b0357e3d69", + "rawBytes": 28070, + "rawSHA256": "9684d50bf35829aa05ffca39b9db919caaab7e6bcdb7b863c5b847f1829cc856" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/preparation-r8-local-scope.json", + "mode": "100644", + "gitBlob": "f8a7c4d54cf21c7e16356ee885fc7893df24e81c", + "rawBytes": 21010, + "rawSHA256": "ee178ea4b25ed69052cf5e02211ee90054f2e02bbe42347e71db8d11b44c29a3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/reduction-diagnostic-r10.json", + "mode": "100644", + "gitBlob": "1fe752a4e85fc95da288bc5a1c5175c15969971b", + "rawBytes": 40618, + "rawSHA256": "3abccbf66562f75b0649b86519353acc317cc4405051b269a6dfdf09cbd23feb" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/sibling-capacity-bounded-v1-20260912131232993-0dae1d73/sibling-completeCapacity.json", + "mode": "100644", + "gitBlob": "3017fed25154289a0805b5d52415c0933bb9f987", + "rawBytes": 12437, + "rawSHA256": "7fa9ed78daf87dbfa065aa82f089cfbf2563fe90f1eef664d3301e3425f2c7de" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/sibling-capacity-bounded-v1-20260912131232993-0dae1d73/summary.json", + "mode": "100644", + "gitBlob": "815a2d74e4a4e2fbea66fafa9c3f6cc23a5894b3", + "rawBytes": 131425, + "rawSHA256": "9af7a77855df07179d3a9899388eecacda58dcee1f78ddf193ef9b3ed6f97fd3" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/startup-bounded-v1-20260912131112382-16de550c/summary.json", + "mode": "100644", + "gitBlob": "1ed4dfdb3311da946164df0d379c7e08952b540a", + "rawBytes": 128047, + "rawSHA256": "c34a27bb72b9fe87d646cc539fcc75140392cfd64edfab6852c7e778957437ec" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/startup-bounded-v1-20260912131112382-16de550c/unchanged.json", + "mode": "100644", + "gitBlob": "0057136fe38fe983785e13a7f29150f2fef32360", + "rawBytes": 9284, + "rawSHA256": "cfd77bacbcb8304d1f814c8e4d3c61749737619edf706f539e48537ce933d94a" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/startup-fixed-v1-20260912130326593-5ae12815/summary.json", + "mode": "100644", + "gitBlob": "e484502dccb4ff6891d04488c9cb61f6d1b81ead", + "rawBytes": 120137, + "rawSHA256": "140a2dceac22be786f125b87bda9c5ddb5fc70e808735394568f1f1fc4dac964" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/startup-fixed-v1-20260912130326593-5ae12815/unchanged.json", + "mode": "100644", + "gitBlob": "2e0071e1b17f0bfe76c0dfeb3149ad844274d30e", + "rawBytes": 1999, + "rawSHA256": "7a384c2680324d69c5f8bafd967bf878b9812216710c5059fc21451e02e99b6e" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/startup-local-v1-20260912130542938-da84d62a/summary.json", + "mode": "100644", + "gitBlob": "0e7dce1534075b00ece9923ffe495056f2205036", + "rawBytes": 128041, + "rawSHA256": "9cb2ec431bfe07917529597f2a951cb612d4aceb1507e9ec245efc1afc895ec5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/startup-local-v1-20260912130542938-da84d62a/unchanged.json", + "mode": "100644", + "gitBlob": "d33d971baa69029797936ab5e49144f0593cfb9b", + "rawBytes": 9280, + "rawSHA256": "afab159ac4c59f2f9a31715c5762bb7eae420e9b0f0941263feaa71df49090e1" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/startup-v1-20260912115946824-c5633795/summary.json", + "mode": "100644", + "gitBlob": "2c860e6280e1151731e21bffb48620a24759900a", + "rawBytes": 124581, + "rawSHA256": "31f1115f7ed0f4ae460aced3dc3e7d12d46d0d24060361b33b612bf1e5aed027" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/startup-v1-20260912115946824-c5633795/unchanged.json", + "mode": "100644", + "gitBlob": "a0236bcce9afedd6b6148c7aec5390de9e416c08", + "rawBytes": 9268, + "rawSHA256": "e8bbafe43c54802f8564204ae1186a615bbbe00aca39498febd2325461782bf6" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/without-code-bounded-v1-20260912131141013-c315be77/capacity-without-code.json", + "mode": "100644", + "gitBlob": "0b4f3a341de5b514131b4ed111ed2ecc00fa063f", + "rawBytes": 11741, + "rawSHA256": "cea9e5fe376c2a5c79699fada5a17ba54ab8df89652b0a71a02638064ac30ca5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/without-code-bounded-v1-20260912131141013-c315be77/summary.json", + "mode": "100644", + "gitBlob": "3dda8fe68487ea6f32fa99665d772a9e8128e87d", + "rawBytes": 130679, + "rawSHA256": "4bbf4d3c1e7e863574691cec3a8031034c01d4c642e1afd09ef0b32746874e2e" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/without-code-v1-20260912130638654-f62ec813/capacity-without-code.json", + "mode": "100644", + "gitBlob": "3a7b97ddc2961100ccd73a47d6e027df86745e6f", + "rawBytes": 11164, + "rawSHA256": "776c35afd301f51c3f46641e0adb319ea220d4f9f42df2625ef8df219d2c9630" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/without-code-v1-20260912130638654-f62ec813/summary.json", + "mode": "100644", + "gitBlob": "fda7e3f0f49661dcce22566ff9739a350d6b33b5", + "rawBytes": 130011, + "rawSHA256": "4a5b4f30c3e2b83f71395407b5d962e87f3f181dd2f69e9d13f72aa80b794035" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/without-scratch-bounded-v1-20260912131205253-a3c06263/capacity-without-scratch.json", + "mode": "100644", + "gitBlob": "dcf1ea6c6512a0b3b76b49ad00f2ff1ffcdb1eb8", + "rawBytes": 12299, + "rawSHA256": "897c3b948e05a28eacde75f7fd7ec9b4336321a51651752583b317586a5e0032" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/without-scratch-bounded-v1-20260912131205253-a3c06263/summary.json", + "mode": "100644", + "gitBlob": "04269d84a46491eb63dcd9a095fe7e6e27cb41e7", + "rawBytes": 131270, + "rawSHA256": "d4490c8903753a59fe1fbb54e2e0f25b7a932ba26c43623d34db135b40f106b5" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/records/write-scope-freeze-r17.json", + "mode": "100644", + "gitBlob": "ee478c7c27cf9996a4d67bda7eefb508b1c1cc86", + "rawBytes": 103609, + "rawSHA256": "d9100b6ee635781917fa551189f764fa66d999664e33a134ff19b0560e8f5d73" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/registry-v1.json", + "mode": "100644", + "gitBlob": "60b2170865b060b909e44fdad0c18975e71c3c71", + "rawBytes": 194, + "rawSHA256": "546ed02ed97227c269c4649c0b75c5a7337b9d40de6ada14cbbe2546ad79feeb" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/snapshots/97405C70ED3B60CED72874D6DF622D2E9BBA0BD8F04808A3F98ED34EE1CEB770/Capstone.lean", + "mode": "100644", + "gitBlob": "8184759bbac7eb8b54cfe5acea62c9b86cb8211b", + "rawBytes": 11412, + "rawSHA256": "1c6cd0a85b77fba7706c77da87de358808a24fa661d5635a3c4b3bbf96005d69" + }, + { + "path": "docs/internal/extensions/bv1/controls/public_mutations/snapshots/97405C70ED3B60CED72874D6DF622D2E9BBA0BD8F04808A3F98ED34EE1CEB770/public_expected_type.lean", + "mode": "100644", + "gitBlob": "77799af6f8a981de81e5e91e85929247d66013c8", + "rawBytes": 13417, + "rawSHA256": "fea8d045ef0a9cb9679949ed8825f2e04a4542c01e8f056a778bb0b474bf7a9e" + }, + { + "path": "docs/internal/extensions/bv1/controls/route_v1_probe.ps1", + "mode": "100644", + "gitBlob": "56b10b0c192073009fd4a98c265e4fb3cc340568", + "rawBytes": 1693, + "rawSHA256": "8c3d92d057026636386bcd075886c54e9d034c6e2322f8c7290244b1934f4d38" + }, + { + "path": "docs/internal/extensions/bv1/controls/route_v1_selector_controls.ps1", + "mode": "100644", + "gitBlob": "33778f78952730c95cc0148f81a8fc070652b431", + "rawBytes": 3190, + "rawSHA256": "d676ac5f587f3eecc0a15b75ccbb0e76b729dd531e7e6a72eaf1ffcb3f0e1228" + }, + { + "path": "docs/internal/extensions/bv1/controls/route_v1_validator.lean", + "mode": "100644", + "gitBlob": "727ff397c3c56a97e4235322fffa310ec3fbe177", + "rawBytes": 4441, + "rawSHA256": "a36acf5edf0750d2f5f01bcce931b2104310e68aefeb4f7a6bbe6cebea30aca3" + }, + { + "path": "docs/internal/extensions/bv1/controls/validation_v2/baseline.lean", + "mode": "100644", + "gitBlob": "702061d81a8595ad940019bb5ec572e768eb78e7", + "rawBytes": 9387, + "rawSHA256": "333b0a6bd8fb3082051845d2f1bd333668b9d33758a9030a68b25695cfee068e" + }, + { + "path": "docs/internal/extensions/bv1/controls/validation_v2/registry.json", + "mode": "100644", + "gitBlob": "eb7884ee4e29c206f40644ecea1c336e565ef92f", + "rawBytes": 3204, + "rawSHA256": "ba82633fc1d6647a294c150dc20a21159c64635a08ffd5cba5b3c16464b64cdf" + }, + { + "path": "docs/internal/extensions/bv1/controls/validation_v2/removed_fixture.lean", + "mode": "100644", + "gitBlob": "36bc541d427a58eefc583cf2c029bb7caad7d16c", + "rawBytes": 9306, + "rawSHA256": "1f2241088dd172b38673aa376f291400c5b68db319545a3c465b78e971875bb2" + }, + { + "path": "docs/internal/extensions/bv1/controls/validation_v2/restored.lean", + "mode": "100644", + "gitBlob": "702061d81a8595ad940019bb5ec572e768eb78e7", + "rawBytes": 9387, + "rawSHA256": "333b0a6bd8fb3082051845d2f1bd333668b9d33758a9030a68b25695cfee068e" + }, + { + "path": "docs/internal/extensions/bv1/controls/validation_v2/wrong_crossing.lean", + "mode": "100644", + "gitBlob": "6eb488621eac8ac4e5306b30c8b08fae9af443c0", + "rawBytes": 9387, + "rawSHA256": "6b9484013683bfa4e6c0f46800582bfede057ba8661273dcaca5bb8453d06d14" + }, + { + "path": "docs/internal/extensions/bv1/controls/validation_v2/wrong_packet.lean", + "mode": "100644", + "gitBlob": "1d0478d02f82624fd652cb8664ba32a339980e1a", + "rawBytes": 9391, + "rawSHA256": "4895b39f548a5c434d173288346a59d812d996f5a2a1d31d1cc0e7fbacf478a1" + }, + { + "path": "docs/internal/extensions/bv1/freeze_contract.ps1", + "mode": "100644", + "gitBlob": "4c5f2997143f1746d914ba3f12c29f8b4ad2019f", + "rawBytes": 11973, + "rawSHA256": "930f16af7c38dac2198f9f894f6ba96aad4b9153fdc02205f2196cc646ea9f45" + }, + { + "path": "docs/internal/extensions/bv1/run_command.ps1", + "mode": "100644", + "gitBlob": "f2b6b69b8339224d2b8787df23bbf404a2686248", + "rawBytes": 2193, + "rawSHA256": "bd1b93838aaffdf67bf06bf5e613b208e0944f55027dedd223b36cce483099f7" + }, + { + "path": "docs/internal/extensions/bv1/run_final_gate.ps1", + "mode": "100644", + "gitBlob": "d87947b32f3b08432f06afc221fc9c22ea14ddfe", + "rawBytes": 6837, + "rawSHA256": "3c7b8f56f96406cc170fe80e135b0cbbd8c6109f0a6eb27d5a9d24f6bef34ea3" + }, + { + "path": "docs/internal/extensions/bv1/verify_phase.ps1", + "mode": "100644", + "gitBlob": "c688d094e5f873da2cd73c7f8b389ea3c7d9ecc9", + "rawBytes": 3629, + "rawSHA256": "0727c072e20b50cddcd983d7caab56eca84b906a5edea2eb242835a88faa4afe" + }, + { + "path": "docs/internal/extensions/lb1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "0ef956c9d6922a94e55b5afed2d2b3e8e768aeb5", + "rawBytes": 18465, + "rawSHA256": "21d7970e80844c07b6e87ab0ca78b3a792b624b11e1f0ee1d975ddf8c5578c95" + }, + { + "path": "docs/internal/extensions/lb1/AUDIT_D6_INCONCLUSIVE.md", + "mode": "100644", + "gitBlob": "7d843c28c6796e6b288cdb3d3ae501330a264375", + "rawBytes": 997, + "rawSHA256": "45c5125ff020e050e05496b3bc061c2f8c0c92228bff4a80becddc894470a773" + }, + { + "path": "docs/internal/extensions/lb1/AUDIT_PROMPT_DRAFT.md", + "mode": "100644", + "gitBlob": "1b5253bffe86d67bd3a0af2f1cdef3f76d1d9630", + "rawBytes": 30280, + "rawSHA256": "c747b0b3d423eba89fa80416627f8dac31f4b03dc690d9afb29b7986e6943547" + }, + { + "path": "docs/internal/extensions/lb1/CONTRACT.md", + "mode": "100644", + "gitBlob": "49c4763d142d277a282aebd510f8ba55b9ecf912", + "rawBytes": 6963, + "rawSHA256": "c37a1604c4d9a73b4e8b9ba336ed7f8138bda9dcc14c9ce4709ebcd51f253dc1" + }, + { + "path": "docs/internal/extensions/lb1/CONTRACT_REVIEW.md", + "mode": "100644", + "gitBlob": "cad3efd2edaf3cbe1c9b432913e9b2cf48148c18", + "rawBytes": 14550, + "rawSHA256": "4521f23d2295abc87cf7dc4735c486c8aaff125f064cd07a973f0bc9c02afda2" + }, + { + "path": "docs/internal/extensions/lb1/COUNT_PROOF_NOTES.md", + "mode": "100644", + "gitBlob": "4f5e5c140d9b76ed6f942dde039931a041b8ed26", + "rawBytes": 22524, + "rawSHA256": "1684dd3dad857808ba959e74fda1f607b55d287069b3d094beb05e6eff794452" + }, + { + "path": "docs/internal/extensions/lb1/EVIDENCE_PLAN.md", + "mode": "100644", + "gitBlob": "1d1553ef9d3ac463fca963d0a4e46555777577da", + "rawBytes": 13426, + "rawSHA256": "bb85ebc1affce213a3aec70695e64d6b27c3d62bfac5b79ae29f7ca67167a8f9" + }, + { + "path": "docs/internal/extensions/lb1/FINAL_AUDIT.md", + "mode": "100644", + "gitBlob": "ecccf970b8ef207dafa9982f73251254cf1069fd", + "rawBytes": 60590, + "rawSHA256": "7f26751cb14dfb9c345bc13dc374c1f4d6aa8cc0e8677d3b7fecd236a6726778" + }, + { + "path": "docs/internal/extensions/lb1/FINAL_DISPOSITION.md", + "mode": "100644", + "gitBlob": "05f0547a0acf7f9bef43538dafc8cde77d07d0e8", + "rawBytes": 9723, + "rawSHA256": "307bef03aa8179ae71cc2c79f7cc4ef211c902be34ffa369de16fbb49d52d967" + }, + { + "path": "docs/internal/extensions/lb1/FROZEN_INVARIANTS.md", + "mode": "100644", + "gitBlob": "bccbdf3e2b7663f219e67f7aae50ed7404c012fb", + "rawBytes": 5172, + "rawSHA256": "dba3e9a832430b6b77af233694591e3f3351b8d0f8f0e1089a742e069983af8c" + }, + { + "path": "docs/internal/extensions/lb1/FROZEN_REQUIREMENTS.md", + "mode": "100644", + "gitBlob": "a13021ea8fca97b96179bad0f42536bb3952d91f", + "rawBytes": 2903, + "rawSHA256": "c6973439fb2f915f47cc0d641f33fa1f4f9844260b3d2a42dc4c5d41baf9a7d1" + }, + { + "path": "docs/internal/extensions/lb1/FROZEN_ROW_EVIDENCE.md", + "mode": "100644", + "gitBlob": "28b9090a802856577550ffbc225837a78380e36c", + "rawBytes": 9483, + "rawSHA256": "ad164b668cbeb805019c4368f3564d5ff5e182b2b09ece89dcd84200fd527f71" + }, + { + "path": "docs/internal/extensions/lb1/PACKED_PROOF_NOTES.md", + "mode": "100644", + "gitBlob": "c5e0c4ad01837b420881a75837b8f6d22e3a4e25", + "rawBytes": 9778, + "rawSHA256": "87699acc658f305232e9ed45054a203be4caa80eb18b20736ec28aa8628358a3" + }, + { + "path": "docs/internal/extensions/lb1/REPLAY_REGISTRY.json", + "mode": "100644", + "gitBlob": "16adc302887bb2d13b8388af8463b6328a604acf", + "rawBytes": 10844, + "rawSHA256": "9015398f8f1aee8af69c21294b2437b68fc77df70006b69edd2a593878d07e8b" + }, + { + "path": "docs/internal/extensions/lb1/REPLAY_REVIEW.md", + "mode": "100644", + "gitBlob": "92c165edc90b806d0115204616408d514836e8eb", + "rawBytes": 7818, + "rawSHA256": "97c9e31d32b6bd801166ee4dd340bfde62ceb7cdf622655d2d5c92bbb0d71212" + }, + { + "path": "docs/internal/extensions/lb1/REPORT.md", + "mode": "100644", + "gitBlob": "8b939ff059a658aef8742b97322ffdf21f954a1d", + "rawBytes": 15415, + "rawSHA256": "0669030286c33c1c2c272a6d3e02313f41bc0f0a0b18e39fd108fb10468460d9" + }, + { + "path": "docs/internal/extensions/lb1/SOURCE_RISK_REVIEW.md", + "mode": "100644", + "gitBlob": "fa24eaf9364f3770d5ff463aa43c042f396e5d5e", + "rawBytes": 25192, + "rawSHA256": "ebd0ef82d236fe465eb246b5835f8df117b76eb43227d17f5ce5a0398b4460d5" + }, + { + "path": "docs/internal/extensions/lb1/VERIFICATION_LEDGER.md", + "mode": "100644", + "gitBlob": "9833d8aa5a5c5a732880a64b19ffda35944bac55", + "rawBytes": 12914, + "rawSHA256": "672f419da9469f6a88528ce56b262f9db2dc43c8eddb057c397b1851f1e9b4b3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/REPLAY_REGISTRY_v1.json", + "mode": "100644", + "gitBlob": "6f97ed70ae35fd0cc49a9cead0425172e6055b30", + "rawBytes": 9654, + "rawSHA256": "c8228678c188c14bf579ee1db2876a0d511010eda539d1404cdfdcaf38bbf0b8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/REPLAY_REGISTRY_v2.json", + "mode": "100644", + "gitBlob": "4257558f7bd807148fb87a4a56aa94ba68e493f8", + "rawBytes": 10691, + "rawSHA256": "c31cf089904cf1b377c53f19109cb756dbbc969dcdd6a95b7d92abb4899b86ce" + }, + { + "path": "docs/internal/extensions/lb1/evidence/S03SamePredicateDiagnostic.json", + "mode": "100644", + "gitBlob": "f3f65cfa14d97b561c89d90b84954bbc3bec2082", + "rawBytes": 1198, + "rawSHA256": "dbb395edf0e0413ec63fec7c91f8e0aee3cd2bb7b8020712b15a88d408aed04a" + }, + { + "path": "docs/internal/extensions/lb1/evidence/S03SamePredicateDiagnostic.lean", + "mode": "100644", + "gitBlob": "47bc35beaed406ecdadfa427e531f3511ed88e1e", + "rawBytes": 885, + "rawSHA256": "3748714fc508b7db57fb97f95dd871ac218e70b1ea7150ccaf29fe8c3d778c72" + }, + { + "path": "docs/internal/extensions/lb1/evidence/audit-launch-5033/AUDIT_PROMPT_READY.md", + "mode": "100644", + "gitBlob": "70514bf71f0262d096e3d6686bccf946234c731a", + "rawBytes": 32925, + "rawSHA256": "63b4119cba8797d2cd8b8a319abbe14fa9fec9f157311c634a52682a9bf91767" + }, + { + "path": "docs/internal/extensions/lb1/evidence/audit-launch-5033/baseline-runtime-manifest.json", + "mode": "100644", + "gitBlob": "1ca9fac057d5fe8ef47a64e9cb9adf368139617e", + "rawBytes": 5761, + "rawSHA256": "4ff2ad65d48a36b95c6bf5b419fbe18c555e2e4fb055101f8a56ce62caa77b10" + }, + { + "path": "docs/internal/extensions/lb1/evidence/audit-launch-5033/delivered-evidence-manifest.json", + "mode": "100644", + "gitBlob": "f58c2bae496148fc5a4cbb855079fd3a9fe87cd7", + "rawBytes": 6369, + "rawSHA256": "3c8459bed9b99a4def74cb8970f4c5038629f46b1a9b79922a6f902423bdee7d" + }, + { + "path": "docs/internal/extensions/lb1/evidence/audit-launch-5033/full-replay-manifest.json", + "mode": "100644", + "gitBlob": "906031c67dcb62eb907a24c238cea76ea784db61", + "rawBytes": 59582, + "rawSHA256": "bc23837a1b04c1714fb8cef1e09be14f456306419687ebced8ca49728048ae30" + }, + { + "path": "docs/internal/extensions/lb1/evidence/audit-launch-5033/immutable-source-manifest.json", + "mode": "100644", + "gitBlob": "0804feb17143180d33dace91ad70d3d8216081bc", + "rawBytes": 283557, + "rawSHA256": "046e16aa91d82722baa39af0f5bf3cf949811757430e85a5372289176e366549" + }, + { + "path": "docs/internal/extensions/lb1/evidence/audit-launch-5033/launch-receipt.json", + "mode": "100644", + "gitBlob": "cebd0f6b667ca07fe1346c041bc1db9d850e77ba", + "rawBytes": 2386, + "rawSHA256": "6ae98c59d886e70e825edff8019fdc54297443d5a5ff2fd463730460847732e0" + }, + { + "path": "docs/internal/extensions/lb1/evidence/audit-report-receipt.json", + "mode": "100644", + "gitBlob": "fdc5c0201a26b7907765d291a774ecab949a5e0f", + "rawBytes": 725, + "rawSHA256": "211fb39287488676c2564e48f8a0fbd7048aec31bc42e5e81a2b3b6c105902fb" + }, + { + "path": "docs/internal/extensions/lb1/evidence/axiom-inventory-development.json", + "mode": "100644", + "gitBlob": "07c09497629f93241a82bc1aaabdc1946c048ed3", + "rawBytes": 6151, + "rawSHA256": "67a7ba044588c45401562d8fc31ba72ddcbb592a3c95d2373c5ce16b305f8149" + }, + { + "path": "docs/internal/extensions/lb1/evidence/axiom-summary.json", + "mode": "100644", + "gitBlob": "c3153265b5161b1b786be806ea0001261e73e61c", + "rawBytes": 1595, + "rawSHA256": "190ddf0cfa10a211d7b519dd621c153a5272e6880f86302cc5863f63d4781ce8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/build-20260912T071459461.jsonl", + "mode": "100644", + "gitBlob": "e6347117261eaf0885e5e8acd65b34b23766c3a4", + "rawBytes": 11228, + "rawSHA256": "aaaf13f1c08e1b64db60bec42c2d92a031deeb2efb411aa4891f64e43d5c67c0" + }, + { + "path": "docs/internal/extensions/lb1/evidence/build-20260912T071953550.jsonl", + "mode": "100644", + "gitBlob": "7ad5569c7acb0e26f5f6f0baa722cfdc4c2e3761", + "rawBytes": 872, + "rawSHA256": "b1fea60da6f066f541abe008c17caa7805beabc6b77fca3ea6df15924ebd80fa" + }, + { + "path": "docs/internal/extensions/lb1/evidence/build-20260912T072455472.jsonl", + "mode": "100644", + "gitBlob": "b3d0ce7bbf257f4ea6ebace50036b5b5c9158147", + "rawBytes": 426422, + "rawSHA256": "3dea96f33f468f166526179324a7d41ca91007c0c6536dd787a477de1eae1bbb" + }, + { + "path": "docs/internal/extensions/lb1/evidence/build-20260912T084142579.jsonl", + "mode": "100644", + "gitBlob": "3c5fb2e6f3f56bfe38284341230687bf5c66dafb", + "rawBytes": 912, + "rawSHA256": "c6bf421628f29bdd09dacc771b9e55d0c990e90ab7169ddac5564cf3bd69878f" + }, + { + "path": "docs/internal/extensions/lb1/evidence/build-20260912T084243070.jsonl", + "mode": "100644", + "gitBlob": "cdb4e39c572186441827e3bb219412d435c71a4c", + "rawBytes": 1427, + "rawSHA256": "c38d36ada3480909082eaea53a5912f23e14c410bb29b7e4dd270f15f3841270" + }, + { + "path": "docs/internal/extensions/lb1/evidence/build-20260912T084355841.jsonl", + "mode": "100644", + "gitBlob": "f9bfac05e3f1bb84441627a081af2d14236962d2", + "rawBytes": 892, + "rawSHA256": "488654f212715a4711625e1fb64f1fe232b8b8e156943f1f0f3c3e41dbca71cb" + }, + { + "path": "docs/internal/extensions/lb1/evidence/build-20260912T100805553.jsonl", + "mode": "100644", + "gitBlob": "adbd6c7d28f2b8130f8e173ffd89e8b0938d2750", + "rawBytes": 892, + "rawSHA256": "be805f42763fefaf78effbb7503797eee36b3851da66ef257a5cdabd07239598" + }, + { + "path": "docs/internal/extensions/lb1/evidence/development-checks.json", + "mode": "100644", + "gitBlob": "bb22f02a1c4a05b270e5e92b8bd71e3adc11da92", + "rawBytes": 2653, + "rawSHA256": "b7ad3379491473351d00e8790c616dd8f2a95ca105f7ae89ec8fd827e132e433" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-evidence-manifest.json", + "mode": "100644", + "gitBlob": "ccff4a28c37009d6041369112e314b84e51e387b", + "rawBytes": 71281, + "rawSHA256": "9eac10b7db0d08a860887145b1e62f2853d7e369095712ef9c3f4006002248e7" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/audit-d6-inconclusive.md.gz", + "mode": "100644", + "gitBlob": "96fef014611389e30b9d0d034273211199e1e75e", + "rawBytes": 22013, + "rawSHA256": "2c3248e96d1804ee2be82ccd46426111fa58b7e794b56aec5ee15e064add782c" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/final-frozen-rows.json", + "mode": "100644", + "gitBlob": "0fc16f19ce945ba4efc7a1a6510eb1c3ba378fca", + "rawBytes": 12424, + "rawSHA256": "785aa40020b248d50f409f53d60dd9aa5eff37b5a775267f86af45705e91a46e" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/final-replay-verification.json", + "mode": "100644", + "gitBlob": "1f55611f91b8b14771e97588522cb06f4cb3f915", + "rawBytes": 338835, + "rawSHA256": "9e12b8d8c2148f38f253e0bcbc8955c89ce371e1a641fe96d12740c3add12494" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/full-terminal-receipt.json", + "mode": "100644", + "gitBlob": "02d7a97efc8d884d245b97fd3818caa28d066a73", + "rawBytes": 2215, + "rawSHA256": "00846aa0f1d3320ddc3ef207286e0110c42382609189008e946cddc999fa86e2" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/historical-audit-claim.log.gz", + "mode": "100644", + "gitBlob": "0e22ab18c1e80077f1caab06255d4af096b629fb", + "rawBytes": 585, + "rawSHA256": "58516be0bf581e826356e33e8b30de65f5ce20fa5d79f75a334746a3bc096ddd" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/report-certified-claim.log.gz", + "mode": "100644", + "gitBlob": "e6066d900344957c8260c6f6f7d643fb86a38dec", + "rawBytes": 604618, + "rawSHA256": "a750c8419abbc29b136282394546a46bb2f07ea22259d6acaa6c5a6d0a980d27" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/report-certified-design.log", + "mode": "100644", + "gitBlob": "07d0a0374e8cb9b21b77987fefe49edd60956bad", + "rawBytes": 76, + "rawSHA256": "cb70c605b01ac3bb88b012b3bcb073900dbc7801060ec0ed0dcf218a86c82b0f" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/report-claim-discovery.log.gz", + "mode": "100644", + "gitBlob": "93a7db9b2819b1a6aba27915f82a8210c2cee65e", + "rawBytes": 3214773, + "rawSHA256": "fe035cf19490c87aeb9a51fced1b86719e4575b69f7fdcf821094d9463883e99" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/report-whitespace-discovery.log.gz", + "mode": "100644", + "gitBlob": "09efc1d151b596ec8738acc243df07260e3711a4", + "rawBytes": 304, + "rawSHA256": "c8754e96a4cc6a627d51c9e3021194bac484130bde04f046c467c9b6b45e64f6" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/run-conflicts.ps1", + "mode": "100644", + "gitBlob": "2272d16533e2b0b05f2eb9efcbf83d343e68a9dc", + "rawBytes": 4906, + "rawSHA256": "dd5da56b8a1dbc34fc659e1e0b88400bc11cdafa2bcad121d967865d999aa466" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/run-final-trust.ps1", + "mode": "100644", + "gitBlob": "affb1c44cc5f02633fd59abfe4de6a093a06b37d", + "rawBytes": 5984, + "rawSHA256": "fe19df3c0d5c562fd01ae7d5918ebba0bcd092caba30d02bdf56275770a55f97" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/run-focused.ps1", + "mode": "100644", + "gitBlob": "a1537b410159d37e2714ad48fa978527a9f12168", + "rawBytes": 4295, + "rawSHA256": "898238cd16bd54a0901b06f2b6a1daaacab761b7a52a3f6aa0e517fba2023539" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/source-5033-claim.log.gz", + "mode": "100644", + "gitBlob": "2a5e9682835181469cd8949cd4226ba0da124950", + "rawBytes": 604156, + "rawSHA256": "83cc10ed0f4c1d64720c15607af0374791f1be40263695bc95fbcd69ec6153a8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/source-5033-design.log", + "mode": "100644", + "gitBlob": "1663957322b0dfe1eb2359c26c93de4446c02e56", + "rawBytes": 75, + "rawSHA256": "b8c6f527afceb3e87aae310e208aa97caaaa1ef4ea72d91d5f4235b55fa828cc" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/source-5033-policy.json", + "mode": "100644", + "gitBlob": "66b602a0fe90abf7ed5ace7ee0783fc1f4087a90", + "rawBytes": 1066, + "rawSHA256": "ac5752d0902fca77f56f5c64da022e9343453daaf7a4a0e4ad4fb2f3466606a2" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/stopped-audit-2.json", + "mode": "100644", + "gitBlob": "96041d9fd10af35b1e31a47022ec19465e8d9a28", + "rawBytes": 721, + "rawSHA256": "64d83970dcc0344b6a7c560756e4001475b5a6ab521017719494d8d1941fd4e6" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/verifier-discovery-001-bytes-property.json", + "mode": "100644", + "gitBlob": "b9fd380af33b911a323661e1e010102f7772eaf9", + "rawBytes": 2334, + "rawSHA256": "000738b4daaa67bb2d262677ba5a093be33cf8a12afca8849487274846f94177" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/verifier-discovery-001-pipeline.json", + "mode": "100644", + "gitBlob": "9a62a8f36455c7bbe29ea04c8d0017fe413a4299", + "rawBytes": 315, + "rawSHA256": "56c0c9e656dbd26dacd0c50ffbf348cc0820d9979348e80a67e3063876aeb36c" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/verifier-discovery-002-nul-excludes.json", + "mode": "100644", + "gitBlob": "170f5cab2d1fa62c7b0724615670834263558cd9", + "rawBytes": 2310, + "rawSHA256": "384d4e5c751d24316f3aed4556008cc9d3dd35c6c7d93daa1799c864f58187d2" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/verifier-discovery-003-local-ignore-pass.json", + "mode": "100644", + "gitBlob": "36390f47e954eea1fa515f855f9dd48c7a776af7", + "rawBytes": 338835, + "rawSHA256": "3a2d74ae62305053853cfb166aa8be7039153429405b4ff6931a9cf022df3722" + }, + { + "path": "docs/internal/extensions/lb1/evidence/final-verification/verify-final-replay.ps1", + "mode": "100644", + "gitBlob": "6265a990614b87686c5b031326c42e44300c84d7", + "rawBytes": 34122, + "rawSHA256": "b0f56d591e67b67df2c5e24f43e8564eea993d579eba15daabc4cf1ce15d7bbb" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/DeadlineOnly.json", + "mode": "100644", + "gitBlob": "11fdbe69941afd303cf18b0b34e55316996fd8c7", + "rawBytes": 3459, + "rawSHA256": "4353b059d6ffca82e65130c6b4cf296bbece4ce42cb95641fd649abd839d48fb" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/DiagnosticOnly.json", + "mode": "100644", + "gitBlob": "e57cd0424a5d837e371c91d12ec45afa1314f6eb", + "rawBytes": 2742, + "rawSHA256": "1d8d9ebab95be41760797f19a189da2559ca0c17404237b1e87b70b6e630248a" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/RegistryOnly.json", + "mode": "100644", + "gitBlob": "b6ea83b2b355941b6a5a110a516511f02f819c1d", + "rawBytes": 2718, + "rawSHA256": "2fad915984f617b7ec55815c63884d68a7357e6709fc59ffd03cc2be5f08c969" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/RuntimeOnly.json", + "mode": "100644", + "gitBlob": "d655b426cacb397b62a629223053c8b4315c0b17", + "rawBytes": 3493, + "rawSHA256": "7ea5df824e0a62032d3d28f914110fc53681e27be8cb9e43061af43645334f1f" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/SelectorBoundaryOnly.json", + "mode": "100644", + "gitBlob": "cfb1c03d05342475dcbcbdd13822b7d9876317ae", + "rawBytes": 3388, + "rawSHA256": "9f89761636147579b8d22fcd45dc8574187875cc6fc58d1c36eed64d2f3ec808" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/DeadlineOnly-0/deadline-fixture.ps1", + "mode": "100644", + "gitBlob": "f26738b0309cb5949e09ed4bcb6b5bf6087ed4c2", + "rawBytes": 431, + "rawSHA256": "4e890249f8d3222ee32d0174e1ed8f886e98ef11642b222f85f67a1317a919e8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/DeadlineOnly-0/deadline-result.json", + "mode": "100644", + "gitBlob": "ab090c44876af83015bcc3e53b44dcc42d97511b", + "rawBytes": 343, + "rawSHA256": "fb778481933e195fcc8630d0a49fcab74f2f2ba697d3eb2a427cfdbb42038744" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/DeadlineOnly-0/descendant.pid", + "mode": "100644", + "gitBlob": "c05bef18ed18cf0cf210446be47381acf4b4eafb", + "rawBytes": 4, + "rawSHA256": "bb4895391bddaadead1c9015d8c4df4806458cd7901f221b5c6b92b8cfa9297a" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/DiagnosticOnly-0/diagnostic-boundary.lean", + "mode": "100644", + "gitBlob": "8dfb0224f2a771d50e00d47e79f440cb1b8bfded", + "rawBytes": 82, + "rawSHA256": "095aa29925219a82ee935057c12ce34296ad318ba3415b2ede6b51a1e3101343" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/RuntimeOnly-0/runtime-full.json", + "mode": "100644", + "gitBlob": "96a2eee91d007ef320d1fb5d9c2f31cda4ae6baa", + "rawBytes": 1135, + "rawSHA256": "526fb4a54d572f9cbb1f38a8573e35b7fbcba651e0963201b4c695f6d0c554ac" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/RuntimeOnly-0/runtime-known-selector.json", + "mode": "100644", + "gitBlob": "81c79328e5fd7c4b3706c397eb78489fd86fe2b4", + "rawBytes": 576, + "rawSHA256": "e95a55307426f3950c42511f860019105428c4047989649ef0e518296f6516a8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/RuntimeOnly-0/runtime-selector-empty.json", + "mode": "100644", + "gitBlob": "b2cb87a292f5fb3ffbc76fa1c37012f7516ad2bc", + "rawBytes": 413, + "rawSHA256": "5943b041fc62558a9894f3e26c267a5315602d1f7ff32dfc69d2622e8c50e7ad" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/RuntimeOnly-0/runtime-selector-malformed.json", + "mode": "100644", + "gitBlob": "077c2cd1e4c74e7b34eedc1d2b3e928086bf8bf0", + "rawBytes": 440, + "rawSHA256": "30c7be856e171a4e692b901d18e35553dff3a993bb34b565218920bbb559d340" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/RuntimeOnly-0/runtime-selector-unknown.json", + "mode": "100644", + "gitBlob": "e358cc0e862d00c4c39681c65a8c9d9d742d43bc", + "rawBytes": 446, + "rawSHA256": "c425152e89c44ccef3a6478b917ead72f71d1e92b10e8eb556bc3af64591ae8d" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/RuntimeOnly-0/runtime-selector-whitespace.json", + "mode": "100644", + "gitBlob": "2d94ed68f3b1aa7b4496a1f33806bf3df682c3df", + "rawBytes": 429, + "rawSHA256": "a957511191d26677e07ba2f86c89443b4276d5b6cf975d944dd7eba677416a34" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/RuntimeOnly-0/runtime-startup.json", + "mode": "100644", + "gitBlob": "1afc54e9702686e392f41f9f5cbd8aab2feeb534", + "rawBytes": 704, + "rawSHA256": "8cff41191a00812cbeb4ad6cb6c2b0304048f25d5146c4be4c4b9c510819efc7" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/SelectorBoundaryOnly-0/selector-empty.json", + "mode": "100644", + "gitBlob": "1fe21ca75323fcb7270e6df47d577af3ef928b18", + "rawBytes": 1002, + "rawSHA256": "c0c4f89ed1c3cf19b7de13d042bca633c8fcc7e7925a29720ffd2b1628d7bb4b" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/SelectorBoundaryOnly-0/selector-malformed.json", + "mode": "100644", + "gitBlob": "34d1cda170d2353054d67ed6bab4e1810b5b7b2a", + "rawBytes": 988, + "rawSHA256": "bdfdc7518f60cccdedc6b5b17bfbf2d0fac8b9b1b2598d66300987eb4e3da2b1" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/SelectorBoundaryOnly-0/selector-omitted.json", + "mode": "100644", + "gitBlob": "0bdf06241e8769275116070af2ac72cf7c9ef2fc", + "rawBytes": 2882, + "rawSHA256": "21edcd4956f58a7603b72ef957b7d68096bf596f9a35ab89695a3f49c4c022b0" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/SelectorBoundaryOnly-0/selector-unknown.json", + "mode": "100644", + "gitBlob": "90feab8f18741e2462aaa6739581fb7cae386d20", + "rawBytes": 979, + "rawSHA256": "4f805dea975d7a07656a90aadbc5af35a827ef5b9ca1b2726f598ee2ff41c664" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/SelectorBoundaryOnly-0/selector-valid.json", + "mode": "100644", + "gitBlob": "97d70c0602cc5e23a99a3d6a53cff30f4abf4896", + "rawBytes": 402, + "rawSHA256": "c9d8e36da4b135b5f5b862d2e24f19a609cc691159754c5436d7d803a21cf231" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/children/SelectorBoundaryOnly-0/selector-whitespace.json", + "mode": "100644", + "gitBlob": "b81fb8b6b1463c19998c565e56e6c67d9f0a3108", + "rawBytes": 1007, + "rawSHA256": "d40cb998a07ac96491c569077bcfee77a5f7d6fbce9a4096310799159ddb2883" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-modes-5033/summary.json", + "mode": "100644", + "gitBlob": "4e8245ecf78250baa3edef49157b0eeacb1b1e4b", + "rawBytes": 18074, + "rawSHA256": "ae6c9abcf27bcbd059ad40d011bec743932b6b31c781039dd4adc769f36fbdaf" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/S03-SIBLING-BUDGET-consumer.json", + "mode": "100644", + "gitBlob": "de749dca468fd290a08685c9e76cf2a5c352df0b", + "rawBytes": 1243, + "rawSHA256": "58e28f29a2494e82314e91b303cfff45ed9cbc71970c8c77f7811d038406b439" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/S03-SIBLING-BUDGET-producer.json", + "mode": "100644", + "gitBlob": "f65794e4d96734e8ddf54124a3005d8cdf98fd95", + "rawBytes": 300, + "rawSHA256": "8105a064ef2c9a4c53e9519ffb999d6cdbd8f864bd829e77dc86fcd0b7c6206d" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/baseline-consumer.json", + "mode": "100644", + "gitBlob": "f96846af6d869aa965898f8ca869dcabfb3f3041", + "rawBytes": 293, + "rawSHA256": "95f31df092195b0153a5dda7e7c2ae3c14594df3ec2f3816d6e7eb068cad1616" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/baseline-generic-consumer.json", + "mode": "100644", + "gitBlob": "ca5712403a40f0d4d90f2c30aa25ad7c136d02e9", + "rawBytes": 300, + "rawSHA256": "96a7ea7dd24b07bead3ab14838c1475fc11eb9707e36cd15243bed27623f8786" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/baseline-generic-producer.json", + "mode": "100644", + "gitBlob": "913ffab5bf21197ff1fec5ad433b009322446d7a", + "rawBytes": 300, + "rawSHA256": "f7698694f62d758cae495b429b00e647b42d956f672d4821e2681281286f2b45" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/baseline-inventory.json", + "mode": "100644", + "gitBlob": "6dcba452a5917a50d6318fb12f2c6bfbd8ec0357", + "rawBytes": 696, + "rawSHA256": "c72559e98dd6854a89f1ce567a2d7d12ca5f921eee17c658848c5bdd0a4dc21e" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/baseline-packed-producer.json", + "mode": "100644", + "gitBlob": "bfe3403f4d7b0f19552b43cb38bbca6e1abe2c6e", + "rawBytes": 299, + "rawSHA256": "233bd9d05b14bcdcbb190913850673b454547efe8308cde36d098a0c06c6b7a9" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/candidate.txt", + "mode": "100644", + "gitBlob": "aea86e28aaca292bc0d7ddbc17018da7072b3f64", + "rawBytes": 40, + "rawSHA256": "38e9f2be4ee79edfa800b36a3e1c3945ea26d0a4b3f9298d014293a2116e3586" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/diagnostic-boundary.lean", + "mode": "100644", + "gitBlob": "8dfb0224f2a771d50e00d47e79f440cb1b8bfded", + "rawBytes": 82, + "rawSHA256": "095aa29925219a82ee935057c12ce34296ad318ba3415b2ede6b51a1e3101343" + }, + { + "path": "docs/internal/extensions/lb1/evidence/focused-s03-5033/summary.json", + "mode": "100644", + "gitBlob": "4f06615480cfa3dc20b36834efa82032dc8d65d6", + "rawBytes": 4162, + "rawSHA256": "76a94106857cf44762efe51ed3c805efa5fae0215c7c9180a5673f45c099fc29" + }, + { + "path": "docs/internal/extensions/lb1/evidence/frozen-rows-5033/binary-git-result.json", + "mode": "100644", + "gitBlob": "37e82f1e2ab6c6f4769e87f172265d5cae406426", + "rawBytes": 398, + "rawSHA256": "12c017570afbf1678e5747b82839b0271ee9cf011d83204f016935b4bed17d3b" + }, + { + "path": "docs/internal/extensions/lb1/evidence/frozen-rows-5033/binary-git.json", + "mode": "100644", + "gitBlob": "e2255a13c499fae39d17e5fa4804400d1763bb37", + "rawBytes": 352, + "rawSHA256": "a4ec1484ef04a42d5a28105480d131ad48f27f897bb09aa5daca2c5f2a454bee" + }, + { + "path": "docs/internal/extensions/lb1/evidence/frozen-rows-5033/evidence.json", + "mode": "100644", + "gitBlob": "06321cef6b1ea909f0a0475b3d290f9f151c1c33", + "rawBytes": 12423, + "rawSHA256": "add641ee29784166fd20f1ff972b1c6242a246e8f82770bb9d6577465fdf8d4d" + }, + { + "path": "docs/internal/extensions/lb1/evidence/inventory-repaired-20260912T084829575.json", + "mode": "100644", + "gitBlob": "d989b47897104ff104ba9224ae4bc7219a9c977f", + "rawBytes": 2973, + "rawSHA256": "7829d223afea1a1933b3009ef1e41585e2e581a2b8ed8be9e732a263e01fd533" + }, + { + "path": "docs/internal/extensions/lb1/evidence/process-controls-development.json", + "mode": "100644", + "gitBlob": "073e0c8c7186927ba8149cfe4804c2c0417555fb", + "rawBytes": 11936, + "rawSHA256": "55980c87b8d7b190f76637809ecf2f2d2e18a4c3863c85e7219965232bcad5b3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/A01-BASELINE.json", + "mode": "100644", + "gitBlob": "56ef52a53841c2d04ea8b94947db2a2504d5effc", + "rawBytes": 288, + "rawSHA256": "fdec8ba62747a85a7d1b3738293aa4c0f28d4365437ac16cb95d18bb0ecceee7" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/A02-PROOF-ONLY-WRAPPER-consumer.json", + "mode": "100644", + "gitBlob": "75e213aba34c37e07d64edba3b5495499aaac128", + "rawBytes": 307, + "rawSHA256": "37b454d8592d08958f89a75a712cbac5af64e4d50579c3736e34c98444bf06ec" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/A02-PROOF-ONLY-WRAPPER-inventory.json", + "mode": "100644", + "gitBlob": "3a4fb21462271dfa897cd02da7a9be7ec86f6a03", + "rawBytes": 711, + "rawSHA256": "01d5f17320d325cf6f7e8ce259372865b5b592612c5bc62e7d1089dbdbcb8bbb" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/A02-PROOF-ONLY-WRAPPER-producer.json", + "mode": "100644", + "gitBlob": "9194d711a00991b0fcdac87ae90f274610f383d5", + "rawBytes": 306, + "rawSHA256": "afee235ac7d1aa045f6a4600ace28b9ab4e466403540ba5ca83b327073d21085" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/D01-NULL-DECODER-producer.json", + "mode": "100644", + "gitBlob": "2e276415d0f4999569b8509b1cd08301b5bdd8d1", + "rawBytes": 3803, + "rawSHA256": "fa7c6d71e4e02baa1dbc4aa987034df930b74c7327eb17883c7be98c095d2b35" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/D02-WRONG-DECODER-producer.json", + "mode": "100644", + "gitBlob": "a93ac9bf7d9069b65b991e0704e8a6720e895393", + "rawBytes": 3802, + "rawSHA256": "d1c575a32a7c9aa61545bccc1f7ed0707c988e7e32ecb953762922d07780b8ce" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/D03-ZERO-SERIALIZER-producer.json", + "mode": "100644", + "gitBlob": "97adb4ef9f73e43210344d81570bce00a27c96d7", + "rawBytes": 2850, + "rawSHA256": "e8a1ef2169a8f95d61979694d6fef263b8a062cefed80b55dda9a32145e399ee" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/F01-DELETE-MEMORY-RECOVERY-consumer.json", + "mode": "100644", + "gitBlob": "10e45c2a3d6ac814113a524d1772c76c0d83e695", + "rawBytes": 1735, + "rawSHA256": "ed099960c4e0bcebce883256f526641142fcf3792b997b2279011786582872ae" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/F01-DELETE-MEMORY-RECOVERY-producer.json", + "mode": "100644", + "gitBlob": "0e9aac910006b5b03d9a34d9256f6a7356718611", + "rawBytes": 310, + "rawSHA256": "bbf32a1fdb4aa435ee98b339a322c94c4ae61eb67630d4dc7e4624156165216f" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/F02-DELETE-READ-BACKING-consumer.json", + "mode": "100644", + "gitBlob": "a9e60617a6c3d7bc3305fea2cbd8401a967eb3d7", + "rawBytes": 1092, + "rawSHA256": "8a83b47fb5c3f77a179ffb52065a0b7b38e5ec91181f00760710c3c027e022c0" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/F02-DELETE-READ-BACKING-producer.json", + "mode": "100644", + "gitBlob": "9757773f41d56af26d9720faa64b0cc5509a569f", + "rawBytes": 307, + "rawSHA256": "dbb7f035489cf8c430d263ebfa7c95840603b0c90476d476427daff1c9ee6ffc" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/G01-LOWER-PROPOSITION-consumer.json", + "mode": "100644", + "gitBlob": "b3f34e5f3f64327e72a00582856401258b57a254", + "rawBytes": 991, + "rawSHA256": "2a76c30f2f32dd5b92e7491f64313ac6a2bd4d393eb485b2d2034ef623c2af38" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/G01-LOWER-PROPOSITION-producer.json", + "mode": "100644", + "gitBlob": "356eba7ebf9ba14c4b7d2125e4938657a1bc59a6", + "rawBytes": 759, + "rawSHA256": "e68d8c9b463e63d8c0ed3bbe51321f7fa76c3d5ee0bf6a4e4d4cca8ecbea1fc6" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/G02-DELETED-EXACTNESS-producer.json", + "mode": "100644", + "gitBlob": "62b7bdc89d904844607780281a3ec7b8a2ce6153", + "rawBytes": 6763, + "rawSHA256": "95002aa2fdbaef374667df66226ac619a2e09924b85ad16932af4d9a4be12ea5" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/H01-EMPTY-ONLY-DECODER-consumer.json", + "mode": "100644", + "gitBlob": "8cbb8d52d19636e61145fce4af9aa8f20a0503ae", + "rawBytes": 3589, + "rawSHA256": "64d45f3fa10261fce5cc8400e50401c0f2214115e41569f492bf45f908fc019e" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/H01-EMPTY-ONLY-DECODER-producer.json", + "mode": "100644", + "gitBlob": "a0a215f0b62997127391f5ef278836a36953735f", + "rawBytes": 306, + "rawSHA256": "cbf16db8fa922bd48b83d2f6ae5e4e36add2f9ce63f5880e5b08d69256795232" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M01-allocationResidualLittleO-consumer.json", + "mode": "100644", + "gitBlob": "6514661b6300e59d43e73510180a75ff5e777a82", + "rawBytes": 976, + "rawSHA256": "52a1cdf91d1d6a4df1b0a61483d0e7fab982401b76fd1dbdbb119b64377f6872" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M01-allocationResidualLittleO-producer.json", + "mode": "100644", + "gitBlob": "dd76685103bbe63543a1123221e71b5915501c13", + "rawBytes": 312, + "rawSHA256": "e2bc4cc288a601b55eec2ed31d867cb7a13890591ff2054de3dad12df8bd2c79" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M02-completeResidualLittleO-consumer.json", + "mode": "100644", + "gitBlob": "fec3dd4f3411d06e6113144a04912887cabf1a0f", + "rawBytes": 976, + "rawSHA256": "71fd5b8bab1717ec19c26d63f63e7af399fe32ac7e9542136bc92863c1ae6430" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M02-completeResidualLittleO-producer.json", + "mode": "100644", + "gitBlob": "26ff2e1f956bf0901d3a708d4b55126af89a9e8b", + "rawBytes": 311, + "rawSHA256": "8fc192d27e487bb714cdf98c19d3cd59bd50bed4c1f7756432e5983e7f3e9c0b" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M03-widthBounds-consumer.json", + "mode": "100644", + "gitBlob": "c058b1a64c91fb2e2c2f10a1e991c276e0b39a9a", + "rawBytes": 1064, + "rawSHA256": "f588f79302daacae86acc4f67859123d34532b38b353e2d6e3e69181df119c89" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M03-widthBounds-producer.json", + "mode": "100644", + "gitBlob": "74624a36195277ceb3fcf616d5214d39576ed01c", + "rawBytes": 299, + "rawSHA256": "36948ca1a254269254682d08fb33e579f0aa40bc8e440c628f25e0cce73ce0ef" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M04-dataCapacity-consumer.json", + "mode": "100644", + "gitBlob": "265032d42a1ef9f5e1d62bb07d6dbf225ac7541d", + "rawBytes": 1155, + "rawSHA256": "76a605143a73753983fcb907d3b52af595f55e7acbbc5f416a05700513ff394f" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M04-dataCapacity-producer.json", + "mode": "100644", + "gitBlob": "a6b9961d1ea3636e02980e2e2b61fca65e9a9196", + "rawBytes": 300, + "rawSHA256": "2ff22457b637e44a4fd57469dc959b6b470b05df1ead7497e998517e6fda25cc" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M05-completeCapacity-consumer.json", + "mode": "100644", + "gitBlob": "ad7c9ee87b2bec6f945209d44d2a56a73c28c8d1", + "rawBytes": 1451, + "rawSHA256": "bf4de5914472dc5399b8f44e381e222e20e11e7f67f10c003fd5e1e2cbcb08f8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M05-completeCapacity-producer.json", + "mode": "100644", + "gitBlob": "9c3f812f06247283cfe44675be20263997d0f734", + "rawBytes": 304, + "rawSHA256": "535722f321bbfbf3f658f63bb35335b2c0bfacb5b690d455047a69c183d64ca7" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M06-memoryWordsFit-consumer.json", + "mode": "100644", + "gitBlob": "a530841acd2c96fbbd9b3a83c4c0b76c36aa390d", + "rawBytes": 1090, + "rawSHA256": "af9a390aa081aefea479238955f8f368616464463d471f8d21469753a9a80857" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M06-memoryWordsFit-producer.json", + "mode": "100644", + "gitBlob": "05aff58b43b4a9ec3749a02a530bcf0ce0f39adf", + "rawBytes": 302, + "rawSHA256": "131ed87169dc670bd4a9a77f5979e3237fee5413f85bbe2c777397a058192398" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M07-allocationAddressesFit-consumer.json", + "mode": "100644", + "gitBlob": "7bbed25891809277ce0d5e270d998d513a1da568", + "rawBytes": 1185, + "rawSHA256": "49c33e5a2d6eee7f94e70715802b4f6b71938f5d95eea5856bb21cb505cd1bb9" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M07-allocationAddressesFit-producer.json", + "mode": "100644", + "gitBlob": "d580f0a44e7b350441e5434e9df9c4a2728f7161", + "rawBytes": 310, + "rawSHA256": "d776d706bb1dd2071e3aff7ce36eb678120c2f23928ead8db6c08b7ba962385d" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M08-programFieldsFit-consumer.json", + "mode": "100644", + "gitBlob": "007e402faec986d225490f1b4ccdfa02b0eba0b1", + "rawBytes": 1157, + "rawSHA256": "db166373a5aba11b0cc688a4f21f552cfd643f25a1b51efb2172eab327f491a3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M08-programFieldsFit-producer.json", + "mode": "100644", + "gitBlob": "083aa484a03cee6deb3ff3b915b0d0237c021548", + "rawBytes": 304, + "rawSHA256": "8cd6de85898ad52882b1cc4c7efaa73b619f5865fe499d9c06aab3e18a0e66cf" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M09-budgetExact-consumer.json", + "mode": "100644", + "gitBlob": "0de884d39664be61f60af50e9392ba4b03c96e4b", + "rawBytes": 922, + "rawSHA256": "3fcf31d0ce5228de3583639784f8aa2c4a8c6cec593924b43955f4a4e924108e" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M09-budgetExact-producer.json", + "mode": "100644", + "gitBlob": "007e22d18b9037c2c2a9cfb8dded7739e24937de", + "rawBytes": 299, + "rawSHA256": "3081b1cebd0d71533f9e7a1bbe63bb7128c91d868372043e6acbafca50bb8a84" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M10-programLength-consumer.json", + "mode": "100644", + "gitBlob": "c3814abb6a6f342aa5358590dcf7be9c8a18cf6b", + "rawBytes": 964, + "rawSHA256": "97601d4adfc9a07a0121f4179541092acb1407ed18284fc2bc9fb5135067f1bc" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M10-programLength-producer.json", + "mode": "100644", + "gitBlob": "8cd0202941aa38a7484c18ea79ae2a2db70a932f", + "rawBytes": 301, + "rawSHA256": "7111e52d9a19792d0870decd6450ed36cb99c1f74bac27dcf6ba5ba83e5a4ef5" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M11-encodedProgramBound-consumer.json", + "mode": "100644", + "gitBlob": "842b812a27427fde87ad2f09cc478d21815188bf", + "rawBytes": 1064, + "rawSHA256": "89918415a3049b7d3c68ff1543072e76b423a03da4483f3172e5d4920c27eedb" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M11-encodedProgramBound-producer.json", + "mode": "100644", + "gitBlob": "c6c99ba041b6bf199f7e53e1d8cca19a862d539d", + "rawBytes": 307, + "rawSHA256": "2f018fe65a7ba0942676c55ec01319d210e394c0519b5a397c90e5d6bf8d6e80" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M12-registerCount-consumer.json", + "mode": "100644", + "gitBlob": "c3d054f96c5349ee9255b89ad9ac78ca10868cfd", + "rawBytes": 938, + "rawSHA256": "9e65f0b76b24299c21e18275508c611d5de70dfe6d101f2f0f7421679f4f2867" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M12-registerCount-producer.json", + "mode": "100644", + "gitBlob": "b0c75f6ff474f26affce28ccfaa426322f0f04fd", + "rawBytes": 300, + "rawSHA256": "393c4bd4bed0b333c6425718ba0527d0b60eb392ba3339888edbbc53f498e0ff" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M13-scratchCount-consumer.json", + "mode": "100644", + "gitBlob": "7f18a117571be6b44f73931d5256f042b5650853", + "rawBytes": 933, + "rawSHA256": "e59c7cc5fa748d6f9c4900b179677c1aca3a44717c0dc8aed1402460962ffb5e" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M13-scratchCount-producer.json", + "mode": "100644", + "gitBlob": "0c003e002d2ad03d9c78478400fa2a071946c61f", + "rawBytes": 299, + "rawSHA256": "536cc66928d9ffec54124b060b0c7f9f530e50a8e816775967cb02c22f9a8e19" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M14-unusedRegisters-consumer.json", + "mode": "100644", + "gitBlob": "7e786181392193b9083728265c30fe3f0ca92fda", + "rawBytes": 1300, + "rawSHA256": "4e3de7b9c684d3864a2933d4485ffe0ad5012f15a5dc84543d3a3571edfe0e36" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M14-unusedRegisters-producer.json", + "mode": "100644", + "gitBlob": "0ec2bf329cee2667841a60b305948318af1d0a79", + "rawBytes": 303, + "rawSHA256": "d7306d7f46e6bcf9097dd7ba1c11f8dd71a52801045388706141bf8098420e55" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M15-validInputs-consumer.json", + "mode": "100644", + "gitBlob": "9041ae5b55daba9b77fd70c7c3ed0ecc03aa879c", + "rawBytes": 1398, + "rawSHA256": "49e61ed2f08fddc5c311b4d93127e885d75e2d5c6bd649c2780de8facbddd06c" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M15-validInputs-producer.json", + "mode": "100644", + "gitBlob": "855860217fecf8ab143bb345234ad637d7e9298a", + "rawBytes": 299, + "rawSHA256": "a3e716a012eaf003e39d62cd01a46593b18a22202e9219ae816d467cf22af13f" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M16-natContract-consumer.json", + "mode": "100644", + "gitBlob": "ca18b04a5d4c2bdb326fd27a6a7bb5e7f33ff8d5", + "rawBytes": 1293, + "rawSHA256": "b252b57ec53d35ee71e10eef5b3a787b781bd95ce2b6a14abdd337ced758b7ef" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M16-natContract-producer.json", + "mode": "100644", + "gitBlob": "0b8882039b329432ca7f7e03d3f7f86dfa125ada", + "rawBytes": 299, + "rawSHA256": "5f0ffbfe7a7df333b5981691d4f0ba069acf65464b39738f67f30fde4c381b4d" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M17-leftmost-consumer.json", + "mode": "100644", + "gitBlob": "2588b61ee7f21f506648d3dd5d9d59f5a62c7e70", + "rawBytes": 1200, + "rawSHA256": "bd9b154a72df1edda22f6a96595f0b3d348611153e99ebfa8d856926dc737a1e" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M17-leftmost-producer.json", + "mode": "100644", + "gitBlob": "fdf2413cef995d20445b24ae7e9e8ca183e10c6e", + "rawBytes": 296, + "rawSHA256": "1cfb0698ad63d6bb3825852c97fce98d9826474aa871a5f6753ec91ab3844b86" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M18-result-consumer.json", + "mode": "100644", + "gitBlob": "1b066be755d18486732065264a46a3f371b70836", + "rawBytes": 1564, + "rawSHA256": "ce88185082c6ab4c80443907c5ffbd01fe8f05fa2e72d03cb96a8baf15c31a8d" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M18-result-producer.json", + "mode": "100644", + "gitBlob": "ebeaa250baf277203c4b2432244883ccf0bd9783", + "rawBytes": 294, + "rawSHA256": "2a34d51d2949dc77a8143e800d91124a821f6e6110724005c46e262211d45d86" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M19-halt-consumer.json", + "mode": "100644", + "gitBlob": "65179872ad931a2da9027822397fd8f8c9378963", + "rawBytes": 1589, + "rawSHA256": "f760abe8e8d28c9acd5b428ca64dbdc6a4d09ad0dcaf86c15f70498e3bf18dd4" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M19-halt-producer.json", + "mode": "100644", + "gitBlob": "a96c7a72645e14c559b49d86f5332d172a6ab6ec", + "rawBytes": 292, + "rawSHA256": "bec9cfb8c418ee47a86e4efe478ca1cf43a7b4879f74cda7cfb786727ecad97f" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M20-invalidGuard-consumer.json", + "mode": "100644", + "gitBlob": "854b62a4cc3dd53947ae284b7ffcbc472c48982f", + "rawBytes": 1801, + "rawSHA256": "9c7ec7724edb8b8a172b379e0a01d8b00b3043d6b206a3b5376225e2d46fe8c3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M20-invalidGuard-producer.json", + "mode": "100644", + "gitBlob": "065f4803838288247c6c2def4046705cfe87f36b", + "rawBytes": 300, + "rawSHA256": "acf764d1efb6be7ed31966b7bbfdd577a215043c1a604d92fcb1bf77e09a1f29" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M21-stepBound-consumer.json", + "mode": "100644", + "gitBlob": "1fc5a4dcd0739959e4988cee7f68d1e7545cd1a3", + "rawBytes": 1234, + "rawSHA256": "9e3930281094149caa088b4cc37ba49ca06a9b21ac1a5787657ba1046ab57c86" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M21-stepBound-producer.json", + "mode": "100644", + "gitBlob": "8bd4fc3b12567027da6ba2e447ab8a535be94f4a", + "rawBytes": 297, + "rawSHA256": "99613f3a5fb34ccf1fd8b9b2edec6eae23e60e2353e26c2ae83797ef8ad1fb19" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M22-categoryPartition-consumer.json", + "mode": "100644", + "gitBlob": "03191e0839e9981c547c58eff2d0ba8cd143269b", + "rawBytes": 1950, + "rawSHA256": "45d66191a6c91cdf1740997169d7bb310920f323dcb36520979cf5565a7d1784" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M22-categoryPartition-producer.json", + "mode": "100644", + "gitBlob": "19c15cdceee1cab89fc29402ef2271b9b6406e6b", + "rawBytes": 305, + "rawSHA256": "bde10cb28be505df32d5af3cedb317424bc595022b88b1b6a454c30893506f16" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M23-finalStateFit-consumer.json", + "mode": "100644", + "gitBlob": "bd415f09e6613f5888968b132830b1cf5d8cb0e1", + "rawBytes": 1490, + "rawSHA256": "99dd41497861fdf086890c56eb1ca462fb2b0cc45d342ae380ced91c8fc783f6" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M23-finalStateFit-producer.json", + "mode": "100644", + "gitBlob": "b1d138155a94740501151b611366e31abdc5b256", + "rawBytes": 301, + "rawSHA256": "607a9ab6c008818ed506f47f4f13bba5a91e97c16f07f366a54de4c1448f05c8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M24-transitionSafety-consumer.json", + "mode": "100644", + "gitBlob": "12c79979d6f04f72b62d9cd8a28d289de167b739", + "rawBytes": 1957, + "rawSHA256": "edbcaaf3cee1ac9ed99fa7d999224c121c81c5780edf5c1cfb386acd2ce731eb" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M24-transitionSafety-producer.json", + "mode": "100644", + "gitBlob": "93cdcc08199c25ae488d4841b66401a4c21d58d1", + "rawBytes": 304, + "rawSHA256": "1c0f49cf32f11c6cec8ee6b3ccde5998e51863adca41504b817aef126ce0181b" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M25-prefixSafety-consumer.json", + "mode": "100644", + "gitBlob": "ea4024437f0a64ca3a659a5c0b73ee02ca092efd", + "rawBytes": 1643, + "rawSHA256": "ef13c51c519f1e5632b47263e19b8263d83db34848742b8f196070ff643e4feb" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M25-prefixSafety-producer.json", + "mode": "100644", + "gitBlob": "a4e1e7afcc8b50fedab8a0adb83d41eb7a52aabf", + "rawBytes": 300, + "rawSHA256": "a30a8e9cea206571c7c7fc51cdbce64472de710f5692c2bc1c14757928a26a05" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M26-readWidth-consumer.json", + "mode": "100644", + "gitBlob": "9e347e1488fc0a26ce7427cd36c0ab2a7bf79c4f", + "rawBytes": 2302, + "rawSHA256": "01722eb97709df2e351dc8c149cc70ae5e4d3ac7e61b53da1209c7bfae2dcbf1" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M26-readWidth-producer.json", + "mode": "100644", + "gitBlob": "b5247842ee988473db28c07b3e0ff64eebf3394c", + "rawBytes": 297, + "rawSHA256": "405b0f1811ca1b3fce0086411e06db0e1e4343ea14b4eda337a3381049b16965" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M27-positionalReadBacking-consumer.json", + "mode": "100644", + "gitBlob": "0f984c0cd4bb8bb1af3e53698dd5f935c28242ff", + "rawBytes": 2732, + "rawSHA256": "15016e3dbd054b4f506b3fa70d81f126a82dac94e5ba8dd2be27ddff16713921" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M27-positionalReadBacking-producer.json", + "mode": "100644", + "gitBlob": "f16ebcbbd5432ec1e6453c1310be05433452131b", + "rawBytes": 309, + "rawSHA256": "8af81870f5235af53f18ce1a8c519305bcbdeb4af1f3998eefd3deed7a55336d" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M28-orderedLogicalRefinement-consumer.json", + "mode": "100644", + "gitBlob": "ee4bc0abf775e8b41cf5d497a5445a514d4489d1", + "rawBytes": 2013, + "rawSHA256": "055a404e3a38d482bf3746846c8b04778b18afb99ac15e779e118151fb71fffa" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M28-orderedLogicalRefinement-producer.json", + "mode": "100644", + "gitBlob": "3b7fab1cee89305fd1c6ad38383a2b15b76aac29", + "rawBytes": 312, + "rawSHA256": "f765fcb1b9b61f86c584b9024264d49d53cc233a592ac6f530b44f3919877996" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M29-logicalReadOnly-consumer.json", + "mode": "100644", + "gitBlob": "acbbf4a6099003a3eb6e13fda6f3e4ef0e43242f", + "rawBytes": 1109, + "rawSHA256": "12e89d09ea556ed3fa6434a0f5a00f34028a5b0231e9e20faa44bbbb2e746472" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M29-logicalReadOnly-producer.json", + "mode": "100644", + "gitBlob": "7f699065dad4dcd1554e4eb24cbda11681984bae", + "rawBytes": 303, + "rawSHA256": "06f93a1d4d01b1cd6f463fadffe687208d76e04b3359a04eab8a91450023c272" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M30-suppliedMemoryAgreement-consumer.json", + "mode": "100644", + "gitBlob": "40c4353c46b79cfbc110ef4bb0173132e3111279", + "rawBytes": 1942, + "rawSHA256": "dcbf711c0ac19cc7df19bfa79ed2a310755b16aa85775a8d58e56d195c7c55ce" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M30-suppliedMemoryAgreement-producer.json", + "mode": "100644", + "gitBlob": "56992ae098ddf9b6903297d26ae5107c4cf4247d", + "rawBytes": 311, + "rawSHA256": "655cb1bd01a97f21a09f0f7a4ddb989679bd38eab32e6e4f83e24e3d6eb78227" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M31-specResult-consumer.json", + "mode": "100644", + "gitBlob": "514f1328b97efa78136e92666e055f3907dae7c1", + "rawBytes": 1391, + "rawSHA256": "0a4cbf278f37a8bc62d81e383798419b754e97f1758469197c280aac7d566ada" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M31-specResult-producer.json", + "mode": "100644", + "gitBlob": "b614949cb8189e60463a353d56eb15178f065780", + "rawBytes": 298, + "rawSHA256": "bc0c669284a5c9619c3ffc27d6da225f5e1179fc7a505a5bac468bdce306bd1f" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M32-noFailedLoads-consumer.json", + "mode": "100644", + "gitBlob": "c9b992ffb04b7e579a98e72d3fa8c39d08159ca9", + "rawBytes": 1498, + "rawSHA256": "cf55c28e9549c75643414e61d9a175bd3d57bcdffae6026f5f42f6b55953d6fd" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M32-noFailedLoads-producer.json", + "mode": "100644", + "gitBlob": "7fbfa176a32d7a0cb5b96739d1225c22c143332c", + "rawBytes": 301, + "rawSHA256": "68c540bb4d1ab09fbccbb7f81ccb929682b60048c9252f75175b3a57389341b4" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M33-invalidGuardSteps-consumer.json", + "mode": "100644", + "gitBlob": "e2b45d1b80c866c6c39dd42fcd2b0b11316da4a4", + "rawBytes": 1299, + "rawSHA256": "d30d71fb88972e36181b9fe2b137fe1e4f5b7067adb0381715906018954f149b" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/M33-invalidGuardSteps-producer.json", + "mode": "100644", + "gitBlob": "c1b1ad088a3748afcb48d053020af0a6b62580e2", + "rawBytes": 305, + "rawSHA256": "3521f57f8a8d1db9217576d3c645c8402f6e8309bdbc2af906c18332d3c78f5e" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O01-wordRoundTrip-consumer.json", + "mode": "100644", + "gitBlob": "1bab1dbca70495331c3006f0da184984e2b3f472", + "rawBytes": 1296, + "rawSHA256": "b88e4cad4eb53110bc7cb35a6738e06976191627ac149dccf3bb644cd089c679" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O01-wordRoundTrip-producer.json", + "mode": "100644", + "gitBlob": "f3e8649c72cb6aaec6590b6a9b9fd92c5ea56229", + "rawBytes": 301, + "rawSHA256": "3a25a97b9f9e68576a4521f2ab8be51cd08a2cb4bb6e680bad45f1745b25de0b" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O02-wordSerializationInjective-consumer.json", + "mode": "100644", + "gitBlob": "a79eb6dfdfe7b4bd7715ca72cabab918aad2b798", + "rawBytes": 1538, + "rawSHA256": "e2aa4c5b24e5ca8c4077ae22d98816d8d9a5637ec656db69f9ae9d87c7ed191c" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O02-wordSerializationInjective-producer.json", + "mode": "100644", + "gitBlob": "1ff54acda8bcca8f6d2d6fa29bc5ac8d352e23bc", + "rawBytes": 314, + "rawSHA256": "bd8279494c42c350fb0307f1416fede55cf7d2b56994a4f140bbe814fe41bd41" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O03-serializedLength-consumer.json", + "mode": "100644", + "gitBlob": "8b604537e056f81ccc83e4bbc60593bbb753527a", + "rawBytes": 2075, + "rawSHA256": "29462ec22b6bc7fd2691aa34f4d4a04bf903908926457a1fd678ab63b7de37b7" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O03-serializedLength-producer.json", + "mode": "100644", + "gitBlob": "f310904b8838e322e77f6794df55696e2e33b0f2", + "rawBytes": 305, + "rawSHA256": "f0538068cc287a6b9ceb91a533ab3324ccb59d00ab156b0935579e47554150f8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O04-memoryRecovery-consumer.json", + "mode": "100644", + "gitBlob": "43d64d5bbb66f87412d1a649246f0b1a58f01df3", + "rawBytes": 1921, + "rawSHA256": "a24af19845a9bc4e522ed1990941d7e36c64f2b57dba41ea1884903cc60d8a11" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O04-memoryRecovery-producer.json", + "mode": "100644", + "gitBlob": "ad8ffce03fa81e69657c847a7cdcdbc43415179a", + "rawBytes": 302, + "rawSHA256": "1f9924ae7df6209bad84ef5063a6e5c34cbfaec4ac4ada5235e4c89b19cde095" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O05-decoderExact-consumer.json", + "mode": "100644", + "gitBlob": "bfa7107d42c5acdfea4b1818a9a0751847b49867", + "rawBytes": 2531, + "rawSHA256": "ad3127612abb183992512dad9612b44af9e53af75ae70b107e725297a0325aa3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O05-decoderExact-producer.json", + "mode": "100644", + "gitBlob": "c49a7b4eb2bfb65604572c3189cc84c3577aa9a6", + "rawBytes": 300, + "rawSHA256": "64d1da3997ec21e6d02d285b1735125dc813d6c166a2dc74c1c69a83821918c4" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O06-decoderLeftmost-consumer.json", + "mode": "100644", + "gitBlob": "5cb1ef899e7a56147832036d198efb6c8d7a3e8f", + "rawBytes": 1212, + "rawSHA256": "caa1439e8f5d2eadc3719749bbacdaac980d87b789ae7e40d6e9ebf622d266b9" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O06-decoderLeftmost-producer.json", + "mode": "100644", + "gitBlob": "33a8d1823042af5dc8b6c29a9e363a4cb53469fb", + "rawBytes": 303, + "rawSHA256": "6abd864afee661e2498efa46c13c71e2e336e82fee39562ed3d1e8fd2210c54f" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O07-sameShapeMemory-consumer.json", + "mode": "100644", + "gitBlob": "b66c7d394d357a54bfb807f57e493c1ce2619712", + "rawBytes": 1033, + "rawSHA256": "ad04875d8635910ccfa45e9859d78e0b4dda0a23b8d028c6f28db1e16e8ce317" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O07-sameShapeMemory-producer.json", + "mode": "100644", + "gitBlob": "7d2422837d2bc19e4ce9838525f426de6b235cc1", + "rawBytes": 303, + "rawSHA256": "5c94efe53f608ecbd3d258daaa3d250a6046a0cbd1ef58502892dd7e591e6015" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O08-shapeInjectivity-consumer.json", + "mode": "100644", + "gitBlob": "55db0fcca6d4805fa676d4ee5f4ac6d7063a544f", + "rawBytes": 1361, + "rawSHA256": "8bb9bfc0e09d59accecd0ef617407f558c5c7f8de1deb9c8af981d44b8bae661" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O08-shapeInjectivity-producer.json", + "mode": "100644", + "gitBlob": "37bbe00215b2b27675e6a755da30d010cf4a0e95", + "rawBytes": 305, + "rawSHA256": "75687da036f7f044e9eb127c698e09ed53a931db39ff0958e1b2752d364cd091" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O09-uniformBudgetCount-consumer.json", + "mode": "100644", + "gitBlob": "bbeff7859c152d15c72ba6db1b27cd2ee8cf3482", + "rawBytes": 1048, + "rawSHA256": "9f0f25849cc2bf121484a25c4e4a88a0e5f61cbd45869763fca27fd0a37e78d2" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O09-uniformBudgetCount-producer.json", + "mode": "100644", + "gitBlob": "254de8fb3868443d46f1f4d9cf1bcfc08ee438eb", + "rawBytes": 307, + "rawSHA256": "fe000646c2d162664379354fb6c088935c293dba9b5eff63e01aa820883797bc" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O10-uniformBudgetLower-consumer.json", + "mode": "100644", + "gitBlob": "7f051c1f72ff7954e4eac87a9c273d515667fdd7", + "rawBytes": 2299, + "rawSHA256": "b5200300879e69b213e200ff1c3332102c976fce314a8eadf97dcd329e759cc2" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O10-uniformBudgetLower-producer.json", + "mode": "100644", + "gitBlob": "5dd8453723c4002d34ce1142be665034f7d0ae1d", + "rawBytes": 306, + "rawSHA256": "3e4aa26fa2d51c1eb3220f2f0ef324b84fd9574b072e5eb02fd637ceb019e16b" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O11-canonicalCount-consumer.json", + "mode": "100644", + "gitBlob": "f845ec431e329719bd10d347553ff9149955f155", + "rawBytes": 1011, + "rawSHA256": "01366d1a1f4432b84d55aa21cc2f189d60c7edfdcedd1432db4b20400a0a5297" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O11-canonicalCount-producer.json", + "mode": "100644", + "gitBlob": "c84867cd53a9519ba6c8cb2dc981dfd9bc3dd119", + "rawBytes": 303, + "rawSHA256": "34f34c9ab9c0f7ddd863655082f815921c1f67e71b10974447b9770c300cde84" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O12-canonicalLower-consumer.json", + "mode": "100644", + "gitBlob": "52750275d72a822f86123d447c97e54f451909a0", + "rawBytes": 1061, + "rawSHA256": "053f00e967b181705ecee68c49136adca110ad8dcc995fd6e4e3a5502cdbb72a" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O12-canonicalLower-producer.json", + "mode": "100644", + "gitBlob": "d79bfee9675230641ac695951ecbc0f6d204f8c4", + "rawBytes": 303, + "rawSHA256": "f0601f18441c8b93a79b465149fdbffd0750cccc0fba3ab9af2774f1eeec06c6" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O13-upperCapacity-consumer.json", + "mode": "100644", + "gitBlob": "7c0ba3d100cb3e41c9b99eeb5d445cb0245639a6", + "rawBytes": 2128, + "rawSHA256": "b31525630541fe48beb949f174d1701a8277b183fc28cf97bb1199afc10ed419" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O13-upperCapacity-producer.json", + "mode": "100644", + "gitBlob": "4ce8209dc749af8a9b9042920c8e81a23b0325f8", + "rawBytes": 301, + "rawSHA256": "43f0e95e59c5cfc4461f7c8b95a1feecc3d1b2c126ffdccbb32b2b22467fea56" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O14-allocationResidualLittleO-consumer.json", + "mode": "100644", + "gitBlob": "1a788667d16f5d00cc20987afd20b313f5a3df39", + "rawBytes": 960, + "rawSHA256": "62cceda85f1d17358e1a68bfd28630f20f9ac682e0d239942298eddd8fe6a6b6" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O14-allocationResidualLittleO-producer.json", + "mode": "100644", + "gitBlob": "10fd4f212a99be14f6a459e71c8b4cb40b6c4f34", + "rawBytes": 314, + "rawSHA256": "3eec155180da431ad9fadfca46f38a9384070d14dab7677a810586e3c694f4ef" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O15-runIdentity-consumer.json", + "mode": "100644", + "gitBlob": "e25c6d2bc55ed7380644230520f6e10ffedddba8", + "rawBytes": 1323, + "rawSHA256": "754f2add08b6de3d6bfde035795c64deb6a7fc48ba4243cff8855d0d8af47101" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O15-runIdentity-producer.json", + "mode": "100644", + "gitBlob": "a340cbff7c46fecdd39fac4d46237f478bb64180", + "rawBytes": 299, + "rawSHA256": "f86c15c3fb7d658c423c39576aec4171d640f222ec58d51e7e804eee635e9a1e" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O16-machine-consumer.json", + "mode": "100644", + "gitBlob": "803dadcbfc1f1f6e1d6226e931994ed5932e7d51", + "rawBytes": 19896, + "rawSHA256": "ed92801e3b7293f66f444845ef4d7c252a0ee539bc5c8a12bad3e9525513e167" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/O16-machine-producer.json", + "mode": "100644", + "gitBlob": "97d6250b106eb1505c29d920363fd738b3bfdb95", + "rawBytes": 296, + "rawSHA256": "b22ae9cd403b27fae432fca588cd28452c04c66ed950388318cf269abe453da4" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/P01-PUBLIC-PROPOSITION-consumer.json", + "mode": "100644", + "gitBlob": "0c34e72101a611d2a86053164a75bac871d1b099", + "rawBytes": 30175, + "rawSHA256": "32d024a563f60b2ff986bfa4662d7d034dc5204fa2c0c5966eab18c9353e27de" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/P01-PUBLIC-PROPOSITION-producer.json", + "mode": "100644", + "gitBlob": "3dd259d113ec9d6df0d4722aea52e0deb02f0696", + "rawBytes": 306, + "rawSHA256": "6a6d90d0b22efd5d20371c5384bffc8219672e5b7b146aa5b57555d8f677e9f9" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/S01-SIBLING-MEMORY-consumer.json", + "mode": "100644", + "gitBlob": "c4f4aa3db1783831d3ac0e2ed181697680084310", + "rawBytes": 2177, + "rawSHA256": "330f0d21f39a19a002dc9e11928cfb6453f811fb2febe3af29b0a8d13c658624" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/S01-SIBLING-MEMORY-producer.json", + "mode": "100644", + "gitBlob": "50095f5ceb6ed9ce3f8be41123381a51a14afee0", + "rawBytes": 301, + "rawSHA256": "cdcc4af58a601dbdea128c7ae5dfc039003576427c154fddfa27526aa119e936" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/S02-SIBLING-RUN-consumer.json", + "mode": "100644", + "gitBlob": "2d5c1097f25f74207a407c4a228b46ab68498709", + "rawBytes": 1792, + "rawSHA256": "4669e67f5f8963200d277714498c47c55cfa599c6b9474f9cb2a01168f9c607b" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/S02-SIBLING-RUN-producer.json", + "mode": "100644", + "gitBlob": "db82028865b978603b19276456a246574061e288", + "rawBytes": 299, + "rawSHA256": "1a26eb830a0d8cf283ac07dde73474ce84e331e114279d887cc3e949b31281a0" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/S03-SIBLING-BUDGET-consumer.json", + "mode": "100644", + "gitBlob": "67eba3584b20d46070585b9c49535dae657bfa2c", + "rawBytes": 1243, + "rawSHA256": "1bdc90e51da8a87c8d84c009f7721e13d3915b959a02e600b62f151d65e36341" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/S03-SIBLING-BUDGET-producer.json", + "mode": "100644", + "gitBlob": "6bc580d324162c033abfb9d113c9ed1af0fc3d9c", + "rawBytes": 302, + "rawSHA256": "df2c6c01c04982dee338c7d751ea6ac6f650d41faf27cf09459bb4346c9cf7bd" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/baseline-consumer.json", + "mode": "100644", + "gitBlob": "c7f612106958cca8486f63b163476414bc282fc4", + "rawBytes": 293, + "rawSHA256": "4c8f7dfd1b77a0738af57caed1c5bcca7a2e2eed4def70f5a77d07d78686b31a" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/baseline-generic-consumer.json", + "mode": "100644", + "gitBlob": "a34c8d6ec4090628d77663399f6d17ca9e690d4c", + "rawBytes": 300, + "rawSHA256": "764b25fb42f66405b8e8f04c6d09744d276c674aba2e8d933f6b5e70201c437e" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/baseline-generic-producer.json", + "mode": "100644", + "gitBlob": "7fcd74c778ef62cb9832a9a06c2e7e1da13c9114", + "rawBytes": 301, + "rawSHA256": "83f1e0bbd236626dc287df8a8f57b6248e1f184ff807c853aa7ff082e8c9213f" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/baseline-inventory.json", + "mode": "100644", + "gitBlob": "b4c6b3d1e8e081922b67b7acf3f5749fb9a26328", + "rawBytes": 697, + "rawSHA256": "212879380044d9da954945eed5c8c31b8395a76b41ae9c4e50c65efb35b0a4b6" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/baseline-packed-producer.json", + "mode": "100644", + "gitBlob": "9cc86fd9c870c02cf33c08a6c62b480d7297c49d", + "rawBytes": 299, + "rawSHA256": "ffa658f03ea44e6974a36fb7cb7a8ef5ccca7b42a6ee1eb34455092615f5f588" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/candidate.txt", + "mode": "100644", + "gitBlob": "aea86e28aaca292bc0d7ddbc17018da7072b3f64", + "rawBytes": 40, + "rawSHA256": "38e9f2be4ee79edfa800b36a3e1c3945ea26d0a4b3f9298d014293a2116e3586" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/diagnostic-boundary.lean", + "mode": "100644", + "gitBlob": "8dfb0224f2a771d50e00d47e79f440cb1b8bfded", + "rawBytes": 82, + "rawSHA256": "095aa29925219a82ee935057c12ce34296ad318ba3415b2ede6b51a1e3101343" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/runtime-full.json", + "mode": "100644", + "gitBlob": "c124c26226a575438add25bf00cf79335dbbdc4d", + "rawBytes": 1135, + "rawSHA256": "274da194cf15e0062ff89a8c775df1ec8fd68c236ad074d9f345df1e9d3ad7f4" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/runtime-known-selector.json", + "mode": "100644", + "gitBlob": "c26c7bcb5290b280e9dc9b1b7f26dc251a50de21", + "rawBytes": 576, + "rawSHA256": "017fbf50fb9f0409528fc1b5b41fdca73aa365798cdb7a51aff0e2e9fc216b16" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/runtime-selector-empty.json", + "mode": "100644", + "gitBlob": "b29e2a075a96d6639ed93a3dc41e3cafc4699f95", + "rawBytes": 414, + "rawSHA256": "a9ea3f0527d05f4eb2d28e45686e32ec1f77cd6018837a11aa78a5839d2cd846" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/runtime-selector-malformed.json", + "mode": "100644", + "gitBlob": "8c6714bb883df4e0e28d932d85c18ef0f6ed1e77", + "rawBytes": 442, + "rawSHA256": "1847fc1a4475a6e45f16c952f51ae441b81030f50b6a3430a13abe0fcdc4d6fa" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/runtime-selector-unknown.json", + "mode": "100644", + "gitBlob": "bff55d182d299409b1e9cd84c1b9933883ebdac9", + "rawBytes": 446, + "rawSHA256": "cc840553f920161cbca7b1f17e1f35ea0fdc19841776f6528ddaa38ccf6a51a0" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/runtime-selector-whitespace.json", + "mode": "100644", + "gitBlob": "c1300f6572c0b9f999abb6de473b173a2c3483d7", + "rawBytes": 429, + "rawSHA256": "4381cf8d5e38bd91674675ebe77f8a42dbe379ab4347d866b277ffb2d531f86f" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/runtime-startup.json", + "mode": "100644", + "gitBlob": "f38e5bd3613fca560d8f27e12ea520ecaadf7a5a", + "rawBytes": 705, + "rawSHA256": "166fe6cd3838e2675e1ffba69b0091f07ae5f161706b3b1375d09037d61d6b35" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-5033/summary.json", + "mode": "100644", + "gitBlob": "4f1fd4b962b9ffc70031fb6282cefffa530e6a37", + "rawBytes": 194336, + "rawSHA256": "2747ef8ed6285b345b683d53b42a58d527b644d183da85ebccbcba53b4c6062a" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/A01-BASELINE.json", + "mode": "100644", + "gitBlob": "b36e50c5d49e3b4639dc21acab3fe74df6a2e0d7", + "rawBytes": 288, + "rawSHA256": "712ec65dfcc9569ba355f40318911d3e7716e0f0b035fe9ba12a29a32f10a3da" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/D01-NULL-DECODER-producer.json", + "mode": "100644", + "gitBlob": "42e764977304594739f9ec4cf5703269628b3f9f", + "rawBytes": 3803, + "rawSHA256": "9ab0de276ba6f9b361462386451a6e25b6f334a45c6856f50ddbb703e78dce1f" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/D02-WRONG-DECODER-producer.json", + "mode": "100644", + "gitBlob": "d722d226522b00e14445f509c2f8f81e92ac941a", + "rawBytes": 3804, + "rawSHA256": "2891cc04c8d8c88c7fb2955549d40405cd995bfa4c1043ae744565f54437d6ce" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/D03-ZERO-SERIALIZER-producer.json", + "mode": "100644", + "gitBlob": "70a0284a157e35280ad0d22009c4c7c7a54f6cd1", + "rawBytes": 2851, + "rawSHA256": "3aae58f5d38e558322255aa1420b437e9231d791cc05dae73cdf25294bffdb76" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/F01-DELETE-MEMORY-RECOVERY-consumer.json", + "mode": "100644", + "gitBlob": "0fe507d577b99e17d9bf611bb7186338ee3f8c88", + "rawBytes": 1735, + "rawSHA256": "1673359a432881002edd754b19577266633995324429c539424bff62e8329d8a" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/F01-DELETE-MEMORY-RECOVERY-producer.json", + "mode": "100644", + "gitBlob": "e184a8aba0d735ae126b9c275b7562e57ee7bbea", + "rawBytes": 310, + "rawSHA256": "41322bc61e93a76f80c7e231b91ac4304c0bd6ae47bb2fe88c28ef5f17524b32" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/F02-DELETE-READ-BACKING-consumer.json", + "mode": "100644", + "gitBlob": "ca7a30075d0adcb19175113ffb2f8e2dfdaa9fa7", + "rawBytes": 1092, + "rawSHA256": "23df298f07e41ee2c0c63202aba114dd792280af2378040011fd9b2ea950d141" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/F02-DELETE-READ-BACKING-producer.json", + "mode": "100644", + "gitBlob": "667c60e8e5cef693288efbf0d487a8668961c0be", + "rawBytes": 307, + "rawSHA256": "5f09bf44698bd1f050efb94264b4ac717ee4f8ef67e270d8f71da962cdc610a8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/G01-LOWER-PROPOSITION-consumer.json", + "mode": "100644", + "gitBlob": "5fcceb46cc62cad390414281b7da700e3c8e38af", + "rawBytes": 991, + "rawSHA256": "f7eb104eaa1ecd664f10c46079e31e701d07a703f21fd9c01384e75fce540b67" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/G01-LOWER-PROPOSITION-producer.json", + "mode": "100644", + "gitBlob": "a54a8e7fc010039cc5a51da7d35b041f5a795a60", + "rawBytes": 759, + "rawSHA256": "bac840040065f8ac81bfdf2af1a6f3fae90b41030fd0b8d07e9b497d373523b9" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/G02-DELETED-EXACTNESS-producer.json", + "mode": "100644", + "gitBlob": "9d4b34aba9fefa6323d303dd0d6c5703634288cd", + "rawBytes": 6763, + "rawSHA256": "91068af99b4e751e80e58ac3e72cb2172ef5f431886938a1c4fb6ef09c81873e" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M01-allocationResidualLittleO-consumer.json", + "mode": "100644", + "gitBlob": "5fdc54b384a5f1b998fe1d8fbd9ae2f9162a8243", + "rawBytes": 976, + "rawSHA256": "71d1df5c907a87ce2bd5c035f73cb52f0ffee526485345d36445dd0044a04c83" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M01-allocationResidualLittleO-producer.json", + "mode": "100644", + "gitBlob": "c7db240d3ce4c39108e43c7d663fbdcf6eac11a8", + "rawBytes": 313, + "rawSHA256": "8a1e7844abaa65aa30027679babcd13fc4ea299f78a92abdfb2d4657efd0106c" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M02-completeResidualLittleO-consumer.json", + "mode": "100644", + "gitBlob": "3ea4379fee98232b3d9208596b74fa926c215430", + "rawBytes": 976, + "rawSHA256": "cdc3e8a2eb0f138d8979e89ac9cde1c31e7e9bbbf5f33cdaa65d360bec167de3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M02-completeResidualLittleO-producer.json", + "mode": "100644", + "gitBlob": "80db857dc1c1a8d5ef493b96b2a7e487c6eb7923", + "rawBytes": 311, + "rawSHA256": "b6f6e90cae01d2c07f0ffa1f8d666719754d47886d3aaca1351e66d24d68faf8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M03-widthBounds-consumer.json", + "mode": "100644", + "gitBlob": "dfa76663878f669419fb14ec7a80bd075d32e74f", + "rawBytes": 1064, + "rawSHA256": "4f5e49899fa2032faf31c3a7791ad76431b8b23776a99ab607628437b20da43a" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M03-widthBounds-producer.json", + "mode": "100644", + "gitBlob": "39b173eb0ab453ce658d1adaa1ac5f980b0dfc49", + "rawBytes": 298, + "rawSHA256": "8ad876e242fdc2dc288ce55fb93098a2b588cb27293dedab9c9a08dff1df13cc" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M04-dataCapacity-consumer.json", + "mode": "100644", + "gitBlob": "d8379c99b44e21a564d49bd87f83b03706a025d0", + "rawBytes": 1155, + "rawSHA256": "c98593cce714da7db49813a7bbe861231a4c3908462928dc48ca2f773ea76c64" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M04-dataCapacity-producer.json", + "mode": "100644", + "gitBlob": "c156b356eb9462cbe6ce5fa8d09e8fcb1b31a751", + "rawBytes": 301, + "rawSHA256": "ad2bf81422144c5141eb5616d7d2d569afb8db9893137cda832b2369756253da" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M05-completeCapacity-consumer.json", + "mode": "100644", + "gitBlob": "0d2baa119663bf189d7a9cbf7af3ebcddc0b85ad", + "rawBytes": 1451, + "rawSHA256": "0141c4c7630f710b312f1c10454700c2b28ad9ead50c669574fd39370e63bafc" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M05-completeCapacity-producer.json", + "mode": "100644", + "gitBlob": "4981b35b9bcf919770e760cda93e0c9f33d7c4c1", + "rawBytes": 303, + "rawSHA256": "62559803035ba720a2349e4dba44eca652c1e5e04918429319b9ab7b4bff6ea0" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M06-memoryWordsFit-consumer.json", + "mode": "100644", + "gitBlob": "43043e5030245bdad72735ccc5e1daca1fef6d19", + "rawBytes": 1091, + "rawSHA256": "7d6bbd1f3a2c31294e7a7249ebe684ef30a1e5b25e454e33550d9c6246959bbb" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M06-memoryWordsFit-producer.json", + "mode": "100644", + "gitBlob": "268ae7e9823c42f70c11225081c8ba8ad1c7845a", + "rawBytes": 303, + "rawSHA256": "c178b8606b69c1d5b6db73fc6f39e1935257b191d54c1dfc9985c3746544eebc" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M07-allocationAddressesFit-consumer.json", + "mode": "100644", + "gitBlob": "57e472d05d20b5c2175c3c708c15608165c2e4f4", + "rawBytes": 1185, + "rawSHA256": "88190a83300b391ca22ca9c7d998015ac4ecf4d9366bfdae8a841dbc626cdf7d" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M07-allocationAddressesFit-producer.json", + "mode": "100644", + "gitBlob": "82fd86ff2830a0ee1822d5517ff2ec58b952d11b", + "rawBytes": 311, + "rawSHA256": "5019dc44af5577d78c81211e45feac432f16309f446fd3f41edbf1181c0e0b26" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M08-programFieldsFit-consumer.json", + "mode": "100644", + "gitBlob": "441b74d0546e7e3c131c78dc8c0582b51dea840d", + "rawBytes": 1156, + "rawSHA256": "ef16f170f686a289146b145c4075af7119f6aa57674e2f4a2319c35eb4fb8c80" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M08-programFieldsFit-producer.json", + "mode": "100644", + "gitBlob": "885dc50550c0b89961162d18aaba36b24eedcc86", + "rawBytes": 305, + "rawSHA256": "9219bcc7a15020d2b10ac6c348a1bbb72ab810692617fb3444c7aac69d495641" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M09-budgetExact-consumer.json", + "mode": "100644", + "gitBlob": "0bd6fefd7f17fa369f8c41041fd49d0af12d83b6", + "rawBytes": 922, + "rawSHA256": "c9df567e6dd0cb566ee9ff40f60e7b48911236f85459778698b9e4db3b2a0252" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M09-budgetExact-producer.json", + "mode": "100644", + "gitBlob": "b1aae881588c0b1760a32954a8ba9aebca5bfc7b", + "rawBytes": 300, + "rawSHA256": "1608e531132669d2ac53f2449be94cc9b4cc47adcad3a31c224bac4e08289631" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M10-programLength-consumer.json", + "mode": "100644", + "gitBlob": "68f6be23e09d4118f723c7b31a9ad1f8e822f4c9", + "rawBytes": 964, + "rawSHA256": "7271e232bf50f718de1deef4be06540d9442d4b366c93c894f9f371c8f5108ef" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M10-programLength-producer.json", + "mode": "100644", + "gitBlob": "0a67f656668449aa7d0b4323873f4fc3457efcd7", + "rawBytes": 301, + "rawSHA256": "25c1c950197e3ce1a468588ba4457d07501a1af31b9ae20e680fceae576c97bd" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M11-encodedProgramBound-consumer.json", + "mode": "100644", + "gitBlob": "df1cbb5f4e14d868d445c169ea064d68a6e5b7ff", + "rawBytes": 1064, + "rawSHA256": "2328c18a6588adae098eadcd03b267d7ecbfd165c1d31278bccd4e2c367e08e9" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M11-encodedProgramBound-producer.json", + "mode": "100644", + "gitBlob": "53110ef54fc1edbed50f76cb7dee386bfffde072", + "rawBytes": 308, + "rawSHA256": "c0921b3da0680fbb7c441b5dafe3b46df160ad012424fd1422e28be652e7efb4" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M12-registerCount-consumer.json", + "mode": "100644", + "gitBlob": "1db13c308f3220b6a529098a13d1fc5f99d16515", + "rawBytes": 938, + "rawSHA256": "9fa45e657d51185e552067a412722afb19aef6afb4e7128b8bb4462121eaaf7f" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M12-registerCount-producer.json", + "mode": "100644", + "gitBlob": "c1c862b994a49cf198fa0aae5ebaa139f69cf95a", + "rawBytes": 301, + "rawSHA256": "d51903240b74dd58af076986b53b0d0c23b9adbf3fafe9d6c1aca27ee3fdd39a" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M13-scratchCount-consumer.json", + "mode": "100644", + "gitBlob": "bde1711ab097b93c1f8ee93c5b9f9c35f6b1b7d4", + "rawBytes": 932, + "rawSHA256": "54875d7954bd56c99b6b4d9358c28302d367a8f77380a47e3f05346d8b49b26f" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M13-scratchCount-producer.json", + "mode": "100644", + "gitBlob": "5723049e23e9a155624dfa5ff49b64a0663bd476", + "rawBytes": 301, + "rawSHA256": "7601da52430a58e68dfddf10da7e625e7b58ba1c0554ad2bcc8c241f13430685" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M14-unusedRegisters-consumer.json", + "mode": "100644", + "gitBlob": "6e8635bd36347f1428ec7a09a0f20462bd649f73", + "rawBytes": 1300, + "rawSHA256": "a374d680402d2b51c320cba41bd609302936944174185957a4eaf42fbe846b0f" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M14-unusedRegisters-producer.json", + "mode": "100644", + "gitBlob": "26f8d4c77c94d1235e9a143616e4f7c1ba9a4f43", + "rawBytes": 303, + "rawSHA256": "9eb1fa04c3583e90a646d59caeed4f785029cb354f8c4854897a60c4f28ab181" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M15-validInputs-consumer.json", + "mode": "100644", + "gitBlob": "ce1392a09de6d1864837d31a5c41d96f5d7fa7de", + "rawBytes": 1398, + "rawSHA256": "2b56336f19d9fa6d09801359ca6c9d5e7f1b3a1c1fc12651b708dee20e0f2469" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M15-validInputs-producer.json", + "mode": "100644", + "gitBlob": "3841bc888d610c5f1738af2eb0ccbfa85e683141", + "rawBytes": 300, + "rawSHA256": "78948c45e83e7714e0647673c8f168a773e61efa5ef7db693de9572f4cd13070" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M16-natContract-consumer.json", + "mode": "100644", + "gitBlob": "c7ebb3c7d67b64de614a6ec3f13608eea168e5a0", + "rawBytes": 1294, + "rawSHA256": "a409be6fee756f258e69d03fab2d37a14363a0ed9ab8571b6f01cfc31936a1cd" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M16-natContract-producer.json", + "mode": "100644", + "gitBlob": "23379a1093d0c9ba5d6765b97753bd883371c281", + "rawBytes": 299, + "rawSHA256": "807ab71cd7525d9330dc28e5cc4ef52157d5ccd0a5d309a763f96dbc8c48d980" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M17-leftmost-consumer.json", + "mode": "100644", + "gitBlob": "4afadb315e40a78c50a6467568167afff13ee833", + "rawBytes": 1201, + "rawSHA256": "603f8250b18880a96864a5afd657c1140de8f8b065384d576ab7449b06d94ebc" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M17-leftmost-producer.json", + "mode": "100644", + "gitBlob": "9178b679a9b0d9b89820bc763bf120ecd6972b69", + "rawBytes": 297, + "rawSHA256": "82380974ef079759bbe7e75b78de2fad505b6cd82fd40bf3407cb2e9f645072f" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M18-result-consumer.json", + "mode": "100644", + "gitBlob": "715a27e818a8454507356ba9c78e0dcb83da4925", + "rawBytes": 1565, + "rawSHA256": "f91c22365e11068be111f7b312299a562f502206ee995759a38ad915322c9ce9" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M18-result-producer.json", + "mode": "100644", + "gitBlob": "e46fb1ac92fa19dcc4be414b5e18a7a3cd924a87", + "rawBytes": 294, + "rawSHA256": "d480bc8fa9eaff0a5ac0d37c52ef89347d7a22149626299e617ca2283dff06df" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M19-halt-consumer.json", + "mode": "100644", + "gitBlob": "b7d8aa589dbd8c6d015ef51ed4b09743ef22ce1c", + "rawBytes": 1589, + "rawSHA256": "0f795c0f1c0074fe2db742bb107d38120f66e63dd155503b482ef2d9c9e556b2" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M19-halt-producer.json", + "mode": "100644", + "gitBlob": "3e771895ae91d98cbebd3bb308a22fbddde44db0", + "rawBytes": 293, + "rawSHA256": "982e151cfb0712d76cf4ef7a083475f0ac5e341895ebf0838cebb18815def607" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M20-invalidGuard-consumer.json", + "mode": "100644", + "gitBlob": "a654ba5a34a25ac57327437cdd1b8f6d0cef5d91", + "rawBytes": 1801, + "rawSHA256": "4cda65ef745b83cdb5baf0cd9611dc0d94d74be02b3625d72190153282a5e080" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M20-invalidGuard-producer.json", + "mode": "100644", + "gitBlob": "a41fc7386ea1803d4a5e18464eeb45094b94cf5f", + "rawBytes": 300, + "rawSHA256": "caae67214f6189a14e432147723496217bddb6e6c8fa3bc493355eb5b0512f49" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M21-stepBound-consumer.json", + "mode": "100644", + "gitBlob": "42d41221b3b98d31f9ee8b459582cf7031e56b22", + "rawBytes": 1234, + "rawSHA256": "6efa500c947041200a3cf7ad25657c54e12447fbfd2f5443ce415d19b192688c" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M21-stepBound-producer.json", + "mode": "100644", + "gitBlob": "41414ceadb3bd635a6f1414e54baaa8bee66f7c1", + "rawBytes": 297, + "rawSHA256": "57c034ca68eeb4826b1a2bafe068d8cf9aa3a7107b5763bfed47066b0fe33829" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M22-categoryPartition-consumer.json", + "mode": "100644", + "gitBlob": "125ffedeef6786fe7a5205c64faab7105fb69547", + "rawBytes": 1950, + "rawSHA256": "a2119990b30012afa64671101109f8cce30d6fdeb5a7746ecea5d1ff3e68b535" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M22-categoryPartition-producer.json", + "mode": "100644", + "gitBlob": "709c692dec1355e8a12471f2a5e2328bfc1c51e2", + "rawBytes": 305, + "rawSHA256": "981040fadbecba59a70b959dba4a058e42644fae3af11efcf88ed6fbbcc37451" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M23-finalStateFit-consumer.json", + "mode": "100644", + "gitBlob": "95276423d9b9884463ba8757e41c20fe47ae0f5c", + "rawBytes": 1490, + "rawSHA256": "610693694f50ea05fa91f4ae101fdecae13e925d9ebad83f2d5e434b00d3ab11" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M23-finalStateFit-producer.json", + "mode": "100644", + "gitBlob": "13b195af966076d4a4c0ad97fc913b381b0ac7c6", + "rawBytes": 302, + "rawSHA256": "1c87a51cc9a7cae61a62c747b987859096a785d6672d6ce82a95a67944fbe75e" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M24-transitionSafety-consumer.json", + "mode": "100644", + "gitBlob": "04e5e010781b81de0c7a56b126b49e7426d7c8c2", + "rawBytes": 1957, + "rawSHA256": "7d78e556a32d4446c8b29e444eab5f66f123f090a30f4ade1f5f96d77002dd98" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M24-transitionSafety-producer.json", + "mode": "100644", + "gitBlob": "c0241b261d7301268f4c3fee7bda7def50857890", + "rawBytes": 305, + "rawSHA256": "6b79612cbc2d452146df208f23ebc465da0081493d4ba6f2ec09ebb2d66c2eec" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M25-prefixSafety-consumer.json", + "mode": "100644", + "gitBlob": "823206cab90b0305696dbff191120f89f20d855c", + "rawBytes": 1643, + "rawSHA256": "35444c870aa75b7eb8e3ba7e26c1d6b6028b6051e2e20b96f299c530a1a85f63" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M25-prefixSafety-producer.json", + "mode": "100644", + "gitBlob": "9547770cd87e21688eb2c550b119d289677adae3", + "rawBytes": 300, + "rawSHA256": "b95451295b9b85456a668553a59d03b82100078d5d66efb49b7a67ccf4414656" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M26-readWidth-consumer.json", + "mode": "100644", + "gitBlob": "27f445d4fcb58e61b896f2c431ceb7d89d4550bc", + "rawBytes": 2302, + "rawSHA256": "016fb0ef469e88bac1018fa6344695ed137baae1440c579b6e9cb9a6e6f037dd" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M26-readWidth-producer.json", + "mode": "100644", + "gitBlob": "c70e227168370b7273d81ac2ca412faeca71f13b", + "rawBytes": 298, + "rawSHA256": "55af6b836cca2aa24e9e5b8023078fd6e4c1b09355d415dbe1ebc9d08346966b" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M27-positionalReadBacking-consumer.json", + "mode": "100644", + "gitBlob": "f6628d222bb5f4b3eaa16f100aa8d30452d318f0", + "rawBytes": 2732, + "rawSHA256": "6c1ff48b31c44a8cbaf504ae600d0115583858e2a1a0028ebd85439d2897104b" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M27-positionalReadBacking-producer.json", + "mode": "100644", + "gitBlob": "64a5753982131fb587c4f523479589873113295a", + "rawBytes": 308, + "rawSHA256": "080af5351a2cd5037b743d790d805826d03deaff01e8b7270acef43980d9e984" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M28-orderedLogicalRefinement-consumer.json", + "mode": "100644", + "gitBlob": "d7c8ce16126e3489080313ff526c226b4727059f", + "rawBytes": 2013, + "rawSHA256": "66e4b7a182d7793914f095e2c9041895e1b26bbbbfa4570b92c943a0898b6a5f" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M28-orderedLogicalRefinement-producer.json", + "mode": "100644", + "gitBlob": "e6a003f4b64f816246e1d87ca55e87b51a44ab43", + "rawBytes": 312, + "rawSHA256": "9671362ffec26ba86ae3f71e2176b07aaeb07d6c8330220980f687e5b0ea1709" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M29-logicalReadOnly-consumer.json", + "mode": "100644", + "gitBlob": "a4120726256164023548761592303f047b0262af", + "rawBytes": 1110, + "rawSHA256": "3a1011b6a80b914704a35357173b08311ea0578323e54debc6009e3fdd255aa1" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M29-logicalReadOnly-producer.json", + "mode": "100644", + "gitBlob": "3dc3c065a9c78a79c0ad6ad3fad5ec1797f91427", + "rawBytes": 303, + "rawSHA256": "3bd1a2488a0b1d856bf01d55fe49022c2b0a6b324e127ce7af774fae49f335b1" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M30-suppliedMemoryAgreement-consumer.json", + "mode": "100644", + "gitBlob": "52b9aa22ea1e2432aad05b10d0ecafff3e344d99", + "rawBytes": 1942, + "rawSHA256": "1c2bbab15a8244915ca2c0dc82f3cf11a9392004792950b4444bf39cb87ce7a2" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M30-suppliedMemoryAgreement-producer.json", + "mode": "100644", + "gitBlob": "51608ee269331c156d358de25801e3624def894e", + "rawBytes": 311, + "rawSHA256": "2684aa2c25e2fc9da94a4a237440369c66c02ec749ec46a85b2f52d96c0d6a24" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M31-specResult-consumer.json", + "mode": "100644", + "gitBlob": "51e67c3e1ba32d0351cce3a2d8e5ff9cbb672265", + "rawBytes": 1391, + "rawSHA256": "f69db00c6d3314ef11a66fc7a02df07c47c245a25163cea3a33a421cadc94317" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M31-specResult-producer.json", + "mode": "100644", + "gitBlob": "c3bfb7ffa03fe20b9c72507876a87c47353475ab", + "rawBytes": 298, + "rawSHA256": "6296098de870d6751744bbd682a9f2a8deb0c681566f5001955104b50a1b0b5e" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M32-noFailedLoads-consumer.json", + "mode": "100644", + "gitBlob": "3c9e870173dd38dd34851e01c78b16601128e819", + "rawBytes": 1498, + "rawSHA256": "26ee8963319c82618845e90cd5d0df747af1a8e8cd735a4cb56e1787dec2862f" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M32-noFailedLoads-producer.json", + "mode": "100644", + "gitBlob": "e2ec911c0f913ba52b846c6539336024c2a0c771", + "rawBytes": 300, + "rawSHA256": "b1b9e0e5825029a2c5b359c8f9b22d32a4a1578816f63b5596a7d6fd4e52cfab" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M33-invalidGuardSteps-consumer.json", + "mode": "100644", + "gitBlob": "8cc3a292cb6d36d823f2b2f81ad8c976ce134dd3", + "rawBytes": 1300, + "rawSHA256": "dfd47a5be28bb4bd05589e3cb1dda6c61f255b77ceab2623cb45d710966adf44" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/M33-invalidGuardSteps-producer.json", + "mode": "100644", + "gitBlob": "3115df21a7faca671e2f7cd962e7c898b33a81ac", + "rawBytes": 305, + "rawSHA256": "d4467aa385cdb38c4772ea0bb5da34bd1e65eac3879f074fb1b06249730fd109" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O01-wordRoundTrip-consumer.json", + "mode": "100644", + "gitBlob": "e16045deb02e18c3ed46d4f16b79a07fbaa14f2b", + "rawBytes": 1296, + "rawSHA256": "25436d389fb8abffb4aa8ea39996882a1b812e9873059b8569f0ad2e77b91faf" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O01-wordRoundTrip-producer.json", + "mode": "100644", + "gitBlob": "9365c1b52f7a42f53b024b3d38c04d0fa37397c5", + "rawBytes": 302, + "rawSHA256": "d6283cfbd841a7939c4acba52c828cbcef540d4144db87d58bd332b05362b133" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O02-wordSerializationInjective-consumer.json", + "mode": "100644", + "gitBlob": "4b7e74523bcca1ffc0ebadd7aac4fc1b5b7549dd", + "rawBytes": 1539, + "rawSHA256": "d4204ebe59276db3fda625575c3ba4393468c7a5409c9e988340994a780eea7b" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O02-wordSerializationInjective-producer.json", + "mode": "100644", + "gitBlob": "b55bd4e4a1cf5e91efcb69dd167339ca6b2dad89", + "rawBytes": 315, + "rawSHA256": "aab4c9363098f58d0cced354122432b317d6154c77d89817bef8d0776080ec94" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O03-serializedLength-consumer.json", + "mode": "100644", + "gitBlob": "b888736b968fc7510fa3b7de889094488e8b74cf", + "rawBytes": 2075, + "rawSHA256": "efe0d627007d44f095aadb0ad8784235d99946d5a08fa943440dac9eeb7ca6e3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O03-serializedLength-producer.json", + "mode": "100644", + "gitBlob": "86ef2d9cb4618a008bdcb659ef77b72e5b52c7e3", + "rawBytes": 305, + "rawSHA256": "76e0286104bd383586a629e70652485da75a295faea743f886906b5e7f17430f" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O04-memoryRecovery-consumer.json", + "mode": "100644", + "gitBlob": "2d3271b9911eb842c0127eef653f16e589b32a7e", + "rawBytes": 1921, + "rawSHA256": "e396d838d8fc9be31e8c840afb0c60d6fbe5913af8c66ffe4a2a747a08f556be" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O04-memoryRecovery-producer.json", + "mode": "100644", + "gitBlob": "e4378daeeb11603280e18971ca8f06c15838898e", + "rawBytes": 303, + "rawSHA256": "9651ba49ee2714497b8d5e549a449d26e0eda7569aeb0610f1b3213fcf210a3f" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O05-decoderExact-consumer.json", + "mode": "100644", + "gitBlob": "b5950d003b664f0abf13d39fe0660c1ab31e5ea7", + "rawBytes": 2531, + "rawSHA256": "c3309947adfd7c38903b5c0d95375c19bdef58981125c59265c2764509000c29" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O05-decoderExact-producer.json", + "mode": "100644", + "gitBlob": "5a0f3095248c56d5dacc34cb04bb8eac75d6e80c", + "rawBytes": 300, + "rawSHA256": "da2573aaf016390bcff800d081a8bf51df4a56e375e5a644368fc96fa7c07498" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O06-decoderLeftmost-consumer.json", + "mode": "100644", + "gitBlob": "bf1200287b64483870daeeede375e87d99058993", + "rawBytes": 1212, + "rawSHA256": "0149be9eb0ba4697a51be013641188bf9ce982787034fad8ccf9a321443a918e" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O06-decoderLeftmost-producer.json", + "mode": "100644", + "gitBlob": "45ddb98b882a82225494d9b6143bc9da7393524b", + "rawBytes": 303, + "rawSHA256": "b4eaf72d6e4c0f52253c5183b444b4467ba0a5c056ebc8b5e1308ac2f7399bc0" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O07-sameShapeMemory-consumer.json", + "mode": "100644", + "gitBlob": "2934cd287c527ee0374ed65e921ce13bffd12849", + "rawBytes": 1032, + "rawSHA256": "53fca2ae56727669e398d3ddbed813ddcfdeec90a1e923d1ace40eb62650c6d6" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O07-sameShapeMemory-producer.json", + "mode": "100644", + "gitBlob": "f7a9754ab7b4bbe90b28d8aaed275b50d465c729", + "rawBytes": 303, + "rawSHA256": "57fd1836d25ff7de7873c77a4ae79c565c95d5a6678501915b42a9727a9a4f4c" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O08-shapeInjectivity-consumer.json", + "mode": "100644", + "gitBlob": "16d5092d45d2519dcf8e26603dac008d9124c09b", + "rawBytes": 1361, + "rawSHA256": "df53e542b880729ec6aebdf07a3bd8cfec7ec4c71e477b936979a8076e6535ea" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O08-shapeInjectivity-producer.json", + "mode": "100644", + "gitBlob": "5265fee757b9431b226db9a3baf163707a740d56", + "rawBytes": 304, + "rawSHA256": "f68612ac0380fa702aa6c2ee27456efb7d0ac02c532bed36136e88d43137cd23" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O09-uniformBudgetCount-consumer.json", + "mode": "100644", + "gitBlob": "0e4abfcebbc003b854237369faced71116a99927", + "rawBytes": 1047, + "rawSHA256": "da7afb39c9af4945126cbbd139f5df244b2ac1f9c3a2b4f5801a5a3a3db35e44" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O09-uniformBudgetCount-producer.json", + "mode": "100644", + "gitBlob": "913815a8ec799082c081155c4ef2aab99e74a3b6", + "rawBytes": 306, + "rawSHA256": "117b32a6caab0e48f647122eec6cd8bb6d92549afe763edbdbcd68fd173e7575" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O10-uniformBudgetLower-consumer.json", + "mode": "100644", + "gitBlob": "5456d8004a1ed8365cfed40b5fd1ef30530a80b1", + "rawBytes": 2299, + "rawSHA256": "636c6393aeea1a6b457dcb93f2cd35310cc351996a71d9e575c5e467e9731bc3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O10-uniformBudgetLower-producer.json", + "mode": "100644", + "gitBlob": "7414f705eed3d593e58a5a32722d16c3639d15d3", + "rawBytes": 306, + "rawSHA256": "33af7f49fbcc886f4973d09c6e2846bf484335c8e4175f472ca498b74de6325e" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O11-canonicalCount-consumer.json", + "mode": "100644", + "gitBlob": "7e4843e8d9e4fa0f99e0f3707cc1acd8729bff60", + "rawBytes": 1011, + "rawSHA256": "0bf6f0ece3e66f670e380334baac904137b9b7dcdb19a52126f15d0f689ad18f" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O11-canonicalCount-producer.json", + "mode": "100644", + "gitBlob": "b3d6b22413dab64521c382ef340b57cf010e3a74", + "rawBytes": 302, + "rawSHA256": "21713190071ea86d0eb9f75d0a85aeaf90079225d8dbea863ee22f43985c9824" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O12-canonicalLower-consumer.json", + "mode": "100644", + "gitBlob": "dac62a2263fec74870fd1e4b01703a7102c60e95", + "rawBytes": 1061, + "rawSHA256": "908e54e31102b54f2ed731cb7439b88f2899be7fe510f971812220745c474529" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O12-canonicalLower-producer.json", + "mode": "100644", + "gitBlob": "5bb0612a8ed31d08e6fdbad70860216bafc05b86", + "rawBytes": 302, + "rawSHA256": "31e97a7fc737852ff89f336ca237ce7dee72b84cf8ba8709938dd7ec2bcbe8ba" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O13-upperCapacity-consumer.json", + "mode": "100644", + "gitBlob": "e169b6636c5419d6592c4188202a410a480e617a", + "rawBytes": 2128, + "rawSHA256": "29d8799807ca8e2c82d58599bc34fc697b4d6264d8ab4a82d43307572e54f83a" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O13-upperCapacity-producer.json", + "mode": "100644", + "gitBlob": "b3303e4d14c6002ea9d1b13a2e1fef6977ebfb10", + "rawBytes": 301, + "rawSHA256": "e8560d7501b44a5efae7d734aa706bd57fb2af84e54e2191bb308b0446dd5760" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O14-allocationResidualLittleO-consumer.json", + "mode": "100644", + "gitBlob": "879fbde25fe62cf7fccaf0d7ba75dc4cc9476c0a", + "rawBytes": 959, + "rawSHA256": "4ed269205be7d8ad960b0577c33d4462147ea16de19345baf25d25585396480d" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O14-allocationResidualLittleO-producer.json", + "mode": "100644", + "gitBlob": "9c2a7af08e1e437093bd363dbbed2af9201d8b53", + "rawBytes": 313, + "rawSHA256": "f636c9083dec9423b7069074b8e7b2daed40c4038c0e5dd7f58d9a16708c283a" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O15-runIdentity-consumer.json", + "mode": "100644", + "gitBlob": "a4ae87b8ac57e8ef08ed05c4b41e25eb69deee50", + "rawBytes": 1324, + "rawSHA256": "d8762ed56920649dd49ef8ea0b1912b853392f0174c61cc7a0a088ea2a0f0291" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O15-runIdentity-producer.json", + "mode": "100644", + "gitBlob": "cf2b040241c5a03cbd0469286e9b60d7bacef3dd", + "rawBytes": 298, + "rawSHA256": "1c1153403d51501e95afe2bcc85ae00cbd3bc5f77d6c621305616616a680315b" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O16-machine-consumer.json", + "mode": "100644", + "gitBlob": "e428d1c078b91272f455427cb7288aedad8991ed", + "rawBytes": 19896, + "rawSHA256": "8da50654b60e400fbfd53dc36dc0c2c54c3957094060d65d80b553809449429c" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/O16-machine-producer.json", + "mode": "100644", + "gitBlob": "12997512a98507be7356179306504bc3bae9c781", + "rawBytes": 295, + "rawSHA256": "23118787b5db8807e2dce020cabc3aaa90237618fa4da0e03a057888f0fdd1e3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/P01-PUBLIC-PROPOSITION-consumer.json", + "mode": "100644", + "gitBlob": "494d00ec08d7fa14256cbadbf34f9ae19fb0338f", + "rawBytes": 30173, + "rawSHA256": "c0da99ecd914a8295528e3e63566ebb448d70651fd56e74b77adb2c0e592f150" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/P01-PUBLIC-PROPOSITION-producer.json", + "mode": "100644", + "gitBlob": "06f0e3eb9674cf9c1354cad05e62dcfac0e257e3", + "rawBytes": 306, + "rawSHA256": "fde7593ada182fc3a19a22fbf5445aa0a1d4a314244dcde79b6fc32405dbd34a" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/S01-SIBLING-MEMORY-consumer.json", + "mode": "100644", + "gitBlob": "1a474022340165ddb13a351dfa933b6e76ef221e", + "rawBytes": 2177, + "rawSHA256": "d38e762fa6d8aeefc2565c43eb1e8a479aa4556fee7fdc640475c422db423c80" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/S01-SIBLING-MEMORY-producer.json", + "mode": "100644", + "gitBlob": "27726bcc57cccf604907ef8e3b740d92405fccc0", + "rawBytes": 302, + "rawSHA256": "f1557ad5988031f6598cb9b2efbcc4a4dbfdafbb5519c8246e020632a836ab03" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/S02-SIBLING-RUN-consumer.json", + "mode": "100644", + "gitBlob": "6a4fdc8b2ac79a4d6cc0ceec109a0019db84ba43", + "rawBytes": 1792, + "rawSHA256": "a746652c8e0a4f2bf0e02f9365945b13e70311dd5f7467dd961c28337f7ae856" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/S02-SIBLING-RUN-producer.json", + "mode": "100644", + "gitBlob": "03566145ef28a07025ec16b44ead4b0fb20bbf73", + "rawBytes": 299, + "rawSHA256": "02f78268b1133836fe2c87333a79a12e46a8308880d6648ef9d086074a4fe336" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/S03-SIBLING-BUDGET-consumer.json", + "mode": "100644", + "gitBlob": "d8b59b4420c91f991cbfd2f94f770b33c468953c", + "rawBytes": 889, + "rawSHA256": "85ddaff9947135f7deb02c69b99698a78f9ed2003d4fa17863f0408c42d4fe00" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/S03-SIBLING-BUDGET-producer.json", + "mode": "100644", + "gitBlob": "315cb225ccbd4f023f1575152879146aa2c34f76", + "rawBytes": 302, + "rawSHA256": "0c640f319f08f91e74398d6f77048b4a04d987cb8fa9457c6b2e2fff67abf19f" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/baseline-consumer.json", + "mode": "100644", + "gitBlob": "377e01237906cacafd980185d7ee47b9bd4aa4e8", + "rawBytes": 293, + "rawSHA256": "4655295d1086e0ad8dc862cdc1edf7512b577c1cc3e1c8668f7698ba5b93ed86" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/baseline-generic-consumer.json", + "mode": "100644", + "gitBlob": "7cc6d049b667ad6d4662249848ff6b37063499ed", + "rawBytes": 299, + "rawSHA256": "a3bc0fb07665c1d64444f12f942029c63d1f9f99c71e37c8b37c6a9becd19c88" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/baseline-generic-producer.json", + "mode": "100644", + "gitBlob": "0d454b9429f04b1eb41fcd4f6a10126b1b476903", + "rawBytes": 300, + "rawSHA256": "e93155eba9dc93e41f07759dd9d2efd883fd9e630bc009336fa28201cd1d3b48" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/baseline-inventory.json", + "mode": "100644", + "gitBlob": "4218a40b84214145749c9e907352dd1eb2f2a912", + "rawBytes": 698, + "rawSHA256": "d67e6fce332574d05c0ebc425117d842b90bceb17b102e7c289b257d081235fe" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/baseline-packed-producer.json", + "mode": "100644", + "gitBlob": "bdd5e229b5b11a0135b302458b7b63b08553d5b0", + "rawBytes": 299, + "rawSHA256": "414f7f7d67e510ba2e48f069bcd80038ac58d3622988a2d397c6a92a01d817c0" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/candidate.txt", + "mode": "100644", + "gitBlob": "98de6cff20ed9739418d9fdbb549d8d137912f36", + "rawBytes": 40, + "rawSHA256": "da3e11358b1cc9538b488dd85b61fdd57c44fb43641201cc68443bb56e377777" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/manifest.json", + "mode": "100644", + "gitBlob": "6f1731fb81a8be5d6169a107060dea1fb99558db", + "rawBytes": 41823, + "rawSHA256": "f2ae19631427f321e1e7878f17007a75da916c4a555aa342ac00a1c5142a7d09" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/runtime-full.json", + "mode": "100644", + "gitBlob": "fa7892e018d86d7d457c2786e99008356a091c37", + "rawBytes": 1135, + "rawSHA256": "559f8a0c3acc4caa060a94a25dbf0d62b43d5ed3be95adba327773152ff5a306" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/runtime-known-selector.json", + "mode": "100644", + "gitBlob": "5a6ef1280e13a0847e642016969d058e1a58d078", + "rawBytes": 576, + "rawSHA256": "e097e7abf6891f6d04b581cabaa24537f3ea451ddb0df74d56f94a8a643f3083" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/runtime-selector-empty.json", + "mode": "100644", + "gitBlob": "a5087e468bc4d73c17dbb73eb2535cce6c2b5620", + "rawBytes": 414, + "rawSHA256": "99b58979b5805894dcfc5b5a4614af30950b986db59018d598b467854f6434ef" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/runtime-selector-malformed.json", + "mode": "100644", + "gitBlob": "a6964d25774cfc79227833d24adabb122c236f9e", + "rawBytes": 442, + "rawSHA256": "15c77e77b560b2c3cffc96a4c79fc70e3ce14a36b91dc4cfd0c00e4d31451e4d" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/runtime-selector-unknown.json", + "mode": "100644", + "gitBlob": "c94e6eb6f56a59fbb2087274a10d70438437bd73", + "rawBytes": 446, + "rawSHA256": "c15cf894b9b9bd4f24f0915ba81f2f5801937252ef6f0c291bf7d38a8fd9dabb" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/runtime-selector-whitespace.json", + "mode": "100644", + "gitBlob": "ff95bfeaab19ae74d737100b1095c5af2a4d48d1", + "rawBytes": 429, + "rawSHA256": "f11c1c023cbfb717b43353f3b2f3c30d29d821eca20fba5ce35b261df0418b53" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/runtime-startup.json", + "mode": "100644", + "gitBlob": "e20df29d7483908806ff4255eddaa87a6a16335a", + "rawBytes": 705, + "rawSHA256": "ecb45140b2ee7e49c007e68fc36c63d80524417ea5fd54590a0c2fe2e3612ff6" + }, + { + "path": "docs/internal/extensions/lb1/evidence/replay-v3-d6dabb-inconclusive/terminal-receipt.json", + "mode": "100644", + "gitBlob": "6e205d103a39324845f4498f3a82030203672857", + "rawBytes": 848, + "rawSHA256": "19a0b34b0ec4e7ac5682b37f81d221ef3525573a6659adbdcf7ac2ccdfa50d3f" + }, + { + "path": "docs/internal/extensions/lb1/evidence/report-check-discovery.json", + "mode": "100644", + "gitBlob": "0deb8f140e24233cad9d31c8349418f31992206c", + "rawBytes": 907, + "rawSHA256": "f04aa797eb9b7e5cbe2f599291d5141f372981179615f27f942ba3f636924d11" + }, + { + "path": "docs/internal/extensions/lb1/evidence/report-checks.json", + "mode": "100644", + "gitBlob": "d137c85f81c3c22f8461d2d8a8dec507e6dbce45", + "rawBytes": 3703, + "rawSHA256": "26b8be7e1f206c890f3f2212d24a2b60031fead2309ec807be938442ec41c7d4" + }, + { + "path": "docs/internal/extensions/lb1/evidence/selector-controls-v2.json", + "mode": "100644", + "gitBlob": "bd0a3b0bbfdaf3e327cac7834e6aab0f5461a165", + "rawBytes": 8594, + "rawSHA256": "3a0636a0995ad0b132a9488309595b4ed23284896d477cc89e500e150c93c82f" + }, + { + "path": "docs/internal/extensions/lb1/evidence/selector-controls-v3.json", + "mode": "100644", + "gitBlob": "f83e78c3fa9770e9d73b383a0ced5cc87f340250", + "rawBytes": 8643, + "rawSHA256": "26c73b74baf4ec5b56a9f8071eaa906594e1717c5d3aa972e2da25d0bd814234" + }, + { + "path": "docs/internal/extensions/lb1/evidence/selector-extra-5033/REPLAY-CLI-ENV-CONFLICT.json", + "mode": "100644", + "gitBlob": "173e7e729b124707d64b710a8fc99e4592fad8d8", + "rawBytes": 2944, + "rawSHA256": "cb8d97b487d4bf17e375b1678603b3eb9a8db2d50510231f63802e939b5b7b09" + }, + { + "path": "docs/internal/extensions/lb1/evidence/selector-extra-5033/RUNTIME-CLI-ENV-CONFLICT.json", + "mode": "100644", + "gitBlob": "7ec2bb4c9c6b3d0ad21c7a7134f8e736124f4b2a", + "rawBytes": 2484, + "rawSHA256": "492c4796a504e51a65ef1f97a0834742a0d354dc89b2eb4ae31004815520d345" + }, + { + "path": "docs/internal/extensions/lb1/evidence/selector-extra-5033/RUNTIME-MALFORMED-ID.json", + "mode": "100644", + "gitBlob": "1c3fd9f521e05bd9d03e6cca6a55f9bd2e0fe564", + "rawBytes": 2415, + "rawSHA256": "d788dd531d1ab304a0a7d999726513e21207e23d744993d4364b30306e7c665d" + }, + { + "path": "docs/internal/extensions/lb1/evidence/selector-extra-5033/summary.json", + "mode": "100644", + "gitBlob": "6cfdf835abd6d733bf82ed4f4fdf7d4c0748109f", + "rawBytes": 9276, + "rawSHA256": "61b0ae5b51bea3fddf89c998ce4f0e32d88315fa002a5a1518b87d4840e4a5a8" + }, + { + "path": "docs/internal/extensions/lb1/evidence/startup-development.json", + "mode": "100644", + "gitBlob": "b542a4c4ad6fa1c9c8428cb782f523bb7fdd4a39", + "rawBytes": 2010, + "rawSHA256": "b430c3f819e0bc17c72d6d9186ecff393e4d603a9fbad4bb905c81fee2ce062b" + }, + { + "path": "docs/internal/extensions/lb1/evidence/startup-preflight.txt", + "mode": "100644", + "gitBlob": "eb5bbe671fd725be5acbd57b43efb76d2aa3f610", + "rawBytes": 819, + "rawSHA256": "5f6d25b0e4b8ccc9d133ea718bccd1044cc22a1df380e8fd56c57fdfb840b0ca" + }, + { + "path": "docs/internal/extensions/lb1/evidence/trust-5033/axiom-inventory.json", + "mode": "100644", + "gitBlob": "fde873811886f8d46353b11ed14f5400f58ff2ba", + "rawBytes": 7453, + "rawSHA256": "c8f1257b67b481f8ccadedd9073c96f550ef21ab683909e1f361477dddc0de70" + }, + { + "path": "docs/internal/extensions/lb1/evidence/trust-5033/summary.json", + "mode": "100644", + "gitBlob": "b73c763570f7286f7a02ffd152d383a906b21361", + "rawBytes": 5963, + "rawSHA256": "b3231da95191829471f5d1110f2f4545e3b4d29eb56f05b145a5a2beabdf5641" + }, + { + "path": "docs/internal/extensions/lb1/evidence/version-20260912T084142579.json", + "mode": "100644", + "gitBlob": "3ef45fe92b0ac9ef0eb7bf4cac5d389ae8df1434", + "rawBytes": 516, + "rawSHA256": "d5446f92b7c94981e647fed1649d3998ef199d61e0e6ed9c42aa8cb3cc2ae8ab" + }, + { + "path": "docs/internal/extensions/lb1/evidence/version-20260912T084243070.json", + "mode": "100644", + "gitBlob": "e02d64674b20315fb72ee5d23224eba5f9c99a44", + "rawBytes": 516, + "rawSHA256": "b17f4335522e25a27ea0698c699fc68b8b805b7df8a76a6fd973ebad83cfa0f3" + }, + { + "path": "docs/internal/extensions/lb1/evidence/version-20260912T084355841.json", + "mode": "100644", + "gitBlob": "f236f7e8a6ac3f3d867710718bd1ae8d0703458f", + "rawBytes": 516, + "rawSHA256": "bfd6be406d367887d822bf5dafee4160ce799a37ed9daa36670eff966f565574" + }, + { + "path": "docs/internal/extensions/lb1/evidence/version-20260912T100805553.json", + "mode": "100644", + "gitBlob": "43f2bfc477dc043484349663d3497205f8e631df", + "rawBytes": 516, + "rawSHA256": "0810b4e5ea75a3bf2299d0b16fd847d885319b647049ce155023f7797daf558a" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/.gitattributes", + "mode": "100644", + "gitBlob": "32c5ed886b694aef66c38c0624568b9a0eb1b6cf", + "rawBytes": 94, + "rawSHA256": "452de0b852ab4578105e47480ab75d7cfc9195f3619ddf189ba73ae2884de295" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "9b07c65cd0250e29faa95ddc7d2fd7781b45e867", + "rawBytes": 18447, + "rawSHA256": "aeb07f3df8638ed47705800b2f00dab42695f35ce6678b95050dfdfb1f0fca03" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/ACCEPTANCE_ROWS.txt", + "mode": "100644", + "gitBlob": "fe30a2239762f3a16070a093c759d471eee1ec3e", + "rawBytes": 8534, + "rawSHA256": "f45113ae6bf3f769105a748b3d0a61ea99532a05a715410f11ef29e7e518ec29" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/BASELINE.json", + "mode": "100644", + "gitBlob": "9cbf9adaa47ce7b79b4e534befc6c64d2de9d8ba", + "rawBytes": 5699, + "rawSHA256": "da869e0c2ac50c3cc042c6c44eccef4e3de9c59bf205ad8dba888b9410c67238" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/BOUNDARY.md", + "mode": "100644", + "gitBlob": "f51cf6c0ea28f8476e953716e9755b3c2015133c", + "rawBytes": 10306, + "rawSHA256": "da0f91f7df36708936ef31e6c17f382fcb7a928e74d57a4b68aae9b96b189f87" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/CERTIFICATION.json", + "mode": "100644", + "gitBlob": "00a9d01cbc85027ed88831617ccb6cb27025dae5", + "rawBytes": 9683, + "rawSHA256": "757f8ec4491f65a6d931b1d7e2f03c53f360fa6be5a34f228bb43a6519e78b72" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/REGISTRY.json", + "mode": "100644", + "gitBlob": "79c348f3218c96576b58d9b37f68ba726fe92c30", + "rawBytes": 5899, + "rawSHA256": "6cd97f40e7c39d2212a8c8705d264d4832dcf2542815b72cd927906a01dc8b20" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/REPORT.md", + "mode": "100644", + "gitBlob": "1d81ea295c38e447102190c05afa08aad4f32a82", + "rawBytes": 25211, + "rawSHA256": "658652feb62b1a5dceec2bcc030c3df3a24b19b8d34933a8fa4561142c8cfd98" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/REQUIREMENTS.json", + "mode": "100644", + "gitBlob": "934885ad0379893486695c78dfcfe6ebf1773677", + "rawBytes": 4361, + "rawSHA256": "0983881a85f9a3b42ecd54c0bfb18170c3be3e5a65602cde66547042ca5421c9" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/RESULTS.json", + "mode": "100644", + "gitBlob": "bca831965f01334670c774b2a08b4a5191bef3f6", + "rawBytes": 63804, + "rawSHA256": "6440a963be7a0e65222f86afe3cfb89e4bee1b6bdcd0226dc0d5cda88d296fdd" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/RUNTIME_SOURCE.json", + "mode": "100644", + "gitBlob": "93989d23e91a6493da487e9f0ad29be9baefcc60", + "rawBytes": 1398, + "rawSHA256": "f32aa70d04aa8fe2a14873da0e6b22501781187544b5335918a7925221c7e9a6" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/START.json", + "mode": "100644", + "gitBlob": "dd481854de39bee665b40c93320c33f1af90e5a4", + "rawBytes": 1174, + "rawSHA256": "1718f02c23f770aa00e288e27c355ca2d78d2cec6aebd4cc017c2300d6da0f90" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/VERIFY_CONTRACT.ps1", + "mode": "100644", + "gitBlob": "67f044f96d61fad65566542e580d1196f558ed24", + "rawBytes": 2236, + "rawSHA256": "00d16569e407149cfaea1a8c34cb81f72cff6fba02ff45841f67c91eeb2ab957" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "80a023437613d52c6b2bd30da914c49a0764b1e9", + "rawBytes": 13436, + "rawSHA256": "236480a9ab5a68aef83824d3aa31ddee8c170203f53c5f6c61cb8ed0aef76925" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/ACCEPTANCE_ROWS.txt", + "mode": "100644", + "gitBlob": "64ba642be3e814192975653c6ab11de3bc5ad375", + "rawBytes": 10983, + "rawSHA256": "74982691e40eb56a10365f66e74877f6518c0a13e959f559e267047bdac7130e" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/REPORT.md", + "mode": "100644", + "gitBlob": "24aa7738d5a920d2e0c2d9b8e23a1ce6044cdddd", + "rawBytes": 25981, + "rawSHA256": "2c260fa9ad51034b1684ed011fdf1cc7ce5e0b485cf3950061e7fd5cfaac34fe" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/RESULTS.json", + "mode": "100644", + "gitBlob": "ff80bb068f63d4c7007bf503bfae5e8548beafdf", + "rawBytes": 98423, + "rawSHA256": "9313e4c20c4326b62f5cf4174bd5d57b54e300480ae48eb97d4aa74f8ebff8a1" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/SOURCE_REVIEW.md", + "mode": "100644", + "gitBlob": "2ee84e9c7095f899e4ea47ae81dfb363db827320", + "rawBytes": 5495, + "rawSHA256": "2b865ab9aacb43a5bba2fb7c5c7af9d5a98ff005ccfe01937689df6d49c2377e" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/START.json", + "mode": "100644", + "gitBlob": "4201934432978b7e31fe19811e8be4889e260586", + "rawBytes": 1004, + "rawSHA256": "9d6a31b3847994c4058625f5aeee2014f222266bf91359610bd8b64e5a2594b0" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/dependency_controls.ps1", + "mode": "100644", + "gitBlob": "ba23024d2167bde1da22c7c018436be7030404b6", + "rawBytes": 5705, + "rawSHA256": "6bc73ad9f00c72a4e2a2d3eb4c38e8efb33a2983a530ad70e5e9c4e6a10c38ed" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/final_checks.ps1", + "mode": "100644", + "gitBlob": "1454af7b0e52f13439a11302859a17ef4a2b8173", + "rawBytes": 2483, + "rawSHA256": "eee489c244b35faf8e1e480f439eb637937a4ccd33b64f889599c0b87a70dcbd" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/freeze_contract.py", + "mode": "100644", + "gitBlob": "94751a0515e077170217cffcebca381dcf0fc277", + "rawBytes": 5677, + "rawSHA256": "83ff711b0d2774690bba99a6ec92c9e8d9c1ab5d3479716eba78d3beb62cfdb7" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/integrity_controls.ps1", + "mode": "100644", + "gitBlob": "2b3907ec07041d16f9f7130b337d670615121c6c", + "rawBytes": 16062, + "rawSHA256": "7d3c787d00e41c5639102fd9f4edad42ceab621c7637df36d8834a505192bf77" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/run_owned.ps1", + "mode": "100644", + "gitBlob": "248d2fdd07bf7282c76dd236ccf6989c07001ecb", + "rawBytes": 4728, + "rawSHA256": "7269c6500f6d04904a14f5c32e2ab000f702577bacfcc039df5e4a24eae5f3ea" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r1/verify_contract.py", + "mode": "100644", + "gitBlob": "d11ac3b94cb61384aff87608c79fdd961d258d37", + "rawBytes": 8376, + "rawSHA256": "6bf80f6082076bc6048c54b744c73e928657b5beaf9a8cedce82f6eff6771ef9" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "da57544cd45c79ab3f3ddd582a747ae205931f4b", + "rawBytes": 17755, + "rawSHA256": "35fc6d35710bed02b021a46a32c0682e9def2fb442b19263dcec07e191cb677c" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/ACCEPTANCE_ROWS.txt", + "mode": "100644", + "gitBlob": "9bb864eb558401ced42b6d540546fbd597cf3041", + "rawBytes": 13600, + "rawSHA256": "7dbc035076ea9cace20ac735b1aa85b099aef3d5b5b1afe514aba2c0c63e237e" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/HARNESS_STREAM_REGISTRY.json", + "mode": "100644", + "gitBlob": "2838bb471f344dee355363663dfb053c9a257e18", + "rawBytes": 3395, + "rawSHA256": "227be213e795a6ff037abb1f67bef328992d6284c56e0e427243ede63c41428b" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/REPORT.md", + "mode": "100644", + "gitBlob": "cab207d14dae45ce91cee4d7fc0bcdebc85503ff", + "rawBytes": 27374, + "rawSHA256": "527cde985093ee77f6ec02a5750d0a7943740c9d3d47d2a0359c4c739285f91d" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/RESULTS.json", + "mode": "100644", + "gitBlob": "07452a5a52c6f153a16519bed81e827f3bc1b533", + "rawBytes": 45177, + "rawSHA256": "6f73111913d67788775fddc6d632d8de34a38c3fdb56e88a6fa94d8acf9d7b21" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/SOURCE_REVIEW.md", + "mode": "100644", + "gitBlob": "ed9226dc1fd88c4c9d5caf3efae5422753bb57d2", + "rawBytes": 14323, + "rawSHA256": "b57511ddc74fee0cf37c9ab81496820d31f24ba537c42bec9bd6834f26c5097b" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/START.json", + "mode": "100644", + "gitBlob": "6137e4772fbebdc88d73f7c6858d5f7f79bc1f46", + "rawBytes": 1008, + "rawSHA256": "a8190551f7523f5f9729b2331d64f8ca174ec99def7fd950814c3152c7ca75dc" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/WRAPPER_STREAM_REGISTRY.json", + "mode": "100644", + "gitBlob": "abbf7db1fec288b68505d13306bf7368f2b67b4e", + "rawBytes": 36673, + "rawSHA256": "39d047a36c138e34787bab33731ef77bb29558233d218a1d76be5ecc8e2b6ddc" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/certify_profiles.ps1", + "mode": "100644", + "gitBlob": "a3479c56bf51768109ffa342f36b5665a269323b", + "rawBytes": 2266, + "rawSHA256": "154bfe41da5d9644eb01b2464e1ff1d2b98418694353922a97e633919008c06e" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/claim_expectations.ps1", + "mode": "100644", + "gitBlob": "f7e6ea23ffbac4f7ac0ce1830603a95125efca74", + "rawBytes": 13914, + "rawSHA256": "ddaf90d70f60c4e339ac4381a279fd0c1e430b2c7fc19c78186a74209371fce9" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/freeze_contract.py", + "mode": "100644", + "gitBlob": "ff9aac13ad220cf2141bf94d9458634af678fcae", + "rawBytes": 5338, + "rawSHA256": "a29909e89320fa2e0f4627e84e0574f30ca0c4dbb882909548aec6043dd39a92" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/harness_stream_controls.ps1", + "mode": "100644", + "gitBlob": "38cd26fdb0616b3f165ef5c556829461be2fb22f", + "rawBytes": 12082, + "rawSHA256": "fbf570c3f191ad6043cbddb71223020166afd842112e41c4709457bbf035249f" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/reproduce_old.py", + "mode": "100644", + "gitBlob": "3b5335044bab8702505b9c70fa673904d656636b", + "rawBytes": 3091, + "rawSHA256": "73949fca39324fd9771f8f22a6f15b4b477d65613dd30ee77d5cc8f9cc74a787" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/verify_contract.py", + "mode": "100644", + "gitBlob": "3bbb81aaabdf71b7fd9103633e3e89281e2998ab", + "rawBytes": 27998, + "rawSHA256": "6f1cfb871656215513fa91f617ea563bc9b2ee4ebfbe04d77a7f2e7c30a69871" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/verify_results.py", + "mode": "100644", + "gitBlob": "586ca7815c343a0e398b8d1219e9bf7ab379ec22", + "rawBytes": 41462, + "rawSHA256": "ce931fd260a5fda818e06beef1c66c6152189b46984fc4510eb445376244cad2" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r2/wrapper_stream_controls.ps1", + "mode": "100644", + "gitBlob": "2590b0bb4da3f461a8edcb40b2a19fb6385a4907", + "rawBytes": 30059, + "rawSHA256": "1b8c9b2f95fa3aa9c88d8228d645b9a6c4a9a2b991db81de7a3a577eaa5b02c3" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "bb0e1811f3351876e93a5e13a4daa32f6c119ed4", + "rawBytes": 24776, + "rawSHA256": "7e8de1b68d4f742ff59d6b39679875e6b59fef9cdc543836bc041e5ce5b92858" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/ACCEPTANCE_ROWS.txt", + "mode": "100644", + "gitBlob": "57979fcf621af11fc2e9f6382b08ea80abee168d", + "rawBytes": 16030, + "rawSHA256": "d567ff2b9f861a6a910cc94a9e7abb44d2d559893cbbc7293cefbe798ce01abf" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/CONTROL_REGISTRY.json", + "mode": "100644", + "gitBlob": "af6ac29ee4401fb3d82d8ac6fe97dfa6347be1bc", + "rawBytes": 14326, + "rawSHA256": "16e26c5b131bbe258b3813bcdb252414e8bed454ef6286eb2ed7f7ef3496261d" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/FREEZE.json", + "mode": "100644", + "gitBlob": "eb128030283818f71516c271f6d6100734557205", + "rawBytes": 851, + "rawSHA256": "8a78737cec55bea8e45bed9785e892cfb8691659bca0cd958f7f12e1e93ca50f" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/REPORT.md", + "mode": "100644", + "gitBlob": "d3ab6bac49ca10dc54b76653c64e8d9c17087434", + "rawBytes": 25656, + "rawSHA256": "ac08ae4dc421c66012e645fd513034cf361b5cf09221c5d8d665f1815b5536cb" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/RESULTS.json", + "mode": "100644", + "gitBlob": "724d20cb7c7af15af36b2d48b2a98584342b4a81", + "rawBytes": 10377, + "rawSHA256": "12a080909522843a1826b9aa0a80d2b3c512996f6b63098b21b4bac0af9a9c8c" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/START.json", + "mode": "100644", + "gitBlob": "dec3323fcc0324529cf06aaff562f6337c712205", + "rawBytes": 1530, + "rawSHA256": "65f8e6a80c875a675c1fe893329351557d7be41a99a7edf53fd2d5554e1bde78" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/certify_current.ps1", + "mode": "100644", + "gitBlob": "1d6412375943407c44742677c1fdc604606fb9ca", + "rawBytes": 6195, + "rawSHA256": "25cb6b0c49a82dfd57de3ed605d7abc32d2ca4520e4ade16873dd17ecfbafa6b" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/freeze_contract.py", + "mode": "100644", + "gitBlob": "d71d10df92f5af163f6050d201016030a616b102", + "rawBytes": 5932, + "rawSHA256": "4288c680f322509f330283347cc9eee76200ee7fe7c3e83c776230ae3255f0c5" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/literal_selector_controls.ps1", + "mode": "100644", + "gitBlob": "a5272f8159f8374a1e56e6e5b8ec27f7508bcf55", + "rawBytes": 12112, + "rawSHA256": "1e4f1bed4fb59da2b39a21b9d52b083651f499f6cfa59ec1310c95cf6d396e61" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/make_registry.py", + "mode": "100644", + "gitBlob": "33d142a544efde258f19feb6e41cb0bf672c7dd9", + "rawBytes": 3828, + "rawSHA256": "89db0d436bd473b3651dd49611cd8f3f2a55888ba5bf322ec6208cf0397708f1" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/retained_registry.json", + "mode": "100644", + "gitBlob": "e92c8369c564f00655400591e455577151b0458e", + "rawBytes": 3340, + "rawSHA256": "521bfa0cd6dee84383ab41f8b7d6cc0f226eefabfc96113ef5ebe835a48a20eb" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/revalidate_retained.ps1", + "mode": "100644", + "gitBlob": "6726c86767028a16b156479db94949bf731a0d67", + "rawBytes": 16744, + "rawSHA256": "e5165926e21ec7e337a71902796d94a98b13e4ac99aa281fb2e813a517642b27" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/verify_contract.py", + "mode": "100644", + "gitBlob": "59e676b3221b665be192ccf84b925839991e27f0", + "rawBytes": 29089, + "rawSHA256": "e364ee4b4b4b867d231e9461260e1dd2fe44d2fb99a32b7a2a5d949b078e2d9c" + }, + { + "path": "docs/internal/extensions/lifecycle-native-p0/repair-r3/verify_results.py", + "mode": "100644", + "gitBlob": "fb2b6138bef802b38eb4de9fdbae441e53c79ad4", + "rawBytes": 35096, + "rawSHA256": "a660cf4344a71ffb3e8e62e936836755598ba37fd483098c42e1733c4a61add4" + }, + { + "path": "docs/internal/extensions/lifecycle1/ACCEPTANCE_EVIDENCE.md", + "mode": "100644", + "gitBlob": "79ef9dcea341dd5906b0aa3b1f4fe864deeea1b6", + "rawBytes": 33319, + "rawSHA256": "f996eb73d4acc9020b093e568521d7413b232aba9d0d642376b564439cb22fab" + }, + { + "path": "docs/internal/extensions/lifecycle1/ACCEPTANCE_MATRIX.frozen.md", + "mode": "100644", + "gitBlob": "1aa9b2139c05574b6256fff28aa8c3035e105e04", + "rawBytes": 43514, + "rawSHA256": "bc596cd8a4866cf8db7bd06360d1c2e797e389c92237c9ac3a0b5e4145cd22ab" + }, + { + "path": "docs/internal/extensions/lifecycle1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "c6b2388371d564b24d9441f2a3489531012460c1", + "rawBytes": 73177, + "rawSHA256": "63b7eb6b7c01fcf9ca109be9cdcbf67141bb83c3927c2d7f707b06e2dc482cf1" + }, + { + "path": "docs/internal/extensions/lifecycle1/CACHE_PROVENANCE.json", + "mode": "100644", + "gitBlob": "6b77739dedaa51dea5538caaac601ed77d4a0477", + "rawBytes": 669, + "rawSHA256": "6f803be4fedb148d054dce987cd78146bb10687cc81ef6581b412d36f8fa0caa" + }, + { + "path": "docs/internal/extensions/lifecycle1/CONTRACT_REQUIREMENTS.json", + "mode": "100644", + "gitBlob": "d8271d9a796dbbd5fec02b4169dee3098357e9a8", + "rawBytes": 54250, + "rawSHA256": "e47ab45acad51fe508ce9b8be9983a136f8c9267d4d8fdd7888195bd0419e488" + }, + { + "path": "docs/internal/extensions/lifecycle1/CONTROL_PREDICATES.md", + "mode": "100644", + "gitBlob": "d41df3a79b34cb4adda997027e5f157030450462", + "rawBytes": 19654, + "rawSHA256": "8528f0abe9fbbea11077f02b6303c772400fc895575b0792a349c7769a13c2f6" + }, + { + "path": "docs/internal/extensions/lifecycle1/DEPENDENCY_VERIFICATION.md", + "mode": "100644", + "gitBlob": "4eadae2fe0e46eee875331a598c758c3dca685ad", + "rawBytes": 15665, + "rawSHA256": "c5a5805b520a5503c70d18a390f8011109381f3d16b2347e9801047b649ed4dd" + }, + { + "path": "docs/internal/extensions/lifecycle1/FINAL_RECEIPTS.json", + "mode": "100644", + "gitBlob": "b5573b9babc6083516bfabd1758e069c54b1dd1b", + "rawBytes": 80207, + "rawSHA256": "697397c8b6b06930393898099e226b576477ca1b1890cf9e5404093548139a5d" + }, + { + "path": "docs/internal/extensions/lifecycle1/NATIVE_VERIFICATION.md", + "mode": "100644", + "gitBlob": "29a4c789ee598f727bce1e0eeb6b8bc597e9020b", + "rawBytes": 14741, + "rawSHA256": "4cc702230f0d16839fa2b5087569d8e27e61fa3c154db5231e52fe75260ffae0" + }, + { + "path": "docs/internal/extensions/lifecycle1/PROOF_INVENTORY.md", + "mode": "100644", + "gitBlob": "2fec2352d7a2057cf147a5fadf487ab9cf66e810", + "rawBytes": 40258, + "rawSHA256": "cacd0c5a9a96f767aa9aad585c0b19a7a98ad2583ac821966af2a8ae384f5c88" + }, + { + "path": "docs/internal/extensions/lifecycle1/REPORT.md", + "mode": "100644", + "gitBlob": "996833fda5424ed6fac4e8b623b05ecb429be01c", + "rawBytes": 25629, + "rawSHA256": "f0a21ef6eb0f5992e5a9584877c65afdb206f52679f40d98344f68c652371850" + }, + { + "path": "docs/internal/extensions/lifecycle1/RUNNER_REVIEW.md", + "mode": "100644", + "gitBlob": "7742b7998d2fe4b1db769629bdd54f8e1bc8ba23", + "rawBytes": 4980, + "rawSHA256": "b2e697ffb04183e56e10354c1cd34a28e67723101a129f21b8adde36e978f722" + }, + { + "path": "docs/internal/extensions/lifecycle1/SOURCE_MANIFEST.json", + "mode": "100644", + "gitBlob": "70ed6bbe243bab060987e8c3f3d4cde854abaf71", + "rawBytes": 16870, + "rawSHA256": "2b8500dbf3573bd4f2f7e6a27bfb7dc46a682ed4e59de5411405a6bc60952ca0" + }, + { + "path": "docs/internal/extensions/lifecycle1/START.json", + "mode": "100644", + "gitBlob": "86b6ff30e72578b97d6664ddcf8ebcee6761272a", + "rawBytes": 1853, + "rawSHA256": "59f47921f87fe08fa92065257cc9a5230d96b8f299d0e9e207bdd6d2a8137ace" + }, + { + "path": "docs/internal/extensions/lifecycle1/VERIFICATION_PLAN.md", + "mode": "100644", + "gitBlob": "c14d285ee06bc44a46d5f5e78623d3129e2eeb96", + "rawBytes": 17841, + "rawSHA256": "60a70ba7eafa7a11584f23809a726d137a4a7538a18c823683b6e5d245a29a5d" + }, + { + "path": "docs/internal/extensions/lifecycle1/contract_integrity.json", + "mode": "100644", + "gitBlob": "7b80274dc93c9d3ec02c7180403ad03abcbdeef4", + "rawBytes": 22548, + "rawSHA256": "5e883a58c09dd23bb21713fe5acf97a2697567bc693264ab1f46b58835389330" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/ACCEPTANCE_MATRIX.frozen.md", + "mode": "100644", + "gitBlob": "d1a682acd99207d855745d016d85eae0cdbda8ff", + "rawBytes": 46274, + "rawSHA256": "20b1db9b99fb730e7075b4b6a4abc0992e40de29336afe8375773ea062e8bfec" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "07386b6f1e6fafd9b856a821f071d34bd722ffaa", + "rawBytes": 86187, + "rawSHA256": "3c2401957389bdfe894574a13ad9c626f038d2873975f61890d6942e3912aac0" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/CACHE_PROVENANCE.json", + "mode": "100644", + "gitBlob": "58ebd6e210f206173ccb797adb33034f890b9aa8", + "rawBytes": 578, + "rawSHA256": "dd303f0f93e929651bb57bc3a3f66294624dcdb8c6fa15cba594c1635c12408c" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/CONTRACT.json", + "mode": "100644", + "gitBlob": "4a7f4f984557cf7d391ba24952570ac2abe6dd09", + "rawBytes": 19993, + "rawSHA256": "3365d6d013eee347385deb2cb4dab042700e7ec259f0cbd62ffba3081f4520e0" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/CONTROL_REGISTRY.frozen.json", + "mode": "100644", + "gitBlob": "204d6c1d48268fdec3a3d369d9b3dacd38ecb8e1", + "rawBytes": 76654, + "rawSHA256": "68ab24530878be76e030313ae4b3a17610b5bec6f70ae3fe83351e67435f1619" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/CONTROL_REGISTRY.json", + "mode": "100644", + "gitBlob": "204d6c1d48268fdec3a3d369d9b3dacd38ecb8e1", + "rawBytes": 76654, + "rawSHA256": "68ab24530878be76e030313ae4b3a17610b5bec6f70ae3fe83351e67435f1619" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/EVIDENCE_INDEX.json", + "mode": "100644", + "gitBlob": "83a62a24f1a6a12c745e1a0e5c2e935c80a8e980", + "rawBytes": 2136062, + "rawSHA256": "af8a32126da5f24ce5d43adfa2e4e8593bd2f6941480172c20a4fe62d9cf1ce6" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/INITIAL_WORKING_FILES.json", + "mode": "100644", + "gitBlob": "52501ead077dbe569e9676338ba569e0afc3b86a", + "rawBytes": 707591, + "rawSHA256": "bbe8b6278795fa2e29d4f68cff348c483e6e44dc4004025c739a78090cfaef0c" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/PROMPT.md", + "mode": "100644", + "gitBlob": "8c218b9b03b7b60753b0dd5b6c155d6fae241a35", + "rawBytes": 46818, + "rawSHA256": "2971ca834f06a62eb33b8589e718246938d8c703ab2211f83be8dbccc80bc895" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/REPORT.md", + "mode": "100644", + "gitBlob": "38ba7debc57f1452c02bfd705ab9bf62313bd87e", + "rawBytes": 23036, + "rawSHA256": "1c30fcf76880e4d275b2881f4074ec29c31c51e4bc80930d3d01d7cdb5a58892" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/ROW_DISPOSITIONS.md", + "mode": "100644", + "gitBlob": "4d6036cc9f01f6141cf8bb73f54a8a52092f459e", + "rawBytes": 39911, + "rawSHA256": "bc74804e65b18a2a08cd0eca008bd763e85945b75111ce380647e91a892aca9e" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/SCOPE_VERIFICATION.json", + "mode": "100644", + "gitBlob": "b823a4e6fed43598bbf4d97e51d8c7012abd263a", + "rawBytes": 33283, + "rawSHA256": "83002220ae3132a424a36e910a50d9c351f1a854d4bcd3e5938684454ae68392" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/SOURCE_FREEZE.json", + "mode": "100644", + "gitBlob": "6b883ce07a59c068a318f82b096085a2b1cd4afc", + "rawBytes": 347686, + "rawSHA256": "4527e51e7e9e5cef2759957f7a1942a6bb6fab89b784d572fa0af3130a81606d" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/START.json", + "mode": "100644", + "gitBlob": "166a5b92fe16c8722237e995bea6f8c4a5522025", + "rawBytes": 2635, + "rawSHA256": "073aecaae06126bf0e4f6ef1ca68450be68a2c685515af1359a43b711d121af5" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/VERIFICATION_PLAN.md", + "mode": "100644", + "gitBlob": "87f0e01f8f3c92d6ae30f5004af7b3aacc04df1e", + "rawBytes": 4563, + "rawSHA256": "228e1aa0eeeca213cde272e0f37ae2ed7a8dec31dbfd94df5beefd2bcfc5cb5e" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/build_row_dispositions.py", + "mode": "100644", + "gitBlob": "36c0bcdb41590781ed1d9b600ea4216b84b8164a", + "rawBytes": 37341, + "rawSHA256": "3202f14f3dcfee4002b1edd3170a8ce944c465b539b5d654141a380bdedbd2c3" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/collect_evidence.py", + "mode": "100644", + "gitBlob": "94e8ac24a23e2b7edeffa898b1425eaf8d528967", + "rawBytes": 4350, + "rawSHA256": "d95377b9657e45226f3b894785411803051d43eb5169c9675e7208df09ec4e6d" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/contract_verification.json", + "mode": "100644", + "gitBlob": "c985666c30fa9c5eafcc3aa4b91162df4010ec6f", + "rawBytes": 15966, + "rawSHA256": "1143b16f9abccbb5abb4d0415b16248fda5f730c66d82d55130088af61462362" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/deadline_control.ps1", + "mode": "100644", + "gitBlob": "e985da4bb21ba3cb6646623fdc0efd0808fde264", + "rawBytes": 3226, + "rawSHA256": "4831cef50ce6043f4afb9f3e2971a34d53e2e0947d4c25b311e2b3b4c1a1e1fd" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/dependency_boundary_cases.json", + "mode": "100644", + "gitBlob": "c5e63fc9f4ce0f7ae97c41a5570e74019ad7cced", + "rawBytes": 28695, + "rawSHA256": "d9e56dc40888cfdb937f0acbd9ec945846a5cac585c99341d21daa9b793d9ecf" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/dependency_child.ps1", + "mode": "100644", + "gitBlob": "b16c812db3acb30043ec470237b86833b9b62b56", + "rawBytes": 7959, + "rawSHA256": "5640ae40e34b05760f9e0fe71779291b8f23a4b053da62408a12f8499454c67d" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/finalizer_cases.json", + "mode": "100644", + "gitBlob": "84c8df0b0339a48a60af93ad446532d2a186cb58", + "rawBytes": 4731, + "rawSHA256": "0f03f2ebef9efe9b8f305db58e8e8636daaccb063a3d87e6872cb0f88a939767" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/finalizer_control.ps1", + "mode": "100644", + "gitBlob": "76165bc0c27e07a7c9aa6874492a140cbb4c5195", + "rawBytes": 27003, + "rawSHA256": "91df97e2042a6c3293632af3de6e0fef4c61ca24c4fe9a34f07182e01134e098" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/finish_report.py", + "mode": "100644", + "gitBlob": "2e3c2ea92ed013b9768bdc21cd3e32976c83bc99", + "rawBytes": 6728, + "rawSHA256": "3eb0b4f946fe5665b87f3f54e09fab8d4b9605b4891825ceb0e681637360daa8" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/freeze_controls.py", + "mode": "100644", + "gitBlob": "b385c8f2f32d8d903c2c712771c272fc5ca2c457", + "rawBytes": 1779, + "rawSHA256": "58aa36c561f27f0b940308e6adfa14ae01887bb0498811dc3b613980ef647c9b" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/initialize_contract.py", + "mode": "100644", + "gitBlob": "648be366f7ce6dec0636f00ee4238ccede69b2b1", + "rawBytes": 5497, + "rawSHA256": "5c6d2ca690e8cdfcac247aa57353c17afb8e18f9c3b4c9a978d365f8a1421209" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/make_dependency_registry.py", + "mode": "100644", + "gitBlob": "3992bc4ce288246c858771067667d37fa2a25041", + "rawBytes": 3747, + "rawSHA256": "a769606ec40f89a07884b255541864629491fd17a9a5c7d3225661f0c2368a24" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/make_selector_registry.py", + "mode": "100644", + "gitBlob": "1150b33fe1b2fca49f84159864dcdce8d8d0ded7", + "rawBytes": 5166, + "rawSHA256": "d46e862f6f3b408ae07a433ae1d54c6365da6a5dd2cc2eb30422cf4805c49b21" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/old_environment_control.ps1", + "mode": "100644", + "gitBlob": "253b002ea3e9928a827e45430b2b63772dfd68c5", + "rawBytes": 2816, + "rawSHA256": "61ac0a6ccba2bb25f2911418ce470bd5791dfe8de21cb2dea030f7c4dad0047d" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/preflight.txt", + "mode": "100644", + "gitBlob": "79701ff2fbd7f1734c51fe124460577e9dc7c90e", + "rawBytes": 819, + "rawSHA256": "c64d1c2760f6bc3cea8a5953f45078ad994eedbf4e6d726fa344006140e8d3eb" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/prepare_cache.py", + "mode": "100644", + "gitBlob": "ba174899fc48bd9ad8e5c2b8c94036d54351c710", + "rawBytes": 3027, + "rawSHA256": "bd06bd2ed9af5ead748655af6ebf805d18d89f98f8784598f80a0294a77732ba" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/prepare_old_root.py", + "mode": "100644", + "gitBlob": "172e0a3cd5bc49e103513f7c93919b6f606cb78b", + "rawBytes": 1698, + "rawSHA256": "b5c456e20bc975a12f5aa5a10e67b9475891c19898130c79e4cc0609728609ad" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/registry_control_cases.json", + "mode": "100644", + "gitBlob": "694154da863eddcb7823dd400c92eb4d4b6bb9ab", + "rawBytes": 12683, + "rawSHA256": "1b8627573b7b8e39944bc8b8f5e87e2595e055af1d04b7ced7b53d2c6229a9e7" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/registry_controls.ps1", + "mode": "100644", + "gitBlob": "1615a4676738c90178f545a47904ffaee1978c09", + "rawBytes": 16273, + "rawSHA256": "833662925bc1986a650a4440fbc2a0031fd0d8db7edc27c0bfbcad944145d13e" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/run_check.ps1", + "mode": "100644", + "gitBlob": "f21505428701c77abd2b6390b64cf127b9a267aa", + "rawBytes": 2583, + "rawSHA256": "70c86a6c07803d19f1092e182a35cc2b266da94e6790e431d84bc53d7ca32f36" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/run_controls.ps1", + "mode": "100644", + "gitBlob": "288a0f4e70adfc3d613f2893e0cb293a2e12a667", + "rawBytes": 7672, + "rawSHA256": "885bbc7c8a5d356cdfc82920d208f7d2de4ce3972abf705b3f02bb518159b42e" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/runtime_profile.ps1", + "mode": "100644", + "gitBlob": "4f26065b241fc676c12249f56d0ea3025590101e", + "rawBytes": 1482, + "rawSHA256": "4f296dad60179a23ba2d049487e29e02e4c78a873a02c8542c84b8fb918f94c8" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/selector_cases.json", + "mode": "100644", + "gitBlob": "0f14678abfb13f44af973d4a2f349b87da7e7bd0", + "rawBytes": 26312, + "rawSHA256": "407e9f8455aec21ef6ecad8098c0fd0febaf557d7be423eccaa0af32f08fbe3b" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/selector_child.ps1", + "mode": "100644", + "gitBlob": "58ff6de108feb2389868e73bff49a32c788a4f39", + "rawBytes": 10856, + "rawSHA256": "f2a6663ebe067a9ab0f2ffd241de92aab0c57db7ca0d8dfa73ef1a36a9d2ddcb" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/source_manifest.py", + "mode": "100644", + "gitBlob": "151d7031b30e62bbb0151c421676c4b0c2a43411", + "rawBytes": 23409, + "rawSHA256": "d3b173d5d74929da4388476095a22f88be71e0751a9b539dbaea0636d092abc1" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/verify_contract.py", + "mode": "100644", + "gitBlob": "2b353beb90079032a8a444a864664b1892265c59", + "rawBytes": 21547, + "rawSHA256": "fccb2933dbb5c498d2ce57e52604dd9c958fa59e9235d8737caaa5c505b5bd76" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r1/verify_scope.py", + "mode": "100644", + "gitBlob": "400f55963696731fb2874a4f348f840ebc890f50", + "rawBytes": 20768, + "rawSHA256": "a91052f6e4e49d78e7e2b7ee935c1871c67194440c6d5207a1aa62d86393e6f1" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/ACCEPTANCE_MATRIX.frozen.md", + "mode": "100644", + "gitBlob": "edf51bdd84f398ceac473075018fdc8ab4bc9dee", + "rawBytes": 49094, + "rawSHA256": "cf11930ded662d07714a5d024ff5b6a3d54923f8951ebe0338cc9a5a92464bf7" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "7ef99baff08d0dbeec2841f8ea9a9e93f321c32e", + "rawBytes": 136520, + "rawSHA256": "25b610b2568f76586c70605ae2009067901b1f653c7f148a1fdefd80226f4927" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/CONTRACT.json", + "mode": "100644", + "gitBlob": "1b41a4f7c0de6a061443700a4b0732eb81f3b4d7", + "rawBytes": 23818, + "rawSHA256": "28fce1d275a6a7d1e48a710173e8d3c7fdb182a819dc8bdc62daa7694afebb01" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/CONTRACT_VERIFICATION.json", + "mode": "100644", + "gitBlob": "3ffcab6a83c00728c053cbea73b24d51119dd8d7", + "rawBytes": 28405, + "rawSHA256": "78f63515019858afe8b4e030b064ce1386fed5cf9759487eff9fc3248e76c783" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/EVIDENCE_INDEX.json", + "mode": "100644", + "gitBlob": "f94875756d11565d7392d4629f8a639a815edfe1", + "rawBytes": 808355, + "rawSHA256": "50f0b1329e91f542ee822cee2955eba136456da9bdd4d4b2192d69c62bd736ab" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/FINAL_CONTRACT_VERIFICATION.json", + "mode": "100644", + "gitBlob": "550d2a36153857c9affbbcb0f537f9fca0ea63d7", + "rawBytes": 28423, + "rawSHA256": "bcb5c9af80775193f48ceed3cccd6be6dee5e97b15cde12f39c0e5e293058047" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/HASH_CHANGE.json", + "mode": "100644", + "gitBlob": "266ecb432e6371b648895f186c94ec24b0d8574d", + "rawBytes": 641, + "rawSHA256": "b5459aa84f31d8263da9ee3540312a09c07308f879bd46d5fc79533e75b76c71" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/HASH_VECTORS.json", + "mode": "100644", + "gitBlob": "1105b0851ce4cfec9203ee22cc5faa0f863f930c", + "rawBytes": 1755, + "rawSHA256": "1f8978a6c12865127c68244da50cf434761a315405ba366f5282000dcc664db6" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/HISTORY_APPLICABILITY.json", + "mode": "100644", + "gitBlob": "5c56e445a847530ea5d19be098435050f60ec47e", + "rawBytes": 73770, + "rawSHA256": "b74d30a4866e4723c02b2986433b21aa50493f496c35a42734ecbbdbf5036abb" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/INITIAL_FILES.json", + "mode": "100644", + "gitBlob": "c1bbd17cda85a6fd054405cf88588b9f3e787962", + "rawBytes": 1860160, + "rawSHA256": "0b7adc9edf480bca8e84d8fb2bb9ba3190827fc044d828afb99da3bfc25a9507" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/MATERIALIZATION.json", + "mode": "100644", + "gitBlob": "d6f0e1b6f8f6cd5ced82c3cf926fc2a7100f51e7", + "rawBytes": 8638, + "rawSHA256": "64f1082afccc82ec98952e94618cb0a52ff6f8e56aad7a830b4b2ee363afd1e9" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/PREFLIGHT.json", + "mode": "100644", + "gitBlob": "4024982fde5e08b3f7d9da31672c1c7efb908651", + "rawBytes": 1407, + "rawSHA256": "a12390ee2fca59d5dbdf69c123dc44d4fc81f123e8cf5fce9bce5df19ac46d96" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/PROMPT.md", + "mode": "100644", + "gitBlob": "88c4332107732eaf72257a90b23cc2dee67b1345", + "rawBytes": 42671, + "rawSHA256": "d265fbb7b634e9cd5dad41ee817a51c32ec14e98cc57400c83e712140795e3e0" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/PROTECTED_BASELINE.json", + "mode": "100644", + "gitBlob": "b719f02e73bf7689d955874d15ce9b34cfcb10a0", + "rawBytes": 715453, + "rawSHA256": "ee37179ce6b3330a278cc43b044202151626a0aec3e8de49fea46d177650cdab" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/REPORT.md", + "mode": "100644", + "gitBlob": "ec46526b0209fa4d4409cfd50a4cede4dac0ae89", + "rawBytes": 25314, + "rawSHA256": "e56720f96b7a77b95d98a6a6e665ba433e0d89541db2f370d49d6e44b7cc4684" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/RESULTS.json", + "mode": "100644", + "gitBlob": "695d2ccefaba960a568a901786d57488621936a1", + "rawBytes": 303999, + "rawSHA256": "827bc69b864b71cb49c26350890bd29e8d744a97e675177ad7d89de59821dba1" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/ROW_DISPOSITIONS.md", + "mode": "100644", + "gitBlob": "adfe856a75dc02bd9ab94d9b30356cb75e05c442", + "rawBytes": 87424, + "rawSHA256": "243ca8fc3e12f0a44e936055e340160f52280f7711ce6833084e65ce2f3fa17c" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/SOURCE_FREEZE.json", + "mode": "100644", + "gitBlob": "4cd65468038a78584195eb64018eb7cbdc232fb4", + "rawBytes": 51722, + "rawSHA256": "ed86cc527ed10e10164ddeef437d4e8afdb44c19cfaf59615670ef0975c8527f" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/START.json", + "mode": "100644", + "gitBlob": "e621a05e2a021300a9f3101504cb5ccf51765af6", + "rawBytes": 6623, + "rawSHA256": "ebd653a8108470d2bd735850d4e788052ef8e939424761f3ee556f6885855428" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/VERIFICATION_PLAN.md", + "mode": "100644", + "gitBlob": "c845f62d150d44a40b444776ee962183a60e8e98", + "rawBytes": 3312, + "rawSHA256": "105d7fa4c41700a1ceb1b8000156835c5076ea47868ccf62d361f4767688b79c" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/bootstrap.py", + "mode": "100644", + "gitBlob": "8cfa05738f6b9bd1f0257398ff1348d24c400666", + "rawBytes": 6784, + "rawSHA256": "8f9c9aedee035111b93d1285283c10eb213c3556781b435df34641c23e9e2fb1" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/build_rows.py", + "mode": "100644", + "gitBlob": "cd0266a1d09b5f14db68bcb0c388304793dcedb8", + "rawBytes": 30931, + "rawSHA256": "73d72aa7051e9848152a81b516e4fffee2afc21ad1228034179211f4ef27ca9d" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/hash_control.ps1", + "mode": "100644", + "gitBlob": "a8b24591062123e7977e1ed79f1da2e5cabfe0d7", + "rawBytes": 4695, + "rawSHA256": "633e6cd248567468cf7755ec7937802e698eac25d84bddc73b48f43427b2f4fc" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/materialize_contract.py", + "mode": "100644", + "gitBlob": "706fcc51dbb5d0e7523c53764daac7201160066c", + "rawBytes": 6584, + "rawSHA256": "881e0946abfe4de07664a67572e3c9fef84dac0c200cda9efd83a31a7faaacd2" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/package_results.py", + "mode": "100644", + "gitBlob": "96c44881fbfe06ffb6b875b83b8afdd43d90613b", + "rawBytes": 1570, + "rawSHA256": "c2603bce25d305af2c46acca5931ae856ac71174d117aa2649476449322fb8a3" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/prepare_runs.py", + "mode": "100644", + "gitBlob": "72785f46b35e2aa37a661a6fdc6341cb3b3d9fe4", + "rawBytes": 3155, + "rawSHA256": "2ff59106edfed101a68926f15a1301ae2e8d3b6b5eea368ddb70d2e2488e9eb6" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/render_report.py", + "mode": "100644", + "gitBlob": "394b67a629e69e71035f9d548dc07e3ebb120f2d", + "rawBytes": 21128, + "rawSHA256": "943b4dce27443e155472dcd6267848bf185dc4645a9d46d56aa053cbfab03047" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/run_check.ps1", + "mode": "100644", + "gitBlob": "1377712ad2e86e8ea3ed0ab497c25960cdebb045", + "rawBytes": 3376, + "rawSHA256": "444ef5bedabfbd29495a0556408a7c3ffa85f937f6857e99127760291e85deeb" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/source_freeze.py", + "mode": "100644", + "gitBlob": "a68ca0066eea5c04af01e42b8c29a76236ea8165", + "rawBytes": 4562, + "rawSHA256": "f2391d3f5dceaebbf79e6b6bb4ddae6a7dd60cd4ee5b907f1d8b0afaccb5d719" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/verify_contract.py", + "mode": "100644", + "gitBlob": "aae2c76ea3d3f670b102cbdbeb33c350a14d8dbc", + "rawBytes": 25567, + "rawSHA256": "92fda271b84d5286b7cccd3277db7b13b4de5d0196fe26e6148da864eb9321da" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/verify_evidence.py", + "mode": "100644", + "gitBlob": "c6436243788fc270d2f5d7c34287182cdf4c5d6e", + "rawBytes": 30668, + "rawSHA256": "614081cb05f073121d02309a2f249da8d27c6535d9b069776c45a57239656cdf" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/verify_history.py", + "mode": "100644", + "gitBlob": "9aa64b4988de69ecfb5a0dd0bcb08237b91c1b24", + "rawBytes": 41578, + "rawSHA256": "64e66a04a1e35486bf1cf35481b8b3fca8d20b00b88dc46292d808211d2e47cf" + }, + { + "path": "docs/internal/extensions/lifecycle1/repair-r2/verify_scope.py", + "mode": "100644", + "gitBlob": "d1e937a09cad712d6c9370560da77ea2e2ccde07", + "rawBytes": 4819, + "rawSHA256": "315751a3cf257382b104d7d7471aa2c9fd9bcd0e22c09e6db6e62e96a6b2961c" + }, + { + "path": "docs/internal/extensions/native1/.gitattributes", + "mode": "100644", + "gitBlob": "0d06cba3191946218cf405cac707d12f0e0c0662", + "rawBytes": 1508, + "rawSHA256": "ccf135c40aadb273a2366d0e9dcda2d80a792e246f77ecec5da894d32956b98a" + }, + { + "path": "docs/internal/extensions/native1/ACCEPTANCE_FREEZE.json", + "mode": "100644", + "gitBlob": "e9099d54833f90abd4660e85243e3ad1f526f816", + "rawBytes": 354, + "rawSHA256": "c049a24b55fd35bdf3ee33eb208b0d6016d332864409f9ace4cd488119b49e0a" + }, + { + "path": "docs/internal/extensions/native1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "42c5ce5ade2640d21cf459520f3cb19fed7312db", + "rawBytes": 74021, + "rawSHA256": "f216c6f8dc13343807e126ce29f33333144306b59b60b270abfdc5224ae80af9" + }, + { + "path": "docs/internal/extensions/native1/AUDIT_PACKET_INDEX.json", + "mode": "100644", + "gitBlob": "453e2448c3f7881718908032e0dd98f402b03281", + "rawBytes": 36713, + "rawSHA256": "81b89157942d4c67a24e3e9885d4a6c51fad0e39b1a0a95c4a5e7275d9c31807" + }, + { + "path": "docs/internal/extensions/native1/AUDIT_PUBLIC_CLAIM_PATHS.json", + "mode": "100644", + "gitBlob": "fcab64d73deea73405f41fe9df0cd88cc386dea1", + "rawBytes": 16613, + "rawSHA256": "6ac9f2b344d1b49c1d0432384bb78e6ed9ea6c04d017c811fa8b5a38517fd57a" + }, + { + "path": "docs/internal/extensions/native1/AUDIT_REQUIREMENTS.md", + "mode": "100644", + "gitBlob": "31c4785e33d5eab258a969bf0a0f96dc8bfdfd72", + "rawBytes": 11035, + "rawSHA256": "2eeb860936f15d1c189d23c67960b1679dfff1ff6feb2dbfe53d018c624cba60" + }, + { + "path": "docs/internal/extensions/native1/BINARY_BUILD_MANIFEST.json", + "mode": "100644", + "gitBlob": "fdf336a77a930da0918b3bbff3e3c01ce6ca5223", + "rawBytes": 5601986, + "rawSHA256": "8acf20e470e6247e3e415fe283f909c7bde2f968518f76f0cda0ed7f988954fd" + }, + { + "path": "docs/internal/extensions/native1/BINARY_LEAF.md", + "mode": "100644", + "gitBlob": "906e2a024425992b1539a005defa668d808e9669", + "rawBytes": 28485, + "rawSHA256": "91d2e40e3fe5b4f39c715f4b519aa59fbbbb32b4958daa3448e8f7231c2c7132" + }, + { + "path": "docs/internal/extensions/native1/BINARY_V3_BUILD_MANIFEST.json", + "mode": "100644", + "gitBlob": "d63988821bd58840a9c2c2848a78ee034e599aed", + "rawBytes": 2779460, + "rawSHA256": "a4c20bcaa5e35402293db522ce8736a81bd84fbc67fc2648693475504e5e1069" + }, + { + "path": "docs/internal/extensions/native1/BINARY_VALIDATION.md", + "mode": "100644", + "gitBlob": "df6b7c855d910159f5901fcef5f073bef32f9a20", + "rawBytes": 47551, + "rawSHA256": "b3caf562182bcae69162d9f00b9563d5ab14dfb8b2320a62bf8a620f1cf19b63" + }, + { + "path": "docs/internal/extensions/native1/CLAUDE_ASSISTANCE.md", + "mode": "100644", + "gitBlob": "f42799175956bfcd92fd01aa3aa5f7b07238f8af", + "rawBytes": 3830, + "rawSHA256": "3570f033f75fe6c181e561616c45c184930b867e165305484fde817969a12cda" + }, + { + "path": "docs/internal/extensions/native1/COMMANDS.md", + "mode": "100644", + "gitBlob": "ba3d2bc55c2bd429a6683017e91f85cc76fc70ef", + "rawBytes": 19228, + "rawSHA256": "dc6a7ddaac59ac4ccb2581175400f08813ad41bc577a81cccb661e72c0354b31" + }, + { + "path": "docs/internal/extensions/native1/CONTINUATION_CONTRACT.md", + "mode": "100644", + "gitBlob": "77e254fdd06d9dc0ad05943adc523486acf7bddd", + "rawBytes": 6940, + "rawSHA256": "41d73e461d330de2306879ac9b30ca6e455832d039c1e9ffbc57942608465ecf" + }, + { + "path": "docs/internal/extensions/native1/CONTRACT_AUDIT.md", + "mode": "100644", + "gitBlob": "925ec8558db396a78dc27b509289eeed0269e095", + "rawBytes": 6559, + "rawSHA256": "8478bf15be3ec6e9b9fbf1ec411b4e6daea98830271e0c8aa63e5925c79294c0" + }, + { + "path": "docs/internal/extensions/native1/CONTRACT_VALIDATION.md", + "mode": "100644", + "gitBlob": "cd3e5d2a00095a22706ab9fc93fbe38e6d663b68", + "rawBytes": 12138, + "rawSHA256": "7c22845d4ff64aa27d2d849b7ddd0a646a1e16f15f83cba452dd8474577025a4" + }, + { + "path": "docs/internal/extensions/native1/CURSOR_LEAF.md", + "mode": "100644", + "gitBlob": "67447ee823e85bb016d4099f87abdf2d3769fd92", + "rawBytes": 14440, + "rawSHA256": "c50ba238172c0148705b86ffee7155dfd7e97b71fe2f017351e9da0113a78932" + }, + { + "path": "docs/internal/extensions/native1/DEFAULT_CACHE_PREPARATION.md", + "mode": "100644", + "gitBlob": "32cdf20bc2676f7e91279f30d3894c25b174158d", + "rawBytes": 6732, + "rawSHA256": "42cd1ee4543e267f2173dc66827b7d3a1917ba2396a85c85365080c0c9154d32" + }, + { + "path": "docs/internal/extensions/native1/FINAL_SOURCE_MATRIX.md", + "mode": "100644", + "gitBlob": "577c669e14fa5e5e66a61a7b5357765a08740165", + "rawBytes": 43376, + "rawSHA256": "ac9259fb49dc6e0cbcdd83760afe61fd2e76ac27979b8e2accdc17782c9395b5" + }, + { + "path": "docs/internal/extensions/native1/FINITE_LEAF.md", + "mode": "100644", + "gitBlob": "41841889fe74394a0cec52bc91e7ddfa9c4d5b1d", + "rawBytes": 14613, + "rawSHA256": "621881f7683ae6f0de9d8ccea6ab9b08373f77f832f6ab0cf738f170de47d325" + }, + { + "path": "docs/internal/extensions/native1/FRESH_AUDIT_PROMPT.md", + "mode": "100644", + "gitBlob": "2af3f1e9c2987ec4e1dd9d32a8c1794e7e021809", + "rawBytes": 15782, + "rawSHA256": "fb993699b9e2cb96c1732251da874038c1ce62872622df2543952349a6dc36de" + }, + { + "path": "docs/internal/extensions/native1/GENERATED_SOURCE_PINS.json", + "mode": "100644", + "gitBlob": "8d42156a171f2bde876868bd715dc54613e9fa8b", + "rawBytes": 7756, + "rawSHA256": "2b577ed972455cee40096a1a7bed5bca2e7805631a159d4f239eff332f06a56f" + }, + { + "path": "docs/internal/extensions/native1/LIMB_WORDS.md", + "mode": "100644", + "gitBlob": "45ee7501d48f5099c29ed1ac1e1842fcdaa87d95", + "rawBytes": 13338, + "rawSHA256": "b6764e1d0f6543756d19b8dd663944193c2ff4ba9571ed2d0b61f76a39a0718a" + }, + { + "path": "docs/internal/extensions/native1/MACHINE_LEAF.md", + "mode": "100644", + "gitBlob": "229f9e7dccb6ede588d1e5ce09c6c0e1531a4b73", + "rawBytes": 20405, + "rawSHA256": "c47a57211500f386e61aa8f5df67d8dad101afdb48ee0746b14f8e2526ab884b" + }, + { + "path": "docs/internal/extensions/native1/NATIVE_BUILD_MANIFEST.json", + "mode": "100644", + "gitBlob": "b40c37c7374b19eca80683b6a23ede34c224086c", + "rawBytes": 2637, + "rawSHA256": "2f2c3fb554ca57d8a1c086460b55817940fc2b238dc6cf00813ba59d54d3f162" + }, + { + "path": "docs/internal/extensions/native1/NATIVE_WITNESSES.md", + "mode": "100644", + "gitBlob": "f107832be50704f9a15dbf5a30238d82adba4b90", + "rawBytes": 17296, + "rawSHA256": "35d66a3eccd53e5f9015222e72b23e0061c9c61d4789aa93ff7253832d4965f4" + }, + { + "path": "docs/internal/extensions/native1/PHASE_RESULTS.json", + "mode": "100644", + "gitBlob": "4004049e42a5c9a650da2753c1f0657f65c883d1", + "rawBytes": 702, + "rawSHA256": "ad6ee54d2d7190dcfef8e352c2f657129664cc712af3f2c58b63f2b6be8358f4" + }, + { + "path": "docs/internal/extensions/native1/POLICY_REPAIR.md", + "mode": "100644", + "gitBlob": "d3418e6ad186d99301fd33ca91038c128f919a44", + "rawBytes": 22255, + "rawSHA256": "5587fc0cdc6e76f136316791fa41b8534bfd30e134b633a8554f9c23c7dab4e9" + }, + { + "path": "docs/internal/extensions/native1/REGISTRY_REPAIR.md", + "mode": "100644", + "gitBlob": "7fff40370c66141aaaa5801e099d2277cd7d3c0e", + "rawBytes": 21980, + "rawSHA256": "7065d9b248d8b1131f4f8446bfc29a58bb7984366228b15989662d61948943d9" + }, + { + "path": "docs/internal/extensions/native1/REPAIRED_BUILD_MANIFEST.json", + "mode": "100644", + "gitBlob": "0cb4b6d21fd8ee965a2ac2a90c2804863ecb5008", + "rawBytes": 954536, + "rawSHA256": "b07f660a24ba5966d7cd5bda3d2c7c7d90ecf6fdd4192de0b709c486d5f006f9" + }, + { + "path": "docs/internal/extensions/native1/REPORT.md", + "mode": "100644", + "gitBlob": "15952d1a5fb792c7acdcbe04cb3aa9a25f1f90e4", + "rawBytes": 14049, + "rawSHA256": "2fb3d34a27414a796cccba0c4483b25a0435c8a8ed03643a60bfa1880d2877cf" + }, + { + "path": "docs/internal/extensions/native1/REPORT_ROUTE_HISTORY.md", + "mode": "100644", + "gitBlob": "98b3e5b65fe1414bd2071200a1d17ee648ede257", + "rawBytes": 21192, + "rawSHA256": "d6c362528d5ff2dae2fa929c1c9a3a05b5e681f2c2e4edf72451cb7d3f5fdc00" + }, + { + "path": "docs/internal/extensions/native1/ROUTE_EVIDENCE.md", + "mode": "100644", + "gitBlob": "57a292527d926f9290ee17c8c0d08cb9ee1c0fe4", + "rawBytes": 12810, + "rawSHA256": "94e4f0c210b219c251188174bc0a0d34b7716bdfc551a9d87c22429e5c300405" + }, + { + "path": "docs/internal/extensions/native1/SOURCE_CONTRACT.md", + "mode": "100644", + "gitBlob": "5ecea9aa6d125a7b3ba6dfb9544d37a257382c5e", + "rawBytes": 18526, + "rawSHA256": "8d9833471c76fd84e7c93e1387a755b063eb3307cd6abe4b604564fab6abe94d" + }, + { + "path": "docs/internal/extensions/native1/VALIDATOR.md", + "mode": "100644", + "gitBlob": "7447bffb343045e1d80629d3a9bd6af3c4b0927c", + "rawBytes": 16963, + "rawSHA256": "a67d9f80ed923b4b87d6a3ece5223fb6277d0e0bc8ba0b58f56407637f0ab6ff" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-controls-20260912T130603847.json", + "mode": "100644", + "gitBlob": "326e720be96cf37a5eb8d6c9f7e455a6d2f1a782", + "rawBytes": 1045014, + "rawSHA256": "2bead2557d7cd8ea6056265636b45f05e0af68f4e39f848441ef51f9226c06ed" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-early-guards-after-v3.json", + "mode": "100644", + "gitBlob": "bca4d41da9036fbde6e1aabff0cdd5fd6ed3958e", + "rawBytes": 9893, + "rawSHA256": "e9f857f0d2c190f5daac6fbae58353745344388c1258cdc90b8cb5160e06e432" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-final-extraction.json", + "mode": "100644", + "gitBlob": "d5fd40c383d3a7445ce6e56899dcfc469d6659d3", + "rawBytes": 37882, + "rawSHA256": "82de67d23a1d730ce1c42b434ee5c9effaa87b543a8d7982fc6b251aaf461ec2" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-final-static-checks.json", + "mode": "100644", + "gitBlob": "661c7af52d71464325f41b4a17e058e85e1945e1", + "rawBytes": 1490, + "rawSHA256": "6cec80bed0022446d33ba641ab88faf11a9d369a3e275b74abe6eaa5d511b00a" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-first-selector-v1.json", + "mode": "100644", + "gitBlob": "b4ace9c6762a54b0ce5fe2b3fb62e5ba82ffe097", + "rawBytes": 1503, + "rawSHA256": "b97bc00109328a43f2aa70c27c147b9c2efc95c043fec4000ebd4d92633f78e1" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-replay-20260912T114513436.json", + "mode": "100644", + "gitBlob": "9393bd83f0dd5dd2f66232883d4cfffeb2f14f3e", + "rawBytes": 2936, + "rawSHA256": "28b9ab5dd8faaed00e96f2ef4295032df9630ddb397f77d8f19167dd28c5b4d9" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-replay-20260912T125636041.json", + "mode": "100644", + "gitBlob": "d7d478c73b8d691ea657e768cd764c519bc4d9c0", + "rawBytes": 41411, + "rawSHA256": "38040feb491e40e1360433730de8ad727dfcdbc712e319e5800a22a9b94c91ef" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-replay-20260912T125916442.json", + "mode": "100644", + "gitBlob": "8e713bc6a67aa891ff6f4d8c46548fc550b9747b", + "rawBytes": 111203, + "rawSHA256": "b1d9822ded4d34540e665cba932506ec251842924aa467ba58c5b1196e2348aa" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-replay-20260912T131637038.json", + "mode": "100644", + "gitBlob": "5dcaca368ac5e1a7f85140b3ade22c57244835e3", + "rawBytes": 41497, + "rawSHA256": "02d81fde724fe4e567bf2e6bc3e5e3592f053174b626ebce68f8bd52a87482fb" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-replay-20260912T131712734.json", + "mode": "100644", + "gitBlob": "4eb3cbb2a0acb3ffe4e62a593d2ebe6da862a5a5", + "rawBytes": 3016026, + "rawSHA256": "c159656b68a1c1757eb439277d21c36c485d39a228a516bd47995e69c8cd60ea" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-static-manifest.json", + "mode": "100644", + "gitBlob": "d09d54defb4553e8597d7dfc74ade1c2e106146f", + "rawBytes": 11606, + "rawSHA256": "3feae48a9ff7ea86dc7ba570d3faa023e2ad590b9df69a4cd768ebbea6d04c12" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-v3-calibration-pq1-n9-full-20260912T125906228.json", + "mode": "100644", + "gitBlob": "330b72a88a12accc0a5cad4e49500fde030f512b", + "rawBytes": 1206, + "rawSHA256": "93dfd7505e6e855e831f87251ee803c5980cda2f54bce3d012728cf5f77c11bd" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-v3-calibration-query-smoke-20260912T125624257.json", + "mode": "100644", + "gitBlob": "b1c334503dd7e850b696168b48e7da72e200f143", + "rawBytes": 1205, + "rawSHA256": "60dcbd76700765af369df952a5e789c9782dfd66a436ee4c9132d55a3cfad5d1" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/binary-v3-final-128-20260912T130558739.json", + "mode": "100644", + "gitBlob": "60f0f27cbba293033cdd97d30d9a183be61dd4b6", + "rawBytes": 16722, + "rawSHA256": "acb96574d5d43e5faa61b1571591cbca9ae41d29c0b27dec3377f30c6e5cd9c6" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/contract-inventory-20260912T132610808.json", + "mode": "100644", + "gitBlob": "d00aa02b41bbf2aeab6a40e357023c0daf356dfd", + "rawBytes": 149868, + "rawSHA256": "f96d0ec22c7331bf5eea3f66182529b6e54cddf9aaa177bba5bd4b13fe13fcbb" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/contract-replay-20260912T131025801.json", + "mode": "100644", + "gitBlob": "c4a0829b17bfe80eefd7d69b70abf9acdaab793b", + "rawBytes": 4465, + "rawSHA256": "c3cdc436ac6ed19165c874e991960017d15f88bd5b47cfdab3b4fe62dd289c4c" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/contract-replay-20260912T132003337.json", + "mode": "100644", + "gitBlob": "220317ca7408bc5dd3f5bdf0204152a9a42f5822", + "rawBytes": 133438, + "rawSHA256": "00dffeb5097288a4f76d7236c933a0e11b0628c979a62a4be3126cca16460f6e" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/contract-replay-20260912T132210348.json", + "mode": "100644", + "gitBlob": "a5ec0ac57d279049b8f7a241eeffb62579001163", + "rawBytes": 135008, + "rawSHA256": "363af8bc6fe34e695c65f019b518b52a125383f26fa069da655b9ccc97f9217c" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/contract-replay-20260912T132516703.json", + "mode": "100644", + "gitBlob": "54e3631b1603d368f7bef1b78d98e9bd3c316b03", + "rawBytes": 40265, + "rawSHA256": "65909fee725067fefe4d46ea196f81878a95942b399af613209ea99a825f2c50" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/contract-replay-20260912T132541948.json", + "mode": "100644", + "gitBlob": "caf0b6c62fe229593d1a885fcc143b3396548c61", + "rawBytes": 133437, + "rawSHA256": "82ec95a14cf0b13143aaad7c0ace1ec641894791fb313b6cf39df389d0c6a6a4" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/contract-replay-20260912T132610808.json", + "mode": "100644", + "gitBlob": "9dca171773b7df7e7d7fa182a623cd6616e467a8", + "rawBytes": 539593, + "rawSHA256": "f98f12d881f0faf1b13a6159ed1f116009c2cd5878771093b892152ed9f894fe" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/cpp-effective-discovery.json", + "mode": "100644", + "gitBlob": "888a90a860c7b2e6a182adeaa3785580e035df7a", + "rawBytes": 14934, + "rawSHA256": "de098ce9a3f2ccf498d3677c3f00ab68c9d87730aae35bb05e2e0a0851c3de57" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/draft-producer-summary.json", + "mode": "100644", + "gitBlob": "2087c3f7cd3e9cbbad3c6287713a17bed6a90071", + "rawBytes": 533, + "rawSHA256": "3f684196ed68d147cfcf0cd3ca173e22d5904529a4a37137cf0babfa547ed506" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/empty-argument-byte-capture-control.json", + "mode": "100644", + "gitBlob": "746b5b00cfcd20906ff2b89556be053fe1fdb66b", + "rawBytes": 2313, + "rawSHA256": "8cb6d96ef0c1d56914662c5620e7f1e1cc7c374eafceb10314c6f317c0fda21c" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/empty-argument-capture-control.json", + "mode": "100644", + "gitBlob": "1c8c1a1e383540f8d13c4b9e0af30b4dfa3533b6", + "rawBytes": 2209, + "rawSHA256": "86230516f2600704250d2d66fad5f5c01dda3d45dd358fa5163484190165d8ef" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/final-field-span-preparation.json", + "mode": "100644", + "gitBlob": "208111f9899f7e87a9c8ab76903b23d7111500db", + "rawBytes": 38263, + "rawSHA256": "58d84de4102babc4f0398133f2c45f97be66b6cf233159872dff6c183785a71f" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/hash-buffer-benchmark-owned.json", + "mode": "100644", + "gitBlob": "a509277ab2c477afd9198813d8758b9da5446388", + "rawBytes": 2499, + "rawSHA256": "64f568f7cbfb21fd2ea05d426245dcf03b89a86f7ed7fbde34e5bceecb791b6f" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/hash-buffer-benchmark.json", + "mode": "100644", + "gitBlob": "768f505b0afed2ecd471397812679a50427e9ee0", + "rawBytes": 3257, + "rawSHA256": "bae105fe253abfdd8ec2d9b1c710859c6609aa8ebab6c40e542138a1f40ed49f" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/hash-small-file-benchmark.json", + "mode": "100644", + "gitBlob": "e40953ea57a6aa7c44baa2404d2c3c87832b2974", + "rawBytes": 61222, + "rawSHA256": "19a5ac6bc0eaf3881767215413dfac6615329889c3f4e38d2101562c959e9b8c" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/hash-small-file-owned.json", + "mode": "100644", + "gitBlob": "b84a392556361a50bf8da110d09ff543c36d5886", + "rawBytes": 2583, + "rawSHA256": "5763a9a03b6f344d7f8620e2bb45ac6dde0b7bbcdddcbc93da33ba302bf324aa" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/identity-v3-controls-20260912T120225336.json", + "mode": "100644", + "gitBlob": "d1b78d71be00f6fb70ed2c310f5cf62441e88991", + "rawBytes": 1992, + "rawSHA256": "7367e3fd75b3bd7c8765dec88da9ae4b36fa14560b1707e3771b547a6426e9f1" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/identity-v3-controls-20260912T120438830.json", + "mode": "100644", + "gitBlob": "682adc55652aa5aad612e5de94d61017d5a36e97", + "rawBytes": 24996, + "rawSHA256": "abf91f122e4266ecdee2252755769874c3dd9cb92edf71aaca01867b11242c4a" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/identity-v3-controls-20260912T120609886.json", + "mode": "100644", + "gitBlob": "1b72cbb15f8cd98d728e718f988ee7ef9b200487", + "rawBytes": 1563, + "rawSHA256": "4d5a6d18b0e74b8684440547e0accb10fafea8b4144e4c17129c10e248a0f2ce" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/identity-v3-controls-20260912T120637882.json", + "mode": "100644", + "gitBlob": "680a11638d1eaa9a437009e8c48b760e1b8142e6", + "rawBytes": 15253, + "rawSHA256": "be853ec667de2def2694ddb1ce5f0f25d0b9bad6a6191cdd82031b32ba5c94df" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/identity-v3-controls-20260912T120706093.json", + "mode": "100644", + "gitBlob": "8ff3585417100f70076b723fb9cc0572b5acd42c", + "rawBytes": 2496, + "rawSHA256": "19c94fd2ef575b3b2ac0fc04f276185a5c12a6246fda7bf8f99068f7538d6028" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/identity-v3-controls-20260912T120722287.json", + "mode": "100644", + "gitBlob": "14edf2705a43fd15538b50719f74c9a4dcd5e003", + "rawBytes": 1661, + "rawSHA256": "660f4c60340033ea224efc5e6d6779b2f6ad40afb8b29f410ae235bbfad1d4d1" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/identity-v3-final-wrapper.json", + "mode": "100644", + "gitBlob": "a7cf9e13ec3838790beba3b99061994b03301cd2", + "rawBytes": 1129, + "rawSHA256": "f1034b215937ba41afbc4a7495bb060087e284750cab4ea3f60ff0b8a77abf95" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/property-span-all-draft-check.json", + "mode": "100644", + "gitBlob": "5396bc0997f963ff3bc68789b61ae8d9f920f564", + "rawBytes": 33001, + "rawSHA256": "d9c0b544446b8b439cc445c0a0ca15a1f10a3355d12854c15c73c68a21d602f8" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/property-span-draft-check.json", + "mode": "100644", + "gitBlob": "a6ddfd38e67460cbb9d870b69cecb376a2cafd3b", + "rawBytes": 10505, + "rawSHA256": "c8d59b7851454d93abdeefd8caf7c030d58c7967a4c56e2e3646618221d0e49f" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/raw-byte-capture-control.json", + "mode": "100644", + "gitBlob": "276b7a70b048bb9c6f36e4c14ec0d0e9a88b1b48", + "rawBytes": 2177, + "rawSHA256": "22f86d139b9a5bc99bb64075b0ac5951cd2417704e2381e47e2e018543865901" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/startup-packed-rmq-native-cpp.exe.json", + "mode": "100644", + "gitBlob": "72711ad9b04fbaba83c061a1c14e648fafe38df4", + "rawBytes": 3331, + "rawSHA256": "aedc6c3534ad0dc03ebbce629748330a4fa80a0a2588793f2781e58a6c53f21e" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/startup-packed-rmq-native.exe.json", + "mode": "100644", + "gitBlob": "a5d0e59b6fb52ca0edcd7a7bf0e0372588647cf3", + "rawBytes": 3313, + "rawSHA256": "89482ae63cc190f1379c76fade26820da142bb8faebb15fba72dc48b0a9b5757" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/toolchain-mismatch-actual-v2.json", + "mode": "100644", + "gitBlob": "ecb79f5bd4f052f42c32b7c9cad9597fd822c469", + "rawBytes": 2641051, + "rawSHA256": "af8459ac7377d3353e5ea96d362a16ef4309d8a2f2a93b9eb1820ed9594bda11" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/toolchain-mismatch-diagnosis-v2.json", + "mode": "100644", + "gitBlob": "cbc8c6bd8ba3f92621cad0587313176a905d3e28", + "rawBytes": 30725, + "rawSHA256": "a2235af69884771caa39b9c9f0b74de1cbebdd4743ffdcbe73eccab27c3a6df9" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/toolchain-order-delta.json", + "mode": "100644", + "gitBlob": "39c96869b3569aae39f67e7718849bfc4416b561", + "rawBytes": 7124, + "rawSHA256": "3b0a9a92d9bc501e8e4fda443b2246757ed11fe128864098f7d372d489e5d229" + }, + { + "path": "docs/internal/extensions/native1/binary-commands/witness-independent-inspection.json", + "mode": "100644", + "gitBlob": "c6a57c4c338d72baebedbb7da4ab3830ff225580", + "rawBytes": 9790, + "rawSHA256": "29f34ca018dbe14d142ad56dadde96039487d9b34e6a14bbfab45c31862e5190" + }, + { + "path": "docs/internal/extensions/native1/commands/audit-contract-extraction.json", + "mode": "100644", + "gitBlob": "caa7945b0a9fb76c403e27844e7e456a27dac013", + "rawBytes": 1398, + "rawSHA256": "d252cd1cd73c44c3ec3eb610b1042455488bd8a384e1b82e03db28a862b0d306" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-bounds-01.json", + "mode": "100644", + "gitBlob": "efa05dcb931d2d9aa65c6462797d432d9188acd9", + "rawBytes": 6054, + "rawSHA256": "5f0f7d0561fb11237d3ea83f0308c43369f086d9dcc95a2733a8045b78e64828" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-bounds-02.json", + "mode": "100644", + "gitBlob": "39310162b4c11cb93e4d37d4d34d0f673a7ac31b", + "rawBytes": 3199, + "rawSHA256": "ba374d694a6394a152ecc67b509b00c772d7cc8bba65a07be2067a13ff6dcb93" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-build-20260912T111100924.json", + "mode": "100644", + "gitBlob": "3ced7ad136958437920d00f6090baf8e5b429ee2", + "rawBytes": 5692692, + "rawSHA256": "8486c0c039365de086e651fbc1686531d1dca4f000c75c62be6a65e70e6c53eb" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-build-20260912T122050486.json", + "mode": "100644", + "gitBlob": "665b38c6255eb2da1c8d6cebea79f4b29d04c49b", + "rawBytes": 2827735, + "rawSHA256": "c62f6ec8198af6636d0ddae410cb6d122f520f784c8ceaa0ff69f2f539252bb7" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-checks-01.json", + "mode": "100644", + "gitBlob": "d0279a328047eaace7f465f9e51d1e20f2e7f632", + "rawBytes": 69557, + "rawSHA256": "9ffd5314d0505914e68580ababb3867c93732929a4703baf0cbb75914692c080" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-checks-02.json", + "mode": "100644", + "gitBlob": "8c96a9a12ad916ed14def10610bdcb7babbea1c6", + "rawBytes": 64553, + "rawSHA256": "a059b23e8873e407583578d1ef839615f35529225829106d6ff82614ab6dc39b" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-checks-03.json", + "mode": "100644", + "gitBlob": "13623c1fdc028ca3803b5699645d27f63236d248", + "rawBytes": 24568, + "rawSHA256": "a87ce7b52b29152565e0de733ff43433d3980a6074d478f96690e00f5698051a" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-checks-04.json", + "mode": "100644", + "gitBlob": "00e474c8316e56e636d969b1926e98b6042b11cf", + "rawBytes": 17971, + "rawSHA256": "c982c3a3b379807a63d530b2b93c8e4bdb7e2957c2fddea2d42163b632be1161" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-checks-05.json", + "mode": "100644", + "gitBlob": "6063d8d1bf9c067e931d05041a9f4ff9ee69b0e3", + "rawBytes": 7644, + "rawSHA256": "776fa98083c7470caf1a437649f5110a985300d48bdeb1999c1479a4c0deff3a" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-checks-06.json", + "mode": "100644", + "gitBlob": "fc8dc5f20e810732c66a63b3ada1a6babccf3ea6", + "rawBytes": 6741, + "rawSHA256": "5a76f1353958b4594daed08a700604c44ebbfdcdc803384da1bd20e6cd36e5c2" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-codec-02.log", + "mode": "100644", + "gitBlob": "027068d19f7ebc8513ae861b56bdd6bea2a6cf90", + "rawBytes": 10849, + "rawSHA256": "c43248bb7e6199fe5c23b46bb092005004b2e548d144da6f9d9ee42470a37039" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-codec-03.log", + "mode": "100644", + "gitBlob": "694a7ea331980e652579416f5be98a360642027f", + "rawBytes": 703, + "rawSHA256": "d4f080c782e70768b9b4ed4ee6f444feb2532e2ae6611b18e64ae7ffae2b042a" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-codec-final.json", + "mode": "100644", + "gitBlob": "a2b5c0cefc65e24eecda8a96e5685b9c4d43dbb2", + "rawBytes": 1717, + "rawSHA256": "58c84cfb005a4100dd2ad0b0f499721f260e2b736c722b6cd01e589286e5d066" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-image-01.json", + "mode": "100644", + "gitBlob": "597979ef9a23525a53b96149dee23416a211d832", + "rawBytes": 35990, + "rawSHA256": "230b0ebd39b5aa079c248ee3435e5dbb8133e69851e217c2146c04f1144afb15" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-image-02.json", + "mode": "100644", + "gitBlob": "4633303c35e579e6ae4fb00b13de24a7c24db8a6", + "rawBytes": 4908, + "rawSHA256": "0e1edd93b4cfa9e78c3a70cc5f11457c1dc8947afddb750b6d030ba8423fdeab" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-image-final.json", + "mode": "100644", + "gitBlob": "5442e49bb00fefa831a07dc8f2ef855bd83745b5", + "rawBytes": 4913, + "rawSHA256": "e7c5d827f4f78602f28c7c7d589e00399d4319b55ed027b622e870c1b35a7aee" + }, + { + "path": "docs/internal/extensions/native1/commands/binary-v3-integrity.json", + "mode": "100644", + "gitBlob": "943e33c5325b6c21258274217e7d670e5b592421", + "rawBytes": 5730, + "rawSHA256": "34c2ffacb61d00b49c2c3b9ad2976bc23c43b97b86e3a19aa5f0bc1851ebe2f0" + }, + { + "path": "docs/internal/extensions/native1/commands/build-20260912T072514256.json", + "mode": "100644", + "gitBlob": "027a9462093ae5bd2907b68be5a0a8ff4b17b885", + "rawBytes": 11309, + "rawSHA256": "cdfa19d6bfe316d21d38c2018ea1f2391a87a1d3e55018978abca5fa8573c24d" + }, + { + "path": "docs/internal/extensions/native1/commands/build-20260912T072850050.json", + "mode": "100644", + "gitBlob": "f8ef49c956b626beef871162c75eb96924302149", + "rawBytes": 13518, + "rawSHA256": "716d8f31995fcb1fc1fa95be385accbe0e6ae3d6640fbeb70436c1f3cfde7b5c" + }, + { + "path": "docs/internal/extensions/native1/commands/build-20260912T073559261.json", + "mode": "100644", + "gitBlob": "bf7fb224703dcb2e37937883368a8cac59f4e50d", + "rawBytes": 18304, + "rawSHA256": "2fada50af95c282e6d240262497de7d8a23dd1e70e01cd94dcbb22fb9ef0b5a2" + }, + { + "path": "docs/internal/extensions/native1/commands/build-20260912T074002536.json", + "mode": "100644", + "gitBlob": "35280ea77c463763c86c71baaea3b233eff8aa01", + "rawBytes": 16037, + "rawSHA256": "91738be73b9d27eb8a6b6c0c15133ffa8fa419fb429dc9641108c8e1c60f616f" + }, + { + "path": "docs/internal/extensions/native1/commands/build-20260912T074238729.json", + "mode": "100644", + "gitBlob": "e237565f9856312c7f10583f031633b0d6114c99", + "rawBytes": 17512, + "rawSHA256": "b08fd8bdea1bcf2db8c2979a50f462e6fe3e8255ad9c7254d08d4d88a04840c6" + }, + { + "path": "docs/internal/extensions/native1/commands/build-20260912T080927170.json", + "mode": "100644", + "gitBlob": "adb28ecad7cdf3f9afa9117a2462f7763bb8c1c7", + "rawBytes": 17510, + "rawSHA256": "09a40460d3a0455e77dae576a772d4167a67e559ace4fe075ffa74b4914331f6" + }, + { + "path": "docs/internal/extensions/native1/commands/build-20260912T091755276.json", + "mode": "100644", + "gitBlob": "155476a9309744fdfdd008add73910ef375125ac", + "rawBytes": 970501, + "rawSHA256": "518cbbf1f1dda3446628b653ebe4cdb8fc0a47f89d2f920f36d40ce1245ee82a" + }, + { + "path": "docs/internal/extensions/native1/commands/canonical-01.json", + "mode": "100644", + "gitBlob": "b203543bffe16dc0c56f0743d22d2acad6733fa9", + "rawBytes": 2145, + "rawSHA256": "a2a87a167918e68aa7edf30db9ad262e8743819e614ccf265dcf029ecaeb28c2" + }, + { + "path": "docs/internal/extensions/native1/commands/canonical-02.json", + "mode": "100644", + "gitBlob": "531132e7df2386d918f77a0d205401398f495e3d", + "rawBytes": 1866, + "rawSHA256": "a77090b43ef13ccb2773eda954b134a5efa7c7744028c4f468a5d5e4ed0ce9e9" + }, + { + "path": "docs/internal/extensions/native1/commands/canonical-03.json", + "mode": "100644", + "gitBlob": "2ccf00150cf52a90488f59369bc71daf67056732", + "rawBytes": 1384, + "rawSHA256": "41532868d2d6e9189e94c2c0f006b6d784220df7b42c5a154d250255ca8edef2" + }, + { + "path": "docs/internal/extensions/native1/commands/canonical-04.json", + "mode": "100644", + "gitBlob": "8b9ff18a4afadeed22fe7ae8e4fd2ac0744ca0c4", + "rawBytes": 893, + "rawSHA256": "29c28d07c986e2045812e3dc24ff023abb05f3068f386d68a86f4fbbf7218fc5" + }, + { + "path": "docs/internal/extensions/native1/commands/canonical-image-01.json", + "mode": "100644", + "gitBlob": "7eeb0c2ac7804c3ee625e78315ec800541c74859", + "rawBytes": 914, + "rawSHA256": "a16c289a697d602a40fd8d43cc83805cec4aec2b717c125299cc1be9be9d561a" + }, + { + "path": "docs/internal/extensions/native1/commands/capstone-01.json", + "mode": "100644", + "gitBlob": "43fc416c31e9cc4e1fe3c19952eb824ba6c010b1", + "rawBytes": 2182, + "rawSHA256": "c8a9c7f515e9d83a4a838b9ca32960231b6492c18da6b8e9fe6928c903007a26" + }, + { + "path": "docs/internal/extensions/native1/commands/capstone-02.json", + "mode": "100644", + "gitBlob": "fdbcfad71717c0364e47ed07dc81e98683f4d26f", + "rawBytes": 890, + "rawSHA256": "c1fb7b2b933e77a6b20ccf403e5d703a847ecd9644a0d76613c6575490f36186" + }, + { + "path": "docs/internal/extensions/native1/commands/capstone-03.json", + "mode": "100644", + "gitBlob": "6ffacbb56b9b9c53b2c63eecf95a7a0d2e7e12c9", + "rawBytes": 889, + "rawSHA256": "79c760e7b620eae8b914e4676268601a04c04400c639d2e58162a08e6f63d648" + }, + { + "path": "docs/internal/extensions/native1/commands/claim-current-report-draft.json", + "mode": "100644", + "gitBlob": "5786a7a79202aecad5199f80e23d94bc90255f52", + "rawBytes": 1110, + "rawSHA256": "5d6717a693063c92451aa5ba0070f253893db8b329ee238114ceb1df3a1679db" + }, + { + "path": "docs/internal/extensions/native1/commands/claim-drift-native-readme-fixed.json", + "mode": "100644", + "gitBlob": "43227ea215e360a251effd9c37281b35250d6257", + "rawBytes": 1013, + "rawSHA256": "dafe8ef920d080a8d949f947b5272d60c398973efb581af3b93f474da6213e52" + }, + { + "path": "docs/internal/extensions/native1/commands/claim-drift-native-readme.json.gz", + "mode": "100644", + "gitBlob": "83332cc415c43d07ae5da8ca434d7bae713b08e5", + "rawBytes": 621, + "rawSHA256": "13c39fcf08bdd46e3fdb735a57244e9d087220ba59433746bb20a0dd849ffbcd" + }, + { + "path": "docs/internal/extensions/native1/commands/claim-drift-packet.json.gz", + "mode": "100644", + "gitBlob": "745ad9f58c2db54286824e555afccd14224e8d43", + "rawBytes": 1558, + "rawSHA256": "1c7d2f500130e861ca6288c32739533b449956c19a130ee85b8ca78d346a8085" + }, + { + "path": "docs/internal/extensions/native1/commands/claim-drift-report.json", + "mode": "100644", + "gitBlob": "8444768244cf7062281d13c2aa2484a9173a0cbc", + "rawBytes": 1047, + "rawSHA256": "96084c9e3458cff2aa8eaa579a9ff19e7ef07effbd3ae510693ac6a4036013d2" + }, + { + "path": "docs/internal/extensions/native1/commands/claim-drift.json.gz", + "mode": "100644", + "gitBlob": "015a6bd866d06ad9885968c4605cf00af80739bc", + "rawBytes": 1165514, + "rawSHA256": "6fd28fee71221a7361929a73a31f4c87369031ce06168a5ea017dd921fd62ff4" + }, + { + "path": "docs/internal/extensions/native1/commands/claim-drift.summary.json", + "mode": "100644", + "gitBlob": "29ac03a67b49a786904c15a2b09154e7edd46115", + "rawBytes": 939, + "rawSHA256": "22defe87bc6b2f5844037bebea7ae766372849629413209671f9464e2e63b80e" + }, + { + "path": "docs/internal/extensions/native1/commands/claim-native-readme-fixed.json", + "mode": "100644", + "gitBlob": "1a02deb8a709d2614794cb8a1ce15674cf11e279", + "rawBytes": 998, + "rawSHA256": "8ba05507455f7e0daccd6e3ed4f5b59421a7928b9dd92fe9f22e53a5f8ef3ca4" + }, + { + "path": "docs/internal/extensions/native1/commands/claim-native-source-checkpoint.json.gz", + "mode": "100644", + "gitBlob": "d7a77d4310b420f0316fe60395b0d7f4fdcb42d0", + "rawBytes": 5812, + "rawSHA256": "3677a12060580e070de15972edc4c7e562dfd82d2ba56fbaafa1ca86ab518386" + }, + { + "path": "docs/internal/extensions/native1/commands/committed-diff-phase.json", + "mode": "100644", + "gitBlob": "2ce215bf8bf63d030182734810aae05b3cbf1402", + "rawBytes": 698, + "rawSHA256": "9a77c15895ac6ed8f7c43e73448782d7816dccab6a6fb6bea2556fb0b5cb2ccc" + }, + { + "path": "docs/internal/extensions/native1/commands/contract-01.json", + "mode": "100644", + "gitBlob": "9ebd0b3336e6d121476a265366bda717ceac8d7e", + "rawBytes": 817, + "rawSHA256": "f2129745a97a78c844cc7671e1e88ab681d69378cdd9a8fcffb9613e7d4572cd" + }, + { + "path": "docs/internal/extensions/native1/commands/contract-02.json", + "mode": "100644", + "gitBlob": "8256ac56ef17f10a47a0f7f8f8174e206348df6b", + "rawBytes": 817, + "rawSHA256": "f58f85ac723523aaec9131afb175762665cd539379069c20f61f35da560d6b58" + }, + { + "path": "docs/internal/extensions/native1/commands/contract-baseline-01.json", + "mode": "100644", + "gitBlob": "11386d5fea9aff9d0aaf3bb559b3e8c298a6a7c1", + "rawBytes": 1656, + "rawSHA256": "b75ab7ab72efa0128b2e88c68bb29509d1a1a891ac9e4307ad7d5387b0bf5fc5" + }, + { + "path": "docs/internal/extensions/native1/commands/contract-baseline-02.json", + "mode": "100644", + "gitBlob": "081a0480bccf08737d6d6166dcd328adb9acbd48", + "rawBytes": 975, + "rawSHA256": "5b5b691636626f3a91b1cbd2f8815e45569d2c7c65db1c5d747d2357e0f56f3b" + }, + { + "path": "docs/internal/extensions/native1/commands/contract-controls-all-01.json", + "mode": "100644", + "gitBlob": "8e2b00704346a975db7dca1f78836e08e4b9456c", + "rawBytes": 1872, + "rawSHA256": "68ab2a0a1092ec8cb70faabbe8692b84c2358099aa80d339e5df3b26f5531005" + }, + { + "path": "docs/internal/extensions/native1/commands/contract-field-n01-01.json", + "mode": "100644", + "gitBlob": "e066bbde6f2150edaada2e3cc1c37e35a4e7309c", + "rawBytes": 979, + "rawSHA256": "1d02ad7662043e8336dab9fa5b863ed26ab1b03a51060fa17bdb3da66416b246" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T075336106.json", + "mode": "100644", + "gitBlob": "f6e5593755bc5247a7c306066b98248cbb8e4676", + "rawBytes": 1489, + "rawSHA256": "f142f9fb559c07e7b0dcbe79458e7b4aad0d6f3911f2e2dfde6903ea93e7b6df" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T081542413.json", + "mode": "100644", + "gitBlob": "a82cd72f8848b2880cc6249a162f8b2c6baa6533", + "rawBytes": 1489, + "rawSHA256": "e13681a3d3caf0e317e65f8667aa47c06b3734dd63fbf785293a5341eb27facd" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T091008993.json", + "mode": "100644", + "gitBlob": "fc878aeffc1e0dfbd26d5e27104cd78df47a6d1f", + "rawBytes": 3705, + "rawSHA256": "c7a84f1aab452d7c00d86c45fc2359cf2b364609c1a507f9081d8f91358cb9c6" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T091026831.json", + "mode": "100644", + "gitBlob": "109c661ad194fd7583d5e5ab944c59976d0bea19", + "rawBytes": 4039, + "rawSHA256": "64ce34453f0f45ca745b5f3c659ada5d39fd560adc1973cd63cf540159e7b04b" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T091036366.json", + "mode": "100644", + "gitBlob": "5021cb241399a19ef75e3c823cc0cc2cd4d351ec", + "rawBytes": 4039, + "rawSHA256": "ba31df84823c979d8e4618caa41b5e7348d410aa71f2776277ac95f8c2fb20b7" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T091459085.json", + "mode": "100644", + "gitBlob": "c3bff1d4a3961f6a3b4056b9e4bb88d541ef63c8", + "rawBytes": 4467, + "rawSHA256": "3f6c3e2d39d6a5ccadf2e0f40f6a7fc7df52afac2d9e5ba45778582157329770" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T091719835.json", + "mode": "100644", + "gitBlob": "af121f92448ff16ab7194e59ae48acafda0813dc", + "rawBytes": 4549, + "rawSHA256": "a31c7aef2ceb3d1660ec02df775ec37bfd707ae96e78f22d218b7e8403bfc869" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T091847484.json", + "mode": "100644", + "gitBlob": "44adec12f968c014ecf440d248696fad7574d7bc", + "rawBytes": 4494, + "rawSHA256": "c2650be432abd4f5d7ac3a05ecd540b250bedf2e052ec5fef1f3e5d837eeb84e" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T091900870.json", + "mode": "100644", + "gitBlob": "bee88d4f509b8a6f42eb4d4a6c0daea3f5cf0aa9", + "rawBytes": 4549, + "rawSHA256": "16ab16b81caf93dee6fa46a21c7ceee4df06a896d2b9b4ce605a780f4a9515cf" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T094238749.json", + "mode": "100644", + "gitBlob": "52e9bd7384a646a1ba2f9d9aeac0a97565a904d5", + "rawBytes": 116103, + "rawSHA256": "30c8f47e755e1f596816e7cdcc88c373eb7be6ac9ae5dea0391a5bac7cae8c66" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T094700539.json", + "mode": "100644", + "gitBlob": "d0df86b610102eff98154b8f48c76028ff2f9099", + "rawBytes": 4692, + "rawSHA256": "065c71b31f95f0ed44f56e07475f11f5f7d2ab7bcfee956d09dc2991b5d93689" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T094711304.json", + "mode": "100644", + "gitBlob": "3bb10cf434d424a2604e459bd0febd84e866265c", + "rawBytes": 4692, + "rawSHA256": "9c5dbdf25a484ecbd183a9edf42f234a2766d0b60f0b4092c2226986a57975e2" + }, + { + "path": "docs/internal/extensions/native1/commands/controls-20260912T100023269.json", + "mode": "100644", + "gitBlob": "7db16ed953a4903110842c6842554df03222b57b", + "rawBytes": 126710, + "rawSHA256": "2f81170ed3d368b2b0ecd87343c9bbf6cccc4a284b3ecbaf0c94e2eefe6e8679" + }, + { + "path": "docs/internal/extensions/native1/commands/cpp-build.json", + "mode": "100644", + "gitBlob": "35545f754dfa7bb135772ad0e876f73ecbbb4446", + "rawBytes": 825, + "rawSHA256": "af65ddd8c7218e4a314b7dedbba4eb201949d021aef05c408aabab406c7fbc65" + }, + { + "path": "docs/internal/extensions/native1/commands/cpp-import-library.json", + "mode": "100644", + "gitBlob": "030f734b2918d4dff32efb00e39841c8ce30a23d", + "rawBytes": 1053, + "rawSHA256": "537450226645a9ea017795e8147b6e31ea2fe715fb187ad7d01f0621c48c747a" + }, + { + "path": "docs/internal/extensions/native1/commands/cpp-n9-full-final.json", + "mode": "100644", + "gitBlob": "362786874bab9290c3751a1291037bd5a797bea7", + "rawBytes": 14727, + "rawSHA256": "f5b341434848a0d7ebf6c77b9717557bc204b8e36a760802c5ab41673a94163e" + }, + { + "path": "docs/internal/extensions/native1/commands/cpp-n9-full.json", + "mode": "100644", + "gitBlob": "cf35d32da34f2562def188367e919aee90bf4acc", + "rawBytes": 14719, + "rawSHA256": "7afe9992e7ea59c424be191e5c69e481c45ba642684cb358f9e47c760076ffb5" + }, + { + "path": "docs/internal/extensions/native1/commands/cursor-01.json", + "mode": "100644", + "gitBlob": "1fb5cccf299a8e6083fc32d83563dc92e206126e", + "rawBytes": 31789, + "rawSHA256": "975c8b63985e2cf68d31175a3d394edd8de757fd7b355ee3ffcbcda2f9190686" + }, + { + "path": "docs/internal/extensions/native1/commands/cursor-02.json", + "mode": "100644", + "gitBlob": "09ae7dacd1a8be658d49cfb4943134d5e908c758", + "rawBytes": 7669, + "rawSHA256": "453f59a5fd780d29a3374a23037ed56dab1db2c1fa8f36ce85dddd4226b7cafe" + }, + { + "path": "docs/internal/extensions/native1/commands/cursor-checks-01.json", + "mode": "100644", + "gitBlob": "05b955c77f62b75069e19a53ec468b26b088d9bc", + "rawBytes": 27427, + "rawSHA256": "33dfd5b67dfbfbc32bcb8723af453c320835c8e8ce4c1df262c6eb853882dabc" + }, + { + "path": "docs/internal/extensions/native1/commands/cursor-checks-02.json", + "mode": "100644", + "gitBlob": "f18a129af7b5c5b41828e0b033b1d5ce0b33e949", + "rawBytes": 3764, + "rawSHA256": "3cdf88bba30d632af09cabcd10cf1d7c20f1cc615aeab0b69ce70b364a863067" + }, + { + "path": "docs/internal/extensions/native1/commands/cursor-core-01.json", + "mode": "100644", + "gitBlob": "d7b7afcd9c17161627b09b19b8d3878ea8b04f75", + "rawBytes": 34569, + "rawSHA256": "6478dee3397b27d2aad897ef816559c93753198ed68ecb49ce0a0daf6ba2a801" + }, + { + "path": "docs/internal/extensions/native1/commands/cursor-core-02.json", + "mode": "100644", + "gitBlob": "3e149f566c06d99153fa136a3c88afb54dd09cb1", + "rawBytes": 18102, + "rawSHA256": "d091919f9f2eb30872e90f8e57a0aa3e616243e8c4d089f4ec28686a9b016e20" + }, + { + "path": "docs/internal/extensions/native1/commands/cursor-core-03.json", + "mode": "100644", + "gitBlob": "7f59a15d2d1034c8185b39027bdb71e6d8238b13", + "rawBytes": 9149, + "rawSHA256": "7c6289f1ecf7a20f8b832d5c458aee5de46597bdbfd28a50bf3db15ee8f68f66" + }, + { + "path": "docs/internal/extensions/native1/commands/cursor-core-04.json", + "mode": "100644", + "gitBlob": "dec441e107455b5a61e796731b9d7bbfb9ae3229", + "rawBytes": 5467, + "rawSHA256": "4d62b4866f3646c63974aac450f73e4b74571dc7f1bfc512a9857b30df0c0f26" + }, + { + "path": "docs/internal/extensions/native1/commands/default-cache-validation.json", + "mode": "100644", + "gitBlob": "ebc948ef80cb3676e8a0e11d014ce02b9d7b6d30", + "rawBytes": 245760, + "rawSHA256": "8ca79f5da6c1cbbfbad7f5ae895d86f5bd5060f589be72d4cbf8b3ad8d7c9c5d" + }, + { + "path": "docs/internal/extensions/native1/commands/design-final-candidate-commit.json", + "mode": "100644", + "gitBlob": "7c43253af1506bbf280b1506ef1851ceb04e09ac", + "rawBytes": 1189, + "rawSHA256": "403c66c0684ad1f896c9ac6306e962988aa79e2f085cb1810afad31fb2ef36ef" + }, + { + "path": "docs/internal/extensions/native1/commands/design-final-path-precheck.json", + "mode": "100644", + "gitBlob": "cd36a59cadb0f0ded72d68d9ca5226db0229965f", + "rawBytes": 1054, + "rawSHA256": "01842a48b4d6dfa6436f91ce5ff730470c367e2304d5babb56fcfc702278a2a3" + }, + { + "path": "docs/internal/extensions/native1/commands/design-native-source-checkpoint.json", + "mode": "100644", + "gitBlob": "d741eb4bc0dbb7c7bd6305ca0b4410065f8faf0a", + "rawBytes": 1091, + "rawSHA256": "36527457e222dd9b43bc098621bf8b104bfecef8df8f68f35507bea6be7ad293" + }, + { + "path": "docs/internal/extensions/native1/commands/design-phase.json", + "mode": "100644", + "gitBlob": "8c248ea7c85b16b5a487828451f7fd7940dbf422", + "rawBytes": 4866, + "rawSHA256": "dab5efeb67de1ea2931b8532281d9722ec7bbaae12d61516ee8e685bec6f96ed" + }, + { + "path": "docs/internal/extensions/native1/commands/entry-01.json", + "mode": "100644", + "gitBlob": "4badf57ff474ce4629593bfbb4e31f8f4af454b1", + "rawBytes": 878, + "rawSHA256": "70fe462ab91f374e65de034a7fc7e68bd8bc06fca38da145d8b2e47f0529be65" + }, + { + "path": "docs/internal/extensions/native1/commands/exact-types-01.json", + "mode": "100644", + "gitBlob": "477a51194813d6e3c3bfa633b42c3d63088ee63b", + "rawBytes": 3382, + "rawSHA256": "4abb38c5871334b8e568757fd434a7b6885edc6ab610d96bbbe0baa930af0f6a" + }, + { + "path": "docs/internal/extensions/native1/commands/execution-01.json", + "mode": "100644", + "gitBlob": "ea40e446472ad8e1cd365cfe640ee28b3b3c8544", + "rawBytes": 2624, + "rawSHA256": "0c85343488d3110fdb123cb47b1daf9267af38f8e30a4d3f0be7e481bbeadec0" + }, + { + "path": "docs/internal/extensions/native1/commands/execution-02.json", + "mode": "100644", + "gitBlob": "ad2ca7cc98c8ae5cdbfa33ab4251450b912b1be5", + "rawBytes": 894, + "rawSHA256": "067229ad45c1764d903242847f80ab60a09291e1177bf234f61424b79e89bd12" + }, + { + "path": "docs/internal/extensions/native1/commands/execution-03.json", + "mode": "100644", + "gitBlob": "d73d1fc6fd3232bc9d7b87ba65111f84263ea34f", + "rawBytes": 894, + "rawSHA256": "a1b1cbd3157db3441d0f3daeca627583753a6881918a9bff0b063d545cbcbbb7" + }, + { + "path": "docs/internal/extensions/native1/commands/final-claim-surface-inventory.json", + "mode": "100644", + "gitBlob": "cb589daac0c8037b581880d78353de4b900d94a0", + "rawBytes": 43648, + "rawSHA256": "c228d2a29ee3f860db2a4b803f3fba0c362fcc0ffd4f271827e7dcb7d030757d" + }, + { + "path": "docs/internal/extensions/native1/commands/final-claims-process-command.json.gz", + "mode": "100644", + "gitBlob": "b88169b2f7ba939b9ee43431c0d710c1e879c6aa", + "rawBytes": 1353, + "rawSHA256": "471ec10a7974d0bbb805d20fd4d62374611f73210c192e6ee16b2eb1bcb3dde1" + }, + { + "path": "docs/internal/extensions/native1/commands/final-claims-process.json.gz", + "mode": "100644", + "gitBlob": "0cd0a4d09ea85f8c35feebc42b34c43d68c5307b", + "rawBytes": 22256, + "rawSHA256": "0c50b6a46d0277023fe9635a7d8a8f6c32f3251b54091a66f896911ae16dfa6f" + }, + { + "path": "docs/internal/extensions/native1/commands/final-claims-public-command.json.gz", + "mode": "100644", + "gitBlob": "59c551b04bd6a217e1d06e801dd13dd98736ce85", + "rawBytes": 789, + "rawSHA256": "771f4654b086d65f2a401fdef3ba7d0e19933ed9f0d5a979ef92787738b49779" + }, + { + "path": "docs/internal/extensions/native1/commands/final-claims-public.json.gz", + "mode": "100644", + "gitBlob": "8fabc5911802f23a31488eda0c09ec75b9a9fcc1", + "rawBytes": 24569, + "rawSHA256": "5d4db70088aa5fb163c2b7c918cb754f482b03678dcd13abeda068d7f96410c2" + }, + { + "path": "docs/internal/extensions/native1/commands/final-default-build.json", + "mode": "100644", + "gitBlob": "4cf9b592b205fad732b779c3453e50d97fcfd840", + "rawBytes": 245718, + "rawSHA256": "0285f7f1f721e8ad4b06f3124d1186120c2aa8df7e68a4d06d9a6d4d1a731ac9" + }, + { + "path": "docs/internal/extensions/native1/commands/final-design-base.json", + "mode": "100644", + "gitBlob": "7183f522e441d7ca5f58ea0d2db7fb645a17e2a3", + "rawBytes": 1109, + "rawSHA256": "f76498183650f9f487bd445683de406280d3853c7f449317fa0c295b82daea88" + }, + { + "path": "docs/internal/extensions/native1/commands/final-diff-checks.json", + "mode": "100644", + "gitBlob": "2eaa063c93e6699259962f85ecfb36af89c38efa", + "rawBytes": 1197, + "rawSHA256": "4b6d90f35abb62f76455540005f2a609f32ea3dc88d02643866acda9963b243e" + }, + { + "path": "docs/internal/extensions/native1/commands/final-freeze.json", + "mode": "100644", + "gitBlob": "e4ae8611a986e7609f49b06ce000d369d67bb176", + "rawBytes": 2907, + "rawSHA256": "9b16c39cb13cc91aa2437655254ab31f27c6bbff6c415113dc87b2a0a56a2865" + }, + { + "path": "docs/internal/extensions/native1/commands/final-integrity.json", + "mode": "100644", + "gitBlob": "e8f17e6fe9fd674dd2478d885096988cb1966f13", + "rawBytes": 20221, + "rawSHA256": "71e5d1d9e8a79527d0ce39dcd4c5c5bc3dd45ee527cd0e6825b8261399514181" + }, + { + "path": "docs/internal/extensions/native1/commands/final-metadata-check-command-02.json", + "mode": "100644", + "gitBlob": "b5076a2f6e8f2ac7091c440c4826199174694955", + "rawBytes": 1033, + "rawSHA256": "34263d52c1f34a87f4010333b1725dee54c52911c235a95f170ba7674b545df5" + }, + { + "path": "docs/internal/extensions/native1/commands/final-metadata-check-command.json", + "mode": "100644", + "gitBlob": "592ce9384938c430b481ab62fdd87bfd985046d4", + "rawBytes": 1028, + "rawSHA256": "ee987818c166a0ae0cb2b05d96acc3a377ee0af7b3852afc88400a52b6c2808f" + }, + { + "path": "docs/internal/extensions/native1/commands/final-metadata-checks.json.gz", + "mode": "100644", + "gitBlob": "a021ad3a3834ce9b037c538df3933135106307ed", + "rawBytes": 5384, + "rawSHA256": "af13f3ad9ebd8fdface7d7f02dee89cad1700d84fa101e15ab120d06850f3c43" + }, + { + "path": "docs/internal/extensions/native1/commands/final-native-imports.json", + "mode": "100644", + "gitBlob": "9a8542eafb7a97f9358ef3c1f0cf402a75e88463", + "rawBytes": 2924, + "rawSHA256": "b2fd1913c4d42bf9fcac481bcac45f108dbf687b57eae54de9138b0c2fe15ded" + }, + { + "path": "docs/internal/extensions/native1/commands/final-static-command.json.gz", + "mode": "100644", + "gitBlob": "fb1f1ea9f3a5b161b86a7adfe91e08fc63724b8d", + "rawBytes": 1114860, + "rawSHA256": "fb288dcbed23770dc9c45e35bf7a00d8434a064f21ace1bc8946f93263ce79c1" + }, + { + "path": "docs/internal/extensions/native1/commands/final-text-claims-command.json.gz", + "mode": "100644", + "gitBlob": "484a29b7032308e5076c5772cc97c6ca49f21558", + "rawBytes": 1358, + "rawSHA256": "f9b8e8610c08d3a300cb09ba8112402e060309581c0ba916d08be8ee6463aa97" + }, + { + "path": "docs/internal/extensions/native1/commands/final-text-claims-process.json.gz", + "mode": "100644", + "gitBlob": "e7eb406d00663913127a8165b206861d11e036a6", + "rawBytes": 22238, + "rawSHA256": "9441834d18427e7653d0157ebc6973710e159ac76128f7f1642fe98543507d30" + }, + { + "path": "docs/internal/extensions/native1/commands/final-validator-import.json", + "mode": "100644", + "gitBlob": "3468ca899fa6614bfe8e56a253d10ebe1ea64c0a", + "rawBytes": 1273, + "rawSHA256": "eeb93871b11d3fcb04346f2cd5931af460a561449bd0fd0de040aba2da0ef033" + }, + { + "path": "docs/internal/extensions/native1/commands/freeze-before-public-blob.json", + "mode": "100644", + "gitBlob": "e900e1094a35259526360cbbf5b304acbfd6649b", + "rawBytes": 2907, + "rawSHA256": "bd084eef9f66048cffd91246c837e009adc3df48e072752152794a0faf87b921" + }, + { + "path": "docs/internal/extensions/native1/commands/host-01.json", + "mode": "100644", + "gitBlob": "d124d4b10973990954f3674d37d9f3a444f49470", + "rawBytes": 805, + "rawSHA256": "40bbc538efe3bc9763b61aafcb86e7ddd3f4aef4bfdcb4f728ff3343fb4707a4" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-20260912T101354869.json", + "mode": "100644", + "gitBlob": "e4145f6d495740cabe42bccbab6d13f84b9a9b87", + "rawBytes": 41547, + "rawSHA256": "f363d6f308f45562dd164eaff190effa1d2cfad81e331eec7fee8ca5cb6d5285" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-20260912T101530710.json", + "mode": "100644", + "gitBlob": "00a7de273312d62a5dd5908b2b30bad9f844da60", + "rawBytes": 351693, + "rawSHA256": "987973262fea98973124d58c65e547de1084511621dff07b42f98154ab7cdd72" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-default-20260912T124121657.json", + "mode": "100644", + "gitBlob": "7fac2326fa031299f3adb60143b8f11f56d78378", + "rawBytes": 39879, + "rawSHA256": "0e617cca970d58564d56748bd471e70d09e4945f0dbbeeffd54bf9cf654e4aef" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-default-20260912T124531692.json", + "mode": "100644", + "gitBlob": "44455d8310637fb331202fad5b4522a30441ca28", + "rawBytes": 272517, + "rawSHA256": "81740862e330845822fc1340e04b24b10545c50927eac7995e6fa587e79c0935" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-default-20260912T125020579.json", + "mode": "100644", + "gitBlob": "f6a289b0e5d5b4cae9a34f7d581ef10827c11854", + "rawBytes": 663953, + "rawSHA256": "7c9ce0db64d31f075fcbe16cf150049048e86bacd43b38afd73c6432164d9a78" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-default-command-01.json", + "mode": "100644", + "gitBlob": "59bd857f4703d13ed79dc57b820f97bb427ee929", + "rawBytes": 1405, + "rawSHA256": "bc4b5338ac4430f9720699067bde3f81f9e1815d346f1f82d9aa62858c362235" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-default-command-02.json", + "mode": "100644", + "gitBlob": "38f2d52ee49eafbd2ccbdc590b2fe0256c84f509", + "rawBytes": 1630, + "rawSHA256": "5a6d45a3a7e2f7d2ab503dda9c97dbf77528e4cc14ff423676d7e675df9ab8e0" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-default-command-03.json", + "mode": "100644", + "gitBlob": "271bcd28d2d962273084ff58a64a4a723d20b7b8", + "rawBytes": 1918, + "rawSHA256": "e82a25c7f15fb900a3cea534b1bca7e2239505b0b62c54cd70ffe7768d787af0" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-default-parser-02.json", + "mode": "100644", + "gitBlob": "690433fa81a63decad9d9f1d7fe4e53db066b9a5", + "rawBytes": 1509, + "rawSHA256": "ae0d2d0fa597b5ebcb627b4195b2be610c44777d316f476715dbcadeda39f04f" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrate-default-preflight.json", + "mode": "100644", + "gitBlob": "b7bf9ece5da39cc33895dabcc255721fef42541c", + "rawBytes": 963, + "rawSHA256": "319d11ebdaa71ee8eb324a7d74c588968bfc6c472ae658f1b13330d5034f6e80" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrated-lake-check-01.json", + "mode": "100644", + "gitBlob": "449cb44d580b909ee7b65d9fc7b87710ba915aad", + "rawBytes": 204092, + "rawSHA256": "5a3e710d6ceb6f59b4f9bf5a99e7eea5585597ff226eb631e47ae0e8f41fa73d" + }, + { + "path": "docs/internal/extensions/native1/commands/hydrated-lake-diagnosis-01.json", + "mode": "100644", + "gitBlob": "8db73bc2b01b12ed26ec82dbf95d94b8073c7d82", + "rawBytes": 519294, + "rawSHA256": "58c1d0dc8ec0ce78f720ad27a21536760599432b66ef22026179226ca76dcfca" + }, + { + "path": "docs/internal/extensions/native1/commands/hygiene.json", + "mode": "100644", + "gitBlob": "21be97def5fe407f40a05357110d1b2f71889480", + "rawBytes": 158, + "rawSHA256": "7a07cbcdaeb5bbbe1b3de4553a43e067463c01cd59dfb5a20b443b477552001a" + }, + { + "path": "docs/internal/extensions/native1/commands/identity-controls-20260912T091130182.json", + "mode": "100644", + "gitBlob": "9a770017877cf45d548a2af264724dae6dc12484", + "rawBytes": 3083, + "rawSHA256": "a20567edabfef552937d49b9dff216825c7e6cba5204f1262048ccc99070be38" + }, + { + "path": "docs/internal/extensions/native1/commands/limbs-01.json", + "mode": "100644", + "gitBlob": "f1404af42fa187f09ae3934bd9388b0e81f14a63", + "rawBytes": 1500, + "rawSHA256": "fa6b4fc3071986966e7a40a2ae0d0ac03281f594aa089e0beb18edcd3a262edd" + }, + { + "path": "docs/internal/extensions/native1/commands/limbs-02.json", + "mode": "100644", + "gitBlob": "e56abf4c8c9d4d8b03e727fe95dbead2fa323fce", + "rawBytes": 889, + "rawSHA256": "9e9a382ad2410c5ca1a98e327c8fffe60829e550cf360d9fc01c5685a7e47113" + }, + { + "path": "docs/internal/extensions/native1/commands/limbs-03.json", + "mode": "100644", + "gitBlob": "51cc8bdd79e88fd37a24bc562fcb3b38135f254d", + "rawBytes": 2361, + "rawSHA256": "ce160e1652942f38db1cef9677f8f2adb3b197e5904a3d95c2f226e31cd1e0a4" + }, + { + "path": "docs/internal/extensions/native1/commands/limbs-04.json", + "mode": "100644", + "gitBlob": "bd9e9019158ca5d6b58f61fd8cf1e217de7e3116", + "rawBytes": 878, + "rawSHA256": "88ee4b7d9e50ae9b37e3ef5bca15fb053462c5125788202b9cda572825be2939" + }, + { + "path": "docs/internal/extensions/native1/commands/limbs-checks-01.json", + "mode": "100644", + "gitBlob": "154e2f96038ceb93ef29340355182c564163e837", + "rawBytes": 19329, + "rawSHA256": "ea06111bb1299639f6fde0380b3b06d819fca5c323083678882d65b9579f22cc" + }, + { + "path": "docs/internal/extensions/native1/commands/limbs-checks-02.json", + "mode": "100644", + "gitBlob": "2a7c8745f93a5aa2b0840b16b0596315b5acbaca", + "rawBytes": 4321, + "rawSHA256": "68a44e93e81334a746ad7f0a878435a234c429be046191a257d42e727e0ed5f3" + }, + { + "path": "docs/internal/extensions/native1/commands/loader-emptyargs-host.json", + "mode": "100644", + "gitBlob": "6dcafda5c219e06c9d3728beadf1fc847824d8c2", + "rawBytes": 412, + "rawSHA256": "f636d0113804cf6df0149f3d923781ea9b73c9ddb6db061c0a5644a87695079b" + }, + { + "path": "docs/internal/extensions/native1/commands/loader-emptyargs.json", + "mode": "100644", + "gitBlob": "276e6c13b2d048868aba34611e3942c762b7b8f8", + "rawBytes": 310, + "rawSHA256": "aa498bb8431127b128f8489a838f38d0f676095c0974f8d0ba8588973a36b4d2" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-01.json", + "mode": "100644", + "gitBlob": "60ad59f47443bcaea67c8edbe4458753d4e77c23", + "rawBytes": 37354, + "rawSHA256": "cb0d103a24748ad8f393d03ac9cda8a21f197c10d550d3b6e9c73206c0690d01" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-02.json", + "mode": "100644", + "gitBlob": "bd31a2f0b2f4767325af2da683d52a6c95157ed6", + "rawBytes": 4614, + "rawSHA256": "96842353ce8a33b968092aff6aeae27c413ea0c0ee15c93f678a72d2f3d89f66" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-03.json", + "mode": "100644", + "gitBlob": "5017f46ed9c458dc9313181e2a5d4bec33ea1de4", + "rawBytes": 732, + "rawSHA256": "92a31e3966e5c942429d715565ab1101a1b4f86aab008ec8b5f9470274944d89" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-04.json", + "mode": "100644", + "gitBlob": "9959f026279cbe310489ca9b3276d92c764fccef", + "rawBytes": 10348, + "rawSHA256": "7284595ef24b34d589e2557b744faef8310d65ba61f2053a8050ecf1bfdc5bf6" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-05.json", + "mode": "100644", + "gitBlob": "a7b36780860980d18775f70a02f2df8ab9e8f5c8", + "rawBytes": 886, + "rawSHA256": "68a3b8ae4780b28d4ad2850ad8886526b57e6c49c755da2550c6f638f761c13a" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-06.json", + "mode": "100644", + "gitBlob": "6104079fe8ce0529f4b2762b2bccc264e23e8638", + "rawBytes": 886, + "rawSHA256": "ec21c7078772aea09f4712a742f0d814b218f4290d5cb62420332ba298cfed42" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-checks-01.json", + "mode": "100644", + "gitBlob": "5418786417e245933e612ac82fdc9a3a0443a7ba", + "rawBytes": 5345, + "rawSHA256": "c6a59d79cf9171cdba43262e4e843a900679205005f106a2cfc1c91008d9bbbf" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-codefacts-01.json", + "mode": "100644", + "gitBlob": "1739f25579cda4082e26d0eb24cf8100e42d9c99", + "rawBytes": 2214, + "rawSHA256": "f0ef60ebbb8f62814e7edcb266826c9de59bb9d9b4e081210467f271cab80c73" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-codefacts-02.json", + "mode": "100644", + "gitBlob": "d16d029ec9e9de69a42bb257d3e4e8ac9c5bc943", + "rawBytes": 9244, + "rawSHA256": "5121d1b2f99f7048b8940f2713a69dc42adad44aed48e5ec920574b40ac7fb1b" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-codefacts-03.json", + "mode": "100644", + "gitBlob": "080028cea7ce79ec72185a1dea2fe9f356c234d4", + "rawBytes": 1874, + "rawSHA256": "b230f552ec24d0e9203c231b1f0432937b1f6d4422eb421b339e23d18b1a7b46" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-codefacts-04.json", + "mode": "100644", + "gitBlob": "c6a035bd855833959307d9b3d88b0c1900935cdd", + "rawBytes": 1693, + "rawSHA256": "db8a1b4d7615400ccfe4fcc761a56875f60ba31e5893dbabfcdacf702449d649" + }, + { + "path": "docs/internal/extensions/native1/commands/machine-codefacts-checks-01.json", + "mode": "100644", + "gitBlob": "caaf6813892a0abb5ecf4b611647b8a42e1b94fa", + "rawBytes": 1509, + "rawSHA256": "32deae513ddd17a82f8ece515bfde7850239d9603998ce06a3a860bf7bb6b281" + }, + { + "path": "docs/internal/extensions/native1/commands/metadata-checks-before-public-blob.json.gz", + "mode": "100644", + "gitBlob": "129720d72ce3cfea87104fa8bb0dc94dc4e56273", + "rawBytes": 5430, + "rawSHA256": "414976873974c97840a1ff89454f858fb8d75f06a61704cd91feac56d6a07886" + }, + { + "path": "docs/internal/extensions/native1/commands/native-axiom-probe-01.json", + "mode": "100644", + "gitBlob": "8fde9ddf99757e77c6d3270b7ff13cbc0471f645", + "rawBytes": 2220, + "rawSHA256": "bffe11fc0a82aaa85c2f9f0fff9718dec1067c239ac72ec470c7647789f1f22d" + }, + { + "path": "docs/internal/extensions/native1/commands/native-axiom-probe-02.json", + "mode": "100644", + "gitBlob": "f3091d4d755bac910f4a929b9120d0f531cbee92", + "rawBytes": 1230, + "rawSHA256": "aa7dc555deb6c8a142d5d53be91f923d5f780e9522a222159e3c21c3779ae058" + }, + { + "path": "docs/internal/extensions/native1/commands/native-axioms-01.json", + "mode": "100644", + "gitBlob": "3029d2095b6931465635451f073c61940f12cc98", + "rawBytes": 861, + "rawSHA256": "e077dfb9565e1e41cc6025edab73864be2968f78a470d7f342747766f8c02d52" + }, + { + "path": "docs/internal/extensions/native1/commands/native-axioms-02.json", + "mode": "100644", + "gitBlob": "78d1f83cece6197b57d545b053816354635eb12d", + "rawBytes": 22834, + "rawSHA256": "cd3e9c38c4fb0388c53fcbd6dfc9c836b6a5ec9fcf485f8e174130c45468bb2f" + }, + { + "path": "docs/internal/extensions/native1/commands/observations-01.json", + "mode": "100644", + "gitBlob": "08119f753459c409eebadd31d45899ac812b1aaf", + "rawBytes": 19966, + "rawSHA256": "19b7de745af11653a67e30f94858754da46abda49eb3908fe4ed4935e1c3491b" + }, + { + "path": "docs/internal/extensions/native1/commands/observations-02.json", + "mode": "100644", + "gitBlob": "8270bf00016d8200cdbbf399355758546d088b39", + "rawBytes": 5873, + "rawSHA256": "e8b81cf994d2826128ba72f97d7e0a1638c04b81cf68f04b3798f1dadcf87df5" + }, + { + "path": "docs/internal/extensions/native1/commands/observations-03.json", + "mode": "100644", + "gitBlob": "010ffee0ade80632c73f09069aed79ee2b529c13", + "rawBytes": 2999, + "rawSHA256": "17710ca133dfeb57997c72c99b8cfa9d35190cb273d51b04554ee556f432408d" + }, + { + "path": "docs/internal/extensions/native1/commands/phase-integrity.json", + "mode": "100644", + "gitBlob": "6e13a94e69460da38c8cc8f6bc6a2559fde4fdec", + "rawBytes": 5519, + "rawSHA256": "7f59e0fd7ee158fd7957a3fa570ddb321149494c0cf6d3093da0a6ce090eef13" + }, + { + "path": "docs/internal/extensions/native1/commands/policy-certification.json", + "mode": "100644", + "gitBlob": "30ef3e7c6deaedda5ba8ba4453ff0c6b78483c34", + "rawBytes": 5163, + "rawSHA256": "859404c6508357d550f351e49cccbcea934b44a91612dff51c0470931440cf31" + }, + { + "path": "docs/internal/extensions/native1/commands/policy-final-certification.json", + "mode": "100644", + "gitBlob": "30ef3e7c6deaedda5ba8ba4453ff0c6b78483c34", + "rawBytes": 5163, + "rawSHA256": "859404c6508357d550f351e49cccbcea934b44a91612dff51c0470931440cf31" + }, + { + "path": "docs/internal/extensions/native1/commands/policy-final-focused.json", + "mode": "100644", + "gitBlob": "e68d46866d1231ead8ec9403d2f55d58bf0849b9", + "rawBytes": 10102, + "rawSHA256": "a99acad7df46f5a5021ab4283e827e89e23307441cae7738d577fecbcb6d9153" + }, + { + "path": "docs/internal/extensions/native1/commands/policy-final-full.json", + "mode": "100644", + "gitBlob": "1a78ac4262e74fabffd40657f80bd4f5a9676d4a", + "rawBytes": 28062, + "rawSHA256": "8d17e7c151f589d881dbdd687dc9d2479530c083e1dc12fc85b8ff28501a0a22" + }, + { + "path": "docs/internal/extensions/native1/commands/policy-final-preservation.json", + "mode": "100644", + "gitBlob": "8b44f6cfb3068a4b4fb0b73909678b4bbaab39b5", + "rawBytes": 174, + "rawSHA256": "a76f7a66714c793c7e7660d70036b53caab852d8ddb6311989fa32440eadf075" + }, + { + "path": "docs/internal/extensions/native1/commands/policy-focused.json", + "mode": "100644", + "gitBlob": "e68d46866d1231ead8ec9403d2f55d58bf0849b9", + "rawBytes": 10102, + "rawSHA256": "a99acad7df46f5a5021ab4283e827e89e23307441cae7738d577fecbcb6d9153" + }, + { + "path": "docs/internal/extensions/native1/commands/policy-full.json", + "mode": "100644", + "gitBlob": "1a78ac4262e74fabffd40657f80bd4f5a9676d4a", + "rawBytes": 28062, + "rawSHA256": "8d17e7c151f589d881dbdd687dc9d2479530c083e1dc12fc85b8ff28501a0a22" + }, + { + "path": "docs/internal/extensions/native1/commands/policy-preservation.json", + "mode": "100644", + "gitBlob": "8b44f6cfb3068a4b4fb0b73909678b4bbaab39b5", + "rawBytes": 174, + "rawSHA256": "a76f7a66714c793c7e7660d70036b53caab852d8ddb6311989fa32440eadf075" + }, + { + "path": "docs/internal/extensions/native1/commands/registry-kind-downgrade-coordinator.json", + "mode": "100644", + "gitBlob": "9a6a5fc8f4516f2f2aa85ff01d8b4afcfbbe92c1", + "rawBytes": 747, + "rawSHA256": "0781ea8258d7a66eff322ce0f4e1740007a546eea27532c420fc7b5f30a7fa89" + }, + { + "path": "docs/internal/extensions/native1/commands/registry-repair-baseline-pins.json", + "mode": "100644", + "gitBlob": "62180ebe9dcbe7fb314be7dcdc3b0299e71bb018", + "rawBytes": 691, + "rawSHA256": "93083056fda50fba0142b6727df37d22ee170fb0854ea0515a3132612ee160c8" + }, + { + "path": "docs/internal/extensions/native1/commands/registry-repair-final-summary.json", + "mode": "100644", + "gitBlob": "d54f22823be46c02be6c1a92530abced7393ebf9", + "rawBytes": 1585, + "rawSHA256": "0bf9c9ada5311923aa6e6ce977d1aa2c5d26d734dacf6faa8b8a81c0e6c6e433" + }, + { + "path": "docs/internal/extensions/native1/commands/registry-source-pin-positive-coordinator.json", + "mode": "100644", + "gitBlob": "e0f371cd192610628d1c0598ff7547da54801c9d", + "rawBytes": 753, + "rawSHA256": "01cc7a0bea50e8c08608d59b0f9d5916bf31cfb4ae3369d3c615f62d679e8f19" + }, + { + "path": "docs/internal/extensions/native1/commands/repair-controls-final.json", + "mode": "100644", + "gitBlob": "70ae6fbc7edf09bd80b741eb324a70bec7cd5120", + "rawBytes": 7610, + "rawSHA256": "3cf01553b7d38456ffad18d0c92df60a7c5432bb86bc764116b927b4816a00fd" + }, + { + "path": "docs/internal/extensions/native1/commands/repair-controls-v3-final.json", + "mode": "100644", + "gitBlob": "b52fb1e3cf7ed96818ccf75103cb6f4a50de945a", + "rawBytes": 7515, + "rawSHA256": "1548c2d5fdc8d259ec6e4c1d531c0338109813c218c5a625cb9c191cfaff5a0e" + }, + { + "path": "docs/internal/extensions/native1/commands/repair-known-smoke.json", + "mode": "100644", + "gitBlob": "1100618bd3965cb9ed10c452525bedd936f2116b", + "rawBytes": 1315, + "rawSHA256": "f576201c872c50b149bed107f0ce63048e934733d0039e7d3a215b34149d0a9d" + }, + { + "path": "docs/internal/extensions/native1/commands/repair-native-startup-binding-failure.json", + "mode": "100644", + "gitBlob": "aca3b363ac5032523ee95127135aef25571e2bf6", + "rawBytes": 515, + "rawSHA256": "e7de9eb8fbb91b7f0d4c75b14c66bd04acea488da8ed86448c71bf8b262d6c15" + }, + { + "path": "docs/internal/extensions/native1/commands/repair-native-startup-owned.json", + "mode": "100644", + "gitBlob": "ebbdcc7691d0aad354230feebc22f4ac58e421a9", + "rawBytes": 705, + "rawSHA256": "1fc18b0c5e1e388aa1cf4697e8540e56a6b6a076284ad70830307050821152ed" + }, + { + "path": "docs/internal/extensions/native1/commands/repair-native-startup-runtime-path.json", + "mode": "100644", + "gitBlob": "264938fdadf21cd6dd3b5dc45524e83a2fac2e70", + "rawBytes": 933, + "rawSHA256": "e99aef78d440d29b325c195864855aa54fbd3667af4128a34f7cd1579fd684e1" + }, + { + "path": "docs/internal/extensions/native1/commands/repair-v3-control-unknown-uppercase.json", + "mode": "100644", + "gitBlob": "04a9955884a4eccddec3550f8ceaead4df3dc889", + "rawBytes": 1674, + "rawSHA256": "fc2a5a9d524d3ce083f5409c459c0651d91fd738f885629023818dafbe6b87d7" + }, + { + "path": "docs/internal/extensions/native1/commands/repair-v3-cpp-error.json", + "mode": "100644", + "gitBlob": "9a1e8877f778efbd6116424f070526f5a6053b76", + "rawBytes": 1376, + "rawSHA256": "493e45d2c36a76fca99d65a016f1848e08cf665d4f3621a10e06ded289980963" + }, + { + "path": "docs/internal/extensions/native1/commands/repaired-route-build.json", + "mode": "100644", + "gitBlob": "726dedd0bf62c9fde9249f1ee1763e8aace8606a", + "rawBytes": 3361, + "rawSHA256": "20c6d7f7156f0eb7af6a3762bf50c8e1eb834c398ea417ba7c760f59f254a0bc" + }, + { + "path": "docs/internal/extensions/native1/commands/route-01.json", + "mode": "100644", + "gitBlob": "8a77e47032ed6aafff4feb5afc9427d295a47ad9", + "rawBytes": 780, + "rawSHA256": "1b212649ac414f2e985b3c4f72c97623994d5bc9fc5e0681530b9078ff579ca8" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T074345564.json", + "mode": "100644", + "gitBlob": "a990afcda12550da3c8a10d980040b1bb50acb20", + "rawBytes": 941, + "rawSHA256": "cbbe37c0f61122199a34d45146f0b45e30eee36f45dd87925e864330708de211" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T074851905.json", + "mode": "100644", + "gitBlob": "4e1e05e5f0888ac5811ab46dee5376e7c9c6ac05", + "rawBytes": 1118, + "rawSHA256": "bcabe60cfe0e56470266094f21f1edf3e66d0954b572ad47f80fcb23873cb963" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T074921501.json", + "mode": "100644", + "gitBlob": "dca2426fe6650447d03093342a836116b50f162b", + "rawBytes": 18107, + "rawSHA256": "056292ad4999142d1e8a39d2daf455e5e4259a667d04e19bf0587e00427f4621" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T075047091.json", + "mode": "100644", + "gitBlob": "096b0acb57ceac9d939bd4c7b6b1016c3871de4f", + "rawBytes": 83637, + "rawSHA256": "4341eda40739acb0239abcfebf0de088b262184f9ae72ce716dccac94c113725" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T075325959.json", + "mode": "100644", + "gitBlob": "3f6ffb49d2e9547b5c88da8b610f2a6e7842fb71", + "rawBytes": 1118, + "rawSHA256": "d39df64de00b994c287dc7a003426450c6801218bde899de473051b4edad0df3" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T081311355.json", + "mode": "100644", + "gitBlob": "666b330a9652cca38fc80c8352cd1dc73ffb1f6e", + "rawBytes": 83647, + "rawSHA256": "82be145305f5be3a6c897f9d2d43f73e1eb8ae6e8fc5916fbb295dfffa5d502d" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T081538732.json", + "mode": "100644", + "gitBlob": "0280b83ec35a76575bf5bd78e779cac9dac3a16e", + "rawBytes": 1118, + "rawSHA256": "e0a424883ab7528b9645f2a4d8b1b692f70c8f097582b5b92941b98a9cebd7d9" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T092619569.json", + "mode": "100644", + "gitBlob": "af944abb9d631227d1b58c9e290b88691bdd4191", + "rawBytes": 2024, + "rawSHA256": "2d5851b9ec55df957e49ad290ebeb0d9b844960dad04ead754218d36be8c95a0" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T094044361.json", + "mode": "100644", + "gitBlob": "dbb032fab9ffe54e5c614a24c0854e5e26606c72", + "rawBytes": 2165, + "rawSHA256": "83d1602c1b234644d8e938e5a46b9228f77a26c99338f150f38eea78a2de86f0" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T094135118.json", + "mode": "100644", + "gitBlob": "be1e3aa3204a959fd0cd932131df50f4c6fcbbca", + "rawBytes": 112175, + "rawSHA256": "621e211ae77e3db4f97eebb2c2577e7e84e8721481569c9d045ee22f0968037b" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T094834598.json", + "mode": "100644", + "gitBlob": "ff515bb32f59fcc677a178a62de8122fa95feed8", + "rawBytes": 2468, + "rawSHA256": "789c8174e0496b4cfcc68247f3a73e9d66b1a762820b7a2c73edf11771f061ac" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T095846357.json", + "mode": "100644", + "gitBlob": "da49f21a7ade75aff1b58d8e6c5bbbd0753a960a", + "rawBytes": 2344, + "rawSHA256": "23a2c407b17e336388c1323cc28b3a48d0a02d757d6a89e07794a920af08e6b8" + }, + { + "path": "docs/internal/extensions/native1/commands/route-20260912T095926516.json", + "mode": "100644", + "gitBlob": "6276cdd9fe5378140068b1a54cb7d503993153ad", + "rawBytes": 121289, + "rawSHA256": "5a31bdda30a5026edd27ed3374e4354b4ad5928c2a75591db0bfcf780b1eb647" + }, + { + "path": "docs/internal/extensions/native1/commands/runtime-01.json", + "mode": "100644", + "gitBlob": "678cc884231638a0fe4c41adde4b31c87e97b2b7", + "rawBytes": 3410, + "rawSHA256": "36188fd19ad55ce119b5b822fb1579bddf170d178675b83d314d1efc028a097e" + }, + { + "path": "docs/internal/extensions/native1/commands/runtime-02.json", + "mode": "100644", + "gitBlob": "f2c5e5910e8148b7841098789bb7fc5d2dbb444e", + "rawBytes": 884, + "rawSHA256": "2e23d7cd6098eba99971ad49bf416db6082936a4009d4e39e324718cff8a57c6" + }, + { + "path": "docs/internal/extensions/native1/commands/scheduling-inference.json", + "mode": "100644", + "gitBlob": "827a3fb46ad9f0bacec145cfd09a705886a529c3", + "rawBytes": 828, + "rawSHA256": "5bd275f9ed0c5c35920cab8ffdd3e76b1050ba3acc61d9c468f310fbb97c42cf" + }, + { + "path": "docs/internal/extensions/native1/commands/thin-01.json", + "mode": "100644", + "gitBlob": "234718ce07423d20fe5d989c93cbdcbd954212ca", + "rawBytes": 2548, + "rawSHA256": "c495339d8a01d960460c2293ca81211d1a9ceb1e9da2e7e1fa1144be7b8fe4a3" + }, + { + "path": "docs/internal/extensions/native1/commands/thin-02.json", + "mode": "100644", + "gitBlob": "2d62e04d31b48c2ae4c0b4e9195bcd5b5d07b6ee", + "rawBytes": 778, + "rawSHA256": "42311f28e41dd4310841b0833ec930f34b66bc3382af8d1ad0097f15f47995a7" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-01.json", + "mode": "100644", + "gitBlob": "b8165ae385dbdad8e47a8646730439f786d05f66", + "rawBytes": 1537, + "rawSHA256": "8e5b1f77ad44301f8c03760bc77f3aaa6f18028792db466d325d78383ac58d41" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-02.json", + "mode": "100644", + "gitBlob": "a62973a5892ff57069f177f189b5f8cfdd702c82", + "rawBytes": 1566, + "rawSHA256": "b92803f61981ffa7b64de060568b7543ed54bcae50ffd6018d96374c9b778e85" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-codefacts-import-01.json", + "mode": "100644", + "gitBlob": "1a7b7376f849a361527b47297ce038875573e50b", + "rawBytes": 1610, + "rawSHA256": "9167c0e94e36cbf1b81953f792ac33216ea9efd4ef8db09b64e2b784df0ec40b" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-compare-positive-01.json", + "mode": "100644", + "gitBlob": "491699db5062d95a44505cf939ed38e223368c74", + "rawBytes": 1075, + "rawSHA256": "a053eb2383542434d5bcb067ebbe0bfc985630875f63218a7165249aec917979" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-compare-wrong-01.json", + "mode": "100644", + "gitBlob": "f470945588e36d5fb1e19f1c11675bb8c26aad3c", + "rawBytes": 1072, + "rawSHA256": "2d4fd0f4f1c4c0b590481620fe8aed396107c580d8a2d79154c1547b60806099" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-controls-20260912T120702123.json", + "mode": "100644", + "gitBlob": "ea0e3e9298aa4183e514d92ce6a39b321398deff", + "rawBytes": 16514, + "rawSHA256": "bb8e08bd2df3c0fe9a305678c4b3c355cdaed10c67de69e8c2cfedd91796b470" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-controls-20260912T121157154.json", + "mode": "100644", + "gitBlob": "fd6d5b1a3287b86cf96cb01c1a0b41cfeb691325", + "rawBytes": 16477, + "rawSHA256": "945970e3ed008f8796e5cc517433865ed13d4e20023bf778b5aca620626365c9" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-controls-20260912T121837285.json", + "mode": "100644", + "gitBlob": "3a1ccee3ffae46fe493ec0f6249c916ae44e1308", + "rawBytes": 43834, + "rawSHA256": "71690b65e283edbac82d6a9171a1cf4c4a33e0145890271ad8be47aaba05c756" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-controls-20260912T125248495.json", + "mode": "100644", + "gitBlob": "a366681004ddb47259a9049531ff352925725192", + "rawBytes": 25130, + "rawSHA256": "221705a5887506cd1709eac76a0b82ec92f7513c05ada001a30b15817d9c2992" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-controls-20260912T125634462.json", + "mode": "100644", + "gitBlob": "730d6281e9d64efec2ac3d11635d562d6c08f569", + "rawBytes": 16497, + "rawSHA256": "fbad7181afd653a53442ae21833bf42f74b1f5759d75fbb45659c36ec823e1df" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-controls-20260912T130117776.json", + "mode": "100644", + "gitBlob": "453cc8bb63c459ef888407f573666090a53855e6", + "rawBytes": 53360, + "rawSHA256": "ed0a09875ddb653270f58ea7fe7df6d16c938e70e6ca0dc963f7124a2af1d6ca" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-cursor-import-01.json", + "mode": "100644", + "gitBlob": "f6501551bd7214658d105c4bdededcd6633899a4", + "rawBytes": 3870, + "rawSHA256": "859f0fc56fd63848b8d4b80942b073b9e498286b63e1d3affa543f57a13782b3" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-default-01.json", + "mode": "100644", + "gitBlob": "f814c2d93bdfc6db4f37d576b944e1b5154a4b72", + "rawBytes": 3318, + "rawSHA256": "e575a1a4df67bc4f60e05f23c1e246d89bbf95a792611bfaf68a3a4c689e0a13" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-durable-all-01.json", + "mode": "100644", + "gitBlob": "4692b2877c5ba8e6ba1cb5f383a96af50f7ea027", + "rawBytes": 4258, + "rawSHA256": "6f6471042a86f7f39252e1b8467e03284a2e9e451f952d054972d36b81621f9c" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-durable-all-02.json", + "mode": "100644", + "gitBlob": "adaebc2d070b895f8e9e20aea768669a92527879", + "rawBytes": 4374, + "rawSHA256": "3b3688dd7842bb0eaa8e2567bc1083eacc2bc3a433a674c8f25496748ddda46f" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-durable-positive-01.json", + "mode": "100644", + "gitBlob": "44c77b31ae446fd3e6bbd8573b2a6e424014ec37", + "rawBytes": 2096, + "rawSHA256": "d22e83d84d7f162fdd863890f82ce0b3c52a9e130fb6d62be77bf3121dbe28c3" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-durable-positive-02.json", + "mode": "100644", + "gitBlob": "b4d7d2205dc7a5dbb2608b836c8d990f6d6f3bd2", + "rawBytes": 1522, + "rawSHA256": "d2ecc69928c5dc84a55cff87c8b873d3bfd37363a483ab36568630d4a716624a" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-empty-channel-01.json", + "mode": "100644", + "gitBlob": "870830d9c7d9caa9c07844136d9730f621b11226", + "rawBytes": 879, + "rawSHA256": "d7b1bd126fea79213681e3fd465fddf46ffda54ebfe9522239586db88b52cf12" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-fuel-format-ps5-01.json", + "mode": "100644", + "gitBlob": "b3c1321e24c4c1b1a49699a26727b286b503e880", + "rawBytes": 1487, + "rawSHA256": "224bae7d1de24398dbba908f6c5cacc02f678b92f3de092bd641e52ef330b21d" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-fuel-format-ps7-01.json", + "mode": "100644", + "gitBlob": "22494f60abe206ecb55565cffae695d96aeff173", + "rawBytes": 1527, + "rawSHA256": "e840eb738fdc50fe9066abc8e6dd1010c238057e17114d571c79dc5d42fb63d5" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-limbs-import-01.json", + "mode": "100644", + "gitBlob": "1e0b797f09b348502a0e8e3732879c20ffbebf41", + "rawBytes": 4784, + "rawSHA256": "33685ceebda2996b3f8426e8bea29036ef1aaa5d84e49bd5bae8ec50f69aba44" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-limbs-import-02.json", + "mode": "100644", + "gitBlob": "e95741ea8a9a65cf2315955ccd7a29351b017b4b", + "rawBytes": 4416, + "rawSHA256": "441db3e4f086cf53d5213dc33df8ff5f1552709fcf7a7af3e004a86ba58a2da4" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-machine-import-01.json", + "mode": "100644", + "gitBlob": "a72627da3f1d56c8b1df62a158f2ab103dfca94a", + "rawBytes": 5445, + "rawSHA256": "a75ce0eccb285f4a81f83895f511f7ac337f45f5ce37697832cfc2028a6e506a" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-malformed-01.json", + "mode": "100644", + "gitBlob": "65181b5fbd6f905504a534e1366757476c600c07", + "rawBytes": 893, + "rawSHA256": "84cdb0f418b2676a0c6d32fe46a66e8dc9a168491aea3326ba80743464c1ba3a" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-selected-01.json", + "mode": "100644", + "gitBlob": "381d4ad585270a3db6d8a4085907d588f0b25586", + "rawBytes": 1112, + "rawSHA256": "4f446e84a08e9aa61f81b5a5bbf1ef29dc621a862b312a0855b85f6c890848f5" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-unknown-01.json", + "mode": "100644", + "gitBlob": "a141ba4b0fae4a2d8b76d5bce737cd3e870447bd", + "rawBytes": 924, + "rawSHA256": "7ab2b57754b40ce04a9b089a3849f0a7e2bec7ea1c6b217eef3b1892d4e4eb99" + }, + { + "path": "docs/internal/extensions/native1/commands/validator-whitespace-01.json", + "mode": "100644", + "gitBlob": "20f02b73dcf9281219069367cd7c0c18772cc3fb", + "rawBytes": 907, + "rawSHA256": "08c2535425d4dba8bf72df102c56b43c917fcf93154a8746362bc58cf5ef54c7" + }, + { + "path": "docs/internal/extensions/native1/commands/warm-20260912T095318994.json", + "mode": "100644", + "gitBlob": "67b1f6f957d88d22fd688b4dff9c58e0069784fd", + "rawBytes": 54492, + "rawSHA256": "622481fd9d2ed43ebcff87576e7053b09ae78b0106e568ee5073ac3778467eef" + }, + { + "path": "docs/internal/extensions/native1/commands/warm-20260912T100814051.json", + "mode": "100644", + "gitBlob": "cfa336fe4d5c71859b648f0fb053512d1a0b315b", + "rawBytes": 65114, + "rawSHA256": "87ec19b2bf8a1fae3530b1938d09749549f2ccf7992cb1f865710635b046c142" + }, + { + "path": "docs/internal/extensions/native1/commands/warm-20260912T102817544.json", + "mode": "100644", + "gitBlob": "df2b5e4cb34630b475cdc95e758df7e1903cd877", + "rawBytes": 312751, + "rawSHA256": "2dc7707aceaf228446f82a8b526205d26499bdb269e66bbd87ac89d12f678568" + }, + { + "path": "docs/internal/extensions/native1/commands/warm-20260912T104121341.json", + "mode": "100644", + "gitBlob": "c29954ec612ce8bfaea4b80563298681e9b79e4d", + "rawBytes": 13540979, + "rawSHA256": "5f00b0f44e9b539d4af2d1c4d36b4bfc3852844575741d03ffbf87482d1ee339" + }, + { + "path": "docs/internal/extensions/native1/commands/witness-arrayrun-01.json", + "mode": "100644", + "gitBlob": "947ab5599ae5616370fbd03122d03ff13e03d6de", + "rawBytes": 2150, + "rawSHA256": "94f9d8f398a3bdb3dacb0cfc14031da487142532df2479ad4279a477fc4718e1" + }, + { + "path": "docs/internal/extensions/native1/commands/witness-export-01.json", + "mode": "100644", + "gitBlob": "282f5420a5d639da8854fbcd89e2f3b51300ec7b", + "rawBytes": 5554, + "rawSHA256": "007a3b6070d8fba5be4a043c3715cbaa58f7070aa1f6c8b2cfe53aa7b1745506" + }, + { + "path": "docs/internal/extensions/native1/commands/witness-export-artifacts.json", + "mode": "100644", + "gitBlob": "aa20762de62562624f00c298ad4274a923c177c4", + "rawBytes": 12512, + "rawSHA256": "129a39464b161895861f54203fb6a7d6d6ce39d4fb1b259b658437322062c049" + }, + { + "path": "docs/internal/extensions/native1/commands/witness-export-check-01.json", + "mode": "100644", + "gitBlob": "f6377d07fb812d0f84d7b301f16b3d9835d4cb54", + "rawBytes": 2973, + "rawSHA256": "1aabc6f50cb4a809a8b525dd4e7b7214bc898da293a327a925252c88798883be" + }, + { + "path": "docs/internal/extensions/native1/commands/witness-export-check-02.json", + "mode": "100644", + "gitBlob": "bbe2e4d628b8278e0f3858a5f966c7b8c895215f", + "rawBytes": 2837, + "rawSHA256": "eb43e98c8c88170bda3206cbed8bbe56615fb42c7822ce2dcf1a554b9212150c" + }, + { + "path": "docs/internal/extensions/native1/commands/witness-export-check-03.json", + "mode": "100644", + "gitBlob": "4680e2c1757edbcb73512a71b309665262e62752", + "rawBytes": 2163, + "rawSHA256": "08af20a323b2b5dc2a212f42f016f2a27d14540325edd5164b470aa17da12192" + }, + { + "path": "docs/internal/extensions/native1/commands/witness-proofs-01.json", + "mode": "100644", + "gitBlob": "4e7cfcf00fe1b4b98e40d139c1924d36ac914604", + "rawBytes": 2721, + "rawSHA256": "2ff9bf1dd18315dd953b3c4886286c1f0bee2625b5a802c4c41e26d47dc5d4de" + }, + { + "path": "docs/internal/extensions/native1/commands/witness-proofs-02.json", + "mode": "100644", + "gitBlob": "6610c039af75585c633cf3d4fd8208a38cd8b0dc", + "rawBytes": 7336, + "rawSHA256": "dff7cc33c162c3698a148366e9a57227d002a40ccaa28c37a53ea861e91cfa6a" + }, + { + "path": "docs/internal/extensions/native1/repair-r1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "4fb7f8a30aacea56c760ce337e9b7fa5be4e46c1", + "rawBytes": 33351, + "rawSHA256": "59509fe6779a33dcfe541a6b182456c5a28cf390ebb765f68cef3e7fb4753b08" + }, + { + "path": "docs/internal/extensions/native1/repair-r1/CONTROLS_RECEIPT_d0b4cef.json", + "mode": "100644", + "gitBlob": "2fda8946dbcdfa6ee9b36476002de6b5124f409d", + "rawBytes": 140190, + "rawSHA256": "15e0e8cce044757d22634c8fd3dd21ced04a28a1f641dbf3cc434e4e94e820a4" + }, + { + "path": "docs/internal/extensions/native1/repair-r1/RECEIPT_ARCHIVES.json", + "mode": "100644", + "gitBlob": "8f98c063aec5df552809bab100b4cd6fb3f588b6", + "rawBytes": 11895, + "rawSHA256": "9d43e4372c04c5ecc5efb88a8bcd8e7fd9f862dbd8054d5ae8f5d55237ed4329" + }, + { + "path": "docs/internal/extensions/native1/repair-r1/REPORT.md", + "mode": "100644", + "gitBlob": "9be8139b4455e9c0b006fff15e45ad0cda466e8b", + "rawBytes": 30747, + "rawSHA256": "bd83c87ed4b5b82fe34b98635a041e51b6c326fe4b0cbad01c84d9c7e2d24880" + }, + { + "path": "docs/internal/extensions/native1/repair-r1/receipt_archive_control_helper.py", + "mode": "100644", + "gitBlob": "5cb77df82f8d7eb0fb72d775096a969f0083de3b", + "rawBytes": 9081, + "rawSHA256": "aca55bc949b7f1034908af84204e214493f7f7b3a2d3f958fa17c833ef0434ba" + }, + { + "path": "docs/internal/extensions/native1/repair-r1/run_receipt_archive_controls.ps1", + "mode": "100644", + "gitBlob": "fe8eed9044c30de12ef6a9e9a2722078035f5528", + "rawBytes": 23630, + "rawSHA256": "71a0e7e382e15c66015b40579a5b903711f0b4b2df1155d065920c485cb8464f" + }, + { + "path": "docs/internal/extensions/native1/repair-r1/verify_receipt_archives.py", + "mode": "100644", + "gitBlob": "de451edbe3e44a9a60672b24eaf0b430d4e05b2a", + "rawBytes": 19448, + "rawSHA256": "5805cc886b3ffaa7c149eaf2eb903b88e71247ef103b0c0ef99863a16334458b" + }, + { + "path": "docs/internal/extensions/opt1/.gitattributes", + "mode": "100644", + "gitBlob": "85d70dcaa28b954b72e266f4bc41a4c9ac85b1f5", + "rawBytes": 1115, + "rawSHA256": "3764865b0ba810e09327b9059e2a4e0a044e4cbd61553003074f8020def95780" + }, + { + "path": "docs/internal/extensions/opt1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "bd5d0eb38fd4a301eb89b027fcc434fc18dbee75", + "rawBytes": 35888, + "rawSHA256": "e21a7b6658e170deeabf01a4f9a4c8593c5642f6048d2662a93306f002abdd5f" + }, + { + "path": "docs/internal/extensions/opt1/AUDIT_DISPOSITION.md", + "mode": "100644", + "gitBlob": "49b2840079bc11aa66d3d67a863b6a4c12f851ab", + "rawBytes": 4625, + "rawSHA256": "c7a68e9ace42b2ca1962a249eb7917a458810753494e12f6258000a91cf032d4" + }, + { + "path": "docs/internal/extensions/opt1/AXIOM_ROOTS.json", + "mode": "100644", + "gitBlob": "4c9314d23730f318c1a4f99ca13e2156912f277b", + "rawBytes": 9189, + "rawSHA256": "ca2908657fe00cf4e0527bf81aa6d095285c18bc5fc66f098c532a1cf812b6ef" + }, + { + "path": "docs/internal/extensions/opt1/BLIND_SOURCE_AUDIT_PROMPT.md", + "mode": "100644", + "gitBlob": "217dc766f8e52f7569d2e6a8ecc19e8e7a4d3117", + "rawBytes": 26357, + "rawSHA256": "5665d4a273c0f0cbe44388de1c7cd76245c415ebb7457dfd5d630b52462e6ac6" + }, + { + "path": "docs/internal/extensions/opt1/BLIND_SOURCE_AUDIT_REPORT.md", + "mode": "100644", + "gitBlob": "dc7287787b5bb1761ab13e241d1e342a9222ffef", + "rawBytes": 44217, + "rawSHA256": "d40be15f651e4f640defd4455e594bccac7c92afcd0a915f0cacb37614c342ca" + }, + { + "path": "docs/internal/extensions/opt1/CAMPAIGN_RECEIPT_REVIEW.md", + "mode": "100644", + "gitBlob": "9d6c6bde769d71133936d1abd79c1d2d3c4dcab7", + "rawBytes": 3647, + "rawSHA256": "934f5c864359bc9fd3099b72e6fecf1da98e00bc6fb0a4a1a6c52eed7ca6bcf6" + }, + { + "path": "docs/internal/extensions/opt1/CHECKER_REVIEW_15E.md", + "mode": "100644", + "gitBlob": "a9b53fd910842a4d03c32986a166ac58dba1bef3", + "rawBytes": 7087, + "rawSHA256": "edc45aac39301cbcef8dbf36ec0ec9117cbc7a914e0de2b123e8104cdc8233bf" + }, + { + "path": "docs/internal/extensions/opt1/CHECKER_REVIEW_BBBE.md", + "mode": "100644", + "gitBlob": "10e4fae7249456bceede7049d6703d539f944342", + "rawBytes": 3686, + "rawSHA256": "3b6c124e626c19f8b01ef00d573819c41301df9f404dd9237f3c24a565d1c66c" + }, + { + "path": "docs/internal/extensions/opt1/CLAUDE_JOB_FINAL.json", + "mode": "100644", + "gitBlob": "0207d51f68ce44bc7ced77c10b317adf8e77ca08", + "rawBytes": 2169, + "rawSHA256": "98a2970b0a6590e1779d11fc7cb8badbd782298ea2016a33acfb65090a90b303" + }, + { + "path": "docs/internal/extensions/opt1/CLAUDE_JOB_START.json", + "mode": "100644", + "gitBlob": "aa6bf247e3a05638860c99381989204a5355f5de", + "rawBytes": 5012, + "rawSHA256": "dfeb56610ebf38e32ad72625c0b90ffd6ab6b10d1e590e94d92f0f48a578c6ec" + }, + { + "path": "docs/internal/extensions/opt1/CLAUDE_SOURCE_IDENTITY.json", + "mode": "100644", + "gitBlob": "40f6910d098b23f2f8c1e00c0e10424bec1b928d", + "rawBytes": 63023, + "rawSHA256": "4191ce36ece567d8e60f135a2704c194a536de38d990c654056245c15a43a768" + }, + { + "path": "docs/internal/extensions/opt1/CONTRACT_AUDIT.md", + "mode": "100644", + "gitBlob": "938ff30aaf3e77cf6ab3491b9546f22281e2e9ae", + "rawBytes": 9657, + "rawSHA256": "1ca92db80e82224be124381af07a57b69331d5b13c515bcd940f7bd0624beb13" + }, + { + "path": "docs/internal/extensions/opt1/CONTRACT_ROUTE.md", + "mode": "100644", + "gitBlob": "c18e698ca2d220a8b04900f48ac750124cf02410", + "rawBytes": 7355, + "rawSHA256": "f9837ca963710fe1074e6cec40877bf06c53338f6cdd1b5a5af0f80539ee4e22" + }, + { + "path": "docs/internal/extensions/opt1/REPORT.md", + "mode": "100644", + "gitBlob": "90a3972aa286c5756ebee789b08725cc31e39f6b", + "rawBytes": 28729, + "rawSHA256": "8fb2e742fabc26bec9c6912078721d5ca8910769a7500c494c46ba15d0ea68d4" + }, + { + "path": "docs/internal/extensions/opt1/RESOURCE_WAIT_20260912_REPORT.md", + "mode": "100644", + "gitBlob": "ccef83c82e964b41a96e992642cbab6b0d9516b7", + "rawBytes": 15469, + "rawSHA256": "bd63f061cbb4ce2b2335f844f2975cbf9620adf403692aa1c25fa93fdfba8997" + }, + { + "path": "docs/internal/extensions/opt1/ROOT_COMPOSITION_PLAN.md", + "mode": "100644", + "gitBlob": "cb72d557c7078a3a099f1114a4601cbd480fc928", + "rawBytes": 5242, + "rawSHA256": "64bd687f1f7ec0f9bc3105fff2b03fdd7d2da4dd101b9e42fe67c9cabf102151" + }, + { + "path": "docs/internal/extensions/opt1/ROW_EVIDENCE.md", + "mode": "100644", + "gitBlob": "92c79d9f5cedb0b54efda2a59020b16448396c72", + "rawBytes": 16496, + "rawSHA256": "eb2c96cee98722b28c77cc33004379bcc12855b7943d381141f988b24450b667" + }, + { + "path": "docs/internal/extensions/opt1/SCHEDULED_FINAL_REQUEST.md", + "mode": "100644", + "gitBlob": "ac71ee945d0448942f34cb7a377cdf872c96b347", + "rawBytes": 3669, + "rawSHA256": "af193708b14b767c6b429adcf5ff726c5c219f2d23c62da5315498c84a565624" + }, + { + "path": "docs/internal/extensions/opt1/SOURCE_FREEZE.json", + "mode": "100644", + "gitBlob": "620e639a1c54b2dd23453c8b0e0ff2bb90ef209f", + "rawBytes": 1206, + "rawSHA256": "d966e19ee39c8480522d7bb83041ff71c49bdb608e90eab23fb43d52b329a29f" + }, + { + "path": "docs/internal/extensions/opt1/STORAGE_REVIEW.md", + "mode": "100644", + "gitBlob": "5d2ef3c1a9b09f5a904b56a758403085450f3965", + "rawBytes": 2429, + "rawSHA256": "8e42b3d1a20d051cbb37f30bd4fd3aefcfc2dfb4cd6e4b85ca65ab6e89954b76" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/20260912-071055-038-Primitive.json", + "mode": "100644", + "gitBlob": "b824d62d53226888491100e26799f98c79ae1e81", + "rawBytes": 875, + "rawSHA256": "f8020a2342dfeed3dffc2e7b284bd51e12c75a9d017d09a81934571995327b40" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/20260912-071115-933-Calculus.json", + "mode": "100644", + "gitBlob": "d146706c96891dca436b1b42b919bcbefb526ed5", + "rawBytes": 871, + "rawSHA256": "38e04345ba342d0d011496eda044b4eaa976a6be552f036c6fb380dcbd87cbbc" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/20260912-071129-992-Structured.json", + "mode": "100644", + "gitBlob": "0299c42c75e3117be2b5f4f5ab8ab015915c307d", + "rawBytes": 878, + "rawSHA256": "cfa30a9035ae69dae7ae1250979462cd2ad687a3ed4ca362a0e5e66fa06f41b1" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/20260912-071153-549-Compiler.json", + "mode": "100644", + "gitBlob": "fba970005ea09b207ca5a35e43e0777ca84e845d", + "rawBytes": 872, + "rawSHA256": "d85cdb5e6196cc721b7b3a5e2319a5bb02631e0fd195748defff70c5370e2a81" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/20260912-071244-077-BranchBound.json", + "mode": "100644", + "gitBlob": "a6dd3c4c551ea476c63d87cfbd542b1e2c409e47", + "rawBytes": 893, + "rawSHA256": "9bdb7b18ad7bad11264c1f1bd7d26e2ad0f6524359d8fbdbcebfcc80b3ee71a5" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/20260912-071445-906-BranchBound.json", + "mode": "100644", + "gitBlob": "cfaa99022c5489ec534b2df310c3c1e2e2d2dc4d", + "rawBytes": 892, + "rawSHA256": "332e373e584bbbc6ef18853a7abf03139c20ed94536827f98c07c88934d67c1f" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/20260912-071538-136-Axioms.json", + "mode": "100644", + "gitBlob": "1c24879b4d19c439cc9b1175af82e453c99c5bcf", + "rawBytes": 4075, + "rawSHA256": "cae51fd3c00c37850b356df3b3ad80708e393e9b22c17143ce929f2506ca9160" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/Axioms.lean", + "mode": "100644", + "gitBlob": "e646384c06e39b3e8521fa12e39fe1844c98eef6", + "rawBytes": 1119, + "rawSHA256": "049cf6714d76fd11c55eac8d0c91d077de99b3b7c3f298e268d3b095b0a81d4a" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/PLAN.md", + "mode": "100644", + "gitBlob": "9777bbfa5e0a40ad20f625e55e28a6c1f5523a92", + "rawBytes": 2653, + "rawSHA256": "e95727b250b6e1c26fc502b93697baa9166fca2fc637546aa783dc1a21c18a2f" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/REPORT.md", + "mode": "100644", + "gitBlob": "8587a9c9cd119ec25cea2a0e3f2bd24ef19a9303", + "rawBytes": 10932, + "rawSHA256": "01fff26b2cfd45553ac9b8f023041a788f6e6f8abf046e55cf0ad11796ae3cd2" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/check.ps1", + "mode": "100644", + "gitBlob": "8bad7fa61764e3deef46d1529a4fec7e4f6fb48d", + "rawBytes": 1837, + "rawSHA256": "44a8da036e2e21970da6b7ddd1e2eae43a944523372459bae1e97b466bcc9126" + }, + { + "path": "docs/internal/extensions/opt1/bound-development/hygiene.json", + "mode": "100644", + "gitBlob": "fddf13ed138175b53e5c863f3105ac95abc5baa1", + "rawBytes": 643, + "rawSHA256": "75d11784e82e6a9915082ac86332ab0d2e724b86852426d151b91c2d1626baaa" + }, + { + "path": "docs/internal/extensions/opt1/capstone-resume-plan.json", + "mode": "100644", + "gitBlob": "45d560887eb3374f879292a65cf88dec562709bd", + "rawBytes": 50, + "rawSHA256": "f4966f34774c32685c9e035eb2ca0aff71201e5f8bd20d52a6bfbc4b417bd123" + }, + { + "path": "docs/internal/extensions/opt1/certificate-consolidation-check.json", + "mode": "100644", + "gitBlob": "dcb1a220faa731f8a2c0a0054b7ea40c38190197", + "rawBytes": 312, + "rawSHA256": "437e61892c2e21b52d6cb493d393836a692988c4d24ba4616862409a28f17a39" + }, + { + "path": "docs/internal/extensions/opt1/certificate-freeze-claims.json", + "mode": "100644", + "gitBlob": "ca948837a05f7b450554171971155b70bee8cd7c", + "rawBytes": 541, + "rawSHA256": "55feafc46968b2f0c5d67f2cdf7401b748efe840ecf41fdee6d75286b64a00af" + }, + { + "path": "docs/internal/extensions/opt1/certificate-freeze-design-base.json", + "mode": "100644", + "gitBlob": "19a1121f3d8b22d11d86057b82dbde0765a5899a", + "rawBytes": 623, + "rawSHA256": "bfb0808ddf0c28dd1ba231be3a76ec34236dcfe98ca44b760e91220ece34f956" + }, + { + "path": "docs/internal/extensions/opt1/certificate-freeze-design-phase.json", + "mode": "100644", + "gitBlob": "17b198fb3dfab718ae1d899b1b2bc783c0c409b5", + "rawBytes": 839, + "rawSHA256": "3fe5b1be8ea1ffa748ca4125484f57a8a471d478160afb4d0669a28b7aac44ed" + }, + { + "path": "docs/internal/extensions/opt1/certificate-freeze-whitespace.json", + "mode": "100644", + "gitBlob": "1c814a9fc9cdc727a578635d50b81b62fd501eca", + "rawBytes": 371, + "rawSHA256": "ffc8ea84c6e52733bc8ea4e4c1570f1edc9979d9b8c0d0fecb2e85707c956b50" + }, + { + "path": "docs/internal/extensions/opt1/certificate-independent-check.json", + "mode": "100644", + "gitBlob": "5b12e2995f8ff1a6d1ee8b2e6e21dce5bba41081", + "rawBytes": 30666, + "rawSHA256": "d4464b694c3ddaf56da4b62be53cf91d6b26da25678dd0e76d47437870f86d8a" + }, + { + "path": "docs/internal/extensions/opt1/certificate-independent-check.py", + "mode": "100644", + "gitBlob": "2c8b91e81ddd2635259112c1aee9390ae652849c", + "rawBytes": 5436, + "rawSHA256": "ab31a997fd0ea861f105fda617858d8824956ccce0b310836687fb2c733f9200" + }, + { + "path": "docs/internal/extensions/opt1/certificate-refreeze-claims.json", + "mode": "100644", + "gitBlob": "3ceb53061c4b527dd743cd719ab587dd831aceef", + "rawBytes": 541, + "rawSHA256": "536bb14e8ed5c1f10f4287ffba541d7fefd869570c59bec2b31822f1fa0dc3f6" + }, + { + "path": "docs/internal/extensions/opt1/certificate-refreeze-design-base.json", + "mode": "100644", + "gitBlob": "a294ddae75e64bc636bbf8f0b50a3b5cdb0a5dd9", + "rawBytes": 623, + "rawSHA256": "f1bd0367ba82a5bb713fee5de51f290dc6782e5c68ee131b52d917eb63f9152f" + }, + { + "path": "docs/internal/extensions/opt1/certificate-refreeze-design-phase.json", + "mode": "100644", + "gitBlob": "fc7d93a473d118557146b1cfa27b07106e14e7f6", + "rawBytes": 621, + "rawSHA256": "d9076ddc0f60f601b4968b2c2d7bebea8bfe06df49de7024be2363fd706f2361" + }, + { + "path": "docs/internal/extensions/opt1/certificate-refreeze-whitespace.json", + "mode": "100644", + "gitBlob": "1a3055e8eeec2352aadaf5279a1ca53fd649857f", + "rawBytes": 371, + "rawSHA256": "4dfda2fe7512f4d522d070c3eb01d616cf494ab4b8d18412344340f5d4c66925" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/FIELDS.json", + "mode": "100644", + "gitBlob": "3760470717560aafc5ae4652522eff1953d001e7", + "rawBytes": 11640, + "rawSHA256": "0d1529c98d35b6ff2ac53d58d107f0a47ec8f5d263f51819c085827c055a63bb" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/REGISTRY.md", + "mode": "100644", + "gitBlob": "8785623d792ff3dbcb9b65c15dee10567f940efc", + "rawBytes": 5953, + "rawSHA256": "997c8a493e5dd368044349bad691d40d498a78adafa66f2ea5afc51d7908721a" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/RUNNER_REPORT.md", + "mode": "100644", + "gitBlob": "65cc59d0c73fd836ee4af9d825d16f21ea54f23b", + "rawBytes": 20159, + "rawSHA256": "eb59209616d32284ac4370b8a8d26e629a4bfe38e904baac508c76260be534c1" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/evidence/a01-import-root-failure.json", + "mode": "100644", + "gitBlob": "de971a9e1a77729b4d48805f66bef0f8e0b95edd", + "rawBytes": 153256, + "rawSHA256": "5f987faf04fa40bcf2319ed2f9c3063d389c0f7411ba21c4fa6b82f1f4fb6a5a" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/evidence/checker-boundary.json", + "mode": "100644", + "gitBlob": "642e34da0a57e5c7e8f44e515abada6ce4f45c7f", + "rawBytes": 3502, + "rawSHA256": "6870368241743aadc3e51882f46ff4368d9b72e6e939a831c71c6f9d8d7addb0" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/evidence/focused3.json", + "mode": "100644", + "gitBlob": "1cfa5aaa9d43e2924be229c8b07ee92254447209", + "rawBytes": 934903, + "rawSHA256": "85eb9c4f2f4f5d964fe4722e4d55e5de9fa1196c62ccc0392988b558f261d6fd" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/evidence/full80.json", + "mode": "100644", + "gitBlob": "6c97d253ebdb58eaab48a4c8372ecf908426bd6e", + "rawBytes": 1382859, + "rawSHA256": "451e108122b077310137e8a2ca206062bb83274ec01a3ce7387fedc271ea66eb" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/evidence/library-controls.json", + "mode": "100644", + "gitBlob": "55cd321fe6eaf8263440652724a3562897a5104b", + "rawBytes": 286241, + "rawSHA256": "a2da227fb1ca66a0403e2f17160f746e84124fc5eb75b2e48098ab8395379ff6" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/evidence/prepare80.json", + "mode": "100644", + "gitBlob": "ed0855b11765dd4c099e49f137273c6b28a17532", + "rawBytes": 127479, + "rawSHA256": "b2e4fecabf82cfbb9e04fe4732b3fc9f0e59178faef22306d6e09e8e0382bd10" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/evidence/selector9-final.json", + "mode": "100644", + "gitBlob": "cbe2ceb9432f1586499d06f67dc5dc2030da9eac", + "rawBytes": 20351, + "rawSHA256": "a9ca2c1bb3ceda7ce2834adb5109dc0536815aa3e655b5c95e8602d72461e0b4" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/evidence/selector9.json", + "mode": "100644", + "gitBlob": "2895c7b7dba8da08cd406207e55bb2a8b2dfc6de", + "rawBytes": 24907, + "rawSHA256": "c4c5301a38d52bfb88a525fe1111a78b2f5598b1df4a9358ecd5e6232e91d13a" + }, + { + "path": "docs/internal/extensions/opt1/certificate-replay/evidence/uncaught-boundary.json", + "mode": "100644", + "gitBlob": "b845007c7087a632e4b51258b50d1d41030190d1", + "rawBytes": 2821, + "rawSHA256": "9e089837103fb2a1d968789c46725f61d7b312744265e13ad376aedcabaae507" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-build-snapshot.json", + "mode": "100644", + "gitBlob": "169622f89d468902a1328a8faf22f9529095445e", + "rawBytes": 424, + "rawSHA256": "04ae861a4c82af33dd59849287dec4f48e34e1ba61f31c8388be03e1d04ce09d" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-claims.json.gz", + "mode": "100644", + "gitBlob": "0fae86e162e6f220a31d747520d45e1620788fdb", + "rawBytes": 11761, + "rawSHA256": "08167e54224598f390183a4ee2038ed8a69bb2e72cd52c5b3bb8506474c9c141" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-committed-design.json", + "mode": "100644", + "gitBlob": "4013ef9ec5deea669fa145690d6c9e71878ea3b7", + "rawBytes": 589, + "rawSHA256": "bafa5c9497eabce97a1d056382b7cf958f707aac094f772e7733ff0e14cdc90c" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-committed-whitespace.json", + "mode": "100644", + "gitBlob": "54c0eead4715bb094c6b886222dd94e1ab60872e", + "rawBytes": 372, + "rawSHA256": "fc37e45574095d4e0121759a46511bd14a6af3ca1660aed5a1133617ccf7dcce" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-design.json", + "mode": "100644", + "gitBlob": "71ebe17e3f16d184b8c85b50023f1e23e31fcaa0", + "rawBytes": 568, + "rawSHA256": "a5a3c2aad2a1e2273ff15d384b0f138ff02f881d72a0afa2ec4ac56b66ef0b57" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-frozen-row-check.json", + "mode": "100644", + "gitBlob": "416725a794e0ccc27eb7d95ed2834c4361f6ef0a", + "rawBytes": 311, + "rawSHA256": "4f52fcd1d9d8ea212a8b3735e9c477cc7f2e249ca84920989fdb93078b6d0318" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-native-trust.json", + "mode": "100644", + "gitBlob": "71487dd5d5376ed1f839a2337d50b3b96c783d85", + "rawBytes": 310, + "rawSHA256": "c80b8bab7acdc4394fc1b66923798686a38fdbe4d509ea7b720074c05b8b13b9" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-phase-design.json", + "mode": "100644", + "gitBlob": "5c9d14840b1616d2ce37337f143511cab1940139", + "rawBytes": 585, + "rawSHA256": "7a82e852e03320fed52c5fc8b971c4fb046b290b2c16b5a8f3250ed2f397f195" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-report-claims.json.gz", + "mode": "100644", + "gitBlob": "4dbace32334765620f1ee094405b12c11e2c5ad4", + "rawBytes": 3724, + "rawSHA256": "718e2fa06ab7547546d5647b0a02536c11abc81fd0a916db2f6dc890754bfc41" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-report-design.json", + "mode": "100644", + "gitBlob": "ad93f155cbca988e0190fdab5e8dd3530024716c", + "rawBytes": 544, + "rawSHA256": "b252537de31cca61c0f59e7517302da86f4e8fd1c3287e8874071025099d9b35" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-source-manifest.json", + "mode": "100644", + "gitBlob": "363a1255d084e9a04b37c5f3b91c864a10e8a0d1", + "rawBytes": 3447, + "rawSHA256": "c5befb4a98e2a66fbb1e7597e8a22550b2e3a4712a6bede1b113efbdf4a554aa" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-trust.json", + "mode": "100644", + "gitBlob": "92fbc475a3bf7e00b29b00bcac7f86d88845559d", + "rawBytes": 390, + "rawSHA256": "15d186460818d17dc5cfb1ede5afcecd2998a23dd60ab071cf289bc22794e881" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-verification.json", + "mode": "100644", + "gitBlob": "833358983e832f377c395900737a43355ba08471", + "rawBytes": 3149, + "rawSHA256": "cb1963cef206f5caecd05466da4d2ca2f7ed684a7ba8c6100dd86e44d973bcf3" + }, + { + "path": "docs/internal/extensions/opt1/checkpoint-whitespace.json", + "mode": "100644", + "gitBlob": "0a57d1e62ed751042f56d2b0a095d8006d4cfd71", + "rawBytes": 424, + "rawSHA256": "3f6e286da95d014e9f3c6be7dbc67c472b9bb573d8afa481455838376b969fc3" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/20260912-084823-803-Compact.json", + "mode": "100644", + "gitBlob": "f3b4b17b8dc30c54b917b56f9236b2fba9b7b7c3", + "rawBytes": 895, + "rawSHA256": "7afae6ba26d203b4a912fc66c856e1f398b8aa65b0c72edb5fafe9247ac29c45" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/20260912-084901-469-CompactProof.json", + "mode": "100644", + "gitBlob": "dc2d2203d0fa5e9a89309affa3713a0535c91735", + "rawBytes": 4506, + "rawSHA256": "4279c74414260141f185461d4d3f2e1478f403b1e7a81c9d8690eea637d640e6" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/20260912-085040-423-CompactProof.json", + "mode": "100644", + "gitBlob": "dc45b16f48f7320e1be6d2a289c8440b0321e8cf", + "rawBytes": 2571, + "rawSHA256": "fdcf0a010ef71bf76958441531a36393a204822f152f3c9edcfe893a17e956f5" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/20260912-085200-649-CompactProof.json", + "mode": "100644", + "gitBlob": "2363ef8d9c0500880a2956ade10ff5a896c354c1", + "rawBytes": 908, + "rawSHA256": "562af6a0a915f68f436523e93d070c622aa12f466855b423e1ee09fc94abcb62" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/20260912-085248-004-CompactSafety.json", + "mode": "100644", + "gitBlob": "272b1fa495cae1929802f68540137e9cd72c49a0", + "rawBytes": 1447, + "rawSHA256": "59a09bf8d0bd6693d776d199ed40b03ec5fcafd725f1082cc36eb53ee66a6240" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/20260912-090310-823-CompactSafety.json", + "mode": "100644", + "gitBlob": "3397478fdcc4d11e01b7743a603bfef1a9c0d265", + "rawBytes": 912, + "rawSHA256": "7f79cb02a40f01afad43965972df4683c8f1b648325733562edd53520ae47a49" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/20260912-090340-416-Axioms.json", + "mode": "100644", + "gitBlob": "dc13facb14702bd6a7596281cdda2a5d15f41f17", + "rawBytes": 5649, + "rawSHA256": "f93aa3a26b117ab1e73e0e38aa1ec7b0dc73b000cccc49267cd66b2bf628e889" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/Axioms.lean", + "mode": "100644", + "gitBlob": "8eced0c19d2b6935b2f3dc64b9966774f14ab724", + "rawBytes": 1466, + "rawSHA256": "727e2c58c62040b3c5800219fedde8b566ff3ea2d5c49b12546612f66ef2935f" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/CERTIFICATE_SOURCE_REVIEW.md", + "mode": "100644", + "gitBlob": "31874cbbfa23d50f1d73a99f911870965f947a9c", + "rawBytes": 2580, + "rawSHA256": "92654fc7d2b5720c8a40ee2e26b2461377a53680b830033feca0f64e6e32b5ee" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/PLAN.md", + "mode": "100644", + "gitBlob": "f3bed146a135b3dcc8d2582737a15b63f8c84a75", + "rawBytes": 2584, + "rawSHA256": "4ae090c92041861ec7a63d2b7f69440474c4fbfea36ead561d95498bd7df633a" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/REPORT.md", + "mode": "100644", + "gitBlob": "01b860f56d432053ff667f71a740126b3bf3e249", + "rawBytes": 18304, + "rawSHA256": "3239e7eadf1e0e2aa03abd96aa9dc5bd2f305c4c7be6c7f7a1ad3c8e1cf9ce6b" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/RESUME.json", + "mode": "100644", + "gitBlob": "77088bab230c467df2f2d116fb2822a707d8394c", + "rawBytes": 884, + "rawSHA256": "8f51968010d6ce363b72c4fc8510a0ce4c46e796872b9c8fcb76163816fd5695" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/RESUMED_DEVELOPMENT.md", + "mode": "100644", + "gitBlob": "8fd8ae853ad34108d8444b13838cb35589497eb6", + "rawBytes": 3356, + "rawSHA256": "eae19a4ad99fb2b3e7e86b6030a5916b896ed34be1074ee90f1b5db1fc381858" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/certificate-source-review.json", + "mode": "100644", + "gitBlob": "e7409051cd704df0cc63e28dc43bf917266eddc4", + "rawBytes": 425, + "rawSHA256": "ae6be09aef5867926eed53871da2eab02edb6ac78334ac4f2b4dc0532cc6c63a" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/check.ps1", + "mode": "100644", + "gitBlob": "5c11dbdaacaa7a16bb8c382a93391d0a0e90a864", + "rawBytes": 2380, + "rawSHA256": "08422a0a46060f662dfc22675282cccbf6c5fe98a415c7366988cb069330513e" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/final-leaf-checks.json", + "mode": "100644", + "gitBlob": "986b39ec3abda768e5601dfe7cc87322eaf2618c", + "rawBytes": 3377, + "rawSHA256": "f3e20ed546ece012062a99eb856613df5e09559bca67abd79930fbd2ca838cbe" + }, + { + "path": "docs/internal/extensions/opt1/compact-proof-development/phase-static-checks.json", + "mode": "100644", + "gitBlob": "e2285e7ee5967ff12dad9e3a97d13540ae789f67", + "rawBytes": 425, + "rawSHA256": "6743c04b38f81ec56ec0d57cedf936d9fa557ecf5cb46f44eab3028e1c15b72d" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/20260912-085342-909-CompactStatic.json", + "mode": "100644", + "gitBlob": "9d9e2aea9e1ceb88f90457a19724d693f2b11095", + "rawBytes": 5604, + "rawSHA256": "421330afadf3460947326d3cfd2293c00f86c496300ed44483c47b49d225943d" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/20260912-085459-926-CompactStatic.json", + "mode": "100644", + "gitBlob": "e5b34d2c418870aac2c7b0385d54ad5eb0819b49", + "rawBytes": 908, + "rawSHA256": "fe696b23bb8ad9e1f82f34c04dd2cfed288123d0f263eadbd279f19b7fe892c3" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/20260912-085506-634-Types.json", + "mode": "100644", + "gitBlob": "919eb3a8dada239c3536458e306a50afebe6dd73", + "rawBytes": 14437, + "rawSHA256": "19356b94b9ad3a6c8316467255f2758d02f14004aeb228a4c1af23456fd9d58c" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/20260912-085620-197-Query.json", + "mode": "100644", + "gitBlob": "70155a96a334c27eb380dd8f436286c40f9f6451", + "rawBytes": 2935, + "rawSHA256": "0a71ca87be84a7b3f09300708006066c37b63536d9dc994a4bf1b12e455b3045" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/20260912-085823-722-Query.json", + "mode": "100644", + "gitBlob": "e39ed459c830f1ae11507052f4cb3abfa525ffaa", + "rawBytes": 884, + "rawSHA256": "4b7a66d6e0022e9defec7ab6564b504847a406a79cc1bc24ac61ee0c8004b4d8" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/20260912-085851-734-Measure.json", + "mode": "100644", + "gitBlob": "22c9c568c941ebb743646ad5c6c89d2d03d857dc", + "rawBytes": 1526, + "rawSHA256": "9712e297c60eb5c8acb75eba3ec3014b3cf288753d5aeefc0bc25419acd4fd66" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/20260912-090142-761-Query.json", + "mode": "100644", + "gitBlob": "62fee6ade232109db2e917f330e6647854f1bea8", + "rawBytes": 884, + "rawSHA256": "fe9e2febc97b6e5c59d3433ee3ede1bdcd0ca03aec8e733fdc4ff28fa4cd106f" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/20260912-090148-784-QueryTypes.json", + "mode": "100644", + "gitBlob": "c8fd47fbb0e4e521b83cedba30700f6d22cc2b8d", + "rawBytes": 10976, + "rawSHA256": "fe18bf368397fcb26b11267210b9ed708a7f3cf790395dce0d7dd80b2c46b3d8" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/20260912-090227-589-Measure.json", + "mode": "100644", + "gitBlob": "849950f2ffd88755587edc009db1bcdb61b85923", + "rawBytes": 1528, + "rawSHA256": "780a78c18cbca37bf789e0fd1ca5845fdd65d4c278749641df4697582ca2f8fb" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/CONTRACT.md", + "mode": "100644", + "gitBlob": "6e0056a8585797b14633fe41e1c6a2392898bf6b", + "rawBytes": 6628, + "rawSHA256": "5ff9ac6b1a64f64320b3ae2f45ca8585cdc6999f13d9ebcaff482c6d91c22b59" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/Measure.lean", + "mode": "100644", + "gitBlob": "3972ba630c8c04334bc041a025e12d5194e60ec4", + "rawBytes": 969, + "rawSHA256": "8df1007bb02c218ebc4f04c56b46f90c03d486bd59727c1be485ac1c9aa434aa" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/QueryTypes.lean", + "mode": "100644", + "gitBlob": "1f56d6ad857e174cb816e82e64f9870a5304dd50", + "rawBytes": 1361, + "rawSHA256": "19eca8b5fe4478dc99dadd8ce03ba3777cffdb97486cc6ae6eb4430abcab3159" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/REPORT.md", + "mode": "100644", + "gitBlob": "4f5fa21952ed36377bf47f5f328bf33985d723ed", + "rawBytes": 13704, + "rawSHA256": "dee26e3f2c8b90f87c9ff9d4b9d3f9e8663e8dffdc066c9faed0fa903d797b0c" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/Types.lean", + "mode": "100644", + "gitBlob": "c4a311a494a6b1d18f32e5e5ac2488d3b8eb2427", + "rawBytes": 988, + "rawSHA256": "06495a99fb8d5c825b5b3718cf82887fc29595e029380835158fff42c1aaca24" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/check.ps1", + "mode": "100644", + "gitBlob": "a0ba77d50fa2cd521e5c703e312734989dc04c1c", + "rawBytes": 2068, + "rawSHA256": "03f3017ad766a9b2d194c58692fd304481b40c5a0ba10ae094272df3a55bd666" + }, + { + "path": "docs/internal/extensions/opt1/compact-static-development/hygiene.json", + "mode": "100644", + "gitBlob": "fcb6c1765b6739b9843504bf466bfbadabc36264", + "rawBytes": 1488, + "rawSHA256": "781e058040a8fe4061c2cf2f28c52b21c0cf24f736112d68419346ee9f996b6f" + }, + { + "path": "docs/internal/extensions/opt1/composition-checked-manifest.json", + "mode": "100644", + "gitBlob": "8eee99fcda53122ed6cce566a4051e2e43b3915a", + "rawBytes": 1584, + "rawSHA256": "f03f3263e6957895ead692c09336c98295b983375ec3b74c14215ac7cef18e45" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/20260912T0909250020255Z-axioms.json", + "mode": "100644", + "gitBlob": "c57f5ed18279ace9964c8a96cd80aebf7e2a2368", + "rawBytes": 23017, + "rawSHA256": "f1c2dc0f11cbda559d47ace223a5c0806629a76399a768b9c751e13643f7c4c2" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/20260912T0922141726079Z-axioms.json", + "mode": "100644", + "gitBlob": "8a897c23ab987efee67cf7732e39a917b5826d12", + "rawBytes": 52220, + "rawSHA256": "8e8e84af416aaace4328706c360210b4a48e24d306deba20dcf057481d4ecfd8" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.Capstone.20260912T0904477547021Z.json", + "mode": "100644", + "gitBlob": "415ca4349b8892f64d5844c438b53287f8cb0f52", + "rawBytes": 1425, + "rawSHA256": "23bc4401036411f7b453b34f8eef86c42c514e947d088968327e64542d637c89" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.Capstone.json", + "mode": "100644", + "gitBlob": "415ca4349b8892f64d5844c438b53287f8cb0f52", + "rawBytes": 1425, + "rawSHA256": "23bc4401036411f7b453b34f8eef86c42c514e947d088968327e64542d637c89" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.Certificate.20260912T0904184780573Z.json", + "mode": "100644", + "gitBlob": "b0bd8dd73100fe945e59f3b59b53474dcfec80eb", + "rawBytes": 1436, + "rawSHA256": "83eae680d8e3cf57bb0a7f02561883bc82577d651d0e7628c5b221fe5a76a26a" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.Certificate.json", + "mode": "100644", + "gitBlob": "b0bd8dd73100fe945e59f3b59b53474dcfec80eb", + "rawBytes": 1436, + "rawSHA256": "83eae680d8e3cf57bb0a7f02561883bc82577d651d0e7628c5b221fe5a76a26a" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.Consumers.20260912T0904550751995Z.json", + "mode": "100644", + "gitBlob": "166a894dfd994882fc928efc74c5d77cb2054988", + "rawBytes": 1428, + "rawSHA256": "a99865249022a28cff6831744bcbd1521d304a7b6a49413922bf69c5d14c2b8b" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.Consumers.json", + "mode": "100644", + "gitBlob": "166a894dfd994882fc928efc74c5d77cb2054988", + "rawBytes": 1428, + "rawSHA256": "a99865249022a28cff6831744bcbd1521d304a7b6a49413922bf69c5d14c2b8b" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.QueryProof.20260912T0904107871054Z.json", + "mode": "100644", + "gitBlob": "902a79d976572ff8df611e8ec4470add495bb622", + "rawBytes": 1432, + "rawSHA256": "ba05922219808e78c74eb9232dea3e2476d08048d2b21fea34f49d38a74d4eec" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.QueryProof.json", + "mode": "100644", + "gitBlob": "902a79d976572ff8df611e8ec4470add495bb622", + "rawBytes": 1432, + "rawSHA256": "ba05922219808e78c74eb9232dea3e2476d08048d2b21fea34f49d38a74d4eec" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.QuerySafety.20260912T0904137135959Z.json", + "mode": "100644", + "gitBlob": "c75cecbd31885ba7a09aad2781077352553c7d23", + "rawBytes": 1436, + "rawSHA256": "6408e084c7eba6f163dde0e5d5d097810eeddbf4835c8a7a57c2b1c85592a9b0" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Optimization.QuerySafety.json", + "mode": "100644", + "gitBlob": "c75cecbd31885ba7a09aad2781077352553c7d23", + "rawBytes": 1436, + "rawSHA256": "6408e084c7eba6f163dde0e5d5d097810eeddbf4835c8a7a57c2b1c85592a9b0" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Packed.ArrayRun.20260912T0907263701277Z.json", + "mode": "100644", + "gitBlob": "de2ed5960461ecb5ec1bf81a009c26688f5fb12c", + "rawBytes": 1400, + "rawSHA256": "2fc6881d3579267b1540f8f6a51406b5056d4394bad1dccb28834f2f5ac1f63b" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/RMQ.Core.WordRAM.Packed.ArrayRun.json", + "mode": "100644", + "gitBlob": "de2ed5960461ecb5ec1bf81a009c26688f5fb12c", + "rawBytes": 1400, + "rawSHA256": "2fc6881d3579267b1540f8f6a51406b5056d4394bad1dccb28834f2f5ac1f63b" + }, + { + "path": "docs/internal/extensions/opt1/composition-development/scheduling-overlap.json", + "mode": "100644", + "gitBlob": "cccd889a1f2d69b749bdd009899da9fb116f2fe0", + "rawBytes": 1137, + "rawSHA256": "e9a2253e539ef1d1278f116bb5d0c45081df26eefd1516245ef014915130257d" + }, + { + "path": "docs/internal/extensions/opt1/continuation-entry.json", + "mode": "100644", + "gitBlob": "49e9bfb3dcd2832f08792ad96405d381248aea0d", + "rawBytes": 824, + "rawSHA256": "014f6dff932f672d844c8356af342a012a6e48c70c9cacb2a23f665787bad352" + }, + { + "path": "docs/internal/extensions/opt1/final-evidence-identities.json", + "mode": "100644", + "gitBlob": "8f116678395084dba455e2a03274cfb52677da52", + "rawBytes": 1306, + "rawSHA256": "82d15a8ba8b269e591cae01eeda2d787123db5568d94a2f32c1777a5a17728bb" + }, + { + "path": "docs/internal/extensions/opt1/final-report-before-storage-claims.json", + "mode": "100644", + "gitBlob": "90e6089a88717a56f9fb68d2542881faf216f472", + "rawBytes": 762, + "rawSHA256": "bac4a2bfa2bdf2c428c6323de0cbb61a6a4bc4b51bc248d7f9b0e1a625346f0d" + }, + { + "path": "docs/internal/extensions/opt1/final-report-before-storage-design-base.json", + "mode": "100644", + "gitBlob": "410865ef2d90360c1203173cd43f4ccecec8dbf7", + "rawBytes": 647, + "rawSHA256": "75b0103370bf4d78f900e7b0ea336847e26db7ba8de90666d44146a687ef30e3" + }, + { + "path": "docs/internal/extensions/opt1/final-report-before-storage-design-phase.json", + "mode": "100644", + "gitBlob": "099fc61d39ade54a165913c4c2de9ef0c3df9cf3", + "rawBytes": 645, + "rawSHA256": "eee3b65442c7f5620bceb7d28d88795a5338fa1ba83115358a30b070c641d136" + }, + { + "path": "docs/internal/extensions/opt1/final-report-before-storage-whitespace.json", + "mode": "100644", + "gitBlob": "484a74b92e4d25732c1fbe07333623809c3eb7a7", + "rawBytes": 387, + "rawSHA256": "d2f94d08a72eb97cf489fc9dcf844b91b272b3c25ac8622efd3a5e5668a37ab5" + }, + { + "path": "docs/internal/extensions/opt1/final-report-claim-check.ps1", + "mode": "100644", + "gitBlob": "60209b954bdca870141958cf0c6f1fccafb9b731", + "rawBytes": 2499, + "rawSHA256": "30f083ca9c59b4397e2879b69d89241432e29c0ac8c33590a5803f130668429f" + }, + { + "path": "docs/internal/extensions/opt1/final-report-claims.json", + "mode": "100644", + "gitBlob": "543b3e23e81be5bbbcff7847203b1baabc3fa44d", + "rawBytes": 1242, + "rawSHA256": "e1abb075a6761c3704f2692750f1748a63eb47ece9533324524d96f475bbb152" + }, + { + "path": "docs/internal/extensions/opt1/final-report-design-base.json", + "mode": "100644", + "gitBlob": "66f063f4b046851d95178bcfaec4ba429b0963a8", + "rawBytes": 684, + "rawSHA256": "5493b1b594c865453689c0453d574e9662467a58a928b0b8248d80b4d2d15547" + }, + { + "path": "docs/internal/extensions/opt1/final-report-design-phase.json", + "mode": "100644", + "gitBlob": "10df1327fd3e01f736ec4f99fe97bf654e8ecb33", + "rawBytes": 682, + "rawSHA256": "3accff510040f90091ac6effc872c2df156ecf3b9e8724a037c51c39fb2d2703" + }, + { + "path": "docs/internal/extensions/opt1/final-report-hygiene.json", + "mode": "100644", + "gitBlob": "aab64100860cd228030f9bd902cbee4d44819313", + "rawBytes": 363, + "rawSHA256": "fab0d5e37b57b301f9e424b5f4c6ce5b930d3e6bbe5d5ce7ffb674b828e5be05" + }, + { + "path": "docs/internal/extensions/opt1/final-report-index-bytes.json", + "mode": "100644", + "gitBlob": "eadd023731b30598b073375b9d8f3c50556fa676", + "rawBytes": 2275, + "rawSHA256": "06d4e94b6e69ba7736ba6521922a4f71f3b476e03da8eb504cc640786a9c1a9b" + }, + { + "path": "docs/internal/extensions/opt1/final-report-index-whitespace.json", + "mode": "100644", + "gitBlob": "24a4ddfea3de9bd653d52f3e84bc4445ffab6eb2", + "rawBytes": 505, + "rawSHA256": "e3bf5feca3b8b7d9fd798066c41767791331bea7997b999dc88c982b2d7f0b48" + }, + { + "path": "docs/internal/extensions/opt1/final-report-storage-whitespace-first.json", + "mode": "100644", + "gitBlob": "8ca9d3fe1134a254924f78d112ad3ac3c3919c9a", + "rawBytes": 489, + "rawSHA256": "f6d62405df797cb6cf0d19518e6708c5d3de063d2d8211b949dc5cd4f3343319" + }, + { + "path": "docs/internal/extensions/opt1/final-report-storage-whitespace.json", + "mode": "100644", + "gitBlob": "6df6613d743bfc6e7ef88a9490eb994b83b7e3d4", + "rawBytes": 361, + "rawSHA256": "f00db22ce9d17d37d8115000bef33219acfb9986c475588744baf49bf8bf3cc5" + }, + { + "path": "docs/internal/extensions/opt1/final-report-whitespace.json", + "mode": "100644", + "gitBlob": "04fa0595a8793c0b859e869d55efa3cb855f2fc2", + "rawBytes": 399, + "rawSHA256": "745c78ab1141c8333cdbfddbc144b86a381ceb89d14574ccbb8e63f81b0eeeea" + }, + { + "path": "docs/internal/extensions/opt1/final-source-manifest.json", + "mode": "100644", + "gitBlob": "5c718ee22a5b7a2f4cb0800e229a864e962226f7", + "rawBytes": 9411, + "rawSHA256": "41f867cb8bdba0ac528974842a131853574e5b5bb66361a5eb9ceeaa75a5608b" + }, + { + "path": "docs/internal/extensions/opt1/freeze-claims-attempt2.json", + "mode": "100644", + "gitBlob": "7652e2e38705107c1a3ca25f2285461c7ec8e16a", + "rawBytes": 711, + "rawSHA256": "c455bf7d69a6719ce8fade81d29b94105c101f753a2968c3638ece6ae6da80a5" + }, + { + "path": "docs/internal/extensions/opt1/freeze-claims-pass.json", + "mode": "100644", + "gitBlob": "8c49dc5348bf6a743a9d36fb9aaf5f26efd82891", + "rawBytes": 484, + "rawSHA256": "6b7e373fd244252c1189ae0eb3cdd265f45c48f14e2cd862cfd4522a7d44564d" + }, + { + "path": "docs/internal/extensions/opt1/freeze-claims.json", + "mode": "100644", + "gitBlob": "eabc08c5f28248eb43b3fd6bf0a7c5cccc20b569", + "rawBytes": 835, + "rawSHA256": "f9aeabf228081df4cb95ca6cc6901d8276f956347adf335a4573567c4dc0baee" + }, + { + "path": "docs/internal/extensions/opt1/freeze-design.json", + "mode": "100644", + "gitBlob": "0f68730eac79f68227c2c847c36917c05b3836b0", + "rawBytes": 518, + "rawSHA256": "73e4cc9da66cf41b9e69feddb1c656e3e20779e47259a6c287e99af803507823" + }, + { + "path": "docs/internal/extensions/opt1/freeze-native-trust.json", + "mode": "100644", + "gitBlob": "ea0e827fe53d266a9e766ee7abb605b5f45bf8f2", + "rawBytes": 120, + "rawSHA256": "4046aec39a9489a8b4d83ba9994b9e39250e8eeacb03e005b94e69cb35292616" + }, + { + "path": "docs/internal/extensions/opt1/freeze-source-manifest.json", + "mode": "100644", + "gitBlob": "4df002e53576e7e63b24035e35144344c6aa6640", + "rawBytes": 3778, + "rawSHA256": "96700be0f86dbf7add1202380cafe33360d2297f54f8f2335cbb465d08e7103a" + }, + { + "path": "docs/internal/extensions/opt1/freeze-trust.json", + "mode": "100644", + "gitBlob": "c8c5fb79528344f8ed05e0c84815ed18ded9b55b", + "rawBytes": 120, + "rawSHA256": "0b6e7fb93852d5ceb7022f5dccff39f42b661164b4b760ee6d6f34fa49253e7b" + }, + { + "path": "docs/internal/extensions/opt1/frozen-row-check.json", + "mode": "100644", + "gitBlob": "d9d937d0b9068009b2c96bc074eccafa0f534063", + "rawBytes": 1185, + "rawSHA256": "0f9aa7e67576c7cd62c7b616bc7a99c27d9ae4d4a9bafbd73e25c321d434e5c6" + }, + { + "path": "docs/internal/extensions/opt1/import-repair-hygiene.json", + "mode": "100644", + "gitBlob": "7ca895bd081903a25390458c6832b475e216b2ca", + "rawBytes": 338, + "rawSHA256": "af74d3f0921c4b02b341bb80b06fdf0ee335057815eb668bbcacef9b51c56686" + }, + { + "path": "docs/internal/extensions/opt1/import-repair-refreeze-claims.json", + "mode": "100644", + "gitBlob": "6e1e6f2e3d0221f0878a18685d29e81192e680ef", + "rawBytes": 563, + "rawSHA256": "84c44752b086cad72abdd715a11bb6f17deba856c05378c79e59c28d06784a56" + }, + { + "path": "docs/internal/extensions/opt1/import-repair-refreeze-design-base.json", + "mode": "100644", + "gitBlob": "f394b8d16b5eb829698f5cd641ae97a96be8b53f", + "rawBytes": 647, + "rawSHA256": "5d9893a7c3e5aa4ae54628117e7b5629a73c99dae286a1afb72ae4a96b9afafd" + }, + { + "path": "docs/internal/extensions/opt1/import-repair-refreeze-design-phase.json", + "mode": "100644", + "gitBlob": "cd7afb2444cec0d8b4e36605b69cf5beac6bffa2", + "rawBytes": 645, + "rawSHA256": "3d1bdb4b32748a5474d0658054e2a3ef2291a9fd887c7333a1d9427b6d825785" + }, + { + "path": "docs/internal/extensions/opt1/import-repair-refreeze-whitespace.json", + "mode": "100644", + "gitBlob": "6856b5661f5966d364f3c4f0a81e2b16225631c0", + "rawBytes": 386, + "rawSHA256": "841596819014c1cd21441dbf8c776cbc177f3d841ab4f9ad20b3061cf8ab309c" + }, + { + "path": "docs/internal/extensions/opt1/import-repair-source-manifest.json", + "mode": "100644", + "gitBlob": "9aa4177063eb13717c9482772390fc551c4b636d", + "rawBytes": 4763, + "rawSHA256": "8143b412b8cbeb6c90c8ee00fb17762fa708a47831207913fed9c0a3f5fabc5e" + }, + { + "path": "docs/internal/extensions/opt1/local-final-scope-check.json", + "mode": "100644", + "gitBlob": "8317750eab45995f58973e78a69a81e762072714", + "rawBytes": 415, + "rawSHA256": "3e0617f0025b6f1646283a3692180fa5319b7767fda9aec8ab22ad96c5988475" + }, + { + "path": "docs/internal/extensions/opt1/query-build-plan.json", + "mode": "100644", + "gitBlob": "e405d726e143e3596a6ea2fc20b496bb7319a988", + "rawBytes": 12999, + "rawSHA256": "799c039592ddd8d42293bed5f94aeb4846edc113ffdbb8ebf60e17d48cafa4f8" + }, + { + "path": "docs/internal/extensions/opt1/query-development/BranchCapstoneChecked.lean", + "mode": "100644", + "gitBlob": "33394feababc91b760f64cd1d44c680f751496c2", + "rawBytes": 4034, + "rawSHA256": "f56c0d5d62b0ba4e480108bae36cc11cae5f3cebf4772efda813d2bb4dbb2d65" + }, + { + "path": "docs/internal/extensions/opt1/query-development/LAUNCHED_BUILD.ps1", + "mode": "100644", + "gitBlob": "5fe81d41eb776c3c0c39b836ac9997bc86708b96", + "rawBytes": 3292, + "rawSHA256": "c6a5a2fd340fbec6eef66d1e014b28719f81dffd5498cbbb5f50ee13c22f5e33" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Backend.json", + "mode": "100644", + "gitBlob": "fc8b37f478652827d44f6e9bc1883c2c78a639bf", + "rawBytes": 1332, + "rawSHA256": "f552eba7694cc8beb494c2ccbc27871e87bb2bfb7c974ec0ca91275de6dafd59" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Cartesian.json", + "mode": "100644", + "gitBlob": "b39da338e9d4ed550ed7d73cbed4604c9a2d5626", + "rawBytes": 1341, + "rawSHA256": "576ffb263966b0fbe7fd2ef75ac59c17d951e0e994d9db7a8b26fb1347863392" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Cost.json", + "mode": "100644", + "gitBlob": "7143d9bb0d7338073a64b2250416d0e121fd8862", + "rawBytes": 1319, + "rawSHA256": "3307ea82d5cd1ab3ab50100add3850165c13f156435e6380c04238b5eeda0e23" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.EncodingLowerBound.json", + "mode": "100644", + "gitBlob": "d2b93cc6a8ade999714c27398a0a76ef0580b23f", + "rawBytes": 1376, + "rawSHA256": "09fa3092e5de54b04e373ae277d7ea368c5b318deeff9af10c4a728f7b196ed7" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.Arithmetic.json", + "mode": "100644", + "gitBlob": "c3c591a49b17b748698d7d578929b785e837b7a6", + "rawBytes": 1402, + "rawSHA256": "305ddc7722cbbc3bc514f3162abedc71ef48f2f0f16901ef03d52c6034fb48b7" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.DenseEntryTable.json", + "mode": "100644", + "gitBlob": "ff4c670218916970ba0f0df6aca6744fbdbbdd5c", + "rawBytes": 1421, + "rawSHA256": "20c0325f4957a136bcfc045b52d137a1e4c56e1f3f61654128c79b388616e594" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.DenseWord.json", + "mode": "100644", + "gitBlob": "d005994b40833eabbf4dfeaf4b8aadcfa48f8db6", + "rawBytes": 1398, + "rawSHA256": "ab9f876246c881a74f216ac68c7da905be0db60ee6c90078b768f8ea5b586072" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.Directory.json", + "mode": "100644", + "gitBlob": "7a39177e03b686e0715d9df0f48d33a29604f01a", + "rawBytes": 1398, + "rawSHA256": "60f22b9378d56e1fd6de78b3d52c7392c91f559aeb56405d2754996d601527b5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.Entries.json", + "mode": "100644", + "gitBlob": "eee679f21b55c07bd474ec93db36bfcd7979691c", + "rawBytes": 1390, + "rawSHA256": "6c2dc392b4ce382977cc42434bb98525848bad1eff340fe118ba8b60fa8e4a06" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.Family.json", + "mode": "100644", + "gitBlob": "6d66a6d1c2eb9750c8421fe926ae406ef23d83e5", + "rawBytes": 1386, + "rawSHA256": "91f5f033935c02cd9d2f1cd4db868091dbae57dd79ad8c9c6256e7d1c4db9b5d" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.FlagRank.json", + "mode": "100644", + "gitBlob": "abb06712fa224f3dce352570b9b5c070773d2c67", + "rawBytes": 1395, + "rawSHA256": "6782ca57fa4e8fbd4faa236afe3d9fa9c108e3dbdc8205b7d0a2b8842aa92641" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.LowLevel.json", + "mode": "100644", + "gitBlob": "df6ae7f22e6b51e69d5fab6e3567d5435ddf3c31", + "rawBytes": 1394, + "rawSHA256": "7ce68787b168f7aea023564d781d805745b06cd5fdcf65404cf8760a2422c308" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.Params.json", + "mode": "100644", + "gitBlob": "3f99157c3fd58086bbbeaa27644a11292fc098d9", + "rawBytes": 1386, + "rawSHA256": "a03ab8a2aa91035fa3558adc197223a295d2c0eff9b9745a3b41d1f32516a394" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.Primitives.json", + "mode": "100644", + "gitBlob": "10a7836a0f5d23a9b5158e2d75320e2cf18b8110", + "rawBytes": 1403, + "rawSHA256": "20aa4aed043cad0e989c317d4d657cd0be95c799aa61484fb9d9957497897169" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.RAM.json", + "mode": "100644", + "gitBlob": "39d1df7eec47042f3d9110afbf6fbf5b263b675a", + "rawBytes": 1375, + "rawSHA256": "5ff389cf709189694f43f3f38f3ff24e4ae9714293b12aea1a9ca5bd9e0fc4f5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.RAMStoreParam.json", + "mode": "100644", + "gitBlob": "209a678afae4b7cb78a066639a4494fe6a3362b6", + "rawBytes": 1414, + "rawSHA256": "159bd2a552ce41e98c2c2074603cc9cac4ac8f06cdaac24ea3bae6b62b9acb9b" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.RelativeSplit.json", + "mode": "100644", + "gitBlob": "b87d962f1530867c92243c86343504b7d1e4b64a", + "rawBytes": 1414, + "rawSHA256": "bca933cc2f8a05b0da672c5c713786e3329987f81e381b5b908f05737963bf4c" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.RelativeTables.json", + "mode": "100644", + "gitBlob": "bfd45589057a82e0f8e11312c8b426a3d02103ad", + "rawBytes": 1419, + "rawSHA256": "1ff092e5f06ff7564107341e6b74db309d9700b2bbf733418de2d944c1c120ab" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.SelectFacts.json", + "mode": "100644", + "gitBlob": "f46aaebffbb564f5e162dd351af1a1308235ddaa", + "rawBytes": 1406, + "rawSHA256": "481eb52ff7d42ba8276219d6ec34731ebd21e267f54ad22423e1b4e83af33832" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.SelectSource.json", + "mode": "100644", + "gitBlob": "19618c2f0e437f845d03dd1c50bdb0ba5b78128c", + "rawBytes": 1410, + "rawSHA256": "26d124d13ac84d0f8b1812b01134488998050433a85d066f3bf89af9348346a2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.Slots.json", + "mode": "100644", + "gitBlob": "27be1523f43b10c3e726b39a82e2d71187aacef3", + "rawBytes": 1382, + "rawSHA256": "86f0569a02c5033dd113a64943d34cefd726517d6bee586d0b5f6284f86474ec" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.GenericSelect.Source.json", + "mode": "100644", + "gitBlob": "7b4392eb0e386cee47a492e14d86f01aa969d4fc", + "rawBytes": 1387, + "rawSHA256": "50323db24cd8f4df8fd1f7b067cf1210b57d1c24f85a0033aff356e47cfbda79" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.LCA.json", + "mode": "100644", + "gitBlob": "6eb3dd08cc636eda63bafc794f04e3f7d2599068", + "rawBytes": 1317, + "rawSHA256": "05855e1541726693d26b2616e12dae17c10ed209672d6bf6b9a9dcf0eec93b54" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.ListLemmas.json", + "mode": "100644", + "gitBlob": "28b9af5f992ab2e69cd9477d9537d2b6aa07179c", + "rawBytes": 1344, + "rawSHA256": "780d6c1feef1e4d6e1341ed5d73b9995f72433b1c4933ce576f76dac30ca6300" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.LowerBound.json", + "mode": "100644", + "gitBlob": "a55bf6560265ce0443832aa8913b6dd95d3b424a", + "rawBytes": 1344, + "rawSHA256": "6ac5e1f5df205034db724aba3ab9d1bd94bc6c8c78fb79e568b71e81a93a7f0a" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Microtable.json", + "mode": "100644", + "gitBlob": "d6e5bcf129a10cf92b70c717b480800e99c5e327", + "rawBytes": 1345, + "rawSHA256": "55a6afc8e17d0eb7e66d90b223a4ba2e87ac4c14ec20139fcb95904f35d32ae7" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.PayloadLowerBound.json", + "mode": "100644", + "gitBlob": "687cc612d76ca9a4526e1d2a293ca03a4ad28e5a", + "rawBytes": 1372, + "rawSHA256": "18b0436ed703e16b13bd181f83724fc52bbf39acd56be7494ca884bdc674f317" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.PlusMinusOne.json", + "mode": "100644", + "gitBlob": "69ebad9b61f1fead3991f863f5d0f42b563b97e4", + "rawBytes": 1352, + "rawSHA256": "af81c051c6c50b139c8d3befe6101bb56d14e663ed3b7e56b62c6dd6ef2dd185" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.RAM.json", + "mode": "100644", + "gitBlob": "ca1130e89bf9fc2892e26cdc269bfed8d65423e6", + "rawBytes": 1316, + "rawSHA256": "7fabad833c2db00ee229f71f090caf691a7ff7fa1254961143a78411e197d387" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.RankSelectSpec.json", + "mode": "100644", + "gitBlob": "8695d6edb78586e330055ac7731f0fc69c508ade", + "rawBytes": 1359, + "rawSHA256": "28f8ca078412a61bcc24d8639ee44c86ebe153050c9d6a7ebeb851eb0ce16c84" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Reduction.json", + "mode": "100644", + "gitBlob": "91deef3b22db05bde6587d480e7a04f3c61efd0a", + "rawBytes": 1340, + "rawSHA256": "689fe67df50f007769a5861519bda38feccb1cb37e84927939847b14be0f6087" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Refine.json", + "mode": "100644", + "gitBlob": "c110565ad4d72a55c51b0e17d7634aaec1c206a0", + "rawBytes": 1328, + "rawSHA256": "476c2c2db42a878d3c4b4c22500ecc035c7fc9a3955a6d2ecd9b3db81c3796e9" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Shape.json", + "mode": "100644", + "gitBlob": "9c94d72b5fdbc22212b78741d6e6abc0f650a985", + "rawBytes": 1325, + "rawSHA256": "841a514afd4a3729d2cdcdade8bd65b16ef5c2502b099159cd787817f25859dc" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Spec.json", + "mode": "100644", + "gitBlob": "1d60209816a15dbfd028f0e58cab31dfc844f5b9", + "rawBytes": 1320, + "rawSHA256": "da6cb769e81defabc8b84ef2fcac0adf57ee787e2f83f9f8303252a360637c92" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Succinct.json", + "mode": "100644", + "gitBlob": "18b9101f26fe0984f83baf6525846bd56e156f4d", + "rawBytes": 1337, + "rawSHA256": "125ec94bc3dbd57ab20d6a38ee5fe77e4959deaf1f4ae0dbcaf69af95b1318b9" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.BlockLocal.json", + "mode": "100644", + "gitBlob": "8d068786a714586be8daddbb04fcd162f02300ff", + "rawBytes": 1403, + "rawSHA256": "45f9d77d4c717eb41afc61cd4dbccf8551fd9f86bbc02c449ab10a23ab5e8b4c" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.EndpointMacro.MicroCodebook.json", + "mode": "100644", + "gitBlob": "2c4b4f588d51b3b36a16e89636505a66dc80812b", + "rawBytes": 1534, + "rawSHA256": "a830185571883ba013c91c819c51a9bde0df16657f8e3707bd36e589a5bacf62" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.EndpointMacro.RangeMacro.Concrete.json", + "mode": "100644", + "gitBlob": "8ffce50c833a0fd73db26bf31497045bc6442d66", + "rawBytes": 1560, + "rawSHA256": "4cacbe0c07e692fd73684d1c27bd545af4d158f69d7200f48b0faec5939d8973" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.EndpointMacro.RangeMacro.PayloadMacro.json", + "mode": "100644", + "gitBlob": "3f8de5f24cf3e461b2bdfa215fdf216b1a4e560e", + "rawBytes": 1577, + "rawSHA256": "2d2ebf7779b03511ec6e74e90565cb4811fadedf781354576ce30765a9b2078d" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.EndpointMacro.RangeMacro.RangeTables.json", + "mode": "100644", + "gitBlob": "fb5fa68fde18c37fe4cbf819aca956bf13beb6c3", + "rawBytes": 1572, + "rawSHA256": "bc77306132b43f7cc1c1419919494b1a9a067c55f64768e1a975de6fc62f8b72" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.EndpointMacro.RangeMacro.RelativeMerge.json", + "mode": "100644", + "gitBlob": "8d461230213a014aea682f84918bd8381f844413", + "rawBytes": 1579, + "rawSHA256": "cdc399e4381fe07026be723f4803893ca58d1385a02a11811aa1eaeb0218f51a" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.EndpointMacro.RangeMacro.json", + "mode": "100644", + "gitBlob": "527042f2b31c6e98e15f24d4324344ce1cd5955d", + "rawBytes": 1521, + "rawSHA256": "bba26b07f5510dd539b82315fafe8b983668664fab1e2e902fb0c7702b79b6ac" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.EndpointMacro.json", + "mode": "100644", + "gitBlob": "7947fb44b6a8717968a494f3e32cb92801ff34e9", + "rawBytes": 1476, + "rawSHA256": "597598f62e3fe1fd04de27f471f309db5e00b85904bf735cc2ca8408d2f1361d" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.Candidate.json", + "mode": "100644", + "gitBlob": "fa267201976c3a72ac44b7031168e9197ed30422", + "rawBytes": 1534, + "rawSHA256": "1dedad8e67b173727753bd3005039dfa952718f1fb1643f0098e335fcdeb4d39" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.InteriorDirectory.Base.json", + "mode": "100644", + "gitBlob": "491db58b6115ba927da4ed5b2d832878c4a1226b", + "rawBytes": 1589, + "rawSHA256": "d428efb3df8ab401fbad3a5e4bb6198315a59da3699defa8eff643729746742a" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.InteriorDirectory.SparseLevelWidth.json", + "mode": "100644", + "gitBlob": "042e3d574b7ab687911cf53a6cdd10add5878142", + "rawBytes": 1637, + "rawSHA256": "60fa3e067e3089d054a5c834fe69aa292b506da461c6b6c0c82cbdc90e70a85f" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.InteriorDirectory.ValueDependency.json", + "mode": "100644", + "gitBlob": "ef6bf8ae229952e5f5735fc725383b3bd9325b74", + "rawBytes": 1633, + "rawSHA256": "090540424063e0d596c3f4b5c6149178732ccadd58d039e9fdf9b7e2fd2964a4" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.InteriorDirectory.json", + "mode": "100644", + "gitBlob": "4d844cda97ca32d5ff50ff3b5ae8e83274097b13", + "rawBytes": 1566, + "rawSHA256": "2a1aaf8eca5773713acbfdff8cfba1954861e8c84264d093915453cd3af3dd07" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.InteriorRAM.json", + "mode": "100644", + "gitBlob": "951fb498cfd6b30bfb68570ba27440210644d764", + "rawBytes": 1543, + "rawSHA256": "63cc3979c2b79a3850b9cec05851734696a186176b6da98b6ce4f07f1b6df73b" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.LocalGlobalSparse.json", + "mode": "100644", + "gitBlob": "cd93adfde80bbb7c0ec5219625b783ad961f2073", + "rawBytes": 1567, + "rawSHA256": "7f890b48a45be67db8631808bf9e9f34e3f4375ee4e7f7c2dacae30925cebb0e" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.RelativeScan.json", + "mode": "100644", + "gitBlob": "c65fbbffe9c487232175610d4b839fd998626668", + "rawBytes": 1546, + "rawSHA256": "73df4276fb6b7e3e02cda9823859672fa1b883b2c1b3a5d5c0f46da5c885f3bf" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.TwoLevelCandidate.json", + "mode": "100644", + "gitBlob": "0ecafd1d25faec6fe034667c45f05a50c11ab0d3", + "rawBytes": 1567, + "rawSHA256": "b4a0471ed7024fbfe4b3e1970042cfa6aed143aa1a1acf1ce34829f7ac94a545" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.WordReads.json", + "mode": "100644", + "gitBlob": "8bad9e4df745595228a6991c63f9c98dc0361717", + "rawBytes": 1534, + "rawSHA256": "e47ab1cd46089c57000d0edf4e56a30a35ec5c9c2769f982816848eab7614dab" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.InteriorCandidate.json", + "mode": "100644", + "gitBlob": "0c4a5813cec704f527b603323912ddbdeb40afa8", + "rawBytes": 1492, + "rawSHA256": "d20e8610fd33e030de4cec47b815f53969a7d55139c6cd169e64ff283e537b89" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.PrefixRange.AnswerSemantics.json", + "mode": "100644", + "gitBlob": "845ee3cf13160596acd6d931c8ac964999fad070", + "rawBytes": 1535, + "rawSHA256": "2cfb592e5499d61af578ba93b8bacc25a2f4b5a63a49508dc0cb561c4d80be5d" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.PrefixRange.LocalSparseOffset.json", + "mode": "100644", + "gitBlob": "2667638cb78545ebd8a7acba3e484a97374ecfd5", + "rawBytes": 1542, + "rawSHA256": "3f3d02d1c51a424e114d9f16a52c87df0eade3a5e8158cb98f1995ace5d556d2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.PrefixRange.PrefixArgMin.json", + "mode": "100644", + "gitBlob": "8425454d725660f97466ba6a3d0bbef8fffc3ddd", + "rawBytes": 1522, + "rawSHA256": "ef13b0581791bc6efba57f382ae0fc6884c566a28a4bfafa7affd35c72126db5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.PrefixRange.PrefixWitnessTable.json", + "mode": "100644", + "gitBlob": "303c32bcd0104a7c73b9c3fab02a9efb757b399c", + "rawBytes": 1546, + "rawSHA256": "761610b731f19915c36de7347ad182368306d2a394511c1d2fc6a1c90ad556d7" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.PrefixRange.RelativeSummaryCandidate.json", + "mode": "100644", + "gitBlob": "a392323cf4e1d08e325fcdc643b4c89b0ea0bf93", + "rawBytes": 1571, + "rawSHA256": "b180d7e7746c11d3fa8ae35b54668eee8ed431e5b77be781f9c0e2636c2057d0" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.PrefixRange.SparseArgMin.json", + "mode": "100644", + "gitBlob": "7b3408f57cc64e32cc13ae627c909a1570d6f781", + "rawBytes": 1522, + "rawSHA256": "c8630b6292756a2ef04da2253ac146c6f5c841e298c188d4993e8df9f0f0997d" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.PrefixRange.SparseLevelTable.json", + "mode": "100644", + "gitBlob": "36203883d6d7ceb985b6c46607386d28165a37eb", + "rawBytes": 1538, + "rawSHA256": "990bac4dfdde10607d95cc12f6635e40e0b92265bbc1b147395e5e3a45672e8f" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.PrefixRange.json", + "mode": "100644", + "gitBlob": "5db6d097f144dade6005ad1f5c4bf78d7e55c775", + "rawBytes": 1468, + "rawSHA256": "2e4e7429623cee6ebcddb24238e3b04222c4ded254d33e1b97c2b566047e9162" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.EndpointFringe.json", + "mode": "100644", + "gitBlob": "0240ae20690433f6addad8d2a05aaeb2a7545b39", + "rawBytes": 1418, + "rawSHA256": "88e72eae767b52f4d9609faa74c583da071eaed7b5f44dd8b23cb56d496b1fc6" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RangeSummary.json", + "mode": "100644", + "gitBlob": "aa533aa807901782da880eb190db6f4a1e2e3ffe", + "rawBytes": 1410, + "rawSHA256": "ad8948ebcb5d6784b1e0eaa142c7f70e71a102f6fb16d68330a2a8d16d23b587" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RangeWitness.json", + "mode": "100644", + "gitBlob": "6335b4dc1b4293d3cf5e22abbef7569c39ef878c", + "rawBytes": 1410, + "rawSHA256": "333e352e3b537077b244750c29f828b4d679e72712c88a9e2eb4b54ced7ba74b" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.AbstractMacro.json", + "mode": "100644", + "gitBlob": "e3177728985efb3756cbab7b5bf0d0c9b2abbfc3", + "rawBytes": 1483, + "rawSHA256": "8089d9106dc081565b41d0ffa82b0cae95d71171642951c355d62f8064ec7864" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedFringeChunks.json", + "mode": "100644", + "gitBlob": "5b573096459d1eb95db704e379188479341b54ee", + "rawBytes": 1509, + "rawSHA256": "d17bb4ef5891b68ae4d22e310e80ea70a6fe4a3eac0974ba57e477d63364ded6" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedFringeSubstitution.json", + "mode": "100644", + "gitBlob": "1bad1190b855dce3bee58963e682c823d6a754bf", + "rawBytes": 1533, + "rawSHA256": "b00d8428bb9489b3a7cae6cd951ecc8eec8ee5617b5ca209c6054dabbb4aa7ea" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedFringeTableFacts.json", + "mode": "100644", + "gitBlob": "f7080e63df9a792cf8c06810cee911cbb7e1d392", + "rawBytes": 1525, + "rawSHA256": "ed6905d5489c2aae0cf94f6893d7f045d33134bf9e5883365fd48d47020d51c2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedFringeTrace.json", + "mode": "100644", + "gitBlob": "220d54084ed75f23771137ab18bd8eb7fc9406c3", + "rawBytes": 1505, + "rawSHA256": "4cb282b436c4a8f66d4c881be5eeb277dedfa2ba7eda9db1ef496eced88c7a88" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedFringeWiring.json", + "mode": "100644", + "gitBlob": "ae868ea5f09acd37f3590ee7881fc0f387794a75", + "rawBytes": 1508, + "rawSHA256": "a3abbe6ba3b2f002b3d0abf7e57d5d3327ea76421ed6748f1e1d0f350b140d43" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedRankSelectLeafTrace.json", + "mode": "100644", + "gitBlob": "64499d3edbca0a4e147c9fceacd0aed237b49e93", + "rawBytes": 1537, + "rawSHA256": "8c85d5333bf216766f984d2239201f101aea1aad0025709dacf8f5e2637d5a3a" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedRankSelectLeaves.json", + "mode": "100644", + "gitBlob": "9e4f4f11fb42e505138918221cf144abb398e492", + "rawBytes": 1525, + "rawSHA256": "5605f6b6964dbd9d8cd7aa83286b3e697791caa0831b7b52ce6a99564c9e0491" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedRankSelectTrace.json", + "mode": "100644", + "gitBlob": "448e3dbfb772d6f8a8e1fe2402fd5847b240310e", + "rawBytes": 1520, + "rawSHA256": "05a742d6d6e184c7ac179d85a446ecb03c7a6caa968301e7632758c6bf862cbb" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedRankSelectWiring.json", + "mode": "100644", + "gitBlob": "39c8404d545a74bd587ee3c4234fc47c65560ad0", + "rawBytes": 1525, + "rawSHA256": "3fbf1133f36a6c3669044e540dad75d185a1a917d89cc60007882eabcdd98c04" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedSameBlockChunks.json", + "mode": "100644", + "gitBlob": "b42611ac845acc5566039cb476d905198f4fa952", + "rawBytes": 1520, + "rawSHA256": "ffd4dd7ecb8395c10ab8c79ce48441e678f8d099b54088f887a5b891933f258d" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedSameBlockSubstitution.json", + "mode": "100644", + "gitBlob": "4fdab1898341817ea4bd34e21eb2d46cfef979c8", + "rawBytes": 1544, + "rawSHA256": "89914cb16d58eacfa7ca1ce7c33d236a616add2756e4861c544c8052cbf436d9" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedSameBlockTrace.json", + "mode": "100644", + "gitBlob": "58669ecc1f358b8604291dff420f9966d0b9b981", + "rawBytes": 1517, + "rawSHA256": "8d5b6579bed8870b99c17e6a4c236733f706394edd424a8bb268d9486d279e27" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ChargedWordChunks.json", + "mode": "100644", + "gitBlob": "9aa99ccfbd8b98e4d6db9faa26f6d9e8237f418a", + "rawBytes": 1500, + "rawSHA256": "c2389ceb6ee5c04fbf540315e1b3e2f3f605b49bedc4814140984492e679333e" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.CompactEndpoint.json", + "mode": "100644", + "gitBlob": "30558460daf8c588ade0b1c1131d9b029e0ff02f", + "rawBytes": 1493, + "rawSHA256": "a7a4903d1f465f48bc63194f9ce3b0c8f22a8545370299c834ae01f6cee90810" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ConcreteDirectory.json", + "mode": "100644", + "gitBlob": "ce678d684ae74b735b41ee1d3a141e6f590717cb", + "rawBytes": 1501, + "rawSHA256": "5e170af6f6c4c8817b8f873b3d7e45a8907431fec212e66767a4109ae80a4ee9" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ConcreteDirectoryRAM.json", + "mode": "100644", + "gitBlob": "db3b0649ca382865f4e0760ef98bf86d6e092c79", + "rawBytes": 1513, + "rawSHA256": "932fbb935d9aafdac7625f919b6e7f23cb70cdd8e7ce2df55b20448887e76f79" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.ConcreteDirectoryRAMStoreParam.json", + "mode": "100644", + "gitBlob": "f23904209a65d82d05e2a655c67450f6789c8c60", + "rawBytes": 1553, + "rawSHA256": "ee79999223211a0e6a8dd8e1dad7cad44c13e78146719a4c8ab0dcabdabd7fde" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.EndpointCodebook.json", + "mode": "100644", + "gitBlob": "d211397ec6672c6fa3f2f788fbe7007449145e65", + "rawBytes": 1497, + "rawSHA256": "f5e9c74ed3704ba3d02a09fe382543aa05eaa43eef0e44f8db70ea07e5d8097a" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.LocalBPDecoder.json", + "mode": "100644", + "gitBlob": "eeb7e83686c28e906d1aaf2aac76864318b236d8", + "rawBytes": 1489, + "rawSHA256": "93c9769ad371942901498f1bcec257dc257689baccf2ffdd134f6124a0ee3fe2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.MacroMicroFamily.json", + "mode": "100644", + "gitBlob": "946918c6148d1b0c23fc3164e87d5e7130434b77", + "rawBytes": 1497, + "rawSHA256": "136952b867dd66a5fa93f17b81b5dfc83ff702884807431d1d5eaf7b2469072b" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeRmmMacro.json", + "mode": "100644", + "gitBlob": "1cc833be7e1207f4a3774b3f9f5c65ba04e17362", + "rawBytes": 1426, + "rawSHA256": "94b5308448be19f2be37317827cd804ad23717a55383ba5720a9e53a43d892cd" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.RelativeSummary.json", + "mode": "100644", + "gitBlob": "3174abf336e3bef317fc5c8417b06231942210fc", + "rawBytes": 1423, + "rawSHA256": "39f8594194aa15baaec5f0d0b3ed3e1007b08612e2a8f1eab044f6fcd83f5c53" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctClose.json", + "mode": "100644", + "gitBlob": "1bf1a72d6aa6e10724d1950a8c9e8d0f73cdcc10", + "rawBytes": 1356, + "rawSHA256": "916a33f82b5a44610c6d2dc31594e1e119c95c765ec70c47fef4dcd6617db36c" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.FlatPayload.json", + "mode": "100644", + "gitBlob": "797b09530e624ab7229e7aaf9afdb514d1f524ff", + "rawBytes": 1426, + "rawSHA256": "642b1fa7140fb9433feb4606dfc54cd4c6d79eb385f45bc22caee70560ca42f4" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.GeometryClosure.json", + "mode": "100644", + "gitBlob": "445c115256756fcebfd19da390426c541a543e8b", + "rawBytes": 1441, + "rawSHA256": "1d30ced4e031ccb3982e84eca899473297630de8e2802212494204aef49dabae" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.Address.json", + "mode": "100644", + "gitBlob": "3d3192a8844722c20c5f0dbe44305f0213959043", + "rawBytes": 1473, + "rawSHA256": "bb4a64a66bb0e19decb8170b7cb344a334a147d7cca02cec67b0bafdfb984c49" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.Boundaries.json", + "mode": "100644", + "gitBlob": "0ece9834f23c8f7000bd340b892f06cffe3a9eed", + "rawBytes": 1486, + "rawSHA256": "470236c88fbc04b9652d084ffa26677774ea6e5ac1964ef31e897d399ae3a179" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ExecutedUniverse.json", + "mode": "100644", + "gitBlob": "0786f57d76b27824b2c79831377bff74778f2706", + "rawBytes": 1510, + "rawSHA256": "bbf0f69bee22be8287f46a9ad10eec5278bc57a8ffb3956e22b5cd17d4b21df5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.Header.json", + "mode": "100644", + "gitBlob": "688d24122fd296acf8e17c24467886804d43b248", + "rawBytes": 1470, + "rawSHA256": "b6e49dd7b546192a1db968790f545215e173855b8e9abfc778469415aad3c036" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.Memory.json", + "mode": "100644", + "gitBlob": "95ad78d4a14a006f04520db8311f5c50decc2490", + "rawBytes": 1471, + "rawSHA256": "fa4f404603e7416d5db9074b45d5b5a8e8dc4034de1135a91d69f6c3db599794" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.Payload.json", + "mode": "100644", + "gitBlob": "60593c8c0caa58de453aa556edfcce8d94a29cfc", + "rawBytes": 1474, + "rawSHA256": "e148142b9167887abdac2b24d3cfaa8b5e399695dbb1e8f8e524644659354942" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.PhysicalRead.json", + "mode": "100644", + "gitBlob": "b1169950ef0f48f7cbbdfe72e0e1f9a004ab2bb7", + "rawBytes": 1495, + "rawSHA256": "95cf7f8e718f7016b253d63a16afe24cdedeb21729be45609c7fb60283d9255a" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.Probe.json", + "mode": "100644", + "gitBlob": "dee31bde665f5d6ad67014f228dfa2a0d94f0daf", + "rawBytes": 1467, + "rawSHA256": "0f67582c28d14b2122ab155ad91c078bdc623bacad293d01a5dbed1b24ad135f" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReadProgram.json", + "mode": "100644", + "gitBlob": "31041fa7a447464ffd7960dc2806c4aa55cd9cb8", + "rawBytes": 1490, + "rawSHA256": "c7d10d342a7f296d2e0a2af5589902f8ffa874f37ca1a7b13df03968d2d91bdb" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerCloseGeometry.json", + "mode": "100644", + "gitBlob": "4c328c832570b376ade5a8c48f45bd78221a6f13", + "rawBytes": 1530, + "rawSHA256": "a50158c20449f603074c7c85c671e6b77826d7a7497fcd3cf244836fb9b3d655" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerCloseRead.json", + "mode": "100644", + "gitBlob": "8df02575878c6c0ad69c5f6d34f8ca4a15cec1d6", + "rawBytes": 1513, + "rawSHA256": "3023a618c930190b1f4a0aa7c7169afe4750f90d5f95035a601b0795fdbb8035" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerCloseWidth.json", + "mode": "100644", + "gitBlob": "1b6d9d6bb2e25130fcee39976e40f1f929b9c179", + "rawBytes": 1518, + "rawSHA256": "b05f7dcf5cc5c068428a599ec210f52817c980a162cce68586a59be6ff8f6317" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerClosedGeometry.json", + "mode": "100644", + "gitBlob": "0d8ec69d47556926c2a16a7c673c0825a22aa668", + "rawBytes": 1535, + "rawSHA256": "bf6a540d4bfdde1f090a86835ffd5d71590fcf106cca7c62e0e8a6c4f5cd34ec" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerComponentAccess.json", + "mode": "100644", + "gitBlob": "b8989c36d30ddb06deeba5ba9c871d32c0fbec9d", + "rawBytes": 1539, + "rawSHA256": "495ee76e6821c046c975d210bb366a3cea9d3471fb395a456ebd86f8dab1d0ae" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerConcatIndex.json", + "mode": "100644", + "gitBlob": "203843f53e8333f76b53b8d4cd6454e72844a1a8", + "rawBytes": 1522, + "rawSHA256": "1431a3d0abb26b8aa0ff54523f12baa1643b8fe1ddabc11c01bcdf828e73d93a" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerController.json", + "mode": "100644", + "gitBlob": "45590db5b68e02bafaf57026b2d5677544e96b7a", + "rawBytes": 1518, + "rawSHA256": "f09fab76829a4a973fd3f9a4e5d81e74a0befec8a4e1ac134ea76871799fb08e" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerControllerProof.json", + "mode": "100644", + "gitBlob": "fd763e000c7c98466a07857fdd14dadc101e0989", + "rawBytes": 68549, + "rawSHA256": "d7dd2aa276709b68e642665e2b28e0964b1dc19a1f118ab321dedd82a90277e5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerCrossing.json", + "mode": "100644", + "gitBlob": "14f31ce19b36a28d7e5c3c4c5b3e236fab169adc", + "rawBytes": 1510, + "rawSHA256": "572d4adf695fb3955b83fdef8b39256928f5aa2adb87fb123c655e834017270d" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerEntryAddress.json", + "mode": "100644", + "gitBlob": "16861314d401347c3651b504c0a6fc820add364f", + "rawBytes": 1526, + "rawSHA256": "91b503b3b8f26d5a72bcf8d4e4c3165e2e853fa6034afa700f749a008ea421a2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerEntryChunks.json", + "mode": "100644", + "gitBlob": "ee80ac72052f6c3966bd625e2bb5f44dabdf2329", + "rawBytes": 1522, + "rawSHA256": "efcc312367af907c7723876273fb2852ebd188f62c6b9d269f2d57c4103d1bdf" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerInteriorCount.json", + "mode": "100644", + "gitBlob": "571e46589acbdf5f370d9e4ccb9ec1e428ed710b", + "rawBytes": 1530, + "rawSHA256": "ff7d4fe2d7231a58a24f5a1a7f753b7dfd92e99f55b4e524cfced44ec851a6ce" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerInteriorProtocol.json", + "mode": "100644", + "gitBlob": "554897ede3091d42ba91ebfe619f12a62e1e98f2", + "rawBytes": 1542, + "rawSHA256": "c7d3c3ba339b74280678a73cebe7cd5e6cef4548610a13ddcfd6fb2a8103071e" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerInteriorRead.json", + "mode": "100644", + "gitBlob": "c2a9e39b718ca564cdca0af455e6db807736a16b", + "rawBytes": 16129, + "rawSHA256": "5ceda7560baf01a1efe2c68538d3f99c8eb2d674cbe7132897bd5640868b4377" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerInteriorWidths.json", + "mode": "100644", + "gitBlob": "0de56b383212ad099ea476e607f715a557625cdd", + "rawBytes": 1534, + "rawSHA256": "8e6e0bd6f1d63a63b9ecdf6429cd715e86dd2423a8da80efb094c415b727460c" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerLcaProtocol.json", + "mode": "100644", + "gitBlob": "7000c1eb92e0a9bd4781c2249beac7c63e1d19a5", + "rawBytes": 1521, + "rawSHA256": "2047f53c68e7f95b24d4f58941de2f851856e5864dfee3a1523bac9f677725e6" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerLength.json", + "mode": "100644", + "gitBlob": "370deb694c782db12bc6bbac35142287604142b3", + "rawBytes": 1500, + "rawSHA256": "f8ceb2400d67f57e6f9eeb7f591d330785691210a777ed073eeba26038c5868a" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerLogicalLowering.json", + "mode": "100644", + "gitBlob": "27e60d3dc11f44ae86692e2986c46b751baa992b", + "rawBytes": 1538, + "rawSHA256": "b29a7a63389beb5a3091af6e349dfb44ea0ac06b770948c7b92133aa7a3bfd1b" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerLogicalProtocol.json", + "mode": "100644", + "gitBlob": "deee4ace73a4c7b683443f90393016ccaba5ad7d", + "rawBytes": 1538, + "rawSHA256": "5b1f1f9c6b79133974cd64fe7cb52372318742d4d1f3086df9bccc2119eef359" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerLogicalSimulation.json", + "mode": "100644", + "gitBlob": "591d330c4f65968ed91ea7afd168d8bb521a1155", + "rawBytes": 179274, + "rawSHA256": "c31de51be143fa756e4f65a173ffb5fb6d5e518ef6d0d6f1de62d04107b17694" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerMachineWords.json", + "mode": "100644", + "gitBlob": "8bf1e03e1da89d0aed780ee4fad15d810bca9958", + "rawBytes": 1526, + "rawSHA256": "dbbdc8f635236e1b34bef4c38eb674d8f52788f76aa81b1a27782e87f16873e0" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerMemory.json", + "mode": "100644", + "gitBlob": "82a6d2ea26b2ce8407aec0fdfce33c629a535c73", + "rawBytes": 1501, + "rawSHA256": "eba3a83095ec4d14a80e33ae65b53311214edae3f367895777f5dacc9feba52c" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerPayload.json", + "mode": "100644", + "gitBlob": "9ae5d4bffd1c92f73a5f5be27c0658a3b3ea62e0", + "rawBytes": 1506, + "rawSHA256": "7880c63ea1cf8e9342058b0d1e2ceb801caf8f7f2fc04928eb20c7cf83fc11dc" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerPhysicalRead.json", + "mode": "100644", + "gitBlob": "cf20405edeff008e3390aef01711b4bfc3efc20f", + "rawBytes": 1526, + "rawSHA256": "7f93db89a5e5ca6f7f26c077c8b27307d5c82bc8fc76583dc548b318c1d81417" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerProbe.json", + "mode": "100644", + "gitBlob": "988b049b14307cad472adf08fe7b0fabea3cfb1e", + "rawBytes": 1498, + "rawSHA256": "1698483b4bfe100920ccd8081b115f5760b929d6b2b5dc47e13c7d6acaf74fbb" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerSelectProtocol.json", + "mode": "100644", + "gitBlob": "38c64d44551fd266d40c88275019ba14e9a10301", + "rawBytes": 2194, + "rawSHA256": "8acb45993066e659e2075cb4b6a8fce7fccbdddbc7eb3fe1451e1216deb9dc47" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerSourceAddress.json", + "mode": "100644", + "gitBlob": "4acf0a106db154ae89a7b95d81373a4606927bbe", + "rawBytes": 1530, + "rawSHA256": "81a380847c57330c63d9b2a29b51a856be92691f862e673f891af2b3e83cb7ac" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerSpace.json", + "mode": "100644", + "gitBlob": "4b8b446f9eb7a44e86ac8a26cddf777186cae47a", + "rawBytes": 1498, + "rawSHA256": "b99dca338704134b6cf5f59c8c7da8f21907b91ad70b28e322c6da96d69f2281" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerSparsePrelude.json", + "mode": "100644", + "gitBlob": "ad2a8d0b5b62c37bd4b0c3677974ef5cc2ba2713", + "rawBytes": 4648, + "rawSHA256": "c02b88e49d8077b32f94a07fd496175b97636c264d8547071699745386b621df" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerWholeProtocol.json", + "mode": "100644", + "gitBlob": "4f06c9d2ad048c24bddd02f9a47992e51ab12f59", + "rawBytes": 1530, + "rawSHA256": "e583292a7ba104ceca87076d7c51e87548063b39fab7ac071f832d6a7831086b" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.ReviewerWidth.json", + "mode": "100644", + "gitBlob": "7afb2ecb76687d013c090d3e26c4de424e05d2f4", + "rawBytes": 1498, + "rawSHA256": "fd87d4d11f4f8e90429cb42e3c20d0f96270b6d6f47871e356f91d01b110e387" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.SourceFactorization.json", + "mode": "100644", + "gitBlob": "7b409f2a4a7368904fb621113733761460c50989", + "rawBytes": 1522, + "rawSHA256": "93d9afe9f76694901a82aaa33b76e417d7901dfbe6fcab5163f8e392a46b2011" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.SourceGeometry.json", + "mode": "100644", + "gitBlob": "cb576e88b3790479428ac67dcd2d8e70d6033173", + "rawBytes": 17783, + "rawSHA256": "2f5b540fb561112204ee042df16338d8436ba6a22730144d85c28cbc50223e27" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.SourceWords.json", + "mode": "100644", + "gitBlob": "58ef1a0c1a598a9fefb73cce79bdb169ea984744", + "rawBytes": 1491, + "rawSHA256": "c0bf6493d2baec45960815bfa8275ddfc1caba115a6ec134f8c7cde96a25113b" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.Space.json", + "mode": "100644", + "gitBlob": "d5c8db5162fecf6a0bdfc65077fda76d73c76548", + "rawBytes": 1466, + "rawSHA256": "7ec30494b447969ee113b90c05480742060390f8925796543f9cebbf991f05ca" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.PackedCellProbe.WordWidth.json", + "mode": "100644", + "gitBlob": "a61b79e1df0444f6050cb05cd1fd9512dad081c6", + "rawBytes": 1483, + "rawSHA256": "31587ddc00f9263375d4a28b2728dc77b0b906a1a0a364d193294fe926544094" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.ReviewerPhysical.json", + "mode": "100644", + "gitBlob": "466d7f9ef64199276eb620e0268db8661b109675", + "rawBytes": 1446, + "rawSHA256": "f4ef49df91c8872e52234a87bf3cd864aef9cd128dfffed5479ae3df50ee498a" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.ReviewerReachabilitySmall.json", + "mode": "100644", + "gitBlob": "7eaf2164cac3509ef0266e1c2b0268e926578f5a", + "rawBytes": 6795, + "rawSHA256": "a4aa061121d1a1df7036d4eeebcd6417f3b49bfc2816fdc0b362c4d6e840715b" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.RAM.Segments.json", + "mode": "100644", + "gitBlob": "d501dff94636ba0b8edcc94cba72e4cde858feda", + "rawBytes": 1413, + "rawSHA256": "f0cf5e5285f71ea6e2e4ac19facd4e528d5cd2c84d8debad4f3ca942aeaa01b5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinal.json", + "mode": "100644", + "gitBlob": "8c887b0c92ba6235abde9dac91ab6a7d6d2b93a6", + "rawBytes": 1357, + "rawSHA256": "73179ac088a67fe38574982f0c6cbf91d78960f5b29bc472b7479b8f2210d3fb" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinalModelAdequacy.json", + "mode": "100644", + "gitBlob": "24f21569f99aff1c0795c595d3fa2df78e4b6c71", + "rawBytes": 1408, + "rawSHA256": "d75da48f48c3f14982b1121a6740fbf4bd762c49f14008a9c00db4e2951f3268" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinalRAM.json", + "mode": "100644", + "gitBlob": "96109bab0992f25de18dbca1c3ab86fd678e4524", + "rawBytes": 11616, + "rawSHA256": "ee1b4b355735844d8881bbf7819d4664cbda6fcb31c5d781147c2a0685c5cba6" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctFinalStoreParam.json", + "mode": "100644", + "gitBlob": "4d47e32a8dd842b6b987ea1530cb7ea9b57a9d49", + "rawBytes": 1397, + "rawSHA256": "b3933c7627209fae908e3109163b0ac7a4d6c10a5b2a85621802578b5f899079" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctRMQClassic.json", + "mode": "100644", + "gitBlob": "1f0a029b3edc091d23e40e4f2b414c1d8e88403d", + "rawBytes": 1377, + "rawSHA256": "0b1cff823990eb558853b943b60143e7d6b43c210db491151446b6e39affc601" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctRank.json", + "mode": "100644", + "gitBlob": "969580e45ef6ad72169b86a0cbe35a1055f2a484", + "rawBytes": 1353, + "rawSHA256": "83171fd7b15f1e3c115aac65e0cdc87b5bc69e256f9a8b3075108234de1e23bd" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.AsymptoticFacts.json", + "mode": "100644", + "gitBlob": "fa5989710e51be9d8e9e877bfe7bf5ff1febeb3d", + "rawBytes": 1426, + "rawSHA256": "07a833e17514c37fd9e1def6ed20b542bf96ead765d7ec027c25b783f9b9e0e1" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.Basic.json", + "mode": "100644", + "gitBlob": "610b16e078fd371d6f953592b8a37f2bc7b3464a", + "rawBytes": 1436, + "rawSHA256": "e251d8c86752931b560b58a8b7114e64c88836535fc18f47b9884b4c0a620cd5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.BuiltRouting.FlagRankTables.json", + "mode": "100644", + "gitBlob": "6b0283275366f0e5255eb889e0fc333a587cb0e9", + "rawBytes": 1527, + "rawSHA256": "eaf45df9bb3b1ea9997c5db252be6aea0d1f96aec0a2947e34445a291e092ff4" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.BuiltRouting.LookupDense.json", + "mode": "100644", + "gitBlob": "08f46517d741411e16e9d3f979202beb97236019", + "rawBytes": 1515, + "rawSHA256": "c2e2c8e85f9ea12af081a8d3703c65266337d257c2524d1a5139b48556ab1c8e" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.BuiltRouting.RelativeEntries.json", + "mode": "100644", + "gitBlob": "4060af0fb50c50347ce13adb3fc029d61ddcb554", + "rawBytes": 1531, + "rawSHA256": "5517bb0dd5a2e0985cc475197d1173f80926afb167b27146d247b1f36c78eb74" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.BuiltRouting.SlotBasics.json", + "mode": "100644", + "gitBlob": "bbbb17ac34fe3b42d43f7482b95fe4faad876a91", + "rawBytes": 1511, + "rawSHA256": "507fedb7de01da41dd0d7266bc8c54bf5077b2b7887020f51a39e4fe4967ce70" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.BuiltRouting.SpanBudgets.json", + "mode": "100644", + "gitBlob": "24c862455adcb69a15e395921b1208321d940b88", + "rawBytes": 1515, + "rawSHA256": "77a12a2d44a8fa2887d97e655e9bda0c1564ecf9e1dd736162a585de7008ddeb" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.BuiltRouting.WidthBounds.json", + "mode": "100644", + "gitBlob": "81136611dff718f262954dbf279678eaadab2f22", + "rawBytes": 1515, + "rawSHA256": "38c94ecd8ab9efd59a118e474ae845b7ea80d6e3ce49de08f03e83ad81adb70f" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.BuiltRouting.json", + "mode": "100644", + "gitBlob": "ccd1c235d572ad558db67a0b517c1a24b2204eba", + "rawBytes": 1464, + "rawSHA256": "88d2c8f5e9c88a20b67f250a776b3df5c5524109d25f96515c20be89490ee637" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.RelativeSplit.json", + "mode": "100644", + "gitBlob": "f627143e7f24f7e3bc06d318a80ffc0604fe5e24", + "rawBytes": 1469, + "rawSHA256": "fca4a688626002535c3eba96ad61173cd023fa84accc90b62b07648b5c70d38d" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.SparseExceptionCloseData.BuildProfile.json", + "mode": "100644", + "gitBlob": "f943c93efb491fb9cde8950579b3b2f16cedfa6c", + "rawBytes": 1566, + "rawSHA256": "658d63e5bb7cb6fe3ebeeba69057e143e122f3ac665a80a15113827885f2abf6" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.SparseExceptionCloseData.BuiltExact.json", + "mode": "100644", + "gitBlob": "a13b4cc2c0af25b7852fd759d71a0cabe84ef4bf", + "rawBytes": 1559, + "rawSHA256": "c73662bf33fe5a50457e47ae098204657539dffefaad63577c6cfe84f34ba7f2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.SparseExceptionCloseData.DataSurface.json", + "mode": "100644", + "gitBlob": "f2413173561ec8d4f7c4304ae52ffc4b6401f8d0", + "rawBytes": 1562, + "rawSHA256": "79b16a1cafe051a34daf8d3c5f61c53e3a77724d71e65d63402c734b3a88e474" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.CloseSelect.SparseExceptionDirectory.json", + "mode": "100644", + "gitBlob": "44c2244e0e83c13175981dfd9629aec44b75c54b", + "rawBytes": 1512, + "rawSHA256": "694f1e35e694cb0df38e77dff461496036a669d617c75566de24af56d32eff66" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.DenseLocalTables.json", + "mode": "100644", + "gitBlob": "83583cdbcbd2aa47a45ec88b8415901d5f75d670", + "rawBytes": 1430, + "rawSHA256": "0cd5b2a754495155a1e04f6e6237d9f39be852ca120343f9fbffa71cd2c42a3c" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.TwoLevel.BPCloseNavigation.json", + "mode": "100644", + "gitBlob": "dd0fd994f1eb47385cd48538f77c15f51ba662be", + "rawBytes": 1472, + "rawSHA256": "dbb710b986c84c40351fd05c3f5289189758e76e4f8646bbe62c9135b803a345" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.TwoLevel.ClarkSource.json", + "mode": "100644", + "gitBlob": "f54518383df1d2c3a5cad9a810e9234a992a9fa4", + "rawBytes": 1448, + "rawSHA256": "1d1ec4f6c6568daac2edc54ad02152f8b3ea438feeafdaadbe60601ceb0cea7c" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.TwoLevel.RankSelectAdapters.json", + "mode": "100644", + "gitBlob": "72491b91e927ff2194861c8c08ee30f0f88f7a6e", + "rawBytes": 1476, + "rawSHA256": "c23d5bc5a6ea56e68cb8ccfa6ecd6215c148185cdd0a3279f15e9e87c9beee35" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.TwoLevel.SelectData.json", + "mode": "100644", + "gitBlob": "987f22d89a15408186ab543b831d2368ec3af6d1", + "rawBytes": 1444, + "rawSHA256": "3a2e67a0195d1ab8f924c137c8b74fb0151cc9a9240a46840fd525e061ade891" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.TwoLevel.SelectSamples.json", + "mode": "100644", + "gitBlob": "7429102cb26d89c33064fdaf8b5b317b59374d7a", + "rawBytes": 1456, + "rawSHA256": "1e533dddad7ec4018af1629d504d1704711d62678e8a14ee14b73d7f05b493ea" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.TwoLevel.WordExact.json", + "mode": "100644", + "gitBlob": "60b5af4a40b7f00b787ba489b6ba229a3a4ac4f0", + "rawBytes": 1440, + "rawSHA256": "ad330eb7487bc8bccd32bb010cfd1dd4c67b8b41180100e3b3f3b5e7b63df9b6" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSelect.TwoLevel.json", + "mode": "100644", + "gitBlob": "a75a0a1b97f9dd0575679c6a8d7eb127f95d0921", + "rawBytes": 1398, + "rawSHA256": "eb17436f02b6c542732e4a73ddb7c106ec74c699348d50e97b92cd400a3d7325" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.Asymptotics.json", + "mode": "100644", + "gitBlob": "49d17e90b1a27c618d9d91afb2de1006e581b388", + "rawBytes": 1407, + "rawSHA256": "67792da386b44107b60b58c7ef4eaf0bfd8a36e9fb7579df2e127b31d1b9f6d5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.BPAccess.json", + "mode": "100644", + "gitBlob": "b4077c4920b1024cffd4751f78eb749125f475a9", + "rawBytes": 1395, + "rawSHA256": "51b62f6b5f57d323f23ad8019679032de0d1813c2ddecef76a1b32410df4ee7e" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.BPCloseLCA.json", + "mode": "100644", + "gitBlob": "5e1d617c3286faee83e1866158e3dd747a5e49d8", + "rawBytes": 1401, + "rawSHA256": "65ea446cbd627e98a1a647a367b3ccbef6f0b822c12e9d622612f238959799fd" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.BPCloseLCARAM.json", + "mode": "100644", + "gitBlob": "f0855d08671f2d8db0c071e09616555c04dce573", + "rawBytes": 1413, + "rawSHA256": "807e6db4a785b4f8dd1473ce54881d51e32d26c3e42ddb1b8298a3ffd99d1023" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.BPCloseRMQNavigation.json", + "mode": "100644", + "gitBlob": "22395603697572b50648314e1ea80b752a840f1b", + "rawBytes": 1443, + "rawSHA256": "321779a2bd88b590f78c4bcd72ab0d03242f767649ae8091fdb3918806821eb2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.BPCloseRMQNavigationRAM.json", + "mode": "100644", + "gitBlob": "cd15657634655590937890dab806c68e0ca9cdaa", + "rawBytes": 1454, + "rawSHA256": "34cd5f2bf41bd39196538c6505ac2f8dc33f74cc07805305b6ece82965b5449e" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.BPShape.json", + "mode": "100644", + "gitBlob": "7b2a0d9bf8dd66ee3ad6b8f3a98055f39ee459b0", + "rawBytes": 1391, + "rawSHA256": "ba62c2f0a4755d443050c34c5c08d7c16b8997851acaa925a3dcc0856ef4891c" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.BroadwordRMQ.json", + "mode": "100644", + "gitBlob": "1fd99ae7b77886d3734d3cd48c8203de46403a59", + "rawBytes": 1410, + "rawSHA256": "902947dee39b45846e3f0d2aa9158ecbe7d2dff7006819b15d2d91190522e219" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.MachineChunkedTable.json", + "mode": "100644", + "gitBlob": "d372d8fd9a7c42d225cd771a7b9aac831ad99b56", + "rawBytes": 1438, + "rawSHA256": "32b1e62774330c9931f39f714a51515934cf06ee38fcb909f64a77617efa465b" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.MachineChunkedTableProgram.json", + "mode": "100644", + "gitBlob": "f0101d0d00d48edea302361df5f8bee450917716", + "rawBytes": 1466, + "rawSHA256": "a29ed495753953ee08ae6c8f240aa293acf3b44cca924e3b2c8124c4fd6bf0d9" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.RankSelect.json", + "mode": "100644", + "gitBlob": "62ef334d97b3ad1c29c6cbf3511ab038c8f09071", + "rawBytes": 1403, + "rawSHA256": "ce3878bcbf38663d74a02ec5c8eb7bf4e47280dc3fe48cfb535c89ed3254797b" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.RankSelectRAM.json", + "mode": "100644", + "gitBlob": "43ff79be2651d6774b56bf87575a697f50467667", + "rawBytes": 1415, + "rawSHA256": "75e347a0a14988955c7369385694ebc31210df83faf2734bc2f6643e1ca016e4" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.SelectSamples.json", + "mode": "100644", + "gitBlob": "e0d7313e9e9e9b0742fc71d24f2ac4cd000f899a", + "rawBytes": 1414, + "rawSHA256": "ceb94f839cd97086d1da9c969a4e3c87167c346615a0d11e2bdf340e575cf2e6" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.SelectSamplesRAM.json", + "mode": "100644", + "gitBlob": "82db0ec85247b07821e311929039e30a44814582", + "rawBytes": 1426, + "rawSHA256": "e71c10583f681996fe0170d349a6cdfbc9a0935d237acb2e07c1b6a605eb4375" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.Tables.json", + "mode": "100644", + "gitBlob": "023ab2a580e6f92dc6c8530f2016a9311349db7c", + "rawBytes": 1386, + "rawSHA256": "f458963611cb56c40f836a3e6a1783e9ca7d8a3bcb9d29346cebf68a487de0a9" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.TablesRAM.json", + "mode": "100644", + "gitBlob": "ae4fd0482bb418132a76c28dee86b43cd22761b0", + "rawBytes": 1398, + "rawSHA256": "44263766e57751ae17772b8c08da5a2a61129d21a7d5f849014d251b25ffbe40" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.WordStore.json", + "mode": "100644", + "gitBlob": "b53a1a59554646ab6e8ce7d52b87e4ce92132637", + "rawBytes": 1399, + "rawSHA256": "832cf7fd9d9528b520d5a9929a4dfc38e8f0e303c6b8e49492217e0ab87e27b4" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.WordStoreRAM.json", + "mode": "100644", + "gitBlob": "862a533dc45d916a00a74fc5432d8e2468f10921", + "rawBytes": 1411, + "rawSHA256": "92814826f32cf4e2273d08b91bc66066a65f3e3b644dd2c8158297bf12faa523" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.SuccinctSpace.json", + "mode": "100644", + "gitBlob": "01e3cda7add36373bcc56b262c617143ddc6ec83", + "rawBytes": 1356, + "rawSHA256": "ea7de8ad3dbcafd8c37114672b0ae21e688ab7eec3f98ed618934d21905003e4" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.TableModel.json", + "mode": "100644", + "gitBlob": "b52018b5b2c140c7e0d39addf0de52f60125ce83", + "rawBytes": 1344, + "rawSHA256": "f32e20cea4b6a82b7296bf4ed1da6cee2095e0664b8b04696fb98e2210ed9e09" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.Window.json", + "mode": "100644", + "gitBlob": "9a4856eecfa16ee5a2550807193963153af9b80a", + "rawBytes": 1328, + "rawSHA256": "007875db33d34813a3ad8eab40d14d07ec2ac9a12e99dc9a0a08b7ced436029b" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.E1FringeBridge.json", + "mode": "100644", + "gitBlob": "8459d8462c59fb86ee8a6ae8737ea07b1a1b65f3", + "rawBytes": 1395, + "rawSHA256": "af76838a21b4fec5df4516dead76798b873e01793137547e7bc7f40cae55bd8c" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.E1Machine.json", + "mode": "100644", + "gitBlob": "63be4a91194e3967684b403d7c2d16656be5d66b", + "rawBytes": 1375, + "rawSHA256": "1429f043964d8655f8b9c629b67138d54392dc78cc6df4dda1c1eb01dc6c13d0" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.E1MachineCalculus.json", + "mode": "100644", + "gitBlob": "11a40ded0093bc4a7311c25847157320d7841231", + "rawBytes": 1407, + "rawSHA256": "22db5a189e91b4d5610919fb8f138e9f0d3c9f28ca9bc589ce6ab8d4e9d4e7a7" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.E1RankBridge.json", + "mode": "100644", + "gitBlob": "ccfc90b5ab96e1bdafe205cdd5dd36a97a3cbe77", + "rawBytes": 1387, + "rawSHA256": "3a6e81d154544d319032f3f6711152bc7a8e9a348133d10fd5f21faad3597054" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Optimization.BranchBound.reuse.json", + "mode": "100644", + "gitBlob": "33dd5080fa0d571ad14328a9e345237da7404fee", + "rawBytes": 293, + "rawSHA256": "30a28dbefbec72b7e074714003a961e301f3c0de0cd8065a5258b1251ceebf1b" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Optimization.Capstone.json", + "mode": "100644", + "gitBlob": "f0d38d670be6e2c7ce6eb15739e35bef4460bb28", + "rawBytes": 1425, + "rawSHA256": "a5d3aab6c1adcc2f2e67138f9857a6e3a904b64e735e2dc87fff9375f5f83d10" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Accounting.json", + "mode": "100644", + "gitBlob": "ceb285c2ad70b4544899695afa1d3d25451111db", + "rawBytes": 1408, + "rawSHA256": "3820aaa6c079836eaa54d861d1c88fc4fcf04acb2ab87f9e949f93bb1b212b27" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Allocation.json", + "mode": "100644", + "gitBlob": "8750443193994a1b5c45f32828e059ccd9661938", + "rawBytes": 1408, + "rawSHA256": "23fe620862a385903145297dbac9f7dd6e1b1838c685c988dfe85a6b3519712f" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Calculus.reuse.json", + "mode": "100644", + "gitBlob": "4808c931173fe3b5fa15fcd93a7de36b212ae3fe", + "rawBytes": 284, + "rawSHA256": "aafcbbe218d4d48db72c9369c1401e73dadabb61e2943c670e2310e26e5a1485" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.CandidateProof.json", + "mode": "100644", + "gitBlob": "ef824bfca876931f2a2d5c4e282a9676294174e9", + "rawBytes": 1424, + "rawSHA256": "22fd10a93767bbc85e1b8a1e90953bbcfbade646c3eb70f49c99064fc95bafe1" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Capstone.json", + "mode": "100644", + "gitBlob": "a874728c0624b8e13a65cd48787ae51d9cc6c3a6", + "rawBytes": 1400, + "rawSHA256": "974c32f67814a77c3d501352b6de73e62f070343ae4e9de2d9e093a9815ccc21" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.ChunkArithmetic.json", + "mode": "100644", + "gitBlob": "800a827f34d15f44c62a590d9dab01eea4bcf22b", + "rawBytes": 1429, + "rawSHA256": "2ee2b8fe4783eb3419ab851f523c83261e5f0692c1e59b7016f45202597b9cdf" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Compiler.reuse.json", + "mode": "100644", + "gitBlob": "53b32e3b1b2c7fefe2a7f42552ff19559381b5be", + "rawBytes": 284, + "rawSHA256": "5fccf89bf4053f9fa578a49a44a1a5078629f446b7a88d615f516a4909dc83b5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.DensePacking.json", + "mode": "100644", + "gitBlob": "b701c74b733e5f02e29bac15cb2c6f5144d0e2cf", + "rawBytes": 1416, + "rawSHA256": "f106cd6e3a739838cc51652329e73f4e07d935bd14cce167d21546fd819af6e8" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Frame.reuse.json", + "mode": "100644", + "gitBlob": "feb47b9ceb002bb6ff5a5555c753f785d7d38524", + "rawBytes": 281, + "rawSHA256": "434e6d03518c0fe925011293cb969450367b861b12d1df9227bc16be368ba879" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.FringeProof.json", + "mode": "100644", + "gitBlob": "2dd074446b0eb8c03affb82aa2cf87f9046fad5b", + "rawBytes": 1413, + "rawSHA256": "d5d106f807d8a17bc918826aacecc38921a261e31bca1e1ffd462e697d5363b2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.FringeSafety.json", + "mode": "100644", + "gitBlob": "f5195c0ffe2eb0880c417e58a6e906dc4ac734b0", + "rawBytes": 1417, + "rawSHA256": "0bbade0f7f66d0c8304e35e4feec0de177ffc3b992ba7b75758d0f12dd4faa26" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.FringeSource.json", + "mode": "100644", + "gitBlob": "add2ff40b1a6015d3240b7750bda3632645b80b9", + "rawBytes": 1416, + "rawSHA256": "537b89158d75abe4914d6a58ae9d6f5b62bffbe372b3df270827bc3c82b376b0" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Guard.json", + "mode": "100644", + "gitBlob": "192902e6c01b00db791e0822608c3f959c5d0a9d", + "rawBytes": 1388, + "rawSHA256": "bcb254c65c4bad5c498a44bcf3fe5432dde4c5d27eefdeddf90eea8818d71c1f" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.InteriorCandidateProof.json", + "mode": "100644", + "gitBlob": "bc55829349174919a7d36bde659a450dff329a38", + "rawBytes": 1457, + "rawSHA256": "fbe72f95b65418d724d1ed327cce0280529328c7650b81648a090ef0a6e2a658" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.InteriorLocate.json", + "mode": "100644", + "gitBlob": "94103f1c4f8aa0e72025d04dd4158b37a2b88465", + "rawBytes": 1425, + "rawSHA256": "a99aaf33860c1f65702901355471ca488e92776acc3b0439475053c8e543f4a0" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.InteriorReadProof.json", + "mode": "100644", + "gitBlob": "6f28fffdfe398a69cfce721a2fc6ef2b03c716c9", + "rawBytes": 1437, + "rawSHA256": "9640c0b4d2cacebada6b146c599d66485ee639a138a0f19170a0e4307c31716c" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.InteriorSafety.json", + "mode": "100644", + "gitBlob": "5a9df64a5c676f839ae6cec8411695a624fcb744", + "rawBytes": 1425, + "rawSHA256": "8119dc9b8e3f9082ce34e572500f22c6b6e32067bd44344d3cf5541c89009e98" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.InteriorSource.json", + "mode": "100644", + "gitBlob": "148bffdf15e8021add9d7213d6b4f79cf6db9358", + "rawBytes": 1424, + "rawSHA256": "481e8f45ab62e35a8f7f864a6f6c19b6fa0f111368178909308dbd437e3122a6" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.LCAProof.json", + "mode": "100644", + "gitBlob": "92cf2503c3dc7170bdffeade855a293081669e80", + "rawBytes": 1401, + "rawSHA256": "d6f67f8497858819560a8bf4f1304e2313ba2557975deef748c41e6379db9952" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.LCASafety.json", + "mode": "100644", + "gitBlob": "d1b540852e3da17d9e3bba96bd0ce23de37b219c", + "rawBytes": 1405, + "rawSHA256": "00089953d612b68e7014ada243a336531313727052ec48688de1cb00be9446d1" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.LoadSafety.json", + "mode": "100644", + "gitBlob": "e816a52b3fe7b67b091a3a9c69fcd012b16dab4a", + "rawBytes": 1409, + "rawSHA256": "b04f7e5872f09727aff7d67a51a532f38c83b6ba3dd890bfdec94fd219a52ed6" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Locate.json", + "mode": "100644", + "gitBlob": "36c736086a5cf85bf1b88f12adadb5a9ecc362e6", + "rawBytes": 1393, + "rawSHA256": "7f923d313677c16413a63e7b213d3a6d91b53ac95f716a8e33a3d3b270f1ff1e" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.LogicalSpan.json", + "mode": "100644", + "gitBlob": "d1931f6cfa406ac949ae3de52307b0ffd37498e2", + "rawBytes": 1413, + "rawSHA256": "537acd62714b8298ae958b765a4e66c2ea59c9fe7a3fbf482b9c6c97531dd869" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.PhysicalRead.json", + "mode": "100644", + "gitBlob": "a1d10b209c6388f7861a445e50d241919c2fb1f8", + "rawBytes": 1417, + "rawSHA256": "2f7ce20361c58624b20b061ce2fe8d600ecb3b24bc52959a3605d0ec96838dc5" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Primitive.reuse.json", + "mode": "100644", + "gitBlob": "6a36eb61ff2d858a3b67d1f63ef7691ce2c4bbab", + "rawBytes": 285, + "rawSHA256": "27160e8474de25b1c484393a2ac04b273289de6e6823f857d02b4c58a13c4187" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.QueryCertificate.json", + "mode": "100644", + "gitBlob": "eeb5c521cdf5bad950b56b63ab864ac272c6369c", + "rawBytes": 1433, + "rawSHA256": "91ea66a9eb4fff083c64b1d6931164a24c78e2bb0637feacecaf32193932d1c2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.QueryCorrect.json", + "mode": "100644", + "gitBlob": "9c2d697117fa9055c2aa10f2d4ca1a04a46f0ff2", + "rawBytes": 1416, + "rawSHA256": "acb83cbd09b5511903340bff79055acbc7582e03f01809f22c543a715dbb54f4" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.QueryObservations.json", + "mode": "100644", + "gitBlob": "51a7c35b2d52f4cdbf42c27f42dde2473b87b7ed", + "rawBytes": 1436, + "rawSHA256": "b6c9dff685b5bf01feb6f054392dbb58dbefc4afaa2e5b47c03dc52d62f04ab0" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.QueryProof.json", + "mode": "100644", + "gitBlob": "aebfbcb8faf53385801aa2026dcf103893178873", + "rawBytes": 1409, + "rawSHA256": "19515482c720d60aec70de5dae561649ea9ec01deb95646c9e2d6a5984ed87fe" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.QueryReference.json", + "mode": "100644", + "gitBlob": "e97bb982c443da3c592a6aef13518da196758df6", + "rawBytes": 1424, + "rawSHA256": "2c287489ee2fd0acea9cbd8d864c433bb52d6b2bed133ed31fa21259c71d020a" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.QuerySafety.json", + "mode": "100644", + "gitBlob": "704f9c06e53c8b1c6e78e3e48385e3254ecc1717", + "rawBytes": 1413, + "rawSHA256": "c5d282cb3269c23b65b19f4ddcaec274d1433cbf6105677a68fcf4d31cda3286" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.QuerySource.json", + "mode": "100644", + "gitBlob": "74a44ffb88b3849b42b487a6515dbc960a89ea09", + "rawBytes": 1411, + "rawSHA256": "62d6b043d741244a4039321b1a466ea261d835dbb6187f04583f6a991517d7dd" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.QueryStatic.json", + "mode": "100644", + "gitBlob": "755e32ad57c188a67270b5e817940484adba36c1", + "rawBytes": 1413, + "rawSHA256": "be08344ec8386d02d0943c08f423338851c41261088de07c701fe368a2d2779d" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.RaggedWindow.json", + "mode": "100644", + "gitBlob": "6a84f9b01cce890877c14d20aef4aea87012d65b", + "rawBytes": 1416, + "rawSHA256": "a09b3647a5588363bbd947ddc39f266f34ecba82ea110cfeaeb580ccb17cef58" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.RankProof.json", + "mode": "100644", + "gitBlob": "ca1cd4c47706178f3d279946e195942c17bb3283", + "rawBytes": 1405, + "rawSHA256": "e14fd56728049cef192b9d2defa6ff2c915251d25f0e0dceb5dd2f6090542729" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.RankSafety.json", + "mode": "100644", + "gitBlob": "496849b0a60d2473f5cc61175de4745fc8914250", + "rawBytes": 1409, + "rawSHA256": "ec8baa545b3b7ec0e3fe5d72da0969e76821b8525d308074868ee5e5bfcb926b" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.RankSource.json", + "mode": "100644", + "gitBlob": "7101cf560258731760e826dec86ecc0740a1ad04", + "rawBytes": 1408, + "rawSHA256": "160a1edba0701037fded801f631ccc019c73777cbd03cb7391b3137ff88474fa" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.ReadInterface.json", + "mode": "100644", + "gitBlob": "7d84123b8911ee28b1c63635e70b0de7508b2b14", + "rawBytes": 1420, + "rawSHA256": "19f7bf4948dc871b79ac4599148765af4f15eb6e739a44fc33286d853f341014" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.ReaderSafety.json", + "mode": "100644", + "gitBlob": "4858994ad2bc8533223dd68591dd35a2619f3a95", + "rawBytes": 1416, + "rawSHA256": "c117551d92269f0e043c1439804999b94cc50809d02035ce6548bbbe9873bbac" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.RegularLocate.json", + "mode": "100644", + "gitBlob": "8a38a193560292da2c07a5d864357562f9f7705c", + "rawBytes": 1421, + "rawSHA256": "292eb3017d185d3d353470ef4ddb2536e889bf4613a232d0eb13b7d4deb106e2" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Safety.reuse.json", + "mode": "100644", + "gitBlob": "f7415c96e1ba46167c9f9878017a77386d16f584", + "rawBytes": 282, + "rawSHA256": "d87e0834d269cd7760feb8e3e7350840ebdcb333c13330fca70dc4ee5c195471" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Scalar.json", + "mode": "100644", + "gitBlob": "37240e9ec726d154160f2ecf5ed1ff584ea3f4da", + "rawBytes": 1392, + "rawSHA256": "4d7d93a5fe17db61e0f9134252e21fc892517947aa632b08b47769f7e57d12c4" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.ScalarSafety.json", + "mode": "100644", + "gitBlob": "ed96862d0996b42e4de803cf972a477074d93dcf", + "rawBytes": 1416, + "rawSHA256": "5a06c8d1614bc35d717dd8a75a4028b492e1310d785f1af933c2f0b9358137ee" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Scratch.json", + "mode": "100644", + "gitBlob": "12d7509b548e7d514888c76bcad5dbf9615f11e0", + "rawBytes": 1396, + "rawSHA256": "f327fa2fce2f98d5ecb48564bd234f687502179ee5ed270827492f97b6ef6966" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.SelectProof.json", + "mode": "100644", + "gitBlob": "abf86d75ffebd2b0958351eced0fc47b9e91729a", + "rawBytes": 1413, + "rawSHA256": "aa52eb32126c0c8ead33c7328dcfb39c4b8a9d8d6fb4ee142d4608da38549dfd" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.SelectSafety.json", + "mode": "100644", + "gitBlob": "386ddd97c861fa76b7d53a131a2bc1d6354bc0fc", + "rawBytes": 1417, + "rawSHA256": "dbd5dfa43c75f513d1075874a6dc8c4bb32bd9b5b8f19dffaedeb1c3f8f101eb" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.SelectSource.json", + "mode": "100644", + "gitBlob": "1801518f2419f437f96efdb10e32ae4b49b26e0f", + "rawBytes": 1415, + "rawSHA256": "b9abb6ecbedaafee00c6f5a0091de26ecbfbbe2a479e4f5d6c61f25077c2eff4" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Setup.json", + "mode": "100644", + "gitBlob": "b25149d329a92b5f0fd2c322acd223f62755e767", + "rawBytes": 1389, + "rawSHA256": "4d28643ec4e3cdd48144c574a1015947c9273172b09d59e00faaaff79aaeec6e" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Span.json", + "mode": "100644", + "gitBlob": "dcd9801035c7c7914e7b0d5fe496e063966a9c99", + "rawBytes": 1385, + "rawSHA256": "1f83993ad157550b62ae22c2580ed35e3ee4e1974368107ed8bb1fd6a186401e" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.SpanAssembly.json", + "mode": "100644", + "gitBlob": "353ddc004d79d5842bb2765b5df4f6ffadc51214", + "rawBytes": 1416, + "rawSHA256": "7352b35462d35448599498600656edef8a36745460f567f50664d85d073cc49e" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Structured.reuse.json", + "mode": "100644", + "gitBlob": "66b870dfc051f2e4dc6076789f278624fa60e437", + "rawBytes": 286, + "rawSHA256": "a9d4f5ed3ab28d84854d3a3c7ab4aa70febc0f86359a34042e951499f5d90c0f" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.Width.json", + "mode": "100644", + "gitBlob": "3e27685779f25fe2a94b869e9a1da0121cd5465c", + "rawBytes": 1389, + "rawSHA256": "3e861bead0479f755b02c5b7f959dbeecf5fce80156a06b1a330ae2bed67c353" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.WindowProof.json", + "mode": "100644", + "gitBlob": "75bdf66ed853ad526579c6bf84db05c42eb69720", + "rawBytes": 1413, + "rawSHA256": "36cc07a9d42c9dce5208fcb8699a18aec4804715044a47047dbf60bb32bb8908" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Packed.WindowSafety.json", + "mode": "100644", + "gitBlob": "4732f2bd78e062c3b2b5dcde3a20f4836a912b99", + "rawBytes": 1417, + "rawSHA256": "e23cc414e1b16b4c64cd294a02bbc528864664e402c46fcd1d878f0c3b36d237" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.ReadStoreEval.json", + "mode": "100644", + "gitBlob": "515f9130bcf916a4f50a7595180e0daa2944cdc7", + "rawBytes": 1390, + "rawSHA256": "c39b048966e6e3574b9973cfd4762f438a06a91eda73aa1fb25e5398260c0881" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.Register.json", + "mode": "100644", + "gitBlob": "bd56ce1b896b0af6ba85ae15348f34ee78812864", + "rawBytes": 1371, + "rawSHA256": "edc909ab8ce627c64754c40f3f8ca0e2583629fead640e671d31baf0137994f7" + }, + { + "path": "docs/internal/extensions/opt1/query-development/RMQ.Core.WordRAM.json", + "mode": "100644", + "gitBlob": "25e42af93b4d716669dcbba4f6be0b4f1db289d0", + "rawBytes": 1333, + "rawSHA256": "81f7b54ffd1c1a6bb27aec4f19342332da94bda0c8f925314ee738810c4f4181" + }, + { + "path": "docs/internal/extensions/opt1/query-development/capstone-branch-pass.json", + "mode": "100644", + "gitBlob": "f0d38d670be6e2c7ce6eb15739e35bef4460bb28", + "rawBytes": 1425, + "rawSHA256": "a5d3aab6c1adcc2f2e67138f9857a6e3a904b64e735e2dc87fff9375f5f83d10" + }, + { + "path": "docs/internal/extensions/opt1/query-development/capstone-first-failure.json", + "mode": "100644", + "gitBlob": "4de1b64e6c7f3a4fde87af320d015a86c1d9bed8", + "rawBytes": 4356, + "rawSHA256": "dfd5855bed02484de412a08c8f0d14c23382b3c748284358a47852a4d150d27d" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/20260912-072230-413-Frame.json", + "mode": "100644", + "gitBlob": "443a7fc9cf442eafbeed9c7ecb96b6acbbef4136", + "rawBytes": 867, + "rawSHA256": "c74b47994c1ec8fe7190dd2e8ce913e1f2a2a819478d823dbb0f74faf40de992" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/20260912-072257-771-Safety.json", + "mode": "100644", + "gitBlob": "811235951ba585b6da784fefb5424fa11eb9f0df", + "rawBytes": 870, + "rawSHA256": "674b48dcf1a64cf4ea090fc85f732745d5878ef9f8d805c6bec90e1934117afe" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/20260912-072317-427-SourceRelations.json", + "mode": "100644", + "gitBlob": "e7999cc18729469fe1c1f231feae4d7b7994476d", + "rawBytes": 16589, + "rawSHA256": "b95f15697ebd770f7aee0785e0dcbcc81245f163736f4abf59f584063cc69299" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/20260912-072444-505-SourceRelations.json", + "mode": "100644", + "gitBlob": "6d49f30a0a42216918cfb3c45f0a0eed398ee9dc", + "rawBytes": 6579, + "rawSHA256": "69d751008a709bcb74008c56b281c08b872803ed5d073706efe94d5f0e1259a6" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/20260912-072545-457-SourceRelations.json", + "mode": "100644", + "gitBlob": "861252f274d70fd8a4ec4f6ff2c8c5b8d620f225", + "rawBytes": 909, + "rawSHA256": "375352f4de6ea39228d30727866687fdb57710a2119124ec75539561ac277380" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/20260912-072553-584-Types.json", + "mode": "100644", + "gitBlob": "a55faf41f5a160a3da98db23ff0f3ad73f9fbbdb", + "rawBytes": 11888, + "rawSHA256": "7f2efc270064fd650077c650900397f7bedf6c57c0d8e42e2889c27236140dd9" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/CONTRACT.md", + "mode": "100644", + "gitBlob": "33364ec377f79ed9f7ce2560fc0e837ad3e0c5b9", + "rawBytes": 4223, + "rawSHA256": "a94f7323c282cdb0b8d1512699771ac71c5c457ef51af374a000af08179f8978" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/REPORT.md", + "mode": "100644", + "gitBlob": "83bf754518156cf720ea7ac693e2aa56c463b0a1", + "rawBytes": 13348, + "rawSHA256": "95799a33b9dcb129f8c4541408a40d2319d7203df1fa0f2b8ffec8b130aa1636" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/Types.lean", + "mode": "100644", + "gitBlob": "0c17956936cd2bd84fa5fbbea2ab3feac87101ad", + "rawBytes": 835, + "rawSHA256": "bfaf00282de4a909d7780d1afe71c960ed693d3f109931a8fe503b3aae1a86b2" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/check.ps1", + "mode": "100644", + "gitBlob": "4ee7b37c363bebb8371f9c5877ac5de4bad1f9b2", + "rawBytes": 1997, + "rawSHA256": "bd95f3b065521b0a0ce2a5c36ec3ee3fd10e8cecac32f5b3bad0c698fc31abf3" + }, + { + "path": "docs/internal/extensions/opt1/relations-development/hygiene.json", + "mode": "100644", + "gitBlob": "145f47243dc09ab3f897494bd848a9c0755c529d", + "rawBytes": 652, + "rawSHA256": "2807f552d290c853f7494453f397d1be25938717ef16606bb58d39a8222bd0ff" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/.gitattributes", + "mode": "100644", + "gitBlob": "79251caef4b743f3bdf7b268f8b66a859601fb77", + "rawBytes": 801, + "rawSHA256": "8e4f9bb9284238f2bcf3b17d0ae28fd631ac2957b3a1c48252d9cc9cfad676f1" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "9fd9cace09ceba1058f83765405762c0fa5e1d2f", + "rawBytes": 64577, + "rawSHA256": "690d9ff348d86c2afdb93016d2626e837721ba1b633a7916dda55284672b4561" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/PROOF_IDENTITY.md", + "mode": "100644", + "gitBlob": "81708677bf85742da2e43a4811507aabded1bf9d", + "rawBytes": 37806, + "rawSHA256": "719c068f469729787700fba2b6c9bc90f9798c0d8e8fba944b7dacc1a68b91da" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/README.md", + "mode": "100644", + "gitBlob": "b4481a512b232a951abfacd500a57c7f1a710d0f", + "rawBytes": 12669, + "rawSHA256": "291e115d5ac35cec517aa3f6199bd7ce7224a181e1ff949e918a418131abc007" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/REGISTRY.json", + "mode": "100644", + "gitBlob": "bcda60d2bb7c3f924b2257897b2fb99e66e5b453", + "rawBytes": 9334, + "rawSHA256": "59db124f0a3b42057977e2613bc0fb841ec62c8cebd2e0e5bfd5003cfe4f9c0e" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/REPORT.md", + "mode": "100644", + "gitBlob": "cfa93ce3d770e4953c4bef86d68be7b64e0a91ae", + "rawBytes": 28707, + "rawSHA256": "c137409db5e11a51df193174739bc38d003fbc03f63ec1ba42ca75be898ebd3b" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/axiom-union/20260913T0055245605662Z-axioms.json", + "mode": "100644", + "gitBlob": "94c3d85757336e599409388284e1d6a8b9d0bce7", + "rawBytes": 42084, + "rawSHA256": "bcdac03a4b240dd7a7692847e419722f35470dfc38e2715f41de9819b75c4d06" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/axiom-union/INVOCATION.json", + "mode": "100644", + "gitBlob": "8a3905684a62865001028bfd0e02c23bc9da55c7", + "rawBytes": 751, + "rawSHA256": "ffe20603a4d0a4693e52734d70993e05b1b0ee1d173dc7aa56b56911d54b3e61" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/certificate-80/IDENTITY.json", + "mode": "100644", + "gitBlob": "fb6ecc9164e1cbb17d17f3aa0df5aa4dc3fd1876", + "rawBytes": 397, + "rawSHA256": "c5a11dd73189b0a9f556b1b5db3d2a91c86eff586f0585c343e9334f22ba0bef" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/certificate-80/RESULT.json", + "mode": "100644", + "gitBlob": "1e5dcd778a1bb7f313b972bd9523f9b0442ee92e", + "rawBytes": 53830, + "rawSHA256": "bf5a0c0a008c7bb0f57264e759b0985b16479208f721327e8a2d249f5fa17d6b" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/certificate-80/SPECIFICATION.json", + "mode": "100644", + "gitBlob": "28420455353fd77f14530c9ae8429bbfb6f3ad29", + "rawBytes": 2236, + "rawSHA256": "28a3c24f5396d6350d47f45e264096107cc8abd5d40c7483005a6dca039741be" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/certificate-80/stderr.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/certificate-80/stdout.log", + "mode": "100644", + "gitBlob": "a2e0e2b5ee3ae49a4e6d8b99863a416cc7455105", + "rawBytes": 19674, + "rawSHA256": "34a7303e3ab6ec7e220c701b5e4ee4611b4f6c7089b938e4583f61dd6e9e8ad4" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/claim-scan-a/RESULT.json", + "mode": "100644", + "gitBlob": "36353a42de92be2be299ead0798059524cff46b6", + "rawBytes": 898, + "rawSHA256": "260284c3b1416d6a13bff273d8abcf3dfc4a65ef95a8ecf81d6a3ccfbfa5cfbf" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/claim-scan-a/stderr.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/claim-scan-b/RESULT.json", + "mode": "100644", + "gitBlob": "a87bc97350effb2dc59113098c2cf543ad0f6b52", + "rawBytes": 902, + "rawSHA256": "5be7f4732147008b02c5988592a61f38fa43f15c29530ef19a2fdbd636dc8f1d" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/claim-scan-b/stderr.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/claim-scan-c/RESULT.json", + "mode": "100644", + "gitBlob": "b991c08ab2d1899700683a77db57b7f199d44146", + "rawBytes": 1322, + "rawSHA256": "97c2c038310c2e9fc26c6764f9453008d00b2746da771b1af67eedc8bcd5c74c" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/claim-scan-c/stderr.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/claim-scan-d/RESULT.json", + "mode": "100644", + "gitBlob": "5ef991a7826c77bd5378d962a3bc802c919a11cc", + "rawBytes": 1322, + "rawSHA256": "3f946d4c9dcab28a99bae40dd0c94902dcfb6fb5c02a94b15ede5a5d82b479b5" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/claim-scan-d/stderr.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/lake-build-attempt1-wrong-flag/RESULT.json", + "mode": "100644", + "gitBlob": "13162dca4d09b0d96e8d1334e087a7569d78e376", + "rawBytes": 2475, + "rawSHA256": "298fd5f5c236afcf40fd8f428228df319d2af2e528d830e2fc9d3598a5c51109" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/lake-build-attempt1-wrong-flag/stderr.log", + "mode": "100644", + "gitBlob": "63d0f6e646c4911b219ebdde29a48adddd34950f", + "rawBytes": 34, + "rawSHA256": "0ccbc6fe2a3ea0a8f40382dcef8ac918f83ad1a42a2ee363d36650a75c6eb05e" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/lake-build-attempt1-wrong-flag/stdout.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/lake-build/RESULT.json", + "mode": "100644", + "gitBlob": "455ebd0473f8efc7a1d2e90cbb7da9287a401822", + "rawBytes": 247426, + "rawSHA256": "ccfa0c741f0962c634a741df1e059bafcce26ed2aa3fee5ee15713fbe5fe1499" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/lake-build/stderr.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/lake-build/stdout.log", + "mode": "100644", + "gitBlob": "4a65b2fd1c88ccd712e74d3b1aa39e4cd370e5f1", + "rawBytes": 109246, + "rawSHA256": "a387e1527714d4aea2d9cb737d26aafb211e1eac41a99632e40b27bf91383f37" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/plans/certificate-80.json", + "mode": "100644", + "gitBlob": "28420455353fd77f14530c9ae8429bbfb6f3ad29", + "rawBytes": 2236, + "rawSHA256": "28a3c24f5396d6350d47f45e264096107cc8abd5d40c7483005a6dca039741be" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/plans/regression-49.json", + "mode": "100644", + "gitBlob": "b0539e0eeae181a576a1d73a8f847dec0a81908a", + "rawBytes": 2123, + "rawSHA256": "f407acce0cf2f8664b22b71b977c4a274dac95ccccc5b68a8c6da18d2ff1ca5e" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/plans/runtime-27.json", + "mode": "100644", + "gitBlob": "ceb23f7621537bfa90f5904503da6c1365f746be", + "rawBytes": 1701, + "rawSHA256": "f1d68fa8aa2b83ed96d90b1bfc9c5a897211e01e98e36e38459f6a70c5daf02b" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/prepare-r1/RESULT.json", + "mode": "100644", + "gitBlob": "b9bc07504ccd107854d482e5314566ec1f599cf9", + "rawBytes": 465592, + "rawSHA256": "33712034a1c59b72d7b35d9907284113b3d3768165e3ec9e6dc159e1fcf25ff2" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/prepare-r1/lf-install.json", + "mode": "100644", + "gitBlob": "0ef395f5aff1230dca1a7612872124903cb59c1c", + "rawBytes": 214771, + "rawSHA256": "2de395e8ba6e8909f62d49dd6aeafcbbba647a0694a64039551a4b7f73ac7551" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/prepare-r1/windows-install.json", + "mode": "100644", + "gitBlob": "4350d933d81b251a17853c5e4a5881dab0d40108", + "rawBytes": 214796, + "rawSHA256": "a3fe7ec7651fab0b85aeda340f8a9a477519b0bb543435b9b5900b34c618f0ab" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-001.json", + "mode": "100644", + "gitBlob": "0bbcf3809c53e91d9fdd45d4d836b86585c57b0f", + "rawBytes": 1190, + "rawSHA256": "ae111322a7686833e3d26fe029e3e36a2c4780e11d160073bddc71863b11e1ed" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-001.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-001.stdout.bin", + "mode": "100644", + "gitBlob": "97b9d54bfb7a66330592e4d63951318547a2e5b7", + "rawBytes": 41, + "rawSHA256": "813e228511628c4ade08271df3ed679170f9801e4c383428a8b492d3f3eb33ec" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-002.json", + "mode": "100644", + "gitBlob": "aa16e87650f6724da55fa1b71dfd5a7cd8437512", + "rawBytes": 1234, + "rawSHA256": "53a2ee9b09b22dbee88591b82964ad67ec9d771b87c55ab1a2f1ac1ba33e016c" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-002.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-002.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-003.json", + "mode": "100644", + "gitBlob": "bc477d6af301e8a40e1f6ac3c611abeeac7828f8", + "rawBytes": 1235, + "rawSHA256": "f8349b143a3b648a7e031293c3b13293c83761ef8a15f893c27eebda9d8d82f2" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-003.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-003.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-004.json", + "mode": "100644", + "gitBlob": "f2ac69902a1dd7f3effd52cffc31b3c0af3b01c2", + "rawBytes": 1497, + "rawSHA256": "af1847c9ee46df0a45e4fb8652cd73728a1be32c7ae3ddb83d346c512d399ab0" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-004.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-004.stdout.bin", + "mode": "100644", + "gitBlob": "539328d7c4bf06ca53176deec58e39608dc48900", + "rawBytes": 68359, + "rawSHA256": "954f4354774e6571fc392a678b8cff302a7c2f361166558bc2d5607cb400ab20" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-005.json", + "mode": "100644", + "gitBlob": "6892b3a825d33befdd1e7daeb02073ba79d0d769", + "rawBytes": 1454, + "rawSHA256": "17136e974059ca690f1e8f9ca5e60cf8281631bd314a919c46944b33c1fcc74e" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-005.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-005.stdout.bin", + "mode": "100644", + "gitBlob": "c8f6ee5e6632fd4c7317d1f703251e0d7de74491", + "rawBytes": 88876, + "rawSHA256": "19b0b3eaaf3e9f799247595a21c7988ab4b917f8952730c65e7b5ef98a200f38" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-006.json", + "mode": "100644", + "gitBlob": "f6ada55b0ec526cf8911f532f53ba427b6836f42", + "rawBytes": 1230, + "rawSHA256": "cfac88aeb900a63d0b9141ce8a9b8b1cd02c38034c18e5181277d5a846712658" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-006.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-006.stdout.bin", + "mode": "100644", + "gitBlob": "96d856ad8ad44f4bd84f862ee5275fb3b57015a9", + "rawBytes": 24783, + "rawSHA256": "bdd50082d978815e9005ede9c34a9757f83693806307ee766e4ccd3c8472aaea" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-007.json", + "mode": "100644", + "gitBlob": "bc609170914a9ed242967fb88a91e8c232e77333", + "rawBytes": 1230, + "rawSHA256": "de72b2864cf8e6a72eeea8fa16d1fe4685f86147909e079be9c58dd3e7bbbf28" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-007.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-007.stdout.bin", + "mode": "100644", + "gitBlob": "bd5d0eb38fd4a301eb89b027fcc434fc18dbee75", + "rawBytes": 35633, + "rawSHA256": "486420760dd5c43312dd0a0e9432771b55adde1953088b70597269e057a06051" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-008.json", + "mode": "100644", + "gitBlob": "dac06935abf70780dab2d6167553744428ede2d4", + "rawBytes": 1240, + "rawSHA256": "5603248f79e5bfce523e71e379eb70cb7dbc07480f567ceb1ba18805ac9cd307" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-008.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-008.stdout.bin", + "mode": "100644", + "gitBlob": "3760470717560aafc5ae4652522eff1953d001e7", + "rawBytes": 11640, + "rawSHA256": "0d1529c98d35b6ff2ac53d58d107f0a47ec8f5d263f51819c085827c055a63bb" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-009.json", + "mode": "100644", + "gitBlob": "403a49c67d287cf967f30845def55739d4a514d4", + "rawBytes": 1223, + "rawSHA256": "1ba3de52603eddb20c81669eff3c0ba5f98186ff31ca4b8db7e6c1718b70c456" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-009.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-009.stdout.bin", + "mode": "100644", + "gitBlob": "7a78c403e548df7ba7e7782ab081f08c4f4ad32b", + "rawBytes": 24706, + "rawSHA256": "6a435eff7e3cd2a2dfea248b3a8abebabaf10ff643927c5c3fcae52e666e7cb5" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-010.json", + "mode": "100644", + "gitBlob": "b65099f9cafaaf0973ef0868e58c230201f5ebb4", + "rawBytes": 1224, + "rawSHA256": "9c4936bc7d04181c049d09c8e64617bfa6ba4a71d4a9f83c19b2fe15663aa597" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-010.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-010.stdout.bin", + "mode": "100644", + "gitBlob": "4c9314d23730f318c1a4f99ca13e2156912f277b", + "rawBytes": 9090, + "rawSHA256": "0d4f03ac19f890b67894b74042ff7559add574a8d160539ad3565a48289ba0ae" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-011.json", + "mode": "100644", + "gitBlob": "02ff154131de2fa6bd4687664d655baa160a1cb2", + "rawBytes": 1496, + "rawSHA256": "75faf48d86b9477bd0f4e6b1315d2dda3ab5a70cce47403c4b9ac92e4b94ce80" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-011.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-011.stdout.bin", + "mode": "100644", + "gitBlob": "9e115d5f5c9e0eeea83a9e31f475494c216ad144", + "rawBytes": 90913, + "rawSHA256": "250c459fcb35fad451c65861b7fdb6b7d5a771550357df7322159af8cf48bdde" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-012.json", + "mode": "100644", + "gitBlob": "966d0c6b228862cb3f82b8c4d957bbf398d50fa7", + "rawBytes": 1230, + "rawSHA256": "5a394e7d202947ca8f15a4c10d54e36c904cfeb33adecd8295961ef0fdaca5a3" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-012.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-012.stdout.bin", + "mode": "100644", + "gitBlob": "bd5d0eb38fd4a301eb89b027fcc434fc18dbee75", + "rawBytes": 35633, + "rawSHA256": "486420760dd5c43312dd0a0e9432771b55adde1953088b70597269e057a06051" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-013.json", + "mode": "100644", + "gitBlob": "4c7368036a1b189a50710dc5e07126e136bebbda", + "rawBytes": 1240, + "rawSHA256": "46150e8fb8bef365f4b027b3839b1581b03be6bb9160a1e5d6cb07ecedf13f26" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-013.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-013.stdout.bin", + "mode": "100644", + "gitBlob": "fdd3690e0af9cc8322aad33d5bafe135ca970a34", + "rawBytes": 32051, + "rawSHA256": "58387df5dc955c5634a0e2bccccdfdb7cc72552d4b1fb89f2f68577f9bff0706" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-014.json", + "mode": "100644", + "gitBlob": "e7b3d7e4209d752a8a2742a29f7118a1f92fb55a", + "rawBytes": 1236, + "rawSHA256": "23c6f70d4415dd966f5be6a549e7855e22e50bf04cab11d57f75851b9673e0b4" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-014.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-014.stdout.bin", + "mode": "100644", + "gitBlob": "81708677bf85742da2e43a4811507aabded1bf9d", + "rawBytes": 37806, + "rawSHA256": "719c068f469729787700fba2b6c9bc90f9798c0d8e8fba944b7dacc1a68b91da" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-015.json", + "mode": "100644", + "gitBlob": "2ef24344290a8adc1a271a8d8ca24d203f999025", + "rawBytes": 1521, + "rawSHA256": "a00a7501778f2eb1f58cca6ccb036fc5c86330f4e42ba135776c94c0c456411d" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-015.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-015.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-016.json", + "mode": "100644", + "gitBlob": "f63b5715134fc138bdb300561d5f219bf5ccbdb1", + "rawBytes": 1481, + "rawSHA256": "ecc7b302e2c934c3a228ad77dd29cfc0b9946b252c26fadb2a9922e542a3a0c2" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-016.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-016.stdout.bin", + "mode": "100644", + "gitBlob": "b101dc308c09d6126c80b402ee0c8a112277b237", + "rawBytes": 4611, + "rawSHA256": "5160689ef625a76112cd3acffcf8cce0488133a14e88fac5800ce967efe44256" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-017.json", + "mode": "100644", + "gitBlob": "68e69625dd6c0d6ced1a3f225f7fbbe1921c3a5f", + "rawBytes": 1454, + "rawSHA256": "87e787ab208fe5397610c13d31bac03f470f8855dfbbb4005b069281f3bb2656" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-017.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-017.stdout.bin", + "mode": "100644", + "gitBlob": "c8f6ee5e6632fd4c7317d1f703251e0d7de74491", + "rawBytes": 88876, + "rawSHA256": "19b0b3eaaf3e9f799247595a21c7988ab4b917f8952730c65e7b5ef98a200f38" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-018.json", + "mode": "100644", + "gitBlob": "a96bc2c725c6c652d8688084591b8e80f2b23637", + "rawBytes": 1454, + "rawSHA256": "f72924344c69571a28569d35e718e0839d3c9d9d8933db26360e9a7b4fa249aa" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-018.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/git/git-018.stdout.bin", + "mode": "100644", + "gitBlob": "c8f6ee5e6632fd4c7317d1f703251e0d7de74491", + "rawBytes": 88876, + "rawSHA256": "19b0b3eaaf3e9f799247595a21c7988ab4b917f8952730c65e7b5ef98a200f38" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/process.json", + "mode": "100644", + "gitBlob": "dcc45f954f4257ce328cb34ae8c1f549cbd4bb25", + "rawBytes": 1046, + "rawSHA256": "a765a87bcec496108746469643592d2b0a415101f7eeda3e4b8c69dc36d3d89e" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c1/result.json", + "mode": "100644", + "gitBlob": "d926f955b3ebd1fb86b64697eef547fa3129809b", + "rawBytes": 543685, + "rawSHA256": "0f80fec5e49d0fae83c498c87b6d30a1973abaac955070e22b3addb11290cd58" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-001.json", + "mode": "100644", + "gitBlob": "8fbc18403cbef3eb7578872d5dbad860e58b94bb", + "rawBytes": 1190, + "rawSHA256": "379cc5ab46da03c965043564427e7f93f251d89305f7f5ca3a9fb9c0bad14205" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-001.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-001.stdout.bin", + "mode": "100644", + "gitBlob": "f12142ba38d47f2798b766f01c3cef9e7e9735d0", + "rawBytes": 41, + "rawSHA256": "f33be2901e99d992a7cfb2f8bd5c41a270f222a087090a9aa5a2054627cbb64f" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-002.json", + "mode": "100644", + "gitBlob": "489fe089aec6b6ca11b9c956f0f3d2fb37fed2ef", + "rawBytes": 1234, + "rawSHA256": "bddcd471d0acc5c9d216d5c683571c49fbcf34b85500328e60e93b86bda7417e" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-002.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-002.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-003.json", + "mode": "100644", + "gitBlob": "0529f1fb349413702391a66d23421d70afcf34a2", + "rawBytes": 1235, + "rawSHA256": "c2f5f4bf651aed8ecd5a4881d5ef63570fd125fd7dc40d7e046932dde4f777d6" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-003.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-003.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-004.json", + "mode": "100644", + "gitBlob": "89d6fa9d10c6d8ecc296f8aba0bfb8c3af6cb0e6", + "rawBytes": 1496, + "rawSHA256": "da6d02e05c78a31d58cab66f1fb67f47f26f4b8a9e3b1d3511f324573f8c96ce" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-004.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-004.stdout.bin", + "mode": "100644", + "gitBlob": "539328d7c4bf06ca53176deec58e39608dc48900", + "rawBytes": 68359, + "rawSHA256": "954f4354774e6571fc392a678b8cff302a7c2f361166558bc2d5607cb400ab20" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-005.json", + "mode": "100644", + "gitBlob": "4abf1a0ed0ad2c9d93eed64473e7eef97e441704", + "rawBytes": 1455, + "rawSHA256": "0b7c20c98642ddba9e83e704582b9213bbd68b9ed58abb1d5b30a1151e076a11" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-005.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-005.stdout.bin", + "mode": "100644", + "gitBlob": "c85dca28255babeb1670c4526e2576c1ae561b7c", + "rawBytes": 107590, + "rawSHA256": "3956f3032d7dc6429dfabfca34ed853c478fd9c3d6eb9bb6d4d1c985a9d5a78a" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-006.json", + "mode": "100644", + "gitBlob": "f913fbd0f7d06dff739c06193b1651356720c086", + "rawBytes": 1230, + "rawSHA256": "f52117fea2e30bdf0f097d69d9d4ba3e9f9575ef0a03c41bfb338223d1f59bd1" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-006.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-006.stdout.bin", + "mode": "100644", + "gitBlob": "96d856ad8ad44f4bd84f862ee5275fb3b57015a9", + "rawBytes": 24783, + "rawSHA256": "bdd50082d978815e9005ede9c34a9757f83693806307ee766e4ccd3c8472aaea" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-007.json", + "mode": "100644", + "gitBlob": "486481e790317d33eff8bc5d11ddc4c62e831b60", + "rawBytes": 1230, + "rawSHA256": "98944a95a35250bada9329e90764efee9a20de52e690ed684121b1585aaf5d0f" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-007.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-007.stdout.bin", + "mode": "100644", + "gitBlob": "bd5d0eb38fd4a301eb89b027fcc434fc18dbee75", + "rawBytes": 35633, + "rawSHA256": "486420760dd5c43312dd0a0e9432771b55adde1953088b70597269e057a06051" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-008.json", + "mode": "100644", + "gitBlob": "b9fa3dd0375dc20397027b0608bd698e89c55ce7", + "rawBytes": 1455, + "rawSHA256": "fd35cc640994a065803ffc325b07ca0d7930c977c263653dcfd531c1237c5bd3" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-008.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/git/git-008.stdout.bin", + "mode": "100644", + "gitBlob": "c85dca28255babeb1670c4526e2576c1ae561b7c", + "rawBytes": 107590, + "rawSHA256": "3956f3032d7dc6429dfabfca34ed853c478fd9c3d6eb9bb6d4d1c985a9d5a78a" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/process.json", + "mode": "100644", + "gitBlob": "b038c7e18cb8315c99944cd85a8c70b53680b5bb", + "rawBytes": 1336, + "rawSHA256": "049620067c9b191e5420f18929bdf35e4e17d780bbb47ff33655fd4704cb6f11" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c2/result.json", + "mode": "100644", + "gitBlob": "5a9458361594def433e3462faa51daaeb25dae77", + "rawBytes": 236051, + "rawSHA256": "2a4f3a10ea0048a22abdba9b8b81fc249325a0d9def42ebbc56b3f238d294cbe" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-001.json", + "mode": "100644", + "gitBlob": "5678264e8f6da757e825514a7a6e9abfb9b32a5f", + "rawBytes": 1190, + "rawSHA256": "ef9ba0562d6904d076e4209d4390afbd1a8fa4544b3701a249aedabee9f2ebf6" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-001.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-001.stdout.bin", + "mode": "100644", + "gitBlob": "c5dba678ffcd745862e13c731b2698463ca3bf9f", + "rawBytes": 41, + "rawSHA256": "8a9c659661f0fdcef1db9a753156cae7577a8a8162b64c2268511d7cb62152f9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-002.json", + "mode": "100644", + "gitBlob": "bf7594f59d6639605e6a5b37cd2890d7640ab304", + "rawBytes": 1235, + "rawSHA256": "a2a3c0b55bd05507049e3df8f4ad58bf4164ead158455aaf06d5554c76e70afc" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-002.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-002.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-003.json", + "mode": "100644", + "gitBlob": "cfd8cedf529da933957e51fbb17796d636108e95", + "rawBytes": 1234, + "rawSHA256": "896fbaf7aaf52b8fba486ea3fa6b02e04e2586046d5d08badf4c525fc418538e" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-003.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-003.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-004.json", + "mode": "100644", + "gitBlob": "f04559f95da3376c6d45e46d8ea416620c60d779", + "rawBytes": 1497, + "rawSHA256": "4b0dc08262f5ba641caecbcb94061e387edb2d7a12f5cecad3f453cb5dfe7d63" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-004.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-004.stdout.bin", + "mode": "100644", + "gitBlob": "539328d7c4bf06ca53176deec58e39608dc48900", + "rawBytes": 68359, + "rawSHA256": "954f4354774e6571fc392a678b8cff302a7c2f361166558bc2d5607cb400ab20" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-005.json", + "mode": "100644", + "gitBlob": "72fc018d6c72349d5233d1e4d108d953dc6d330d", + "rawBytes": 1455, + "rawSHA256": "a4d2d3716117482bde7dc14a20f5bf0c3296e91ec87199d14f5a17a7e6246d64" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-005.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-005.stdout.bin", + "mode": "100644", + "gitBlob": "91a242f75d835a0c123040f5cb2b67c2ccea051a", + "rawBytes": 111272, + "rawSHA256": "324a4b9d41064758dedfd3e46936fc54b8107fd1b903f24a20bc2ccbfc663826" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-006.json", + "mode": "100644", + "gitBlob": "8ea4ed198a130c58cf78b40de82f0a31424789cd", + "rawBytes": 1230, + "rawSHA256": "410525760542d3efd72a4b6d10209baea6bac32479150ab5e899a2808c3b51f9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-006.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-006.stdout.bin", + "mode": "100644", + "gitBlob": "96d856ad8ad44f4bd84f862ee5275fb3b57015a9", + "rawBytes": 24783, + "rawSHA256": "bdd50082d978815e9005ede9c34a9757f83693806307ee766e4ccd3c8472aaea" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-007.json", + "mode": "100644", + "gitBlob": "cd379992ea3af1e8cd28a7611638b593a888ee7f", + "rawBytes": 1230, + "rawSHA256": "d1c1cc3677bfce2529775bcd921c2a84cd34daaa2c61b06a178fcae447267074" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-007.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-007.stdout.bin", + "mode": "100644", + "gitBlob": "bd5d0eb38fd4a301eb89b027fcc434fc18dbee75", + "rawBytes": 35633, + "rawSHA256": "486420760dd5c43312dd0a0e9432771b55adde1953088b70597269e057a06051" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-008.json", + "mode": "100644", + "gitBlob": "e25f5da50f46b930b3777d5a91dbad4f1edc5b73", + "rawBytes": 1239, + "rawSHA256": "878708d2ae422020a36780047859ee199001dfea8b717e9a0ccbe013dc9a2382" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-008.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-008.stdout.bin", + "mode": "100644", + "gitBlob": "3760470717560aafc5ae4652522eff1953d001e7", + "rawBytes": 11640, + "rawSHA256": "0d1529c98d35b6ff2ac53d58d107f0a47ec8f5d263f51819c085827c055a63bb" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-009.json", + "mode": "100644", + "gitBlob": "0e16f68664fd66251bd931f2f923fab64db1f30e", + "rawBytes": 1224, + "rawSHA256": "223551b9c7bdd44fb306016fed93bf7afac19e280c30869fab62d1065e41a1a7" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-009.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-009.stdout.bin", + "mode": "100644", + "gitBlob": "7a78c403e548df7ba7e7782ab081f08c4f4ad32b", + "rawBytes": 24706, + "rawSHA256": "6a435eff7e3cd2a2dfea248b3a8abebabaf10ff643927c5c3fcae52e666e7cb5" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-010.json", + "mode": "100644", + "gitBlob": "8a1ad87378cf6f88bf51b120f1bd0448e6d461e4", + "rawBytes": 1224, + "rawSHA256": "a4c33ca61d0ba0573296a47bcd281483f868b197a4ec85530c8379e4df0463a1" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-010.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-010.stdout.bin", + "mode": "100644", + "gitBlob": "4c9314d23730f318c1a4f99ca13e2156912f277b", + "rawBytes": 9090, + "rawSHA256": "0d4f03ac19f890b67894b74042ff7559add574a8d160539ad3565a48289ba0ae" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-011.json", + "mode": "100644", + "gitBlob": "8fb5111e11eed8c7c2108eaa4368c23305e78261", + "rawBytes": 1497, + "rawSHA256": "791384894174f65adb6425dd87ffee3883a9ca510c3f8dd65cba4c2530c18dda" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-011.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-011.stdout.bin", + "mode": "100644", + "gitBlob": "303c58c52a6738e98ec4ed2d676d1c3cc498c786", + "rawBytes": 113807, + "rawSHA256": "11c14eefc05a6ffe6f644b10dd031a04b8ae0376844f675a9adcc1609a267411" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-012.json", + "mode": "100644", + "gitBlob": "4996431bc212b97974d8adba7907baad4c7df9da", + "rawBytes": 1230, + "rawSHA256": "2d96d9f52f0798d1bd8d7f07c6dbf1e10e08b8a3d1d72a55f31e255392e7f422" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-012.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-012.stdout.bin", + "mode": "100644", + "gitBlob": "bd5d0eb38fd4a301eb89b027fcc434fc18dbee75", + "rawBytes": 35633, + "rawSHA256": "486420760dd5c43312dd0a0e9432771b55adde1953088b70597269e057a06051" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-013.json", + "mode": "100644", + "gitBlob": "c09972f808a928ac81fe5612586a6543618fc39f", + "rawBytes": 1240, + "rawSHA256": "1c2b7096fb3e206ea194441560a9d9292d19d2b54973145264c2e7824db63f64" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-013.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-013.stdout.bin", + "mode": "100644", + "gitBlob": "9fd9cace09ceba1058f83765405762c0fa5e1d2f", + "rawBytes": 64577, + "rawSHA256": "690d9ff348d86c2afdb93016d2626e837721ba1b633a7916dda55284672b4561" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-014.json", + "mode": "100644", + "gitBlob": "70c9a9e00d1e4047217793d60faddb53e1d7dffb", + "rawBytes": 1237, + "rawSHA256": "b3618116483a66ddf3a5206a867a05d03565c3808fba7d719bddaf08acc9c7d5" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-014.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-014.stdout.bin", + "mode": "100644", + "gitBlob": "81708677bf85742da2e43a4811507aabded1bf9d", + "rawBytes": 37806, + "rawSHA256": "719c068f469729787700fba2b6c9bc90f9798c0d8e8fba944b7dacc1a68b91da" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-015.json", + "mode": "100644", + "gitBlob": "91c2d239537f53c6aa601e65c64a638add29e0ec", + "rawBytes": 1521, + "rawSHA256": "a7f0cf8fe9d5b012729de35157367481a0da7ba41975dec8c661e399314194ff" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-015.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-015.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-016.json", + "mode": "100644", + "gitBlob": "e9a44bdb4669aed9435b9de4d9349528a3a95cd0", + "rawBytes": 1481, + "rawSHA256": "175a13a24febfee41a54205efa5eed7c6b8dce8dbe17210dd37cdd5f09fa5563" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-016.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-016.stdout.bin", + "mode": "100644", + "gitBlob": "8fc2e260632e387b58a5d07cb77701b22c68ff55", + "rawBytes": 4611, + "rawSHA256": "3111db4dfd9dd148ab70f4d78e762f78c9994f0b5c9d805a36b5d4ad3d623204" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-017.json", + "mode": "100644", + "gitBlob": "dd0a10300e9a09622a046f25760323cc9b986750", + "rawBytes": 1455, + "rawSHA256": "f807d40c6310a4f7a0bc96074106f1b7fa3923440264ac8cd9376dcc4b3a4ad4" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-017.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-017.stdout.bin", + "mode": "100644", + "gitBlob": "91a242f75d835a0c123040f5cb2b67c2ccea051a", + "rawBytes": 111272, + "rawSHA256": "324a4b9d41064758dedfd3e46936fc54b8107fd1b903f24a20bc2ccbfc663826" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-018.json", + "mode": "100644", + "gitBlob": "f72753927cbf9066240513ea70f5a7b35e48fd20", + "rawBytes": 1455, + "rawSHA256": "22cd1b7d1f60566ada3911e334ac0e7e7defbdd04aeab53a3c7611792097d9fa" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-018.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/git/git-018.stdout.bin", + "mode": "100644", + "gitBlob": "91a242f75d835a0c123040f5cb2b67c2ccea051a", + "rawBytes": 111272, + "rawSHA256": "324a4b9d41064758dedfd3e46936fc54b8107fd1b903f24a20bc2ccbfc663826" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/process.json", + "mode": "100644", + "gitBlob": "3359b1da30ba271964a0b8a27a2e839c821e63b6", + "rawBytes": 1046, + "rawSHA256": "04dcfee265cfedb81df514644803ce7b57f73cb6070107c624a3b912a10313dd" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/preservation-c4/result.json", + "mode": "100644", + "gitBlob": "8c730b33eca2fd5f709d6cdaef29398a78728dbb", + "rawBytes": 543691, + "rawSHA256": "d180c5ec6281f297dce3091687f6da136d83784650b3b0846c4b789e06510313" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/IDENTITY.json", + "mode": "100644", + "gitBlob": "44d0539a706634d98e7137447f9b2a7d828843e3", + "rawBytes": 396, + "rawSHA256": "69fae4175530c7a65d7b1737d445741b5a8634b074f46cdae90cfd019c4a9c2f" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/RESULT.json", + "mode": "100644", + "gitBlob": "bce6c611783d246464de4c46237a94e72ac96616", + "rawBytes": 11880, + "rawSHA256": "0ab69a10bb6caf5453ad0ba7dcfe4b49ba5d6824f2a887c6be16c091ae23ec9c" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/SPECIFICATION.json", + "mode": "100644", + "gitBlob": "b0539e0eeae181a576a1d73a8f847dec0a81908a", + "rawBytes": 2123, + "rawSHA256": "f407acce0cf2f8664b22b71b977c4a274dac95ccccc5b68a8c6da18d2ff1ca5e" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/C09-MIDDLE-OMITTED-restoration.json", + "mode": "100644", + "gitBlob": "dc95d574cf148d394078905e98414030461978ca", + "rawBytes": 525, + "rawSHA256": "905b1886bc406d72411c6182c691219abf225d8c99e18d974ba348b7fd6a8fd9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/C10-MIDDLE-DUPLICATE-restoration.json", + "mode": "100644", + "gitBlob": "dc95d574cf148d394078905e98414030461978ca", + "rawBytes": 525, + "rawSHA256": "905b1886bc406d72411c6182c691219abf225d8c99e18d974ba348b7fd6a8fd9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P05-SOURCE-TOKEN-restoration.json", + "mode": "100644", + "gitBlob": "80144e73576e92bc5d66cd474a97919170b04b57", + "rawBytes": 486, + "rawSHA256": "4147f09c50bef089668d2c89d99bbbc94510f0c0cdcb9e95d7ce7575eeb3fbfa" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P06-ARTIFACT-TOKEN-restoration.json", + "mode": "100644", + "gitBlob": "326943a101becbb2ee7f0076a0d8c7f271518705", + "rawBytes": 508, + "rawSHA256": "e7131480510326d9939b7f6ea32cc20c6108b641f1c12fa765e872f457793e65" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P07-ARTIFACT-MISSING-nested-failure.json", + "mode": "100644", + "gitBlob": "3c1c3477a3d04788e09e803d6e0098ff1e28ff02", + "rawBytes": 1146, + "rawSHA256": "f306dcd75b2d986189008fa3c5f517fe475846055d9545d8198b14d6bb545ca6" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P07-ARTIFACT-MISSING-restoration.json", + "mode": "100644", + "gitBlob": "326943a101becbb2ee7f0076a0d8c7f271518705", + "rawBytes": 508, + "rawSHA256": "e7131480510326d9939b7f6ea32cc20c6108b641f1c12fa765e872f457793e65" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P08-ARTIFACT-STALE-nested-failure.json", + "mode": "100644", + "gitBlob": "963df18de15ef61334e8038af8782fb28dc49fac", + "rawBytes": 1013, + "rawSHA256": "e73e5863f62d1e014f03f3365576a9a8a560b588d21e6db83507e43e4a308a63" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P08-ARTIFACT-STALE-restoration.json", + "mode": "100644", + "gitBlob": "326943a101becbb2ee7f0076a0d8c7f271518705", + "rawBytes": 508, + "rawSHA256": "e7131480510326d9939b7f6ea32cc20c6108b641f1c12fa765e872f457793e65" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P09-SOURCE-PROFILE-restoration.json", + "mode": "100644", + "gitBlob": "43a29200eac0dcfd625651c2ef1487b06cb7665f", + "rawBytes": 532, + "rawSHA256": "9d8814f36e7b1549d39839f9aba6c84deaa0f54134afd7eb97c19c01900b209c" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P10-BUILD-RECEIPT-restoration.json", + "mode": "100644", + "gitBlob": "82520ad5e28736c34f7a3da73af78e26ce0ed386", + "rawBytes": 531, + "rawSHA256": "4f4193f5f46cceb04d87e3630d58d7d0d266fe981a88bec8842d9db76ff79cb9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P11-TOOLCHAIN-TEXT-restoration.json", + "mode": "100644", + "gitBlob": "ddb5676811a933360e51a08e250faf1eca8f8361", + "rawBytes": 479, + "rawSHA256": "544dfb38111ab496f9a9d668548715b1080b6029ab86f80c7cbdd73907c4df12" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P12-IMPORT-OMITTED-restoration.json", + "mode": "100644", + "gitBlob": "148c552dddde65ba0bfcfda684c9967cc2c130b9", + "rawBytes": 501, + "rawSHA256": "b67f77a048fdd21908b1420af6e36d01d5a8a5962a7e3b3fa3365237a0c88d74" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P13-IMPORT-DUPLICATE-restoration.json", + "mode": "100644", + "gitBlob": "148c552dddde65ba0bfcfda684c9967cc2c130b9", + "rawBytes": 501, + "rawSHA256": "b67f77a048fdd21908b1420af6e36d01d5a8a5962a7e3b3fa3365237a0c88d74" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P14-SOURCE-SPACE-restoration.json", + "mode": "100644", + "gitBlob": "80144e73576e92bc5d66cd474a97919170b04b57", + "rawBytes": 486, + "rawSHA256": "4147f09c50bef089668d2c89d99bbbc94510f0c0cdcb9e95d7ce7575eeb3fbfa" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P15-SOURCE-UTF8-nested-failure.json", + "mode": "100644", + "gitBlob": "16d19c4c2aa007e8b51cfe386d83c5c09d1b0c9f", + "rawBytes": 1092, + "rawSHA256": "e6ee064e7cf6ed416a887a65d8acbdf44071bc7ded58b830f42fb23f18ab8126" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P15-SOURCE-UTF8-restoration.json", + "mode": "100644", + "gitBlob": "80144e73576e92bc5d66cd474a97919170b04b57", + "rawBytes": 486, + "rawSHA256": "4147f09c50bef089668d2c89d99bbbc94510f0c0cdcb9e95d7ce7575eeb3fbfa" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P16-SOURCE-BOM-restoration.json", + "mode": "100644", + "gitBlob": "80144e73576e92bc5d66cd474a97919170b04b57", + "rawBytes": 486, + "rawSHA256": "4147f09c50bef089668d2c89d99bbbc94510f0c0cdcb9e95d7ce7575eeb3fbfa" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P17-SOURCE-BARE-CR-restoration.json", + "mode": "100644", + "gitBlob": "80144e73576e92bc5d66cd474a97919170b04b57", + "rawBytes": 486, + "rawSHA256": "4147f09c50bef089668d2c89d99bbbc94510f0c0cdcb9e95d7ce7575eeb3fbfa" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P19-EXTRA-ARTIFACT-restoration.json", + "mode": "100644", + "gitBlob": "23b71374f17e7f22ee7673b89f45703c8b35f19a", + "rawBytes": 70768, + "rawSHA256": "aec31169a8011e973c4df074973b9bdf8125696fdd1e31216d7b79e3ad26f6b0" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P20-SHADOW-DIRECTORY-restoration.json", + "mode": "100644", + "gitBlob": "b178bf3844f94a373b6f2e5c2a6371d6a23c436c", + "rawBytes": 70762, + "rawSHA256": "6419eef8696ba7a59d016f1b6c05be1db0d7615d29a779b5c318e23d7ee9d043" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/P21-ARTIFACT-SIDECAR-restoration.json", + "mode": "100644", + "gitBlob": "23740fb7bc4da4c31e7e9ae0894f9d2144160d88", + "rawBytes": 70787, + "rawSHA256": "9b816c60dcab454d197c0a53b9ac24c6a392cb2652d94a6d19c29005a52970aa" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/R08-MIDDLE-OMITTED-restoration.json", + "mode": "100644", + "gitBlob": "d999e3af2b0a0024ed0325214bf9d12555df28b8", + "rawBytes": 518, + "rawSHA256": "28f6f6ae31540dd82a7397317598ccd369a0d00f4b5a97137bfb628df61c08d1" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/R09-MIDDLE-DUPLICATE-restoration.json", + "mode": "100644", + "gitBlob": "d999e3af2b0a0024ed0325214bf9d12555df28b8", + "rawBytes": 518, + "rawSHA256": "28f6f6ae31540dd82a7397317598ccd369a0d00f4b5a97137bfb628df61c08d1" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/RESULT.json", + "mode": "100644", + "gitBlob": "8469a93815a4292767126418b4f1d203ca528344", + "rawBytes": 113872, + "rawSHA256": "246f53054f8dd081edfec90874534fea2e133489872dabd9ca01664f01156192" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/V01-SOLE-SETUP-verdict.json", + "mode": "100644", + "gitBlob": "21729a397a3e422a76960d46526bedd1713452b0", + "rawBytes": 175, + "rawSHA256": "e9d7dbb1b3ae1d490c30d805d8e66c9013f121d342006f1cee8b0848d9fbaae6" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/V02-MIXED-STDOUT-verdict.json", + "mode": "100644", + "gitBlob": "3dfeb4266c5e56de81f66708721d7a095137a4f4", + "rawBytes": 228, + "rawSHA256": "8bf7693e8b6c45bde24c64df5441a59f779b3fdb60cfaa3ce0736dcd3dc4a028" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/V03-SUCCESS-STDOUT-verdict.json", + "mode": "100644", + "gitBlob": "0629cd35dfd04333ac9bf09c870b8be8204d76b1", + "rawBytes": 230, + "rawSHA256": "b94a644278506b55d89133f3aedb2bc784501a39b84cb79ee1ab044fdcf19882" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/V04-WRONG-STDERR-verdict.json", + "mode": "100644", + "gitBlob": "3fb8583ecc248afe4b3b72bc33d74ec5f712cbe5", + "rawBytes": 231, + "rawSHA256": "31417ebe11cd21e031eef8b8773e0459de1cc902f1ce4d4639d323bfaa9035e5" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/V05-ALLOWED-PROGRESS-verdict.json", + "mode": "100644", + "gitBlob": "71b2c4051dbe3920f48dcb2e66775195056da9cc", + "rawBytes": 181, + "rawSHA256": "f421487d1a9a0efbeadcaa6dd6624fa9815dd16ba4b8b0dfb37590cbc4719b56" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/V06-DUPLICATE-PROGRESS-verdict.json", + "mode": "100644", + "gitBlob": "f037ffa28c1d294f5eadc5dd295957ef55c1e764", + "rawBytes": 237, + "rawSHA256": "becf65636ac794285e33a32c8201374657942f451406f15035ad7ddc0a5d58d6" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/V07-REORDERED-PROGRESS-verdict.json", + "mode": "100644", + "gitBlob": "9dae2e436d6c7f73327535b575f01a6e127d900c", + "rawBytes": 237, + "rawSHA256": "d11c552242c5a1c6216ccc5801ed31834ba8fa08102e6fdea0afbee8ae382006" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/V08-EXTRA-STDERR-verdict.json", + "mode": "100644", + "gitBlob": "a41ff19b841d05a49676f3ca8b8571ebb409a266", + "rawBytes": 231, + "rawSHA256": "f8f905a829c23c214a187762a9cd214aaf15a662b296e2b7196bc2e706f63b8c" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/V09-PREFIX-HOLDOUT-verdict.json", + "mode": "100644", + "gitBlob": "5548db51189b55071111ebe24cee7c7333a85879", + "rawBytes": 230, + "rawSHA256": "ff15c97a7590ec0cf0eb1daed2ae935a178580d917b1de15b5d21a91264f73be" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/runner/identity.json", + "mode": "100644", + "gitBlob": "4686ecce5457d1b35a9877ecde209e69bf14310d", + "rawBytes": 441, + "rawSHA256": "dde0ee7cbb6098f9a762f6f1615e8a67562762a4a12dbec126c589ef0fe7f7ee" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/stderr.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/regression-49/stdout.log", + "mode": "100644", + "gitBlob": "ed2cfdbebfad9904c63305126019212837db2189", + "rawBytes": 1912, + "rawSHA256": "9e1d31cc96f4ae09d6a8ad08ef069ba180e9cb550d30f0736beddc5e8dcb0efb" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/runtime-27/IDENTITY.json", + "mode": "100644", + "gitBlob": "fca3f78b81f7800de01bdf8318bc2bbdfab230f8", + "rawBytes": 393, + "rawSHA256": "6032d42915b2cb8cba8dc24245758f2ed0f3cfcb0ac3eeb2c6d414fd2f329f00" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/runtime-27/RESULT.json", + "mode": "100644", + "gitBlob": "19c59af2365d6fdb1aca636e3450dfdc2d7ce056", + "rawBytes": 11348, + "rawSHA256": "aa3d8d9ce004e0736e0aa0a9ba004e736236c03e388f96f522c886e42666d97a" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/runtime-27/SPECIFICATION.json", + "mode": "100644", + "gitBlob": "ceb23f7621537bfa90f5904503da6c1365f746be", + "rawBytes": 1701, + "rawSHA256": "f1d68fa8aa2b83ed96d90b1bfc9c5a897211e01e98e36e38459f6a70c5daf02b" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/runtime-27/stderr.log", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/runtime-27/stdout.log", + "mode": "100644", + "gitBlob": "6a718e97da0812a68704c6260471dd998c1bc46a", + "rawBytes": 2106, + "rawSHA256": "e5cd7b9cbf20996b6a7877ff3a1093ac99e4556ba1e6918b9439f6603c80691d" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/runtime-53/RESULT.json", + "mode": "100644", + "gitBlob": "510e58b1a6623e799cc12686db90e804998ebfa8", + "rawBytes": 87799, + "rawSHA256": "aa71e8d2e2c411bffe031e2fb7b0ab86f0b87ab5429a414c795d0522f937eb00" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/lf-A01-UNCHANGED/executed.json", + "mode": "100644", + "gitBlob": "38e81e50f77df3c1504a1647e455fecb926f5579", + "rawBytes": 844, + "rawSHA256": "d754f489c164e09fa9d291ab5e25e69c8c7fcc2306406a49ab126e0671c1b30b" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/lf-A01-UNCHANGED/summary.json", + "mode": "100644", + "gitBlob": "f57a8b0d5f039aff5400bf3fca1d3ce3e614dc4d", + "rawBytes": 7926, + "rawSHA256": "b8227e7e58140ffe6619b43948524cb704e94658e0b251aca67604941f647f74" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/lf-W28-stepBound/W28-stepBound-Consumers.stdout.log", + "mode": "100644", + "gitBlob": "49aea9adf781c314f08baf8c07845f5a90b179ae", + "rawBytes": 343, + "rawSHA256": "46ec0f12821201b4d9a0ecc3cb3bc2af7b48f81e2cc6d1f32787db14fd15763e" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/lf-W28-stepBound/executed.json", + "mode": "100644", + "gitBlob": "1c94fe568ce30979d9cf432fd880bb78c7e481f3", + "rawBytes": 844, + "rawSHA256": "d1bfebe109e78526821c069e1ca79771c29c639209272b3b0645c5d5b8c33434" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/lf-W28-stepBound/summary.json", + "mode": "100644", + "gitBlob": "fee4f4d0fe84d300c02ca573af3002800a57cf90", + "rawBytes": 8838, + "rawSHA256": "35d8ae0a5891d0b3891d36db05f393e477264328b69d3149eaa9b9be711c7ed8" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/lf-library-selftest/library-control.json", + "mode": "100644", + "gitBlob": "e1c3f7292ae9ebb1fd0bcc28236dfbf965b31bd0", + "rawBytes": 843, + "rawSHA256": "d02ee2854553246b89ec25a67ee4cc7c472e0843a35ddb345aba6b643e1a7d16" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/lf-library-selftest/summary.json", + "mode": "100644", + "gitBlob": "e7345e41850ae8b66250fe19f8667a4b74bd058b", + "rawBytes": 4429, + "rawSHA256": "0748d02d5eb35d25d9fc48191353e0b38f414e51119ab833d0a31ae3a39f72a4" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/lf-runtime-startup-only/summary.json", + "mode": "100644", + "gitBlob": "a4ff8a08772e26e66e40c5477bee22cb4d8a27c7", + "rawBytes": 98299, + "rawSHA256": "742ded8e73f07ab695f900ace06cbdc537ffcdcbc05cc203580f5e21d55bfd78" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/windows-library-selftest-powershell51/library-control.json", + "mode": "100644", + "gitBlob": "2920fb44daf3b14e3db794531cd649e957ecf077", + "rawBytes": 1060, + "rawSHA256": "f2caa3aa69905b872f55af47abb3d4f32a40768c67eeff150d2bfcd339b8edb4" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/windows-library-selftest-powershell51/summary.json", + "mode": "100644", + "gitBlob": "e68fc70a9b64ca6de04f6922bdf249990079c16f", + "rawBytes": 8122, + "rawSHA256": "38d9bc35b047c93c08dbafb992ff1fd1781e8a51246ee8bfa9f68a0b5af2d03c" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/windows-library-selftest/library-control.json", + "mode": "100644", + "gitBlob": "52ad6b59ce0eea9f470b62db860e742fb0afb64d", + "rawBytes": 843, + "rawSHA256": "537d3d7bad4ce6e358480e94373a8f542a5983cdbbad2e5b2010085730150623" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/final/smoke/windows-library-selftest/summary.json", + "mode": "100644", + "gitBlob": "365bcef53b5272fa774026bdd967afb2e68e3531", + "rawBytes": 4458, + "rawSHA256": "25cbe297a780f14fbee045613a7d80b6f44b47b8df0d7c2b009ecd58d3a10aa7" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/freeze-integrity.json", + "mode": "100644", + "gitBlob": "d94d141d3a1d603af05a499e4cc1647ad233d126", + "rawBytes": 3588, + "rawSHA256": "d7563a985b954f139fe3df81aa45fce1336f749e031eba95b6dec4a758c857e1" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/prepare-checkouts.ps1", + "mode": "100644", + "gitBlob": "d4ab9dcc14d358cf851094dfa6079f02ff306bf3", + "rawBytes": 4570, + "rawSHA256": "04df708af450d374c2029c3d2356c649dd7afc897207d27a25951ad6dae46408" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/.gitattributes", + "mode": "100644", + "gitBlob": "dec65d7ad94b973c87a547099e442f3e124538a4", + "rawBytes": 11884, + "rawSHA256": "7bea47e94099d26bbe5d16009717d9066d00c59eba6fab9814bbc42714b78cb2" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/DEVELOPMENT.md", + "mode": "100644", + "gitBlob": "1e8f4f310a5418b7e1dc77c4c17213abdd844ca6", + "rawBytes": 2976, + "rawSHA256": "42c8ca60b99c3a27040b1780dd2ffb66b50e558e284b1c9be98a6ce3fbd79155" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/README.md", + "mode": "100644", + "gitBlob": "fa7e57a8aee4437efe5d0fef4653cf108ec6c894", + "rawBytes": 2930, + "rawSHA256": "b0973cbcf11011f52126f0e122edf86245e8ca9aaccde57fe38719dcdc6507d4" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/check.ps1", + "mode": "100644", + "gitBlob": "e606c4c606978351480e52fec04c96d9eb41f9d7", + "rawBytes": 2398, + "rawSHA256": "288b8def19720bd53f448ec80598cd658cdcd3c287178d0677c8515f5d5fb496" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/check.py", + "mode": "100644", + "gitBlob": "b9371490047ccd2b4d16329be4d6a499cb449410", + "rawBytes": 26009, + "rawSHA256": "ab47af51d7074c00b1a3a8c73ca5321ec5447b284c0edeba04ce2a5d8954a38a" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/registry.json", + "mode": "100644", + "gitBlob": "18c902e9a1ba9b6bfcc8b2639e96eccf489e3179", + "rawBytes": 1401, + "rawSHA256": "add660412125551a7f73cdc1693e953eff5cc6ccc9582dbf09f8b21ef2e032a1" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-001.json", + "mode": "100644", + "gitBlob": "fabe38e01835dd2746f7217a5e18d6c508957de2", + "rawBytes": 1196, + "rawSHA256": "437736c6ceb992e04bca72116535469b0e48690e6314837a390c3fdc50548e15" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-001.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-001.stdout.bin", + "mode": "100644", + "gitBlob": "10ad37bc51367b2668d4db62d9742137bf808bf6", + "rawBytes": 41, + "rawSHA256": "45ac888455ea4aef7c2599ce38e52991800e604d3735fd45881d8d5076e41d2f" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-002.json", + "mode": "100644", + "gitBlob": "c807cc1224d160d56ce8b1e515d2d74208488eee", + "rawBytes": 1241, + "rawSHA256": "5394f7e4f5a1d46c27c17ee614df88a1d11bf26d0f146659adf9a1648809f8af" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-002.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-002.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-003.json", + "mode": "100644", + "gitBlob": "f2d796683347e486320eaab9ea53a7c2f9638fac", + "rawBytes": 1240, + "rawSHA256": "3feb84472415a73120917549b997e703dae9358c837ee20eae65b11b9e699bcc" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-003.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-003.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-004.json", + "mode": "100644", + "gitBlob": "b1ea73ae64931a4001ef243bb1f6dd0ff33f88df", + "rawBytes": 1502, + "rawSHA256": "327f07167f5ed5375e55c625ae25d58a33543312c0fc380304744205d44b7c32" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-004.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-004.stdout.bin", + "mode": "100644", + "gitBlob": "539328d7c4bf06ca53176deec58e39608dc48900", + "rawBytes": 68359, + "rawSHA256": "954f4354774e6571fc392a678b8cff302a7c2f361166558bc2d5607cb400ab20" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-005.json", + "mode": "100644", + "gitBlob": "3bf9e57d67ed151b68e9dbd65fc7354acc511c98", + "rawBytes": 1236, + "rawSHA256": "234fadd2a6e97d307cf31323140ca103248ac65e393e4f0554338781dcef1ce7" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-005.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-005.stdout.bin", + "mode": "100644", + "gitBlob": "96d856ad8ad44f4bd84f862ee5275fb3b57015a9", + "rawBytes": 24783, + "rawSHA256": "bdd50082d978815e9005ede9c34a9757f83693806307ee766e4ccd3c8472aaea" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-006.json", + "mode": "100644", + "gitBlob": "f70587215e9239dd3e26517d07fb826e148cca9c", + "rawBytes": 1235, + "rawSHA256": "498b9a03892a1f36cc75e6dbebef460ed4c82c3c0fe7aff8bff459232cedc431" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-006.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-006.stdout.bin", + "mode": "100644", + "gitBlob": "bd5d0eb38fd4a301eb89b027fcc434fc18dbee75", + "rawBytes": 35633, + "rawSHA256": "486420760dd5c43312dd0a0e9432771b55adde1953088b70597269e057a06051" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-007.json", + "mode": "100644", + "gitBlob": "fadb74d3ec95e7f56ba709a17d5f7189fbf1e441", + "rawBytes": 1245, + "rawSHA256": "7154ca8079c8403448a7b6efe8406776cb59acbd490d5042bee57d033cbbe32d" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-007.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-007.stdout.bin", + "mode": "100644", + "gitBlob": "3760470717560aafc5ae4652522eff1953d001e7", + "rawBytes": 11640, + "rawSHA256": "0d1529c98d35b6ff2ac53d58d107f0a47ec8f5d263f51819c085827c055a63bb" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-008.json", + "mode": "100644", + "gitBlob": "fb526d0f2bcd6e3b39bc2dd080db88a750f09662", + "rawBytes": 1230, + "rawSHA256": "bedfccf8ba300d172f4d8b7dd1c2ab896e9242ea3549f5103ed567ce917ee651" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-008.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-008.stdout.bin", + "mode": "100644", + "gitBlob": "7a78c403e548df7ba7e7782ab081f08c4f4ad32b", + "rawBytes": 24706, + "rawSHA256": "6a435eff7e3cd2a2dfea248b3a8abebabaf10ff643927c5c3fcae52e666e7cb5" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-009.json", + "mode": "100644", + "gitBlob": "6e47bd62944b951aad7a64e5eb075c70de72a0fd", + "rawBytes": 1230, + "rawSHA256": "2cd0b483698e4f475cd4b4295f6f7fe9ca694c32c69b1175888e6e5276944fa7" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-009.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/git/git-009.stdout.bin", + "mode": "100644", + "gitBlob": "4c9314d23730f318c1a4f99ca13e2156912f277b", + "rawBytes": 9090, + "rawSHA256": "0d4f03ac19f890b67894b74042ff7559add574a8d160539ad3565a48289ba0ae" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/process.json", + "mode": "100644", + "gitBlob": "4bc6ee76be1257761e8cd6e3e340a50f28495e09", + "rawBytes": 1474, + "rawSHA256": "5cca6c004d2fed7261ff7c53f888f07ef5e6479a77dd923c1dfe0a9fd001b36a" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-01/result.json", + "mode": "100644", + "gitBlob": "a644cbb5a2187a9f85aacc9690a974a412028f14", + "rawBytes": 258011, + "rawSHA256": "73163b98d940cc59dd5458a781bfeb2a47b04c1c8cce1f2be52cb39498a63b63" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-001.json", + "mode": "100644", + "gitBlob": "fe6da93a5c5718a1e4ef835a25b7d1afab9942b4", + "rawBytes": 1196, + "rawSHA256": "f263d627648ac4de38976dafbefde1b2b7c70e558e2dbfe915ebbe2614221ebd" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-001.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-001.stdout.bin", + "mode": "100644", + "gitBlob": "10ad37bc51367b2668d4db62d9742137bf808bf6", + "rawBytes": 41, + "rawSHA256": "45ac888455ea4aef7c2599ce38e52991800e604d3735fd45881d8d5076e41d2f" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-002.json", + "mode": "100644", + "gitBlob": "038eca6c7025dcfb0d22c285ba074d52650cd98b", + "rawBytes": 1241, + "rawSHA256": "0fe3639b92409f748170be0c15d143788f5f73d64fef55df3a3d2bab93415d17" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-002.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-002.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-003.json", + "mode": "100644", + "gitBlob": "7c7d2953e478fc99809a25f97e3a1271ae71e044", + "rawBytes": 1241, + "rawSHA256": "0a8647ecb60f767bc30b7218e1e8656dbcbe8ab142c354def5ed9d3f7a805344" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-003.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-003.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-004.json", + "mode": "100644", + "gitBlob": "d4f9554aff2cee1ec249a2c99f007cdbf80dfff1", + "rawBytes": 1503, + "rawSHA256": "26220b11d8e7be113fb02d8663bd1ac99d1d019482f12ba93dbad7a8d776b29a" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-004.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/git/git-004.stdout.bin", + "mode": "100644", + "gitBlob": "539328d7c4bf06ca53176deec58e39608dc48900", + "rawBytes": 68359, + "rawSHA256": "954f4354774e6571fc392a678b8cff302a7c2f361166558bc2d5607cb400ab20" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/process.json", + "mode": "100644", + "gitBlob": "97b4e44cdbba7508e7427cb61963742559e62ec3", + "rawBytes": 1759, + "rawSHA256": "900acfc74743c61fa34ec94fcfb43d5296b06f268e3f19baeffa573ee4730161" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-02/result.json", + "mode": "100644", + "gitBlob": "d486100c8324e453c59e7cf599712528fdd7c776", + "rawBytes": 216984, + "rawSHA256": "ef852b6c574a9a6e114fea1538d65d8e8012b1bffeeaa8380ab1485acd19a4ab" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-001.json", + "mode": "100644", + "gitBlob": "03180e938a23801ed2138d15b6ebde74dcd40256", + "rawBytes": 1196, + "rawSHA256": "05058dd47572c0cce48b88e92f202c42f0069c9b2693a899c5f5ea588d819871" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-001.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-001.stdout.bin", + "mode": "100644", + "gitBlob": "10ad37bc51367b2668d4db62d9742137bf808bf6", + "rawBytes": 41, + "rawSHA256": "45ac888455ea4aef7c2599ce38e52991800e604d3735fd45881d8d5076e41d2f" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-002.json", + "mode": "100644", + "gitBlob": "de538c568117a8ef73170f5c799013b8c545fb53", + "rawBytes": 1241, + "rawSHA256": "96aac2c0187f3b72d3944d3303ed80128ddf67ddb0673363c020358458670d68" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-002.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-002.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-003.json", + "mode": "100644", + "gitBlob": "3092fde7ae5f7a62d9bd9b133f275c4fd356daf7", + "rawBytes": 1241, + "rawSHA256": "970bdb76ceb298d35f4d9012915aadd51c907f61dd9e0dc65c172586fe63fea2" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-003.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-003.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-004.json", + "mode": "100644", + "gitBlob": "ce90f25e2d703979538ffb46fe1a095b21c168cd", + "rawBytes": 1502, + "rawSHA256": "5abda3e84133b9e13079679830b65a679db6b2f58369cba0b15b13605891cff9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-004.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-004.stdout.bin", + "mode": "100644", + "gitBlob": "539328d7c4bf06ca53176deec58e39608dc48900", + "rawBytes": 68359, + "rawSHA256": "954f4354774e6571fc392a678b8cff302a7c2f361166558bc2d5607cb400ab20" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-005.json", + "mode": "100644", + "gitBlob": "a5d30a5cb73eab77bed5d6e94e0daabc1edeb5b5", + "rawBytes": 1459, + "rawSHA256": "7ee6befeb85403aff151a9f5af706bbc9044956f1f04ad4cc63647296e6c74bd" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-005.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-005.stdout.bin", + "mode": "100644", + "gitBlob": "b135a0846eb41af84fb599df0524fc61eec6c962", + "rawBytes": 66829, + "rawSHA256": "b0d9df27cf51042a17f4be283545c7c19b330e25fd0fa7e2971977b483fa2f5a" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-006.json", + "mode": "100644", + "gitBlob": "03c9a522e44b3141a7bd78a66937c0e66a4ab567", + "rawBytes": 1236, + "rawSHA256": "1ee487f543901aa6e4ae0cfbfeb43908122a72b319ed61fa4bb108b233ffaa5b" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-006.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-006.stdout.bin", + "mode": "100644", + "gitBlob": "96d856ad8ad44f4bd84f862ee5275fb3b57015a9", + "rawBytes": 24783, + "rawSHA256": "bdd50082d978815e9005ede9c34a9757f83693806307ee766e4ccd3c8472aaea" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-007.json", + "mode": "100644", + "gitBlob": "7a9ff74fd8e360585aa4119854a8ea4e9909db38", + "rawBytes": 1236, + "rawSHA256": "9fb44d74744e314e6496da84c486d0417ba24cbd80a44ca1a2e9ad7a1933e292" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-007.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-007.stdout.bin", + "mode": "100644", + "gitBlob": "bd5d0eb38fd4a301eb89b027fcc434fc18dbee75", + "rawBytes": 35633, + "rawSHA256": "486420760dd5c43312dd0a0e9432771b55adde1953088b70597269e057a06051" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-008.json", + "mode": "100644", + "gitBlob": "ee3251eb690b7c907e1483d2b1c7d593d48b581a", + "rawBytes": 1246, + "rawSHA256": "f23e6a2fb34d07712ec35ea0d658abe0f8ead7a923a288ecb750c8a11e368980" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-008.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-008.stdout.bin", + "mode": "100644", + "gitBlob": "3760470717560aafc5ae4652522eff1953d001e7", + "rawBytes": 11640, + "rawSHA256": "0d1529c98d35b6ff2ac53d58d107f0a47ec8f5d263f51819c085827c055a63bb" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-009.json", + "mode": "100644", + "gitBlob": "94278895900c80dcb0fcc1d44aaf553e5b1cb5c2", + "rawBytes": 1230, + "rawSHA256": "4d1b21ee33df720f5d039457f6e07a09375827017083e619c056a671c582ccbe" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-009.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-009.stdout.bin", + "mode": "100644", + "gitBlob": "7a78c403e548df7ba7e7782ab081f08c4f4ad32b", + "rawBytes": 24706, + "rawSHA256": "6a435eff7e3cd2a2dfea248b3a8abebabaf10ff643927c5c3fcae52e666e7cb5" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-010.json", + "mode": "100644", + "gitBlob": "a3110083a3bad98be3c5fc0faea6c6ec5519399f", + "rawBytes": 1228, + "rawSHA256": "70d528593521988187564ed7e1197e3c4929c48d5ff326dfb0d968707dc4bd6d" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-010.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-010.stdout.bin", + "mode": "100644", + "gitBlob": "4c9314d23730f318c1a4f99ca13e2156912f277b", + "rawBytes": 9090, + "rawSHA256": "0d4f03ac19f890b67894b74042ff7559add574a8d160539ad3565a48289ba0ae" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-011.json", + "mode": "100644", + "gitBlob": "baa3a06251817a16f0137c0a62b82a9179058226", + "rawBytes": 1460, + "rawSHA256": "4a244fa7231a10dbd75cc11a36b75797fd96f24cf93f68800a3cddb1bd1d2f53" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-011.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/git/git-011.stdout.bin", + "mode": "100644", + "gitBlob": "b135a0846eb41af84fb599df0524fc61eec6c962", + "rawBytes": 66829, + "rawSHA256": "b0d9df27cf51042a17f4be283545c7c19b330e25fd0fa7e2971977b483fa2f5a" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/process.json", + "mode": "100644", + "gitBlob": "b15e6eb932d96f9c315d8466c1c5ba24388a2f2e", + "rawBytes": 1473, + "rawSHA256": "de01d42569f10ada97405d0be370cb81b14cd899cec1d58436e4767daf57a213" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-03/result.json", + "mode": "100644", + "gitBlob": "259f4b7541eed219aa31fa65385db3c7b6c2d8ca", + "rawBytes": 261488, + "rawSHA256": "cfd79d9e0cc7e4166bb9419b2cf3cd54ca3dd9767c6174bf97e084e2fd06b03e" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-001.json", + "mode": "100644", + "gitBlob": "2dbae161b1adc43134a9f69365e92425a7ec69a8", + "rawBytes": 1194, + "rawSHA256": "ca9c09ed96a4fa701b680a83e13b35681d0bfe89e400b5d38dfe508bf4cb327f" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-001.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-001.stdout.bin", + "mode": "100644", + "gitBlob": "10ad37bc51367b2668d4db62d9742137bf808bf6", + "rawBytes": 41, + "rawSHA256": "45ac888455ea4aef7c2599ce38e52991800e604d3735fd45881d8d5076e41d2f" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-002.json", + "mode": "100644", + "gitBlob": "4bff5ebff4751d6d02e5f423332d6b94d322b338", + "rawBytes": 1241, + "rawSHA256": "b934433543cdda36c676c3724d5053abba2a91324f6aff8b8f81e301c1c7143b" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-002.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-002.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-003.json", + "mode": "100644", + "gitBlob": "726d7c940b7562dd016ee421fe58d6880649d64b", + "rawBytes": 1241, + "rawSHA256": "5da6ab1cba939653d41b45392a502e0a58798dcf169c98638428bfd17c264224" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-003.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-003.stdout.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-004.json", + "mode": "100644", + "gitBlob": "f63cc03e78ca6352cd9c9e11ce0b79f7836fe9b7", + "rawBytes": 1503, + "rawSHA256": "bf85f4bc78ec77f406bb6f8481e9187cae76f6d03405b43d6e4606257dee85c7" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-004.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-004.stdout.bin", + "mode": "100644", + "gitBlob": "539328d7c4bf06ca53176deec58e39608dc48900", + "rawBytes": 68359, + "rawSHA256": "954f4354774e6571fc392a678b8cff302a7c2f361166558bc2d5607cb400ab20" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-005.json", + "mode": "100644", + "gitBlob": "71096ff3aafab13e8e59359ae89e8e299a35e531", + "rawBytes": 1460, + "rawSHA256": "8017aef38b8447cb3bda4a3c7d8cdb2d9b409fdd1338f7f0e6095b8442ac25aa" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-005.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-005.stdout.bin", + "mode": "100644", + "gitBlob": "b135a0846eb41af84fb599df0524fc61eec6c962", + "rawBytes": 66829, + "rawSHA256": "b0d9df27cf51042a17f4be283545c7c19b330e25fd0fa7e2971977b483fa2f5a" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-006.json", + "mode": "100644", + "gitBlob": "9bd3e44ce9f5b6f829da80880603937f6feae84b", + "rawBytes": 1235, + "rawSHA256": "b8311242d14f1b40701e9dfb7907dd913ade2d6fbfa1cc912aeb536b7738fd55" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-006.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-006.stdout.bin", + "mode": "100644", + "gitBlob": "96d856ad8ad44f4bd84f862ee5275fb3b57015a9", + "rawBytes": 24783, + "rawSHA256": "bdd50082d978815e9005ede9c34a9757f83693806307ee766e4ccd3c8472aaea" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-007.json", + "mode": "100644", + "gitBlob": "a77c7d0260111ca3e5c3be855440cf43759f396b", + "rawBytes": 1236, + "rawSHA256": "d4414939ecfe2562919fb2546d46bee2b0a17dbc6cd24d87ee7d48394e652d7b" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-007.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-007.stdout.bin", + "mode": "100644", + "gitBlob": "bd5d0eb38fd4a301eb89b027fcc434fc18dbee75", + "rawBytes": 35633, + "rawSHA256": "486420760dd5c43312dd0a0e9432771b55adde1953088b70597269e057a06051" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-008.json", + "mode": "100644", + "gitBlob": "2cc5fbd86b243ac84e2770f9798ff8103423d07f", + "rawBytes": 1246, + "rawSHA256": "945a0a9e4aa65c9c33c2234bc7cd2ba00f041be5617e97ca60f1007087c21f7e" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-008.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-008.stdout.bin", + "mode": "100644", + "gitBlob": "3760470717560aafc5ae4652522eff1953d001e7", + "rawBytes": 11640, + "rawSHA256": "0d1529c98d35b6ff2ac53d58d107f0a47ec8f5d263f51819c085827c055a63bb" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-009.json", + "mode": "100644", + "gitBlob": "2337c5f4c2fdd0aaf1f07ac9a7d1d0edbc71f7a8", + "rawBytes": 1230, + "rawSHA256": "75512231b3f6432b8e3c1ce58196c068623e16ac7a9b764bf7244dc516cde1e2" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-009.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-009.stdout.bin", + "mode": "100644", + "gitBlob": "7a78c403e548df7ba7e7782ab081f08c4f4ad32b", + "rawBytes": 24706, + "rawSHA256": "6a435eff7e3cd2a2dfea248b3a8abebabaf10ff643927c5c3fcae52e666e7cb5" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-010.json", + "mode": "100644", + "gitBlob": "b89bdd93866d587bd882f11ef801d2640c64c925", + "rawBytes": 1231, + "rawSHA256": "4b894f7c03530853795f9fd6be5156497b4390d2c36930d6857b7320d6f2efc8" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-010.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-010.stdout.bin", + "mode": "100644", + "gitBlob": "4c9314d23730f318c1a4f99ca13e2156912f277b", + "rawBytes": 9090, + "rawSHA256": "0d4f03ac19f890b67894b74042ff7559add574a8d160539ad3565a48289ba0ae" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-011.json", + "mode": "100644", + "gitBlob": "ab56e5d5aadb535acd1c26a1a079311c6543da3b", + "rawBytes": 1460, + "rawSHA256": "4c49720764fadffebb8d167f05a536429f2f6eca2248ceeb3e7920ee6533dedd" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-011.stderr.bin", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/git/git-011.stdout.bin", + "mode": "100644", + "gitBlob": "b135a0846eb41af84fb599df0524fc61eec6c962", + "rawBytes": 66829, + "rawSHA256": "b0d9df27cf51042a17f4be283545c7c19b330e25fd0fa7e2971977b483fa2f5a" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/process.json", + "mode": "100644", + "gitBlob": "96230bc9722a4766c750e6e527272e76228effb0", + "rawBytes": 1473, + "rawSHA256": "8e4995c80eb575ca904a128bfd965ae9de85114a4ea7f6f845a4bb04d5cd0e31" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/preservation/selftest-04/result.json", + "mode": "100644", + "gitBlob": "9fbf8d15b4edef2c7e0d8b750a7ca962b9e71876", + "rawBytes": 261490, + "rawSHA256": "8872d99690a49f2c3bd059dc71023a42977028e2343d564a3f5af51cc9939485" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/profile/.gitattributes", + "mode": "100644", + "gitBlob": "9c1a2ed32bb8ec1191c5dc332ea9700fa0af5943", + "rawBytes": 561, + "rawSHA256": "6042504a00dcaa30bfec535d61686cfe22b98065cde695b80eca0fc572a3cd75" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/profile/BUILD_DRIVER.ps1", + "mode": "100644", + "gitBlob": "29f3b5d558cbf037791c4a0d47bc86ac8645e215", + "rawBytes": 17548, + "rawSHA256": "a14f1205c57ac4d475c38e3d73179fc1645eaf1d5bc4962dad9f3c42655588a9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/profile/BUILD_RECEIPT.json", + "mode": "100644", + "gitBlob": "4e79ef322c0bbd75814d28600f84f3e73a4153dd", + "rawBytes": 734327, + "rawSHA256": "eed1ecee4a031a9c3cfcadea445307d8e15e70e732e6ffdd5b166d135292b64e" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/profile/README.md", + "mode": "100644", + "gitBlob": "516ccfbe9dd7384e28faa97019392fc5a8ce8db4", + "rawBytes": 9888, + "rawSHA256": "30a5deb7f03013a51b495a5d30dac2596fc5d1fd2e94af928506134837b3d926" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/profile/SOURCE_IDENTITY_CHECK.json", + "mode": "100644", + "gitBlob": "fd9303a2eb8162392c362688dc433f120c8164b4", + "rawBytes": 314, + "rawSHA256": "e9d16d471e46497586658d52ba6b346a5bc92aedd306cb032dab8b5020c7ef18" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/profile/SOURCE_PROFILE.json", + "mode": "100644", + "gitBlob": "534850c886539b9334c5d9f18fc27c257c333660", + "rawBytes": 1039454, + "rawSHA256": "b83ada3baa438d812da076b48422c0a92f88ce686cd48ef982f39de7701699c9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/profile/TOOLCHAIN_VERSION.json", + "mode": "100644", + "gitBlob": "50bb8de202db60474638d4b75ff9c78ede1eaa59", + "rawBytes": 886, + "rawSHA256": "5ecaf07fb8a1b0f081a4321dd4cba3133e63728fdb86aa217a664118c91577a7" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/profile/TOOLCHAIN_VERSION_CHECK.json", + "mode": "100644", + "gitBlob": "ef0fd251048ef2d504afc98272f22416ab708feb", + "rawBytes": 707, + "rawSHA256": "bc0d11b70e3fa7593ffff29195c5a17037cdfe63df153c64733b979c79ff805c" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/provenance-reproduction/checkout.json", + "mode": "100644", + "gitBlob": "2cc14c6b87f66620819b087deb05ed357b4e9a99", + "rawBytes": 491, + "rawSHA256": "ac677628eece057c583f55d417f317ab391fc8b6500cd19dacaf788c5b7c4fe9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/provenance-reproduction/fetch.json", + "mode": "100644", + "gitBlob": "81c39e82ccaefd9632ad91de3357a8fd73e193bc", + "rawBytes": 572, + "rawSHA256": "f2aa7c343d3ad3e3e45d7b00e06d886427caaf07bd809f21601f637ccce22334" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/provenance-reproduction/init.json", + "mode": "100644", + "gitBlob": "0fce03eb91321b2c00dd181da264f832dd8bee9d", + "rawBytes": 491, + "rawSHA256": "dee455b1f90954840c3be3ec2131b37b18005e90d22e2e6330473d92c4947fde" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/provenance-reproduction/lf-profile.json", + "mode": "100644", + "gitBlob": "9c2391ce6bc7cccb4ebebc0b97872f2aa29f28a6", + "rawBytes": 285, + "rawSHA256": "e410dc3bd06794b8180fe9e5632181bd983db090d8eebb4f2b40014ec42f7c7d" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/provenance-reproduction/raw-library.json", + "mode": "100644", + "gitBlob": "be321df155fa52e964f12c0712b5febace21d644", + "rawBytes": 1430, + "rawSHA256": "569fc9cf918fa6a60de36833bc2176d8a71821fe42c1da12716425bb76f0794f" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/provenance-reproduction/restored-status.json", + "mode": "100644", + "gitBlob": "213b3bcc02ef6fdbf876fe45bdf35ee6102245d5", + "rawBytes": 290, + "rawSHA256": "489f9b6f20997e320b1051e3f4578b3890bc2bffed155e9880cfd448fde6c182" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/provenance-reproduction/source-artifact-pins.json", + "mode": "100644", + "gitBlob": "f38ef492a422ae143705175071a868f1422fcc86", + "rawBytes": 118279, + "rawSHA256": "3a3110c60b0906257a170ee6bc550a6a3e0f4cd5bd38d414f64ecdb7dff9ef30" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/provenance-reproduction/summary.json", + "mode": "100644", + "gitBlob": "9b2b8590f7b32086138f8a40a104007b571e5ee8", + "rawBytes": 482, + "rawSHA256": "3d03746cfb268606c17e1b825f1f3c2404037f9d7d749c82870eb8a0ec5e41fa" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/run-command.ps1", + "mode": "100644", + "gitBlob": "f5bfabd18940cc46407f603ea039be670cb0dfd2", + "rawBytes": 6015, + "rawSHA256": "4e9cefa6709720f672d0c0337297b83fc33e1ffcd9963a62ce72202322aee0a4" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/.gitattributes", + "mode": "100644", + "gitBlob": "3ca7a684bfd3f7e00ec198867b1dc20668667b44", + "rawBytes": 1093, + "rawSHA256": "cb6f85c6781e7980c8f5c74aaa713f1ed5b5e69a58aa49c75ac2ace88b7cb623" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/README.md", + "mode": "100644", + "gitBlob": "1e462cdfd300b5acff35bed3fbbda9f71e1763e9", + "rawBytes": 6183, + "rawSHA256": "630c124e87dda7fb7a7aea54cabf4c7c20ee50261553618eff4f9297242ce564" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/REGISTRY.json", + "mode": "100644", + "gitBlob": "4621407c3ba15dc31ca86da6768c8d421b3f7442", + "rawBytes": 12444, + "rawSHA256": "35dee68d8efbb972fb35276bc03b1ec18071048d83e0bfac0334daa9364ade4d" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/RESULTS.md", + "mode": "100644", + "gitBlob": "bdb7379bd2cbde3fb342aa3e796e5dfba2ccd8d0", + "rawBytes": 7535, + "rawSHA256": "a32d6a4eac4ece606a873b48a7d5d5072526104391089326411430febd03bd19" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/evidence/development-full-1.json", + "mode": "100644", + "gitBlob": "d49f4a0c97394c9f9dc17f6bbbb8140f75702bf9", + "rawBytes": 60410, + "rawSHA256": "42758d526392fd5ea923807ff9cc4561a07f82a860e25a491a4ed963dd3b2af9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/evidence/development-overflow-failure.json", + "mode": "100644", + "gitBlob": "be46acc610c59fa2c89d08f58de833e0f62d7759", + "rawBytes": 1777, + "rawSHA256": "dcf039bc5eaefa0fb00bd453d41fc83b415e8841a3f32d9f1ba2a03917eb1292" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/evidence/final-runtime-repair.json", + "mode": "100644", + "gitBlob": "040568c918d866c9da0fd07b2d270a766d4a4fa3", + "rawBytes": 88913, + "rawSHA256": "d53853e373dfd04500bc4f1842c3aefeb92adadbaf74fa4161d648a4406594ad" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/evidence/final-runtime-wrapper.json", + "mode": "100644", + "gitBlob": "27a3669982b2f201d0657d96e12d642a039e4c40", + "rawBytes": 7981, + "rawSHA256": "ebe14ae1ca6979d897b90cb1ec3c47ed51f2f89f2a4f0011696b5626bca77f8c" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/evidence/frozen-raw-reproduction.json", + "mode": "100644", + "gitBlob": "bca6df58c4364d6558eec1433245d2e9e267a872", + "rawBytes": 3291, + "rawSHA256": "b132c2a76400aa98c723c9962d9ccd020f43c1c1a3ff9d5b1e5437b85ea1daff" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/frozen-reproduction/RESULT.json", + "mode": "100644", + "gitBlob": "f8d5d8528b873b5502c57051ac6a143ead8bea70", + "rawBytes": 2685, + "rawSHA256": "739ced2cbe0a8eed869b7ef941e55cd42d315a7bb416d03789fa5c201d9f9458" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/frozen-reproduction/mixed-streams.ps1", + "mode": "100644", + "gitBlob": "fed74d73245fce35619ba4780f76eb81ef8a2572", + "rawBytes": 180, + "rawSHA256": "4ec6115eb4f44000a09c073e697fbe3a106fd125c1e94cf2ebede24152063574" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/frozen-reproduction/sole-expected.ps1", + "mode": "100644", + "gitBlob": "90977fdd0d84c21b00ed4cd7bf8c7738bb44e5e6", + "rawBytes": 97, + "rawSHA256": "4a4fd004e3979a1f2d05e0b0c3c33bca0af2e9c00dcaa24020e59a805476fafa" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/frozen-reproduction/unrelated-only.ps1", + "mode": "100644", + "gitBlob": "118f8c5a1bb19e2eb3c4acf13b57d5a95b6a2ab4", + "rawBytes": 91, + "rawSHA256": "957cf83ad76bfd0ce34d86090f3d8704b353a81023a7691cc8f93d01cc1abb39" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/replay.ps1", + "mode": "100644", + "gitBlob": "14868ae0d9ea940db1af11edaddfaa3d92f59066", + "rawBytes": 19726, + "rawSHA256": "77511fc8f0013cd839599e80ac192ccbadb2733dc925286fa788956b191a1077" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/reproduce-frozen.ps1", + "mode": "100644", + "gitBlob": "31f765d6ba6be396196274617f1b091245112f07", + "rawBytes": 4677, + "rawSHA256": "85353a39ed6353e571076a66a41de9471f285d3725b4f0c0d9b741bf46c3a857" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/review/PARENT_SCRIPT_BEFORE.ps1", + "mode": "100644", + "gitBlob": "6aa6f7536e0e23b505673f8c175f4ba5fe39261c", + "rawBytes": 16561, + "rawSHA256": "9f52c599fee4b7bee683ba9a87156a028959e37339afa7ad8e430d04517c71fd" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/review/README.md", + "mode": "100644", + "gitBlob": "bf136b7080919af995047d57a1e7447c43170337", + "rawBytes": 4499, + "rawSHA256": "aa8a040bc344f542769c34a6c38eb7e76304113ad2d0d63573a586d5c42887b9" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/review/RESULT.json", + "mode": "100644", + "gitBlob": "be6f67caad2f986a0866f223832baaf6c6e2cd0e", + "rawBytes": 2738, + "rawSHA256": "6b94bc821130eaddea08c8818a0a0b485b6610ac6e9e799397ddb346bd555231" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/review/fixed-controls.json", + "mode": "100644", + "gitBlob": "36d3e2c6794517acdfe67b0d79eb07648335c6ff", + "rawBytes": 27889, + "rawSHA256": "3eb4611c50e28c0708986c2aba87679cfeec20bcab4b1e00cb4921648bb41fff" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/review/mixed-success-stdout.ps1", + "mode": "100644", + "gitBlob": "3414697777ef5b6a5ed141231a1d5f606bf22542", + "rawBytes": 239, + "rawSHA256": "0a30a82fdd1d7fcff0d2a7e14f5d2c1ce1ea09ff25277fdc607f394db779ce5b" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/review/mixed-unrelated-stdout.ps1", + "mode": "100644", + "gitBlob": "e67db033990296be5b418e10035c5fed50b4a5ce", + "rawBytes": 211, + "rawSHA256": "75fa54cfba3824c3e2063a70c777be87b097f47c8a243f8efd587cf7d4288608" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/review/replay.ps1", + "mode": "100644", + "gitBlob": "7ffd775d5460c15f149853b845484a195f8d2c74", + "rawBytes": 2664, + "rawSHA256": "ea33e00e5c1d83c615dfbe98553d39997ea3492b0a3f8eeb2d320647732e7f79" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/review/run-fixed-controls.ps1", + "mode": "100644", + "gitBlob": "d1634201f68a62db6b8f03a204f52bd2da131ac3", + "rawBytes": 3313, + "rawSHA256": "288951c138df0b5d44836be09f42976586ac2102dc55d2c7c82b47c1bd6f82d7" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/review/sole-expected.ps1", + "mode": "100644", + "gitBlob": "d0c293d1099a538e3a7487df3df3523b9f9793f9", + "rawBytes": 128, + "rawSHA256": "1d479aae3fa4775cb3ceb928fedcd4f3a8ad5cf9b43d8a2807bec7db1cbb8265" + }, + { + "path": "docs/internal/extensions/opt1/repair-r1/runtime/run-bounded.ps1", + "mode": "100644", + "gitBlob": "89f07d3640a4c3259645430bff26e6172dc80b09", + "rawBytes": 2424, + "rawSHA256": "1cc0a634394749cb56000a03c15c805d3a209ef8ae9d4284e6a0295871b111cc" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/.gitattributes", + "mode": "100644", + "gitBlob": "40ffcb2e7b5576390e868bc926fd7b2d90f8fe06", + "rawBytes": 718, + "rawSHA256": "cb9ed8254a683519b59a24842aa1f928677cb4bc790a0b21cb0961011d6324fa" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "a291d46d5ad592ec1b215dc31d59d38883a05a10", + "rawBytes": 33574, + "rawSHA256": "a1c1912126ab17d2b11b6a900f445ccb5832f815529756d5bca89b4ce1397dcf" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/RECEIPT_ARCHIVES.json", + "mode": "100644", + "gitBlob": "341989ae42a368d142ffe83c70e4b8f7112ff7f4", + "rawBytes": 9954, + "rawSHA256": "bb808ab761f6136215b361ab93e7405843040adb8d6bcbbae963cdc6b0f15492" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/REPORT.md", + "mode": "100644", + "gitBlob": "0e5bdc9b6fae2ac7c3d5f0e610ca616b0e9c27a7", + "rawBytes": 46596, + "rawSHA256": "6934d5ae549a055954d4d7038fc34228810742b5a54b0c39b4847888e8431032" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/preservation/check_relocated.ps1", + "mode": "100644", + "gitBlob": "85be19e39057c10b88146e0d234422064534a1a0", + "rawBytes": 7097, + "rawSHA256": "8f3e53880af81cf6af3b3f325043f924632923ecd969b8edd309c53b419d891f" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/preservation/check_relocated.py", + "mode": "100644", + "gitBlob": "258d37c02a4105c29fade62d9f45f18be182d562", + "rawBytes": 29354, + "rawSHA256": "da0dc413f1af56727f5e009a79df115d4933272854dc17967f15879020d2060c" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/preservation/relocation_controls.json", + "mode": "100644", + "gitBlob": "ab9776919c6579a556a08fcd4d93a4482520f4f3", + "rawBytes": 978, + "rawSHA256": "d0de6d0b68cc7334054210432ab0b40a6e3995dda5400a8d2423e4da64c2db6e" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/receipt_archive_control_helper.py", + "mode": "100644", + "gitBlob": "5b81f42c7f92ac99f2454f44991b35a7a31634d3", + "rawBytes": 6180, + "rawSHA256": "efc3775d6b8c55e85f7ac4ce52865b6aab5b50a79ffcf52a66ccc39d2a301cee" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/receipt_archive_controls.json", + "mode": "100644", + "gitBlob": "058f480d94432b649731b6e0c147b45d86922698", + "rawBytes": 3790, + "rawSHA256": "69ff8eb23d710a0134c408d2029a177ca6d73e64e1ea9f63895ef3566bdfa447" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/receipts/checks-3b82967.json", + "mode": "100644", + "gitBlob": "4527767b88522e949fe54bccec74076f3fd25b95", + "rawBytes": 24593, + "rawSHA256": "17376ccf3323c3ba18811e4a409c0a694ef16cc8c2f727523931152a7429c77e" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/receipts/controls-3b82967.json", + "mode": "100644", + "gitBlob": "9599082670bc8b3e82854aec89d4fbf2c31db71b", + "rawBytes": 30154, + "rawSHA256": "4b75cba83529f84de99c01cee166ae9d76d9c0476d5bb9b34d94fd7872d3823a" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/receipts/preservation-3b82967.json", + "mode": "100644", + "gitBlob": "8576e46804b57889fa160252fcd70ff3050f8796", + "rawBytes": 51499, + "rawSHA256": "85986d1baf47272d971e2658c0f7a5ed84664f5aaaf4db16d3c04c72dc85532d" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/receipts/scan-base-4cc9501.json", + "mode": "100644", + "gitBlob": "682f8b3eb7eb5ab66f03c3b6e63511f033eb725a", + "rawBytes": 20267, + "rawSHA256": "c288b9df8342f77d141637b48e0cf93e88aad716d4f535bbba9bb929ac2aaddf" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/receipts/scan-repaired-3b82967.json", + "mode": "100644", + "gitBlob": "3f82b3a5ec424418a2bc55c880dbf6fd1b5512f1", + "rawBytes": 6099, + "rawSHA256": "e09229daf12e45186bda4659d3ab18e838a1086cb1694f05833e53ada190b782" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/run_receipt_archive_controls.ps1", + "mode": "100644", + "gitBlob": "d2328ae593630279aeb142a9c5dcaaa2baf81818", + "rawBytes": 17574, + "rawSHA256": "1c247f13fec0ea2c1ceaacc3b57e76039f1efd747000fa520ced2e0dbdf067af" + }, + { + "path": "docs/internal/extensions/opt1/repair-r2/verify_receipt_archives.py", + "mode": "100644", + "gitBlob": "5507db6f73d57b7eafd1a8468762e3077ea329b3", + "rawBytes": 27132, + "rawSHA256": "01c91e8fcdd25b57430369420a1c359132d06d6f484522b4e3cba70dbd63e367" + }, + { + "path": "docs/internal/extensions/opt1/replay-source-manifest.json", + "mode": "100644", + "gitBlob": "241c66d5fe7fec1b8391c0c52653b24616d8d744", + "rawBytes": 4649, + "rawSHA256": "abf64c86d32412386978aa788ca92d9d1b0fe36418c626e4f05bacac0542b22c" + }, + { + "path": "docs/internal/extensions/opt1/root-composition-plan.json", + "mode": "100644", + "gitBlob": "529a00fc1a24439189d1ba1d1faf4277715ed9ba", + "rawBytes": 239, + "rawSHA256": "1d5d04aedf782fc9412fdfe7955816c11debd8595541469d3465ebe9a3ec9f3d" + }, + { + "path": "docs/internal/extensions/opt1/runtime-prerequisites-plan.json", + "mode": "100644", + "gitBlob": "5aab8ad094734756b0c3b4bd086c500a4ab665aa", + "rawBytes": 44, + "rawSHA256": "11230e0e01faa36d958a9c5b85a373f24dfbe290a804bb395a73e766c1d0ec81" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/REGISTRY.md", + "mode": "100644", + "gitBlob": "7c38145bbed1a4e12c7c4758d6f1898129e9dec4", + "rawBytes": 4943, + "rawSHA256": "94fbb20f078eeaf8c199b85f74b34e9c0293aad7decf1ae7f5e9fcf36b940af5" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/REPORT.md", + "mode": "100644", + "gitBlob": "a6fcc6987c8c61141236fc8a46399d4e45644c13", + "rawBytes": 19773, + "rawSHA256": "92adb83ced48b409325bb472a0a3c61fe9506b3f6b8285de65aced408a2a7cd6" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/checked-source-hashes.json", + "mode": "100644", + "gitBlob": "95345551dd393c7a69ef8f05e264d81df2366e9d", + "rawBytes": 600, + "rawSHA256": "c14708fc3fa9d661cf0b597b722082225e0c8ae9ff0e72eb669b4957792a916f" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/continuation-source-hashes.json", + "mode": "100644", + "gitBlob": "91b4c0c3eaf36b3b58076ea62cd78f2ebf904924", + "rawBytes": 621, + "rawSHA256": "066a84597bf6348c7c0a9e52a4edd98ca79b3b16b2cd0010a537e63a0035cde0" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/deadline-covered.json", + "mode": "100644", + "gitBlob": "e54ef17c1ad3abb0e4b80c79a9f3b9c58960e0ef", + "rawBytes": 3927, + "rawSHA256": "af19867b3cc67c3e7890501df9c2494938231ce0fe77ea1b6bb04472025991fe" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/deadline-first-uncovered.json", + "mode": "100644", + "gitBlob": "a66c0ea8c7e6da6e762bfb4c773dfb12a155c7ae", + "rawBytes": 3788, + "rawSHA256": "9401b78d769a2639e621a1c42e1782d7512741635037b97d803b62292eebb73d" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/deadline-host-coverage.json", + "mode": "100644", + "gitBlob": "1a459a445c0dbf300d17c6179e346249be15c0d2", + "rawBytes": 182, + "rawSHA256": "ae2927746b6835bd0e721e29f11676ca807dc52f65228987ab1a6214ac43a0f8" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/full-runtime.json", + "mode": "100644", + "gitBlob": "67dad1cc6085f41f481068284641cb7c0ef627a7", + "rawBytes": 510115, + "rawSHA256": "a7eb5831a88a7431607d5fe1d7189318d41978391e0a10be3ed336c014563661" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/interrupted-before-full.json", + "mode": "100644", + "gitBlob": "af87864beaaa33e6d72adb19794db618ea63c55a", + "rawBytes": 1784, + "rawSHA256": "d76bd74773b5b40518c57b5b611cd13d2cb0581da38e70bd588561a39b100c6e" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/powershell7-selector.json", + "mode": "100644", + "gitBlob": "6c74400005a50aaf606d8006f26da98712012d9b", + "rawBytes": 23413, + "rawSHA256": "b399b5193d9e0f6d828ba55fdd9eca15322a116d1066f7557c3dfd25d272930a" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/startup-checked.json", + "mode": "100644", + "gitBlob": "2211f10a0ff7401ceab0b01b6d56de83977adb32", + "rawBytes": 173188, + "rawSHA256": "ae128efa28ab54effa1b9381c3e04b9f17f11081716675169b5474959e759ddc" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/evidence/windows-powershell-selector.json", + "mode": "100644", + "gitBlob": "63910c48bf30f005f34ecbd38ea1fb54a6c706dd", + "rawBytes": 44302, + "rawSHA256": "0946a0fe7e5b8b2dfca5ca76f31863a43ee55694b6a771c90b3b4ef4b9a3dd15" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/kernel-attempt-1/RMQ.Validation.PackedOptimized.20260912T0911577149359Z.json", + "mode": "100644", + "gitBlob": "b9951a6dbf679edc3b9fe24354189bf4bc395005", + "rawBytes": 7143, + "rawSHA256": "c618620a957f8de205a5a90b8f9c6727a6060982c491ac2f276b2f2118ae99ff" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/kernel-attempt-1/RMQ.Validation.PackedOptimized.json", + "mode": "100644", + "gitBlob": "b9951a6dbf679edc3b9fe24354189bf4bc395005", + "rawBytes": 7143, + "rawSHA256": "c618620a957f8de205a5a90b8f9c6727a6060982c491ac2f276b2f2118ae99ff" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/kernel-attempt-2/RMQ.Validation.PackedOptimized.20260912T0913380735403Z.json", + "mode": "100644", + "gitBlob": "d0924b767ab8560b3d1a536b05323bfd70ffcd43", + "rawBytes": 1388, + "rawSHA256": "90c4c951dc62e99661f255aff1ca71f359290f5e14384d045ed20b42fec4ce2e" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/kernel-attempt-2/RMQ.Validation.PackedOptimized.json", + "mode": "100644", + "gitBlob": "d0924b767ab8560b3d1a536b05323bfd70ffcd43", + "rawBytes": 1388, + "rawSHA256": "90c4c951dc62e99661f255aff1ca71f359290f5e14384d045ed20b42fec4ce2e" + }, + { + "path": "docs/internal/extensions/opt1/runtime-replay/validator-plan.json", + "mode": "100644", + "gitBlob": "406737c81b76ae41769f20c86e4dae990d8314bb", + "rawBytes": 36, + "rawSHA256": "2babc5547271a4a23a78a8186cd80a68fd8e4b4962fd5346e5c27c2582134ab1" + }, + { + "path": "docs/internal/extensions/pre1/.gitattributes", + "mode": "100644", + "gitBlob": "9bd69dd96a4e84d257b6d97cc197fa0215573443", + "rawBytes": 129, + "rawSHA256": "ca36dc03d28b9591e3d97bd76e0ef1f8a3a3584a04ceda79b27cdb55ab571607" + }, + { + "path": "docs/internal/extensions/pre1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "166a048000d4f5de9d19b7a3bd9f1a3f270efae1", + "rawBytes": 126306, + "rawSHA256": "7b0488caf93553ad801b5f801d6e9e61871bf5d224e8cbf906d413844d3ba057" + }, + { + "path": "docs/internal/extensions/pre1/AMENDMENTS.md", + "mode": "100644", + "gitBlob": "f459e88d92950b240864495184ce9e1a6ebc83ab", + "rawBytes": 34078, + "rawSHA256": "5875b3c6b8f243321bb0a8f3fd9abbf3e75f6387f1eebfdb6936dc04b3882d7c" + }, + { + "path": "docs/internal/extensions/pre1/ATTACK_TABLE.md", + "mode": "100644", + "gitBlob": "7b840ab8964a67ef026cd8150cd68c8e330bce22", + "rawBytes": 8212, + "rawSHA256": "1b8bccd323c6e80b4a6f15b18305c357435b8c83bfaae5da1abdb2be915dc3e7" + }, + { + "path": "docs/internal/extensions/pre1/BUILDER_PLAN.md", + "mode": "100644", + "gitBlob": "1bbde52be65889ef6b59cd3a4b0745521152ea89", + "rawBytes": 69280, + "rawSHA256": "5ddea33280ca08db590ba847f5210d0317425cdc8ef191836eb28f255d8c0eca" + }, + { + "path": "docs/internal/extensions/pre1/BUILDER_REPLAY_DESIGN.md", + "mode": "100644", + "gitBlob": "0dc145c0768dc0ea19d63f6aea06997da096066b", + "rawBytes": 33478, + "rawSHA256": "2d335c81af45e7fd207d07b22fdf2c50e0fe0933fa471dc6ed2977e6fbbc62c3" + }, + { + "path": "docs/internal/extensions/pre1/BUILDER_STAGE_LOG.md", + "mode": "100644", + "gitBlob": "4b140e76af38d4ad665a7670347bb4856940b315", + "rawBytes": 127416, + "rawSHA256": "fcae86dcad1fcbafe0153251926d8b4608c4b30575e00999aed4bd2737abb132" + }, + { + "path": "docs/internal/extensions/pre1/CONTRACT.md", + "mode": "100644", + "gitBlob": "58c2c69883a45a5f6ea81346ed1121e46a8d13a7", + "rawBytes": 50947, + "rawSHA256": "3dbe6e8c3da5191c12d193113a8a2303cb2285d393edca95613d968e3faf1f94" + }, + { + "path": "docs/internal/extensions/pre1/REPLAY_DESIGN.md", + "mode": "100644", + "gitBlob": "8af8542a322febda78710e424dc231f666da4463", + "rawBytes": 10951, + "rawSHA256": "6021056c4d80f73a8fac162cbaf5c3fd307d4f9486274b5af17394a463b86eb2" + }, + { + "path": "docs/internal/extensions/pre1/REPORT.md", + "mode": "100644", + "gitBlob": "a4f0104aabdd452b9459d3baeff64542c976930c", + "rawBytes": 150971, + "rawSHA256": "663f25a0637187a49ef1f2e9aa50713ecb5b9894ad50e8c0e7a9f47153397a49" + }, + { + "path": "docs/internal/extensions/pre1/SOURCE_FACTS.md", + "mode": "100644", + "gitBlob": "c4191dc06dd86b4571809bd0cbf30f34233707dc", + "rawBytes": 6006, + "rawSHA256": "49f6589f23d197d443780152a45498310a87d2b7e04a166f2d6f3e683f988473" + }, + { + "path": "docs/internal/extensions/pre1/builder_cases.json", + "mode": "100644", + "gitBlob": "45778d8177bd746d85a7ef93d75e4b22281573c4", + "rawBytes": 87144, + "rawSHA256": "911ed51bc30f2260508000d6c6e892c840d80afbba0233610559289861e1c931" + }, + { + "path": "docs/internal/extensions/pre1/builder_manifest.json", + "mode": "100644", + "gitBlob": "cdb685ca943f38b9a727559677290b8794e4b2fe", + "rawBytes": 3016, + "rawSHA256": "2d860bf6b6dd4cbdd6e1147b3a66c738926b17fb01c833c8e754118ab641fbef" + }, + { + "path": "docs/internal/extensions/pre1/contract_cases.json", + "mode": "100644", + "gitBlob": "8c95728686e569aaec1f0cfeb7d94c66b3208f6a", + "rawBytes": 19219, + "rawSHA256": "85eaffcd86e95c0f8468a76596c1153bb0a6b986f5b3a977b40926e1776e6c97" + }, + { + "path": "docs/internal/extensions/pre1/evidence/Input-check-r2.json", + "mode": "100644", + "gitBlob": "1ce8161e1180f97ceaadfcf6bfe5050024b9d0f4", + "rawBytes": 3580, + "rawSHA256": "385d256e603dc4523ce54760b940237ffa831613104b7ea92a4ca2722a657d5c" + }, + { + "path": "docs/internal/extensions/pre1/evidence/Primitive-check-r2.json", + "mode": "100644", + "gitBlob": "145f5347cae99d2b89426200d17a455835f9d916", + "rawBytes": 505, + "rawSHA256": "947223783505d60bec7460d42aff9870bff6426c568879825cd39bbaaeb24994" + }, + { + "path": "docs/internal/extensions/pre1/evidence/Primitive-check.json", + "mode": "100644", + "gitBlob": "61268f60c97cbab020db7d3efdddd95246693c13", + "rawBytes": 5381, + "rawSHA256": "0ef34fd60e6c9789f985eb6d46662571cf3425334d21845903c5e7196ddc3eca" + }, + { + "path": "docs/internal/extensions/pre1/evidence/REPLAY_INDEX.json", + "mode": "100644", + "gitBlob": "f3311e1f8a5dec9c948c51990eac93af253699f1", + "rawBytes": 6022, + "rawSHA256": "df45abb5b7da9c40a5fbf644629635ba9c47e5dcddab82046038b81744d454f2" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.Shape-check-r5.json", + "mode": "100644", + "gitBlob": "fd07d65ee4232dff9e8f0427feabce86e6edc647", + "rawBytes": 1032, + "rawSHA256": "f07e6b06d4eaf8fb26b22f3c804b2c48356e6b286c6d906cef61d1f8d69561c1" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Conservative-check-r7.json", + "mode": "100644", + "gitBlob": "921fecb764dc00d75be5ad329086c971d91aed00", + "rawBytes": 23787, + "rawSHA256": "3f59b240f66b9cff9b5bbf1c2ff8d909da621f3d42e5f248b9fefd34c2d04275" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Conservative-check-r8.json", + "mode": "100644", + "gitBlob": "c4c410542a5019fd38a6272de21ac3db313c2dcb", + "rawBytes": 543, + "rawSHA256": "e600fc324d19772fee89191d172b1722782e2102a1fd87bd870fe943a57a58dc" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Contract-check-r7.json", + "mode": "100644", + "gitBlob": "409bfd8ae07316e6c2ea09fea82c48046faec24c", + "rawBytes": 535, + "rawSHA256": "7981f8035fb3c9c17e28a72cc817328bf8dbeaebbf72559d4a2aee185c315eaa" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Contract-check-r8.json", + "mode": "100644", + "gitBlob": "3833a903877b8765fb3d925ba1f7e252eea7d038", + "rawBytes": 535, + "rawSHA256": "bd46ca11d154bf1972aa106223826d67aca2f6432e0f0642057e451855476b41" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Controls-check-r5.json", + "mode": "100644", + "gitBlob": "e694c4b4abbb080b3584ff6153d8d7a335fb4d19", + "rawBytes": 7322, + "rawSHA256": "e994af2080ee1b338ed8efc77fe2be471c72196cef398602370c84661fd2df1a" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Controls-check-r6.json", + "mode": "100644", + "gitBlob": "8a24e611f4c1aa94c4158e918b4c4a814954acd0", + "rawBytes": 5869, + "rawSHA256": "83a1f1c000119afdec2bc18bbe82d5368b887ad1395306baeccea1ebb4ce706b" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Controls-check-r7.json", + "mode": "100644", + "gitBlob": "310d9b0595c2a4b17e6099c0cd7b245d0ca94658", + "rawBytes": 535, + "rawSHA256": "344f3720e08b8fc7680fc3dabca5f9126edaedd109d8c55023889265dcfa6451" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Controls-check-r8.json", + "mode": "100644", + "gitBlob": "05936c9748bccaa41e286eafbd90957570c54f4c", + "rawBytes": 535, + "rawSHA256": "957f992257f990286c0fffbc8aac708a130c8be6af937e726059b66cc9948a11" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Input-check-r3.json", + "mode": "100644", + "gitBlob": "c7960fda818a7aa9d6ea8bec2ac3ef73eff87168", + "rawBytes": 522, + "rawSHA256": "f7c7cc2f0253d6aa6284fc3008e595159fc91efef845d1823119fedb40d24617" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Model-check-r3.json", + "mode": "100644", + "gitBlob": "eb2952ab38f7936824b0e8d2aa5686c76d8b0310", + "rawBytes": 3999, + "rawSHA256": "212ef834bd2c34f18493531afb1edb20a49c7a9967e0bf987b7f413dafa935b2" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Model-check-r4.json", + "mode": "100644", + "gitBlob": "47e7faad6a5ee35186c45bc8e9e62c42a9eafa97", + "rawBytes": 2911, + "rawSHA256": "7e3ae7f940ab52d5dce2399fc26cff44e52896aef15d39f8e1708dca25f68bc1" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Model-check-r5.json", + "mode": "100644", + "gitBlob": "11c125cce63e05a4788cb6e25a99946f99586472", + "rawBytes": 523, + "rawSHA256": "5191770df1a5c982f7961bdc0c2ab3f7b07e2f0b3caa0d76098e21e7441b3955" + }, + { + "path": "docs/internal/extensions/pre1/evidence/RMQ.Core.WordRAM.Construction.Model-check-r8.json", + "mode": "100644", + "gitBlob": "fd84d6013dd8eda8d3be159e8d96bf35bebdebb3", + "rawBytes": 522, + "rawSHA256": "8f84ccc5915b9b4fe36836006b68c1dc4e4a9d24e0ce9fea09608adcd5a808e0" + }, + { + "path": "docs/internal/extensions/pre1/evidence/aggregate-gate.zip", + "mode": "100644", + "gitBlob": "9e82dbabd5ac1a28d0dd4f862f11346a25165bf6", + "rawBytes": 2488373, + "rawSHA256": "e701983375fb3d632a01ffad26dae2be3e38cb9bd990ee9791f05d924269192b" + }, + { + "path": "docs/internal/extensions/pre1/evidence/aggregate-summary.json", + "mode": "100644", + "gitBlob": "57a201ba96ee1dc8fca83487ebd6f12cad0f7446", + "rawBytes": 5123, + "rawSHA256": "6bb95bc989398ec71e403df4f06e94a0fca6a74126a1c25864cd62d80490491a" + }, + { + "path": "docs/internal/extensions/pre1/evidence/archive-integrity.json", + "mode": "100644", + "gitBlob": "2febfd154e47ad41a7999b36669222439554bdb8", + "rawBytes": 5873, + "rawSHA256": "c92ce6c0578c96ccaa9d47166d11fbc30d8f6c36049078b595073c7974e46037" + }, + { + "path": "docs/internal/extensions/pre1/evidence/audit-archive/2026-09-12_PRE1_contract_fresh_blind.md.gz", + "mode": "100644", + "gitBlob": "066ab81ff6387a8cf342e7799a729aee4d5ec1bb", + "rawBytes": 33919, + "rawSHA256": "e8f77103ce5ab4e15734af6e09564d3fe8a6bda8c2463c2776471e8a02d0fdbd" + }, + { + "path": "docs/internal/extensions/pre1/evidence/author-final-checks-summary.json.gz", + "mode": "100644", + "gitBlob": "8cf2fa3e8dbc7b784ec1a974a0a3162cfc535041", + "rawBytes": 1199, + "rawSHA256": "db44f7ac0d2dbfe58cab93ccf20b0bf1abd14b71625c458ac72f66822fd45e39" + }, + { + "path": "docs/internal/extensions/pre1/evidence/author-final-checks.zip", + "mode": "100644", + "gitBlob": "ef7e51eb73cfbb60e14543b690c3b2ae42415fe4", + "rawBytes": 2332193, + "rawSHA256": "34d9f499033f67eb0373537b372ae63f6a5116fbe27b0a7547d40acebbf1424c" + }, + { + "path": "docs/internal/extensions/pre1/evidence/deadline-margin-check.zip", + "mode": "100644", + "gitBlob": "22caa734160e214ee78da049b330bb6a3ca5ba1a", + "rawBytes": 3398, + "rawSHA256": "58564bf8b345a85e942bf0f3f6744f697eea934b354cf22e4ada0e8040d50084" + }, + { + "path": "docs/internal/extensions/pre1/evidence/final-evidence-summary.json", + "mode": "100644", + "gitBlob": "346ad868efdf8c01a5350e3a1a53e35c493eed24", + "rawBytes": 11588, + "rawSHA256": "629d98184381f0d538a92dc7b8c28b6168d7bc79e01519464262f19a941d1bd8" + }, + { + "path": "docs/internal/extensions/pre1/evidence/focused-C01.zip", + "mode": "100644", + "gitBlob": "d3920cd184c1a5e320b614be5ddb115a6a323731", + "rawBytes": 51920, + "rawSHA256": "4a57aa1f63f36acd9dafcb4c843ca8d468aa9270939d8c3cd0acea6a7e04bd71" + }, + { + "path": "docs/internal/extensions/pre1/evidence/gate-failure-diagnostics.zip", + "mode": "100644", + "gitBlob": "b04dcf140b4edaccbe11f4e1a8abeb593660a46e", + "rawBytes": 5240, + "rawSHA256": "a709586842fa18ae57f3cd87999e677dbb1aa90dcad7cb5b47cd2aa0b5c09d58" + }, + { + "path": "docs/internal/extensions/pre1/evidence/initial-build.json", + "mode": "100644", + "gitBlob": "9aa00707d027f76c92bf9edaa11cea811b3bdb24", + "rawBytes": 671, + "rawSHA256": "b26c8250cb2b0b2dc8a33db12c15be7bafea6a6b9b2537d889d0a4d447505e46" + }, + { + "path": "docs/internal/extensions/pre1/evidence/postgate-final-checks.zip", + "mode": "100644", + "gitBlob": "1a9b9e4f1a096359667053fe5123b8821ee6ff61", + "rawBytes": 1172050, + "rawSHA256": "890d595f45d2ff98d4d478dc03d3cb644735be71ad3c08843ccc7b4eb8f0f486" + }, + { + "path": "docs/internal/extensions/pre1/evidence/primitive-build.json", + "mode": "100644", + "gitBlob": "7740441cda96a67900823dd81f1ef5cec4c6fb6e", + "rawBytes": 2560, + "rawSHA256": "7367026a8773fb9f89c7354d6dfaac0bb33179bf2eb948d84129eb2ac54bba8f" + }, + { + "path": "docs/internal/extensions/pre1/evidence/ps5-registry-matcher.zip", + "mode": "100644", + "gitBlob": "86b094dca031b94d1c1632532963e25ce0061965", + "rawBytes": 1008, + "rawSHA256": "4d8418a4aff2cb02fb4ddfd31c30e1c131a3545ca34b8f34c231d3f4c473877c" + }, + { + "path": "docs/internal/extensions/pre1/evidence/ps5-selectors.zip", + "mode": "100644", + "gitBlob": "aca6c790dea6968833ad7b8d5b0c7f029db6f844", + "rawBytes": 9813, + "rawSHA256": "278e2095f846d88236f6b67f75b0938c0e11e9ba8ca1e6262471a27d3e8f2cc9" + }, + { + "path": "docs/internal/extensions/pre1/evidence/ps7-deadline.zip", + "mode": "100644", + "gitBlob": "c7208b6b90e838a115c1a31ad4eb711466061d13", + "rawBytes": 3406, + "rawSHA256": "0dfe2785591c500414070524a714786a6f8dd423fc105473c3868b995b9cbe90" + }, + { + "path": "docs/internal/extensions/pre1/evidence/ps7-registry-matcher.zip", + "mode": "100644", + "gitBlob": "0710b3ed9879eefec666ef4817545b67c6cc91e3", + "rawBytes": 943, + "rawSHA256": "fc01a94307ad981bd5763967839be836c98e826997f677dd1eb0b00a4a09be14" + }, + { + "path": "docs/internal/extensions/pre1/evidence/ps7-selectors.zip", + "mode": "100644", + "gitBlob": "83c06faca43eca0733c888b7b0f44ac68bb0c331", + "rawBytes": 9186, + "rawSHA256": "4d518769461b29daf0b5ea21a7f281ef62b44c3f59718cce2006f0b4fea93e3e" + }, + { + "path": "docs/internal/extensions/pre1/evidence/replay-full-summary.json", + "mode": "100644", + "gitBlob": "4299f4b51921aac54dbbad2dd30a227e477908d6", + "rawBytes": 14500, + "rawSHA256": "47ac250e4e306617b9ba05941be20c7417ef760ecd4b397fd7edcd7073c87036" + }, + { + "path": "docs/internal/extensions/pre1/evidence/replay-full.zip", + "mode": "100644", + "gitBlob": "eadd16208862614d571e15c74eda07409000f432", + "rawBytes": 394230, + "rawSHA256": "2c27a21720206014042ddb7b1ee57b4322ac665bf1b4d2c999ad6ce7705c6a12" + }, + { + "path": "docs/internal/extensions/pre1/evidence/replay-inconclusive-startup.zip", + "mode": "100644", + "gitBlob": "ceeb1df311c3c8c1785277666741349475416177", + "rawBytes": 28326, + "rawSHA256": "f611f107c1fea26241505a3dd6eb0e7725e1d7d42290985c5b01657b3f5bc2d6" + }, + { + "path": "docs/internal/extensions/pre1/evidence/startup.zip", + "mode": "100644", + "gitBlob": "6d49aac4eb31a056ab29eafd0c650817ac2056a0", + "rawBytes": 31912, + "rawSHA256": "cf0251628b1aa2d2408768addca688d37145f885f877712d73bcd7b478ea6662" + }, + { + "path": "docs/internal/extensions/pre1/evidence/typed-consumer-final.json", + "mode": "100644", + "gitBlob": "a4cccb195bf4b3f5274139ea4e241aebadd49a6c", + "rawBytes": 2403, + "rawSHA256": "65d2051211837334368ecc17e8df7c9277dfdf50a83c4e8aa908a7a61156bff1" + }, + { + "path": "docs/internal/extensions/pre1/evidence/typed-consumer.json", + "mode": "100644", + "gitBlob": "4109f54442bd2417661c9bde4e4f160e672cbb17", + "rawBytes": 2873, + "rawSHA256": "964283bb8a0ff2a5d7f72ddb07c4a6f570ca965217bb793015efc2c86877b4b0" + }, + { + "path": "docs/internal/extensions/pre1/primitive_manifest.json", + "mode": "100644", + "gitBlob": "88443b4a8bc49e89e2a01b8b4d144ca2d461ff5a", + "rawBytes": 627, + "rawSHA256": "308d30d13b89117fa5d75a7cdae561bc1132dff33aa9740c06233cab034ee409" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/.gitattributes", + "mode": "100644", + "gitBlob": "a4d7d77d1297e414a4e7481b04371ac472f77365", + "rawBytes": 174, + "rawSHA256": "1eef15fb19fa9a9ab5c368c3417d3502e61782ff0bef1bcdc77a65ea6dc7371b" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "8afedb2a3cfbb6d8ae159d0aef4b57827cf13ca4", + "rawBytes": 40623, + "rawSHA256": "305a35019df93cdecb13e1d2f8ab252dbbfe40f2cd06a4e78dc6317a5d77630e" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/RECEIPT_ARCHIVES.json", + "mode": "100644", + "gitBlob": "699f96c6c0f53c72f02479ef6fd4214116c79551", + "rawBytes": 5095, + "rawSHA256": "8351a360960132f8f37ff15189fb6bfb84422fd83db3dbb725f0de98c3f0885b" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/REPORT.md", + "mode": "100644", + "gitBlob": "b98e2b68a2baa2485257cb050aa2c1067f524315", + "rawBytes": 44353, + "rawSHA256": "8e39b60ecd3facfd86749326734916962cc3670cda57430712bcee3292063c5f" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/REWORDS.json", + "mode": "100644", + "gitBlob": "57d61db39e5a8d737bb7b536abff69d53ed9f037", + "rawBytes": 5108, + "rawSHA256": "8fcea55e77c01c13fc1ea8137875f62065e6513a5833b9989c88b7db3a772e23" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/build_repair.py", + "mode": "100644", + "gitBlob": "1dba9c1f97d6a2d28e2144182f6195f3c85cf096", + "rawBytes": 12869, + "rawSHA256": "9e8741f82762da06683fd023c479984234b407a0e0641b8b79957673268fea4e" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/check_preservation.py", + "mode": "100644", + "gitBlob": "a0e863a41a8b906b6147788aeebdcc9b5313620c", + "rawBytes": 16282, + "rawSHA256": "345048e430e98e9185c3a409ac6165644077fd8ab4c2d5b28ed39abe25d14c42" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/claim_scan_detector.py", + "mode": "100644", + "gitBlob": "4efcd5df2aed1e5d3deee0bff48c761e2aa5fe11", + "rawBytes": 13995, + "rawSHA256": "cdbcbc8816e094a9ba20d49410eb78f9c724f40153267d36697615ad087c8c76" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/checker-modes-84ae12f.json", + "mode": "100644", + "gitBlob": "46e3ab3f9213ac645c0051b78ff4f76aba67689a", + "rawBytes": 30970, + "rawSHA256": "eea3cd642ab7c5d94ebce92f27eb44016bcacce638f7fb19450a16ad6034ea0e" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/checker-modes-e977053.json", + "mode": "100644", + "gitBlob": "732fb0e1e696a6d76fe5d8c86c7c4a516af83972", + "rawBytes": 30971, + "rawSHA256": "7d61361a3bfdfe4b98a93ed848ae150759c87832261b688e0b599561f622e9a0" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/checks-e977053.json", + "mode": "100644", + "gitBlob": "ea5e395d7dd334d1efba62791866cb29ebbfb91f", + "rawBytes": 2692, + "rawSHA256": "7bcce381f2a937e95af16ab99061b960fca0c21b64eb0c4aac6ae7a105bd8804" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/controls-e977053-incomplete-attempts.json", + "mode": "100644", + "gitBlob": "b423f901cdaa1ecc450e7931d63d499b69e3f386", + "rawBytes": 91573, + "rawSHA256": "fbd98bd4b582791b66ae9fd197e8b195a2be8b2423a9e0d5f40d534345d03690" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/controls-ece8ae5-ps51.json", + "mode": "100644", + "gitBlob": "659aa5b9f943d29e8819b55712ddd4e0444defde", + "rawBytes": 79009, + "rawSHA256": "6e1252b420b5d658998b2143062e57e839a9020a6b0513373e9681034db82252" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/controls-ece8ae5-pwsh.json", + "mode": "100644", + "gitBlob": "1fa56a1fb0bb63e4b6fce6e476bab3ffa00a73c9", + "rawBytes": 78752, + "rawSHA256": "5f4568cff8057367522f3b07d828ae070b47d82a7cbfa633e9b20b5345d98a87" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/controls-focused-runner-fix.json", + "mode": "100644", + "gitBlob": "2c90fa2f5e72c91568cc0441905932ec69b719f8", + "rawBytes": 8962, + "rawSHA256": "8a30f9dcc95005db66e45b299f329f13820c409afc56d7bbeef28b3fc6d5e7fa" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/hit-accounting-84ae12f-e977053.json", + "mode": "100644", + "gitBlob": "340f013745ef348a735fd75864ad75fa2beb511e", + "rawBytes": 2172, + "rawSHA256": "c85644e02eab7318ef22db072038460bee9663d07b90baaa11db094b30d29c0f" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/preservation-e977053.json", + "mode": "100644", + "gitBlob": "502b4ff21125879a7e271c07f4ab89b1c3776c1d", + "rawBytes": 13833, + "rawSHA256": "c11bb96d3372eb2103a8879aa191ba86a4001b6a8c1eec0da04e4a076840ef4c" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/reproduction-84ae12f.json", + "mode": "100644", + "gitBlob": "aa9ac87d3ce304705ded23ebb23b7bd0f8dd3a69", + "rawBytes": 24839, + "rawSHA256": "b095113c73381bd1aa5a3e351cdbb24493c7bb9a312807ece10f509f178502cb" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/scans-e977053.json", + "mode": "100644", + "gitBlob": "150c3b247644d90bcfb763824c0b7f7ec5028556", + "rawBytes": 12144, + "rawSHA256": "bf2fd2ca2b0b94832e35b9cc46f097c0e644ec5d243e14450aba8ee31f9ad2ac" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/verifiers-e977053.json", + "mode": "100644", + "gitBlob": "579f292748126db4427b6a462e5fe944a2943ec4", + "rawBytes": 5066, + "rawSHA256": "0b8372db5fe35b3503075126e28509aa5786b1965b470c32c967a34b4a9884f3" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/receipts/verifiers-ece8ae5.json", + "mode": "100644", + "gitBlob": "05ed2ad2310040b772cf101de75f7b22231e41ec", + "rawBytes": 20160, + "rawSHA256": "2cc4ecc7cbc679534a2407daa9b42a5ea76e13cf27c690d1d24aa0168ae98562" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/repair_control_helper.py", + "mode": "100644", + "gitBlob": "15ecfc0b00d74627a9817284bc61ae7dab0f93ce", + "rawBytes": 11198, + "rawSHA256": "7d4ed15eddff0e6358d1973e782240cfc215ea9cb393da8b3b82ec45c246a476" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/repair_controls.json", + "mode": "100644", + "gitBlob": "1e227e13d4486fca59377ee7d4c0f2e179ea4af1", + "rawBytes": 7582, + "rawSHA256": "3b44c6bc3693b1017d4451bdc5df1e372af97afee1b7183366c7c349c5eb7ed7" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/run_checker_modes.ps1", + "mode": "100644", + "gitBlob": "ed3a9977b88b7c198adf4be26c26920afb1294d2", + "rawBytes": 11820, + "rawSHA256": "578e9779bffbf7bcf65eb7886e8379e702b7e3ad05a78540fc2ab8c9398b3db5" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/run_claim_scans.ps1", + "mode": "100644", + "gitBlob": "9b18c6564d452421d13776677df72fecaa08627b", + "rawBytes": 10015, + "rawSHA256": "0a3ce98812903458b103008fd519de3a8ce72d2f87f3d5cd9646ad14c7b97af8" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/run_repair_controls.ps1", + "mode": "100644", + "gitBlob": "3cb1d35aa64d4d60dd8bc8f7d249f377ee02e6dc", + "rawBytes": 23099, + "rawSHA256": "3c7ae3b0aef6fbb4a83ea027c528ad4ac8ef16e5fae8c6edc337ff4e683b1b87" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/verify_receipt_archives.py", + "mode": "100644", + "gitBlob": "4352d77640533519caf97a01bfdabf7581dddd80", + "rawBytes": 32791, + "rawSHA256": "76afaacba4d788856f4f023872019cf999c63b2af41ad9fbcc6da5d2d278a3d3" + }, + { + "path": "docs/internal/extensions/pre1/repair-r1/verify_rewords.py", + "mode": "100644", + "gitBlob": "79fb096c0e9379cb3a8d22410343ec6fd4500d62", + "rawBytes": 21504, + "rawSHA256": "b980778487d495b2bc7434edf26d03c758a5a81ffd975c3de5f93a7f0f65df85" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "ca1a2c086cdc47f5d0cb6fd29fcfd2937e1c5e0f", + "rawBytes": 51944, + "rawSHA256": "5056d888ac2c79a7b1f011206e8b32ae78d078a8a0db3f812345635a9fdc1027" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/REPORT.md", + "mode": "100644", + "gitBlob": "5f85e2b1e9ca96b6b34e636a6cce6f995364e3d1", + "rawBytes": 28219, + "rawSHA256": "66eafcf92d325ab3d90b7444cb101ca34773dd10b7c94bf68cb1239f97c2e42c" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/marker_controls.json", + "mode": "100644", + "gitBlob": "a941723cd42205f1b9151c271d53479607249f68", + "rawBytes": 25912, + "rawSHA256": "554072ec7ffd20de73a74ef78528a6b7902b100a4b13b0bce6b7c86fb4678310" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q1-build-consumers-341bc28.json", + "mode": "100644", + "gitBlob": "f0304059d93be6584b94b67fb22a8d343f8f206a", + "rawBytes": 14869, + "rawSHA256": "c873d58d3bd17c29ddea4d4a0b2766b4a4ff4d5b712f2b54fe2cee3ec0981074" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q2-focused-replays-c33f2a8.digest.json", + "mode": "100644", + "gitBlob": "7ddcb20a896c990f456a3d2cd13b3bbe3160e744", + "rawBytes": 37466, + "rawSHA256": "3a689e197a2236cbdb57650fa245da202ed23d7f07a5830415f304eafcb9eceb" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q2-focused-replays-c33f2a8.json", + "mode": "100644", + "gitBlob": "ad2e7305c5107df919adb546d821be67afa09409", + "rawBytes": 8293, + "rawSHA256": "27e170e7ac997a972fa7f04b764c658214d40f36ee5fe3d3c11b5c431c563c3b" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q3-marker-controls-26b175e-ps51.json", + "mode": "100644", + "gitBlob": "1d7bd325421dbd432274bb6397e97a449df88d16", + "rawBytes": 112308, + "rawSHA256": "147f2e34e546dd509ecdf22ea829e453fbc4f9a6e5adca2ed106aa5d8c15faa6" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q3-marker-controls-26b175e-pwsh.json", + "mode": "100644", + "gitBlob": "1db92f1d9c50b54254e6cc9d0471be9b9e0db827", + "rawBytes": 13891, + "rawSHA256": "d43c613e31b260af8c4ecb69cf3a850ada59ffea4fcace0bb5b63ae50f349375" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q3-marker-controls-26b175e.json", + "mode": "100644", + "gitBlob": "d58fe48cf1e973c50b79097b4af12d52926bc7a0", + "rawBytes": 5920, + "rawSHA256": "63a267d75d204ae47e87648ebac9915efcd5ba60797c197c57666dbb91ac08f4" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q3-marker-controls-e935f84-attempt1-ps51.json", + "mode": "100644", + "gitBlob": "e51a2b6e56268c89035035a8322724daccabe823", + "rawBytes": 112325, + "rawSHA256": "6210fd56f661987be039663e6370558199e41ea0425e8477d4a8777bd396b450" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q3-marker-controls-e935f84-attempt1-pwsh.json", + "mode": "100644", + "gitBlob": "8535506f3f786dd6fa8fb00274a311985325a496", + "rawBytes": 13997, + "rawSHA256": "0e4a6552cc5d982cb636e8b1c71c5ff13613d7dfd32c2e39a8ce603fb464a70c" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q3-marker-controls-e935f84-attempt1.json", + "mode": "100644", + "gitBlob": "6743adb933405e1787fa7ed9af7898a57c804d0e", + "rawBytes": 7005, + "rawSHA256": "f191e8082c6fc9e64e252ce6d6726657e752de13fd79b660e1b68d754e383038" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q4-builder-replay-full-f5d6128.digest.json", + "mode": "100644", + "gitBlob": "e29c716674f951b1158e254a4788e825f98821e4", + "rawBytes": 276464, + "rawSHA256": "9e26d05c041690e8cc8c73a2c86a38f9308301aeef20d22d5b718b71343372ab" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q4-builder-replay-full-f5d6128.json", + "mode": "100644", + "gitBlob": "fdb8f6b8d70f7c44f29de7b022cc79fc6e10faf4", + "rawBytes": 4137, + "rawSHA256": "b205d5c09ec98b7aed38e92335afdd27104b94c5936e815402ffba6d63a6de37" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q5-contract-replay-and-selftests-f7bdf20.digest.json", + "mode": "100644", + "gitBlob": "82852aa6f833861aa3faf0907f0fab89487a0cae", + "rawBytes": 102729, + "rawSHA256": "8997264344c6fa8680c09c41ff7b74ef0fe0abe857ceaeea54398d599930ed96" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q5-contract-validator-selftests-f7bdf20.json", + "mode": "100644", + "gitBlob": "1509c128b6d215b7e33632271d24c0fb7f6d5752", + "rawBytes": 20230, + "rawSHA256": "7fa0c101bebb0899852c9e118875554e59787a96ad9f51bae35637918c532b8b" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q6-claim-scans-9598f72.json", + "mode": "100644", + "gitBlob": "353d58e005e1fd59f34a8f869f3069e780bb340f", + "rawBytes": 6424, + "rawSHA256": "30eba9677921448179b0b8dc692cac3739f38b58ff43b0f97fd2ff357573ae7f" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/receipts/q6-static-checks-9598f72.json", + "mode": "100644", + "gitBlob": "4eed9c3127ba7439c5cad3907a58f55256a179f0", + "rawBytes": 21467, + "rawSHA256": "7b7c8f4650dd262185a26482736aeaa7981047e3133e82482d3e547bb159fc81" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/run_marker_controls.ps1", + "mode": "100644", + "gitBlob": "33e336860111a7eb7d1d2eb875b42f5d96458cc0", + "rawBytes": 25996, + "rawSHA256": "763af78ea72149ff92d080ea04b39bcbbb8371f35120db7ced39f62eba4504ab" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/apply_consumer_edits.py", + "mode": "100644", + "gitBlob": "aa0ebf9538ca395ccb8ecfe9fb7877c2eaab464a", + "rawBytes": 9826, + "rawSHA256": "8c0b7e702b288280b377d7a4d91f9c8b7f744ff6e6c93835d40df343ce0c05c5" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/cab_probe.ps1", + "mode": "100644", + "gitBlob": "dd1f23e247ca3d7571e18d5d921a9aaf96d3901f", + "rawBytes": 4734, + "rawSHA256": "65975106acb5f0a7365f08ce71d2d6ba53ed991a64be56d491fe0337915059f3" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/clone_cases.json", + "mode": "100644", + "gitBlob": "2239e2292978aa240f239bf846968595964bef87", + "rawBytes": 34934, + "rawSHA256": "fc706e3811651949b11bb6b48363b3aea97190d7a9d0235ee5d3d90b016124ca" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/clone_mutant_probe.ps1", + "mode": "100644", + "gitBlob": "b778fd024784ccc04cbe898125a8ed62828df726", + "rawBytes": 4250, + "rawSHA256": "55b33fc42c69cd4822d2ff311619d3dc4c0eb1db807481a05a318c71aad30be7" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/make_marker_registry.py", + "mode": "100644", + "gitBlob": "4d3faa3df71bbdcdf1fed56ef928c024e3340212", + "rawBytes": 7335, + "rawSHA256": "b9022b920b314f6ccb677d83eaf27656a9159499f6192da841d549ad639945d4" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/make_registry_v2.py", + "mode": "100644", + "gitBlob": "1f826cf31fcb4afcfedddd5cbe167b4b4576bb58", + "rawBytes": 5300, + "rawSHA256": "763997c57836de44facb2e16e07927fb4014afb8d9a48c9d28c525147f1b0e12" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/marker_block.py", + "mode": "100644", + "gitBlob": "e303f0af86ecbe21deea23013ad09e05ff7f2fc2", + "rawBytes": 3085, + "rawSHA256": "7899af501d6427d0a6572007de22ec2ea770b264943e429e42848037e3f95a75" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/mechanism_toy.lean", + "mode": "100644", + "gitBlob": "ff4949ee91f6e29dc6ab52ae27ec1258120c0095", + "rawBytes": 2047, + "rawSHA256": "88399fbeb37f4766dc3925aeea0108f78a3f714acb0746b5789a6f22ed72fd61" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/mechanism_toy_variants.py", + "mode": "100644", + "gitBlob": "d5f7ce8db5bc258b6538deae6063156dfe463906", + "rawBytes": 1693, + "rawSHA256": "ed7c7d6667d11401295d7110311ae2b9ad2b024d65abc99128c98d26e50bf6f4" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/p2_2_work_probe.lean", + "mode": "100644", + "gitBlob": "92247bfe7792b106670150183517ee18cca6daae", + "rawBytes": 1818, + "rawSHA256": "95f002099b86f8f77882c38bdfe9c03f7cb4d2dd76197ffbb9c64c93dff3c205" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/queue.ps1", + "mode": "100644", + "gitBlob": "c4f8b8c33861f9cd9a308602021d49b53fe3f10b", + "rawBytes": 2554, + "rawSHA256": "3a65d5efca05ce8e48f110fb6c4b9883cfde319dcf4c5b20982399ebf858b9b5" + }, + { + "path": "docs/internal/extensions/pre1/repair-r2/tools/runsafe_mutant_trial.lean", + "mode": "100644", + "gitBlob": "0aa55521e295be888b0a5396287b32b3d46a228c", + "rawBytes": 3577, + "rawSHA256": "7a100040c52c211b059e1651e46a13c0ad70099e3846c535d51c87f9fd9ab3af" + }, + { + "path": "docs/internal/f03_evidence/F03_COORDINATOR_FINDINGS.md", + "mode": "100644", + "gitBlob": "222efcede6e4f73af780d125041c84440ec76754", + "rawBytes": 9846, + "rawSHA256": "d0474352835fbbeb2d7639177b2974bc4c34e9472537563e35dfad61f68d448f" + }, + { + "path": "docs/internal/f03_evidence/README.md", + "mode": "100644", + "gitBlob": "86288c8a12ad7b2a82511f6c5130171db39e892f", + "rawBytes": 2838, + "rawSHA256": "7211afd058ac8c49a29c7e71b718e967dbd0b0eb9868a506dd7188243afdf820" + }, + { + "path": "docs/internal/f03_evidence/T1_COORDINATOR_FINDINGS.md", + "mode": "100644", + "gitBlob": "c43d7f076c0e27b82cb76c87a21cecf54806a4fa", + "rawBytes": 3267, + "rawSHA256": "3428203fbbb459e8ed682dba0ee824bbb5007c5e463990dea8e26e413ddf773b" + }, + { + "path": "docs/internal/f03_evidence/adv6_L1_big.lean", + "mode": "100644", + "gitBlob": "5b00f3abfc14571ab35a55378e71c8837c8c17b7", + "rawBytes": 4829, + "rawSHA256": "2296f855f37754f6bee4ebcd559e3ec0d3bc031b97aba2be7200bf57cf372661" + }, + { + "path": "docs/internal/f03_evidence/adv6_L1_cross.lean", + "mode": "100644", + "gitBlob": "18beaa24784b467ba4639e9d600164ec7dd6507a", + "rawBytes": 4349, + "rawSHA256": "4e2b66ad2b7abfd035acaec63c778ed56f46872dbc2d211f2013a996b5c2d8cd" + }, + { + "path": "docs/internal/f03_evidence/adv6_L1_degen.lean", + "mode": "100644", + "gitBlob": "717516493b62f1f9eff846b427c45d3a7fb9c416", + "rawBytes": 7122, + "rawSHA256": "1f662cc299653b365ea1b3f231ed9829fc15c1d836e0711ac14f72df990b88ff" + }, + { + "path": "docs/internal/f03_evidence/adv6_L1_forced.lean", + "mode": "100644", + "gitBlob": "4d213a6cb6c1933c348270e2eefb920b05346076", + "rawBytes": 4911, + "rawSHA256": "58302c766df60226a0fbd574b902e440e25f74f1403c5593851e842574f53b9e" + }, + { + "path": "docs/internal/f03_evidence/adv6_L1_forced_out.txt", + "mode": "100644", + "gitBlob": "2d944985193025bdbd8ef1e66e5aa861c77fd519", + "rawBytes": 917, + "rawSHA256": "c237126f01017fbe06ccad9d6d492ffb60556ac356c922d3005b78be13e37ae4" + }, + { + "path": "docs/internal/f03_evidence/adv6_L1_real.lean", + "mode": "100644", + "gitBlob": "09676973ed603d386abc94afebf51a61c366a657", + "rawBytes": 4993, + "rawSHA256": "b086db935b42728a772dadf111b28ccfe4f73784f61f85b1d264031ad2126db1" + }, + { + "path": "docs/internal/f03_evidence/adv6_L1_refute.lean", + "mode": "100644", + "gitBlob": "54987d83a27def1b1bb9c132d83a9b898d76bf6e", + "rawBytes": 8567, + "rawSHA256": "ef835ae1ca55b62361096ef563e51413b4cd924a6e7bb0865d3e07b80530daf3" + }, + { + "path": "docs/internal/f03_evidence/advF1_attack.lean", + "mode": "100644", + "gitBlob": "16e2e24c4ca3fda75a018fd2f7bc12d03a595daf", + "rawBytes": 7694, + "rawSHA256": "91a9269f28d97b426f522ad3c8f8e70cf61353b7524f58145259cf40a98a7e10" + }, + { + "path": "docs/internal/f03_evidence/advF1_attack2.lean", + "mode": "100644", + "gitBlob": "688496c7b8d445e5403d31b4b5a1d9e476c12826", + "rawBytes": 6559, + "rawSHA256": "48a95206c8fcc5b33b0a091df326e6744aee58a708f5ff6d761938268bca0ac1" + }, + { + "path": "docs/internal/f03_evidence/advF1_attack3.lean", + "mode": "100644", + "gitBlob": "c96f4ab804b314c7876f02cd56f13ccc1ef58f2f", + "rawBytes": 4931, + "rawSHA256": "75d7ddcb305732a350a1d34bf222ead10a97386ed036772d8ec996bb0a365eb4" + }, + { + "path": "docs/internal/f03_evidence/advF1_reach.lean", + "mode": "100644", + "gitBlob": "6df91d76d18f966f7f9309a6db0b483b8737b770", + "rawBytes": 6551, + "rawSHA256": "42b2e60349e3785cf2009b0e5dada2af615f5906a705c3628eea9e734130757a" + }, + { + "path": "docs/internal/f03_evidence/advF1_refute.lean", + "mode": "100644", + "gitBlob": "c69bf86bc4ad050012f6ca7629fcdca80f9c24b6", + "rawBytes": 8233, + "rawSHA256": "10385a7c8bafb73793d4abd79a43693c8bcdeaf47a2c48fcb1b92bb7d9b7bdd9" + }, + { + "path": "docs/internal/f03_evidence/advF1_refute2.lean", + "mode": "100644", + "gitBlob": "94f1ad811137f30c17d6dac4f3d5b6ef6f9e025d", + "rawBytes": 6372, + "rawSHA256": "63747a41e13265337783edab0f7320e0e3b1fd1655a36ea2766269e46b20be9e" + }, + { + "path": "docs/internal/f03_evidence/advF5_antivac.lean", + "mode": "100644", + "gitBlob": "ec2dcbb5412ff8d2175999380f920e4d775d1049", + "rawBytes": 4071, + "rawSHA256": "841eccb20c1d4f07997010cb0aae8b0eed1f39453332f67ff88a00de2df33642" + }, + { + "path": "docs/internal/f03_evidence/advF5_antivac_out.txt", + "mode": "100644", + "gitBlob": "29b1ddf845353b72e53558730c8ed69ca5084a10", + "rawBytes": 4423, + "rawSHA256": "aac7213f6b329d3738b4c07cdb40bdbab64aad6f563ae79994a747ccfa11f403" + }, + { + "path": "docs/internal/f03_evidence/advF5_live.lean", + "mode": "100644", + "gitBlob": "e413938829553fdb343e12c7dc158d214fa2064b", + "rawBytes": 4492, + "rawSHA256": "638de48fc052f46af0300045e842f76d8c1197bfa7d7c8108c6c6301d7255cf8" + }, + { + "path": "docs/internal/f03_evidence/advF5_live_av.lean", + "mode": "100644", + "gitBlob": "7d3bd53c2d5d82fa16cbdebc0e47286689618360", + "rawBytes": 3727, + "rawSHA256": "db32698baa1379b638d30c3e37a573efd80fa431231ae552a52f5e4f63946c56" + }, + { + "path": "docs/internal/f03_evidence/advF5_live_av_out.txt", + "mode": "100644", + "gitBlob": "cca181778bb455e320d3ab3fc3d9428ff76b7361", + "rawBytes": 1140, + "rawSHA256": "0884572fb34a95dacc16535126074395ad095c7ee20b807084d7cee2ecc0eb98" + }, + { + "path": "docs/internal/f03_evidence/advF5_live_log.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/f03_evidence/advF5_live_out.txt", + "mode": "100644", + "gitBlob": "30de603098d62e2214ccb9914d57401be8445546", + "rawBytes": 272, + "rawSHA256": "0f0392944f536416daa5f8294215093c575702ed2f594dbaf0e57ccbf8dc4c64" + }, + { + "path": "docs/internal/f03_evidence/advF5_rand.lean", + "mode": "100644", + "gitBlob": "6569408b0fdb2c42cef03b88651431edfc0fbf79", + "rawBytes": 6505, + "rawSHA256": "df977646dedfa3c83d0e2f759d10e31bec5ecd1dd5b1d6d932f8a72cf02d8cea" + }, + { + "path": "docs/internal/f03_evidence/advF5_rand_out.txt", + "mode": "100644", + "gitBlob": "47735f142da34fd9c881a992841c1f8c2609e0ee", + "rawBytes": 2118, + "rawSHA256": "aeff543853d475e19726d65c3d2dd64bb5f6f63fee4058abc59b1222c24b4893" + }, + { + "path": "docs/internal/f03_evidence/advF5_realstore.lean", + "mode": "100644", + "gitBlob": "0eebe26dc937a6b94b3162194ae1faea9f89d40d", + "rawBytes": 4057, + "rawSHA256": "dafd050ae29d9a641934b1619cdad9ffc9e8687858162e330141ba883ac6ef46" + }, + { + "path": "docs/internal/f03_evidence/advF5_realstore_out.txt", + "mode": "100644", + "gitBlob": "4da2132dff19ae82e499c214453843a80fea4697", + "rawBytes": 461, + "rawSHA256": "063234c228d26205d7bd1fbb825fbc3221c2c75ee8ebada1ee4bb7638d9f5d31" + }, + { + "path": "docs/internal/f03_evidence/advF5_seg20.lean", + "mode": "100644", + "gitBlob": "9825c8e266d976ec70baa70729decc0d2e79169a", + "rawBytes": 2778, + "rawSHA256": "f21d8a537f3b43c285c9bf2bae368c09c3613d200894304959c836a3713d98e4" + }, + { + "path": "docs/internal/f03_evidence/advF5_seg20_out.txt", + "mode": "100644", + "gitBlob": "20ebe9c2277bf833426813c059b21864c1a0fcfb", + "rawBytes": 205, + "rawSHA256": "9aa375fd682949671f3ec490e3b0d8ac013cdb7a456a4e2a02787b00de7caca3" + }, + { + "path": "docs/internal/f03_evidence/advF5_seg20b.lean", + "mode": "100644", + "gitBlob": "133d7bbf2ce487a28643fad64a8f7fb7259b956f", + "rawBytes": 1840, + "rawSHA256": "45b21637a8ac8f59c6696569f008ecc71ed6c550527b99df3b5cf13d08de6bb0" + }, + { + "path": "docs/internal/f03_evidence/advF5_seg20b_log.txt", + "mode": "100644", + "gitBlob": "5a6a98bdf28057616afd7b55a920f4440fc59a77", + "rawBytes": 1444, + "rawSHA256": "e8efcc30699afd6179bf5acdda67bed3679bda810c96967c16586b57202d6428" + }, + { + "path": "docs/internal/f03_evidence/advF5_seg20b_out.txt", + "mode": "100644", + "gitBlob": "5c93fe57e9d1fccb757b64a9677a53bcb05331f4", + "rawBytes": 1442, + "rawSHA256": "0f693efa05e9733678fa6ff1ecf4fb66c51ddcb84e99b89100dffe41e0b2c7cc" + }, + { + "path": "docs/internal/f03_evidence/advF5_top.lean", + "mode": "100644", + "gitBlob": "72a8dcc75bbdb63ca4e50524cbee659201222b27", + "rawBytes": 4292, + "rawSHA256": "487e7b46431406ff249cbf24db38e49382c372cfc52720338a437d97341c37af" + }, + { + "path": "docs/internal/f03_evidence/advF5_top_out.txt", + "mode": "100644", + "gitBlob": "4d10ad510bd3c141f3f97998884c69437a6be421", + "rawBytes": 729, + "rawSHA256": "cfcc838eb98d35f361214e04b9695824092a38590c023a92b57d47c66a5a6d20" + }, + { + "path": "docs/internal/f03_evidence/advQ_f1_core.lean", + "mode": "100644", + "gitBlob": "f811ed5264b8f2ddb4e07edaec714b054ad3ffc9", + "rawBytes": 6363, + "rawSHA256": "61ab1f4a9b110a2d9a04c4a6411c02597aff9a108ae23ae69b38698308b4574a" + }, + { + "path": "docs/internal/f03_evidence/advQ_f1_quant.lean", + "mode": "100644", + "gitBlob": "6a7e63c7156207fad102398931834e1fe964997d", + "rawBytes": 11570, + "rawSHA256": "45747a4f6184060bac11480d4434f178621407e6cb919f94a35647e01df10992" + }, + { + "path": "docs/internal/f03_evidence/advQ_f1_sweep.lean", + "mode": "100644", + "gitBlob": "2a3b075eb1ea1f1a36dc333451a62d504e02a026", + "rawBytes": 5534, + "rawSHA256": "960412aa54fe7152a903f46b80dafe1b9312442aaf15dbed889629a571a69db5" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_forced.lean", + "mode": "100644", + "gitBlob": "0b625228f0cb3eae2ba5ae5272c4ef35962283d7", + "rawBytes": 3991, + "rawSHA256": "0b8fa153fdfc8ffbfa0fbba791d14a62af1dde3fcb1470c1c0b8ea37ce64e3a3" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_forced_out.txt", + "mode": "100644", + "gitBlob": "f73a87b739aeadac47f6cd93a171a01b7fcbf84d", + "rawBytes": 3272, + "rawSHA256": "e05e82f70d038384d23f7850dde0641a9b0ac5c082833a2576d4a18354e538d2" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_global.lean", + "mode": "100644", + "gitBlob": "e38263eb6d38eb08826d91d66776f618bd0c02c8", + "rawBytes": 6190, + "rawSHA256": "0f1e01696af991af5c1b36135b6b8197c2690dd91e298e299d4d046fa7bf1ef8" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_global_out.txt", + "mode": "100644", + "gitBlob": "49f75996e8777e96d8097e684c47a0176764e011", + "rawBytes": 459, + "rawSHA256": "5cbadcb2904d83d414185435eab83c37a790e8538763b10371057d8bac87e98c" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_offsets_thm.lean", + "mode": "100644", + "gitBlob": "b361406c2c18f68538acdafa48d596aa263f3b4b", + "rawBytes": 4815, + "rawSHA256": "7decb57a627866e946c7578b0dfa6335cd40f6834b495312584cc9f6deac35cc" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_regime.lean", + "mode": "100644", + "gitBlob": "c664cfc8ee37563a9c149a86d3b050d63c39cdf2", + "rawBytes": 5040, + "rawSHA256": "2458d558dad5dfd9f62b9064b05949eaaafceb3672020eb1e3424551e4978d04" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_regime2.lean", + "mode": "100644", + "gitBlob": "8667296960bcf61fb04c0251b2f8ad0a7326dfc5", + "rawBytes": 4806, + "rawSHA256": "5ae86f40e93d2ab344a441de868d9345fe9e0c04a9c9ebb3ccbe2c2a7460c98e" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_regime_out.txt", + "mode": "100644", + "gitBlob": "8056689c3cce7839d11b799aeaca398b5c68df38", + "rawBytes": 4083, + "rawSHA256": "f505717258d3ef5108be34ca658a2fbeb85f5583e353ec0044ef5a73f70f588c" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_uncovered.lean", + "mode": "100644", + "gitBlob": "421b69f6d19d9fb93e0e47bf8517650e6166a760", + "rawBytes": 5289, + "rawSHA256": "3d87d3362a56aa0a3ae759d2646249222aa5324c539dcb45c02e7f3b8bcbd2cf" + }, + { + "path": "docs/internal/f03_evidence/advQ_f5_uncovered_out.txt", + "mode": "100644", + "gitBlob": "467ab1ad59b880c9f1f5b8abce5fdf9e14b60057", + "rawBytes": 3185, + "rawSHA256": "31d1b50ba11db7e90e21a519b159dfacaac5b21fff3645e621f262e02486fe5a" + }, + { + "path": "docs/internal/f03_evidence/advQ_f6_big.lean", + "mode": "100644", + "gitBlob": "2debecdcde893031994576270329d8802faa5243", + "rawBytes": 6596, + "rawSHA256": "4dcc601d51f5339e5929ca91ea688985c758d74df6b07d6ae3fc6d9a77124e2c" + }, + { + "path": "docs/internal/f03_evidence/advQ_f6_big_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/f03_evidence/advQ_f6_kernel.lean", + "mode": "100644", + "gitBlob": "a59b280a8c99d56e3ff461de4ef9806b330edc7b", + "rawBytes": 4837, + "rawSHA256": "7be21820d2483d7b75f459677099707442b060785091e170928eacbad4e4d0fa" + }, + { + "path": "docs/internal/f03_evidence/advQ_f6_raw.lean", + "mode": "100644", + "gitBlob": "c38707ce61f21fe83d707507fb80ac77bce4af3c", + "rawBytes": 6464, + "rawSHA256": "e565576531bced3a0a9e1fdcf2931c527b1cd57e9bd851deff51a633da431340" + }, + { + "path": "docs/internal/f03_evidence/advQ_f6_raw2.lean", + "mode": "100644", + "gitBlob": "0e596d955a76cf82964c65790e39f4859eb52cc6", + "rawBytes": 5929, + "rawSHA256": "b4ba1ad0ab3a74cde1eed6b982cb1e2bff429c87131e5f2b91abf63449db703f" + }, + { + "path": "docs/internal/f03_evidence/advQ_f6_raw_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/f03_evidence/advQ_f6_thresh.lean", + "mode": "100644", + "gitBlob": "7972ff5e98acfb9c7bceeac63fe82ba972dc7e9f", + "rawBytes": 2116, + "rawSHA256": "3d4357c219271ec21c19db4b7b25cc34d159338db00122fb54c22d4b9d8141f7" + }, + { + "path": "docs/internal/f03_evidence/advR_f5_addr.lean", + "mode": "100644", + "gitBlob": "73f5b7b97de436e1a9db0850587de7b823b648df", + "rawBytes": 3238, + "rawSHA256": "69d3d1b255b255158c6ac0c9ff848401d86993428994aaed6c18586f7853671c" + }, + { + "path": "docs/internal/f03_evidence/advR_f5_cut.lean", + "mode": "100644", + "gitBlob": "3f46f1cd63e0e555bed66c964d29db2bb2974e05", + "rawBytes": 7478, + "rawSHA256": "dc651fb6e64d5e3f4b005e0036b6eda1ac919a0c4b5f8805077a3938bfa1ef1a" + }, + { + "path": "docs/internal/f03_evidence/advR_f5_cut_out.txt", + "mode": "100644", + "gitBlob": "d145bdcb9a2dae21439f9c608b761d4466dcbd9b", + "rawBytes": 5201, + "rawSHA256": "afffd96e20c852404a847866774c32f05efb1d163bb4630f0fe125adad312026" + }, + { + "path": "docs/internal/f03_evidence/advR_f5_root.lean", + "mode": "100644", + "gitBlob": "1fef6d2c53949e0c93bd8697924c76bde67426bf", + "rawBytes": 3938, + "rawSHA256": "62e0dc3ff361937800fcaf38278d99a5e7f7d6592601d8540b8742dee0a648cc" + }, + { + "path": "docs/internal/f03_evidence/advR_f5_root_out.txt", + "mode": "100644", + "gitBlob": "23891c08a675dfb5331ec29475071d84636d8bb2", + "rawBytes": 1308, + "rawSHA256": "52979171305096fd4e93e6a4455ffd2bf97b12eaa6c278d57ad65530576725af" + }, + { + "path": "docs/internal/f03_evidence/advR_f5_vac.lean", + "mode": "100644", + "gitBlob": "9fe3a02cc20c3cb1c0f2273e4467036bf4d98ab4", + "rawBytes": 2642, + "rawSHA256": "a70ccd6266e84c543e763f8966a2b5188e163dfcfed86cc98474c9fd562383f4" + }, + { + "path": "docs/internal/f03_evidence/advSZ_axioms.lean", + "mode": "100644", + "gitBlob": "11fd9c54ea0e05083c52ebec3192d127cf851901", + "rawBytes": 3344, + "rawSHA256": "3d5d9fb2c3d4cdd9db6272ac8461b824a5fb412b14a634b7ead754287f0b6afe" + }, + { + "path": "docs/internal/f03_evidence/advSZ_big.lean", + "mode": "100644", + "gitBlob": "06f1dd062fc3cddda08eeafa9e612c4a62783b96", + "rawBytes": 7205, + "rawSHA256": "bede7f4a12e2e1b6f723110af755ae6b730361998b0facd1c66d32a036d6d786" + }, + { + "path": "docs/internal/f03_evidence/advSZ_chk_rank.lean", + "mode": "100644", + "gitBlob": "52f6541e19a13fc5e6d6281e118b61230b4cca30", + "rawBytes": 3206, + "rawSHA256": "bee74772a7b66255eb93360ed1b57b27057544dec535819ace6685b679c24dc5" + }, + { + "path": "docs/internal/f03_evidence/advSZ_chk_size.lean", + "mode": "100644", + "gitBlob": "59c5228b77235e4db6bb17ae8684c0f6ffda136a", + "rawBytes": 9503, + "rawSHA256": "b27b0e8f4fe02d983fcbf17e93b9da4309111e7d14b4d206855d0ffe2549edd9" + }, + { + "path": "docs/internal/f03_evidence/advSZ_ctrl.lean", + "mode": "100644", + "gitBlob": "4491f9aad117d87266730dd69c346d7617534806", + "rawBytes": 3172, + "rawSHA256": "c84d2a1d30ef36c2c3cc3123106e8dc008706fe995dee80c8849e00f2f106bd2" + }, + { + "path": "docs/internal/f03_evidence/advSZ_decide.lean", + "mode": "100644", + "gitBlob": "ff921260c68b763e38a9b3dc5f7f9255bbc3721e", + "rawBytes": 2927, + "rawSHA256": "230471e703a359aa798b3497d72f94d984b16c8006dba12a9f320fc245fb4286" + }, + { + "path": "docs/internal/f03_evidence/advSZ_decide2.lean", + "mode": "100644", + "gitBlob": "0932787e4989c02452026081cde1259dab03325e", + "rawBytes": 2699, + "rawSHA256": "6109040b4cf2333057d5a1614bf4b03ee07580829b0dad92edba748fffb8ad81" + }, + { + "path": "docs/internal/f03_evidence/advSZ_decide3.lean", + "mode": "100644", + "gitBlob": "87eced826ecdcae9fdc864ad807f71722816fdf2", + "rawBytes": 2678, + "rawSHA256": "5b89af0bc36a649777345cb7ecd171214a7599231b48a49a54170fc4b2c6dd80" + }, + { + "path": "docs/internal/f03_evidence/advSZ_exh8.lean", + "mode": "100644", + "gitBlob": "6a44c3596aa658fde7464e27735ba22d4e998306", + "rawBytes": 2189, + "rawSHA256": "e363351bb9fedfe975f968549c733754db0cbe0d9eb5384509818b43a2ec6024" + }, + { + "path": "docs/internal/f03_evidence/advSZ_huge.lean", + "mode": "100644", + "gitBlob": "4091faba89139b01b7fb3e30c32dc626222ba30d", + "rawBytes": 5813, + "rawSHA256": "53ea79eae41caf88d773744becc8faa9ecdb4ca4f39d27f0d1111735da9655e4" + }, + { + "path": "docs/internal/f03_evidence/advSZ_layout.lean", + "mode": "100644", + "gitBlob": "400a2dd3852d725dd37940e2e2d1286971c43278", + "rawBytes": 6025, + "rawSHA256": "b6b76f44132cb583addd4e44d1ab011e725801c46e58aa2af328c9a9fe2c0492" + }, + { + "path": "docs/internal/f03_evidence/advSZ_layout2.lean", + "mode": "100644", + "gitBlob": "4ad3086766fb97f6b7a8a47c085324d60f465a17", + "rawBytes": 5616, + "rawSHA256": "a712d57abb8f47a6fa5e2a8429f6765b4ac5909a5798f3498cbc1fce46e3d45d" + }, + { + "path": "docs/internal/f03_evidence/advSZ_probe.lean", + "mode": "100644", + "gitBlob": "fbf03d252cddfdd8922215f971c61107541b7f89", + "rawBytes": 2243, + "rawSHA256": "031d5386cdafea6a95f7a842190c951871052cac03a3880d8eccdbbe30d46363" + }, + { + "path": "docs/internal/f03_evidence/advSZ_sparse.lean", + "mode": "100644", + "gitBlob": "6d3f752812018adeb95546be10109a63e745cadb", + "rawBytes": 3621, + "rawSHA256": "bb053a952e8b58ac8a1423fde25c13b62ae1c68c081f9bed4af9f57299d7fae5" + }, + { + "path": "docs/internal/f03_evidence/advSZ_sparse2.lean", + "mode": "100644", + "gitBlob": "297b4498c8d83f51eabff472645c6fcff5c3d7d6", + "rawBytes": 3617, + "rawSHA256": "6de1f9f073a641ef531e46582f3dda08f85b8373af45e9e4d14ca745881e2f41" + }, + { + "path": "docs/internal/f03_evidence/advSZ_store.lean", + "mode": "100644", + "gitBlob": "bd303471f038211d90251e51bb8b91d78633572c", + "rawBytes": 3472, + "rawSHA256": "b7b85fb6cdb30882a72c8c98f03d3f3e08519dfc59630af6601e768e6f4dc1ae" + }, + { + "path": "docs/internal/f03_evidence/advSZ_strides.lean", + "mode": "100644", + "gitBlob": "8ee9290ba9e454760c113332e6084ed958853594", + "rawBytes": 6107, + "rawSHA256": "babc1c02a3be69baa67d0337b3ae3deac78538354399729719e041a5143507cd" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack.lean", + "mode": "100644", + "gitBlob": "ef03dc2e5265d857b7722c429e9d80e8b446b0c4", + "rawBytes": 8008, + "rawSHA256": "afe1b805fe3db50000a5b220f016825d882199e51d8eda2f1418ef4e0b375880" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack2.lean", + "mode": "100644", + "gitBlob": "5a71be7ec0c107c481983915ee7fc9108c721e67", + "rawBytes": 6826, + "rawSHA256": "f01039d1d32283706dc3c860a8a53c6bb63ec6e034ef32f2082e5fcef9c2ceb9" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack2_log.txt", + "mode": "100644", + "gitBlob": "28409735729251605cc1007c9d97c6145c2327c7", + "rawBytes": 154, + "rawSHA256": "1b523fe252a7a813ded19e5751628f769328c3df4aac868c09c763fc57c9f427" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack3.lean", + "mode": "100644", + "gitBlob": "5289bbae06043bea216ededbe9e8281fe3e29418", + "rawBytes": 8449, + "rawSHA256": "35f5b3ceacc4e89c65c58bbdb062e6f137c04de7e806c978b761b83d827f411a" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack3_log.txt", + "mode": "100644", + "gitBlob": "eec3b9f201b9914b2409148951f5ab415b699995", + "rawBytes": 1756, + "rawSHA256": "c78bf65b7d6567a0c7e2e809fe8cf511120c2e231ea98e9b5eed7a6ffe6fa689" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack4.lean", + "mode": "100644", + "gitBlob": "f4d0f8f2432408173e780ded73389e409b108fd0", + "rawBytes": 10925, + "rawSHA256": "acd00dae304613ff05dc1db415331fc5a9e0ed7cc39fe358e2319f405c0e1723" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack4_log.txt", + "mode": "100644", + "gitBlob": "0adcc14e557e451fa554713f1fbee4fe2f5867d2", + "rawBytes": 2032, + "rawSHA256": "4fab92b64f781b45951de881c9c1d929072d89f6360866532039b9dfe582f29e" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack5.lean", + "mode": "100644", + "gitBlob": "5f4ee86ff53c694c2dccc6486741ae2b94b252fc", + "rawBytes": 10880, + "rawSHA256": "1c4c45986a09aca8b0048c6455fc8d26e8ae867d098f33daeba022648926ba8e" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack5_log.txt", + "mode": "100644", + "gitBlob": "0776b5bee5940c375d35bc98e89d698c9413f51e", + "rawBytes": 1876, + "rawSHA256": "c200b23d7e9ac23516fe4a06b336bd37e88a8962d8ae732d560cf87d358c7b6d" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack6.lean", + "mode": "100644", + "gitBlob": "893edfa680993ef27dcbb09208159c30e07742bc", + "rawBytes": 7305, + "rawSHA256": "3bcbcb3d465fec21bec45c598e563d4c87e067418586d014d2fb2c29ec375f6a" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_attack6_log.txt", + "mode": "100644", + "gitBlob": "0e0a40dcdf63ea6cde5e35767972f0df99d1c26f", + "rawBytes": 1858, + "rawSHA256": "f5cd1251fa50c3d9e171b86c9fd23b14f71ad31f5b9e622f90033f63a69fa1d1" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_cost.lean", + "mode": "100644", + "gitBlob": "7065e8ebceeb983b31f33037509ce517863dbefb", + "rawBytes": 3461, + "rawSHA256": "119e12052ae6db2ea29b48f91bbaaaf53d186e690a8da626800f80babbcabacf" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_cost2.lean", + "mode": "100644", + "gitBlob": "d6c37db3e0499679e4ec1b9334cfe925d3867d35", + "rawBytes": 3082, + "rawSHA256": "5ab2d4175cdd58d4d03e6574a3e88147042d5c58ac2c3a3c5b6840a6c6bef8ad" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_cost2_log.txt", + "mode": "100644", + "gitBlob": "4936f417a793effa6e2b439f1ed0073990c6adca", + "rawBytes": 848, + "rawSHA256": "9ffd0c739c8e4c62e71b326c1650447d79ee7386202af2c9054fa95334447b52" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_cost3.lean", + "mode": "100644", + "gitBlob": "469ddc342689ea3712dd82552319cc031d75da55", + "rawBytes": 2309, + "rawSHA256": "719087894b25538525416479e36470294965789db02315fa437366b287bd72da" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_cost3_log.txt", + "mode": "100644", + "gitBlob": "4cae1deacca584b633289fe9a73ec72887ea4b26", + "rawBytes": 818, + "rawSHA256": "18904f5683aa4498f2f15933a3dc5795c3f3e1ee52062176a903418320a30262" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_cost_log.txt", + "mode": "100644", + "gitBlob": "090c111c5323c1231366a9f52ab765521da07b44", + "rawBytes": 1423, + "rawSHA256": "c2e7ae10f25ca4d55f80eda510c58b93f2c8dbfc6b9eaa24f06c55968699b763" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_diag.lean", + "mode": "100644", + "gitBlob": "c720d7d98c00b8da12c38d72a54099d8dfcadb5e", + "rawBytes": 1365, + "rawSHA256": "4b33fbb409cba895d77f3bcbd7d1c18a259c2b8f214e9ff1891c42a9445d8980" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_probe.lean", + "mode": "100644", + "gitBlob": "afc0226aefd0c5f7df48e26f8a39f3f8bd340b4a", + "rawBytes": 2606, + "rawSHA256": "9e2f7132f6938d86d6e5dcddb2c6c80752eb5e28f976729ed58c9bbd5bd42d3f" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_probe_log.txt", + "mode": "100644", + "gitBlob": "87d643f0ae0a4d836a154c666814f69e115fbe41", + "rawBytes": 497, + "rawSHA256": "9503178276b9a55acaf054f957a1c9a597aeb1fce359f88158f30d0f8d86c03b" + }, + { + "path": "docs/internal/f03_evidence/advS_f6_time.lean", + "mode": "100644", + "gitBlob": "5692578e457e7231676cc20b97c715bda15f3205", + "rawBytes": 2522, + "rawSHA256": "e0aaa845f678834f1d8bafba9a52e59d261585c66797a96c083b4d5c13adba5d" + }, + { + "path": "docs/internal/f03_evidence/adv_f2_bridge.lean", + "mode": "100644", + "gitBlob": "ce3f026d15e5bb973dea1aeadb73ae51e90debe7", + "rawBytes": 5250, + "rawSHA256": "50e52ec28270573fbfd975879414bf33f8f8262425029e257687b0348fc25326" + }, + { + "path": "docs/internal/f03_evidence/adv_f2_nonstore.lean", + "mode": "100644", + "gitBlob": "d806cc2ed59e15e3014390a0b36e2a2eae089614", + "rawBytes": 4732, + "rawSHA256": "9927255460e4554f48bf483b466fce7e329f446977015cd39d31c21cb73d0b39" + }, + { + "path": "docs/internal/f03_evidence/adv_f2_reach.lean", + "mode": "100644", + "gitBlob": "7468b985be07efa2347431285c21c33d0ca49436", + "rawBytes": 5647, + "rawSHA256": "f2514a5f08a05f691ea27b9f45630732debf8621521edd2ccc1ce17335185037" + }, + { + "path": "docs/internal/f03_evidence/adv_f34_attack.lean", + "mode": "100644", + "gitBlob": "b7ee196406f9e23a8ec4f39e5f1f8280d4864791", + "rawBytes": 6936, + "rawSHA256": "ee417757dcd423af0981e4316c4a3e3be7e7bd47d23369af794764bb75cfcb7f" + }, + { + "path": "docs/internal/f03_evidence/adv_f34_attack2.lean", + "mode": "100644", + "gitBlob": "5d3fe92753e2ac740e2344e17fe03465b3473bc4", + "rawBytes": 5172, + "rawSHA256": "20757c750c71eebec51a09eafa78836af13bf779184b9b0e19c0b466db9f5de2" + }, + { + "path": "docs/internal/f03_evidence/adv_f34_density.lean", + "mode": "100644", + "gitBlob": "9ee50adae44e409dfbd40963172aa84f06717b48", + "rawBytes": 5446, + "rawSHA256": "3ca82f2168389671a5c948d0614cdb9db4b70ca9ad6400bfdc4472d85ca58cfe" + }, + { + "path": "docs/internal/f03_evidence/adv_f34_density_out.txt", + "mode": "100644", + "gitBlob": "cae228e346251d73adca25d6311c696f1b01bf91", + "rawBytes": 1275, + "rawSHA256": "869536b3a43bd6d0b1c71d02206ead28dc4685981ab07bbb192f84b0b4cd7e0a" + }, + { + "path": "docs/internal/f03_evidence/adv_f34_out.txt", + "mode": "100644", + "gitBlob": "93ffe88d303e0b47b86bf8a46fe9d3a58dbe8bc0", + "rawBytes": 3274, + "rawSHA256": "8c600ec1f2db13ac4e296026c9046c33f4dfcecfd139074d968264ed72a9311c" + }, + { + "path": "docs/internal/f03_evidence/adv_f34_reach.lean", + "mode": "100644", + "gitBlob": "31eb630c6517b8ad50ac7918a7eefa47f5396c0c", + "rawBytes": 2828, + "rawSHA256": "2df6cb7beb3ee14c4f666c235f83a3eab4b97248e0b0c6ec7066f8f1ad4625af" + }, + { + "path": "docs/internal/f03_evidence/adv_f34_refute.lean", + "mode": "100644", + "gitBlob": "c80408018f5616825b5cd00243b9b85bfc1b714f", + "rawBytes": 7257, + "rawSHA256": "d79b11f3f883bbc73eabad102bcd05dccb09281e7d25dded59de4e242a4ecc55" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_bign.lean", + "mode": "100644", + "gitBlob": "cc8df582f712480e9a720ecd70d40ad5ec5017a9", + "rawBytes": 5279, + "rawSHA256": "d73855acf47e9824bcb7edd9954b8f6a8f6ebbbab5bfa54ababdd2b33fe42a69" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_bign2.lean", + "mode": "100644", + "gitBlob": "562510a4f4e84d2b8524274938db6faed42e1e25", + "rawBytes": 5292, + "rawSHA256": "525bd12787316583b2e81c00a0246fcd10952d7ca927c052d0effa3f6a217b68" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_fulltrace.lean", + "mode": "100644", + "gitBlob": "fa3fd8108015f3b9dc84d60666687f1992bfbe3a", + "rawBytes": 6097, + "rawSHA256": "35136691b981601d49e721cb3abaa03cb5fd80f63a65f17e878c8d37da661f49" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_fulltrace_s.lean", + "mode": "100644", + "gitBlob": "c759d0fe400750f44d4350f07e04f9f650c6dc7c", + "rawBytes": 6090, + "rawSHA256": "2753620a7a2af10ef52efdd79d2727bc595c03d07c01c5ad23197e88a60c72e4" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_leafvac.lean", + "mode": "100644", + "gitBlob": "e2ca9442e955844ae3756da9765540748f1b6779", + "rawBytes": 6662, + "rawSHA256": "c4e081289afb2cbf45cd6440ce4bcb731193b5c05b939a8b373c40a427c8a427" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_leafvac_out.txt", + "mode": "100644", + "gitBlob": "e7bfe7f6ad5c936a963b5680ba6d73c42f091d6f", + "rawBytes": 8800, + "rawSHA256": "77bd455e13b16e310b5185cd16b52b6ff0d6fe97b2685fe74bcc61f3be9d366f" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_off512.lean", + "mode": "100644", + "gitBlob": "c47494d36f0b80b448f885b4087e46ae2d393f6c", + "rawBytes": 2166, + "rawSHA256": "cbfa26d6c0198544ae27c8695ff9e3990f6d92839fbfb9372edccae1ba629519" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_offsets.lean", + "mode": "100644", + "gitBlob": "dde1c1693ff694c5760ce59bed02f5aa87cc68e2", + "rawBytes": 6403, + "rawSHA256": "09276af3393f2f958db3bedfdfd38d825255c5c8e5628df90bcb3db073c4711e" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_offsets_big.lean", + "mode": "100644", + "gitBlob": "5cfe77bb262f39deff282ed4ea1cb4a450c204ff", + "rawBytes": 6411, + "rawSHA256": "200332316ab3c364f897578950f9aba3d4c7232e7f8d72ff219e9c151c1cb65f" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_sweep.lean", + "mode": "100644", + "gitBlob": "468501e354f740fac5707daded0094a497a9f5bc", + "rawBytes": 4967, + "rawSHA256": "6709633e705aa539189ca7275c26445f05059eaada75c2ee05260466deea7622" + }, + { + "path": "docs/internal/f03_evidence/adv_rx_sweep_s.lean", + "mode": "100644", + "gitBlob": "a3da65ed76ceadde09615e2745e538cd20ab1995", + "rawBytes": 4941, + "rawSHA256": "9a5f7837fdfe19baed5745a955492074ace5f6b5017ff62353df365f14144958" + }, + { + "path": "docs/internal/f03_evidence/atk_crossshape_big.lean", + "mode": "100644", + "gitBlob": "a2e4af929807b383a30cf22ec0cf6c0db1763209", + "rawBytes": 2575, + "rawSHA256": "5ea5efb7ccf4503eb6abcd83a6434eafde38b709d74ce3f841c5c7395cddf5e6" + }, + { + "path": "docs/internal/f03_evidence/atk_crossshape_lite.lean", + "mode": "100644", + "gitBlob": "f27d423126edbd06a3d262f3febb246d6c91a84a", + "rawBytes": 1268, + "rawSHA256": "f574ef8a142d5e144ff6ac585a07bd599cfa9a524df69ed818bfa54b5e37b2aa" + }, + { + "path": "docs/internal/f03_evidence/atk_frontier.lean", + "mode": "100644", + "gitBlob": "d6d3fcdbb0841fa9e861d430ccb59e9c49ea9b48", + "rawBytes": 6516, + "rawSHA256": "c8bc01583cb6e42030f05b4c6edc62aac8f12426906906e8bb27e023b7ae32c0" + }, + { + "path": "docs/internal/f03_evidence/atk_frontier_out.txt", + "mode": "100644", + "gitBlob": "ff4796c75fd34868d2c1414697d6f2c6b903f881", + "rawBytes": 8615, + "rawSHA256": "55b1227a8027d7902adf5ef92575f972f31524e9aff94164227701d72e800b72" + }, + { + "path": "docs/internal/f03_evidence/atk_guard.lean", + "mode": "100644", + "gitBlob": "58c350e22d246bc7216fb7aee6af6e9ff900ba87", + "rawBytes": 1095, + "rawSHA256": "8333e3df8c169d83d80d15d275c0981eb629b82ce1fd53f1d6aee8006372242c" + }, + { + "path": "docs/internal/f03_evidence/atk_lengthonly.lean", + "mode": "100644", + "gitBlob": "c25b1479720b1d899268da2189ae22949bb72c46", + "rawBytes": 2896, + "rawSHA256": "2c3107fd1dff8c383b79388112d664a029dd913021a186f0ccb0a014e45111cb" + }, + { + "path": "docs/internal/f03_evidence/atk_linchpin.lean", + "mode": "100644", + "gitBlob": "fdaeca8c6b6dbe798a79172aa7220dddbe909e45", + "rawBytes": 8771, + "rawSHA256": "2a71020c34e62b369225c997cba34bafd713ca1a61917eb666e290adcdaf5046" + }, + { + "path": "docs/internal/f03_evidence/atk_linchpin_out.txt", + "mode": "100644", + "gitBlob": "e59677e40021e324c8807e5fa1507ea7281dc290", + "rawBytes": 5870, + "rawSHA256": "e1c52d2378792f9afe4220ea81a2c8962936e81013b31ffde53c79f9f8f14f53" + }, + { + "path": "docs/internal/f03_evidence/atk_paths.lean", + "mode": "100644", + "gitBlob": "64dde886a22309b6aa5787c8fd1593b5e11fb8dc", + "rawBytes": 5578, + "rawSHA256": "269218005efb0467cac80e56a3fe4ad62066db623881e1fa1f43e79c74278f3b" + }, + { + "path": "docs/internal/f03_evidence/atk_paths_out.txt", + "mode": "100644", + "gitBlob": "4847fad7938024eb1845042418b9e11b44ed64b8", + "rawBytes": 16931, + "rawSHA256": "3e22f9058195fc1203dd9d5ca706b395be310955957dcbb2cfbf37485d20f8ac" + }, + { + "path": "docs/internal/f03_evidence/atk_sizeonly_eval.lean", + "mode": "100644", + "gitBlob": "e7428fe7e3c087bc21424aa80eb209a28ce483c9", + "rawBytes": 2669, + "rawSHA256": "03ad661c712e20d03baa5381949d3aed6c6cfd138385f69f0a2990d6028b1ad6" + }, + { + "path": "docs/internal/f03_evidence/atk_taint.lean", + "mode": "100644", + "gitBlob": "44fdf1b596615d3dbad8952bfba4655248d18538", + "rawBytes": 6960, + "rawSHA256": "1e5f7047cbde50615b372d07e138cc4fa713823cc5258c7d0aa1168a941bfc01" + }, + { + "path": "docs/internal/f03_evidence/atk_taint_out.txt", + "mode": "100644", + "gitBlob": "598102a099c916b944845993c7c86ca4e6f845ca", + "rawBytes": 3540, + "rawSHA256": "14e8fa27b8ab71462064a8bac599fef2bfca93dddd3a2ad00c7da3408698aad2" + }, + { + "path": "docs/internal/f03_evidence/c06_comp_antivac.lean", + "mode": "100644", + "gitBlob": "2f97fcfb8f38f24e64d78c5c57c8b23031f5d0d3", + "rawBytes": 2313, + "rawSHA256": "0a1b36e6f54014c0f48dd31507c4bcbe5d5b53614667ac13d04a8b92c2e7952d" + }, + { + "path": "docs/internal/f03_evidence/c06_composition.lean", + "mode": "100644", + "gitBlob": "348134a02687f616ba2643900887f253f39d4694", + "rawBytes": 2501, + "rawSHA256": "7562d98d3a17f6c7d3f38d90b2a0504540b01f83be01077374f3bf32d36c13b7" + }, + { + "path": "docs/internal/f03_evidence/c06_f03_final_check.lean", + "mode": "100644", + "gitBlob": "034321cc0fd222658d34ad102a7ad0afbdb40ecf", + "rawBytes": 4036, + "rawSHA256": "fcf978516eba22ed0563aef720d30ab2354be18455efd182f7acd2ac2fcb82c0" + }, + { + "path": "docs/internal/f03_evidence/c06_sourceinventory_check.lean", + "mode": "100644", + "gitBlob": "eda401aea5c91bdfda2801c66042087f321b9a4b", + "rawBytes": 1471, + "rawSHA256": "21725f258a614369613052f0dc472b30e5c4030c065ddb7d3e51c7d2a57c3805" + }, + { + "path": "docs/internal/f03_evidence/dpR9_f34_attack.lean", + "mode": "100644", + "gitBlob": "dbdee3e0ba4ad3880071da0e486bb626e5d454f1", + "rawBytes": 7402, + "rawSHA256": "6fe38f8bf3264838e475d4aada116b88a82d93040e1c6f7fd0950c19628ebdf4" + }, + { + "path": "docs/internal/f03_evidence/dpR9_f34_regimes.lean", + "mode": "100644", + "gitBlob": "1266b9e1c0879378aabbda28209ccb968973f978", + "rawBytes": 2391, + "rawSHA256": "cc941a4dbb8cf9065194847a4754b782f308e57faf5165a94f2e3b6963fdf122" + }, + { + "path": "docs/internal/f03_evidence/dp_cross_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_branch.lean", + "mode": "100644", + "gitBlob": "7220b65503936692061aa131eed911eba2e38eb7", + "rawBytes": 15399, + "rawSHA256": "e3676db775bf5c4ed007fb071b656988c26b0895a3b4655d03ea98e86bacfbd2" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_branch2.lean", + "mode": "100644", + "gitBlob": "f8a5061654ee226d903079eda97be37743edef20", + "rawBytes": 12946, + "rawSHA256": "4b73dcf6934dcf8f918c1960bc13445e315c18ed09e65f856d9ed2bf8cb59b2b" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_branch2_out.txt", + "mode": "100644", + "gitBlob": "9d0d1fc9931dd78984e8d67bc627fdeac1b606f7", + "rawBytes": 22614, + "rawSHA256": "7637f1bd959813ca9217e5fe660ee603d345f59eacaba72dd30626b7be0a44ef" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_branch_out.txt", + "mode": "100644", + "gitBlob": "12e06a862cd7caa3ebc8e49488d1ff13ab44a503", + "rawBytes": 12335, + "rawSHA256": "7eeae522aeb9e55a47dc9c6615463d20dfce7188d1fda9d974d6686fb70b3204" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_cross.lean", + "mode": "100644", + "gitBlob": "1552e98131b1c0d3a06c81fdaf54d32a21bd52b3", + "rawBytes": 4673, + "rawSHA256": "24afe12dfe1cdf881c3f53a803308d76621a9cb2ecdaf1363eaaba616dee9590" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_cross2.lean", + "mode": "100644", + "gitBlob": "811409c44a1b63f3457748256a67e16db9059c68", + "rawBytes": 3947, + "rawSHA256": "16d75cb57208cb4381e732ea228f668968d43b2360b71a4f78cb7b3f00e9a2f3" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_cross7.lean", + "mode": "100644", + "gitBlob": "afdeb218825eb427e72f0df2f5a0a293ed00d89d", + "rawBytes": 2010, + "rawSHA256": "62b14cb14b45942744032e54218d29552ee755c07ce1fed57dcd6231bbb12139" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_cross_small.lean", + "mode": "100644", + "gitBlob": "56d69c962521cec866a30f2b68ed882c4fce58dd", + "rawBytes": 2238, + "rawSHA256": "52db3d4660d9b1b389a887cd3295bb35ca5c43b9290ee9b025e5735f4c93641b" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_div.lean", + "mode": "100644", + "gitBlob": "3c785e707e976d6d3ce332b0b468f2fceef02075", + "rawBytes": 12292, + "rawSHA256": "9a87571c206083c495961798e4d3616af3b4241c34eda5b63951c0020322cda9" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_div_out.txt", + "mode": "100644", + "gitBlob": "f3bcb53b5c2857526566ba8a49590e33fa920971", + "rawBytes": 23143, + "rawSHA256": "344ff32991d9ecb2a1553454488a2a2e66f176ac8306a8e730340733a6cc8ca2" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_path.lean", + "mode": "100644", + "gitBlob": "bd227cbd4aacfb635eee3a57e4c45b558b83c918", + "rawBytes": 3202, + "rawSHA256": "eeb04f999a9affd8e89337cb070b277d5a330b14b3b56a9325d73d1dea353e82" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_path_out.txt", + "mode": "100644", + "gitBlob": "c455a263894c2bb5ff68a81a2aff32d44759e5e3", + "rawBytes": 11821, + "rawSHA256": "adefec0eccb0564b977e26680f4bb13b6d8f0d2f42f0511927aceef1fe20e947" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_rankfields.lean", + "mode": "100644", + "gitBlob": "ea62f45de157913b4e5abeb59c3642895bb7d67a", + "rawBytes": 2885, + "rawSHA256": "f2cb4de4a8be830308ecea8af21791b4e0210e4f14453ba8144a3d152d2c260b" + }, + { + "path": "docs/internal/f03_evidence/dp_f03_size.lean", + "mode": "100644", + "gitBlob": "8feca10a722aae6c6dd168714202beaeb5ef165d", + "rawBytes": 8706, + "rawSHA256": "667322712b50a6f5728e9552bc24a029b47c79fb18e1b3700aa1be7a31d54870" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_A.lean", + "mode": "100644", + "gitBlob": "7b8eeef3b13060b3a8e9fecd1704287b924048ae", + "rawBytes": 4423, + "rawSHA256": "be1a9179be11f57ac33e709d1fd0c514370ace66252c7778e385a41e2c79b735" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_A_out.txt", + "mode": "100644", + "gitBlob": "5175afdc0e54f2ee4c3b62f3aa39dfbba9460a94", + "rawBytes": 627, + "rawSHA256": "066aff6cb1cc35105e83c4eec97d6cf7f09da39be565db3e55e83f683b309c46" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_B.lean", + "mode": "100644", + "gitBlob": "c21fa704517e1d098f9b6c51f8d7d660ccd576e6", + "rawBytes": 3763, + "rawSHA256": "10d971deee48dabaffa54924e3df70a66b572224312d08c90be6960e6840c2f5" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_B_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_C.lean", + "mode": "100644", + "gitBlob": "e448fbd2f4da3c9238f736909030d5722ed75501", + "rawBytes": 4009, + "rawSHA256": "9b9ac6d036cc9e9ffaef2cd8512bdc5574786435263a464fb462e47a1cc7c70c" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_C_out.txt", + "mode": "100644", + "gitBlob": "8a531b130c650c9aa117412c8371c83abe06cf06", + "rawBytes": 5379, + "rawSHA256": "babb25927d442db2609995ad73afa4bcee0f7a78967ee2649299516bba04ba24" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_D.lean", + "mode": "100644", + "gitBlob": "f82da2852577b4ab389edc53ca5fb795e15c8cfb", + "rawBytes": 4440, + "rawSHA256": "34a73593037e0dd184f45b4b0fb65041aeeb476407b186fc60365fd13afffd79" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_D_out.txt", + "mode": "100644", + "gitBlob": "44f84f6f85b0d82fbd1b9ae9954f28f85bddb9a1", + "rawBytes": 5186, + "rawSHA256": "688ee8a5a5f5cef088c77a63f0112fcdff5f4f9510356d59c78056b0e78e44e8" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_E.lean", + "mode": "100644", + "gitBlob": "d83d4414bb176462f528c3241e1a11e037871e19", + "rawBytes": 3864, + "rawSHA256": "b1f43dc1dd3c8ecfd57c23c9094351e81de065c509a2fee45a707e0bb913a29c" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_E_out.txt", + "mode": "100644", + "gitBlob": "77a43175d4be4d32e746aa2c161d0868d35518c0", + "rawBytes": 3338, + "rawSHA256": "e80519dcd3ee1457f32623f220f7726339270f714ebbe917bcd2ef9b09e5babe" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_F.lean", + "mode": "100644", + "gitBlob": "2979430ea3033b5bfd0b4f49f11df5d6394282f4", + "rawBytes": 3381, + "rawSHA256": "1315d7ff8cacd60d494c734a87888d4d71552b4fdea27e1a78e21e66d13ead1a" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_F_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_G.lean", + "mode": "100644", + "gitBlob": "d91d0c2099dad6f253c786be9d2a4b0f89b070bb", + "rawBytes": 4108, + "rawSHA256": "4c6e970429f82fbc05201d8f118dc5f85f19a559d8bfb06cbc3b0b9fca0abd52" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_G_out.txt", + "mode": "100644", + "gitBlob": "c0d5b944d21325f0d059eb90f4b21dffbdbf47dd", + "rawBytes": 85, + "rawSHA256": "c3f33a8fd37784904ea1d7584b8f911520a3c7522fd7d34be134a513eabcae7f" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_smoke.lean", + "mode": "100644", + "gitBlob": "de38926d0df08a6b633adc6d2751908cbc8e9420", + "rawBytes": 1424, + "rawSHA256": "084fe3008e9c7c954201c9ba4ede36f4ef2a882f37abb98fbd052652f8bea985" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_sweep.lean", + "mode": "100644", + "gitBlob": "42239a927db37d998c97c50f274462e24f33078a", + "rawBytes": 7022, + "rawSHA256": "2d24d94aef9b456fd894a00dcb71edf3fcaee34ad41b59447384c1002061c445" + }, + { + "path": "docs/internal/f03_evidence/dpref_f2_sweep_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/f03_evidence/dpx_a3_out.txt", + "mode": "100644", + "gitBlob": "a2e34e9e65f9afe3bb9789afe4e23a303f3fd5e6", + "rawBytes": 255, + "rawSHA256": "7be6a7ede7c0882317216d26eb0264f301c2837304532f2882707f937ad48110" + }, + { + "path": "docs/internal/f03_evidence/dpx_a4_out.txt", + "mode": "100644", + "gitBlob": "781126d79d4c919e8a0463cb1e425a8ff80e0515", + "rawBytes": 176, + "rawSHA256": "a756db83b4865ecc2e0ceae93d90c1be205f5c579a8e6cd1f7fefbae269ed583" + }, + { + "path": "docs/internal/f03_evidence/dpx_f2_attack1.lean", + "mode": "100644", + "gitBlob": "80b6b8bf9afd7a921c20ff5eb079f2cc0b805110", + "rawBytes": 4731, + "rawSHA256": "b608353baaa3dd577b33a6e81816b121883e2e78cfd3565a73757d5a9a1402ce" + }, + { + "path": "docs/internal/f03_evidence/dpx_f2_attack2.lean", + "mode": "100644", + "gitBlob": "973a4dad3922541f2ad624169b55442da78fe0ed", + "rawBytes": 5940, + "rawSHA256": "e218a0e43cc0d5acfa7385fde6a0407e99bc1ea92adef35e472b33c5c867d15f" + }, + { + "path": "docs/internal/f03_evidence/dpx_f2_attack3.lean", + "mode": "100644", + "gitBlob": "9d8e741d66840318b4eb006588a15896c46d8f85", + "rawBytes": 3717, + "rawSHA256": "7819dfb47cc9b60e1b1c1572a4fe2837e07560449c5aa63eea9668c1dd382e85" + }, + { + "path": "docs/internal/f03_evidence/dpx_f2_attack4.lean", + "mode": "100644", + "gitBlob": "5469b47074ee4a9cfc94c325e592fb9ff98b6da2", + "rawBytes": 3301, + "rawSHA256": "f5909f163270669e0143bd4115d50077ac86b0fdd85bfc2547472e6e261ed776" + }, + { + "path": "docs/internal/f03_evidence/f03_F1_addr.lean", + "mode": "100644", + "gitBlob": "fe95008406fd8c717300af406f4991540049b27d", + "rawBytes": 1623, + "rawSHA256": "b2bbee3870cffd11a8b806395325150366990f5daeddd1f689bfd3c288e2695d" + }, + { + "path": "docs/internal/f03_evidence/f03_F1_exp.lean", + "mode": "100644", + "gitBlob": "c858176729826a7f86e27808ab2ee6c77106085d", + "rawBytes": 4963, + "rawSHA256": "467411cdcaa0ab0aa18648ae000cbaff9e60b5825a847d4ebdf677e7a2a031f9" + }, + { + "path": "docs/internal/f03_evidence/f03_F1_exp2.lean", + "mode": "100644", + "gitBlob": "e02cc128d8dafe4e80300a7a25d1acbe72235361", + "rawBytes": 3670, + "rawSHA256": "9a76ea26952635c6fd9f6e3058b90e309ae62c7a8b3753ba572e45c71395e04d" + }, + { + "path": "docs/internal/f03_evidence/f03_F1_exp3.lean", + "mode": "100644", + "gitBlob": "5ac47b2615857dd898aa715091c953afc50ee6e4", + "rawBytes": 4156, + "rawSHA256": "4ac29311d71d30dae497bd8430e787363547aab99d3c494b5365e9296e74393b" + }, + { + "path": "docs/internal/f03_evidence/f03_F1_out.txt", + "mode": "100644", + "gitBlob": "665c0b498e86eedcd33480a0c933a8ffa2d5fe37", + "rawBytes": 763, + "rawSHA256": "24fdcd4d940624fd07717f69bf1295a4e1d9a25eb91be3923ce7f1eeb98cbb97" + }, + { + "path": "docs/internal/f03_evidence/f03_F1_rankleaf.lean", + "mode": "100644", + "gitBlob": "042dd31f38cc540b1eef33834f40792424cc4738", + "rawBytes": 3547, + "rawSHA256": "4ed355ef4760220681bc962ace60dfd5b8afc80c6cd5bb2521961de408bfd2d2" + }, + { + "path": "docs/internal/f03_evidence/f03_F1_thm.lean", + "mode": "100644", + "gitBlob": "09b68dc798d6966c22163270676f26746a6728de", + "rawBytes": 4159, + "rawSHA256": "6c71cad4f9970e64e5008690f1abd9f7364fcd6ab24472a6fc043c7a7298486c" + }, + { + "path": "docs/internal/f03_evidence/f03_F1_tiny.lean", + "mode": "100644", + "gitBlob": "099fede6238d5a6577c03b71fd0f5cca51f3f62c", + "rawBytes": 1123, + "rawSHA256": "06a0a4770b7109f7572b28302f71745c6bf960b7f829fad9a5588372e31c3716" + }, + { + "path": "docs/internal/f03_evidence/f03_active_regime.lean", + "mode": "100644", + "gitBlob": "4b3dd02584af7008b31f3115dba6010a75f862e8", + "rawBytes": 3999, + "rawSHA256": "6b6fe026376a699c71c5ce09dd6cc4cb82dbbcf1c45d82c388782f2c984cdf8f" + }, + { + "path": "docs/internal/f03_evidence/f03_channels.lean", + "mode": "100644", + "gitBlob": "e5adebe754a27016f8771b5d4912848b3a4de59c", + "rawBytes": 4500, + "rawSHA256": "2af4f79114ac6bcf303f780f10b9d989cbfed69a5518f4518081ed0a65fb59ef" + }, + { + "path": "docs/internal/f03_evidence/f03_channels_out.txt", + "mode": "100644", + "gitBlob": "6c36a456dc19315e32eeeb2f790097a55578154e", + "rawBytes": 1275, + "rawSHA256": "84f8270b146980ff5449407e83bdff3912c8132072c3c9901262dea156f17e2f" + }, + { + "path": "docs/internal/f03_evidence/f03_crossshape.lean", + "mode": "100644", + "gitBlob": "eb75f88b15e2d50e5265f62a55de00283fe87370", + "rawBytes": 2553, + "rawSHA256": "fb252ed629102963eece560b3c0c3a34b6a6d28e2b1c0b5c9fd6da2cfab95327" + }, + { + "path": "docs/internal/f03_evidence/f03_crossshape2.lean", + "mode": "100644", + "gitBlob": "33f1bef50891549ddddf7ee22585b60d1b1ec6ca", + "rawBytes": 4420, + "rawSHA256": "4d7a42dcaf2b6a5ccda439da1cf73876decb2defba5d03617a58bb73a3c93418" + }, + { + "path": "docs/internal/f03_evidence/f03_f2_antivac.lean", + "mode": "100644", + "gitBlob": "7de89bebbed5180d65aa0179d6dbdcd1693d459d", + "rawBytes": 4155, + "rawSHA256": "2120bac991a75c52d4389bf8b9d4a95ddbc0484fdd98ceec76e000780d3cd5e8" + }, + { + "path": "docs/internal/f03_evidence/f03_f2_axioms.lean", + "mode": "100644", + "gitBlob": "97e131b0f97049da6305ec78a385342f53984f8d", + "rawBytes": 7325, + "rawSHA256": "3bf69a5e58da9869673963af233dc889c546aa8e8a3b93084407f9e9f9348f4b" + }, + { + "path": "docs/internal/f03_evidence/f03_f2_parents.lean", + "mode": "100644", + "gitBlob": "db8f52eebbab986e1ccb8d0649e388251f981da8", + "rawBytes": 1861, + "rawSHA256": "61eb1ee480148299cd6f8d294a6a78703d22ea881ae41a5efd536204faf2248b" + }, + { + "path": "docs/internal/f03_evidence/f03_f2_path.lean", + "mode": "100644", + "gitBlob": "03ea09fc507dd6fcb57a87a0af67bf4aac7edc77", + "rawBytes": 2164, + "rawSHA256": "8ff5b98bf88bc682594ec92e15a1d46272af9584b98ee9694a890ac218b94cbf" + }, + { + "path": "docs/internal/f03_evidence/f03_f2_rankgeom.lean", + "mode": "100644", + "gitBlob": "65d4b6b88ba6be0a9b45317406183396ef93ba56", + "rawBytes": 6932, + "rawSHA256": "9ce9c2f0910c51bd24e6098884eb39f21a1de6e57c9a87b2fc13fef4a0ef0424" + }, + { + "path": "docs/internal/f03_evidence/f03_f2_segments.lean", + "mode": "100644", + "gitBlob": "0449a72bc695623267bee384af310856f09cfb1d", + "rawBytes": 2920, + "rawSHA256": "156ca2dbd8a0f05d7b532377771ed4d03d4b85395abfb4b9a978ac929208e408" + }, + { + "path": "docs/internal/f03_evidence/f03_f34_binders.lean", + "mode": "100644", + "gitBlob": "9489b1fb7aa4790215fc38c09547d6b525026c8d", + "rawBytes": 1901, + "rawSHA256": "edbefc26c92467a5e4d45f5574ef5d091e450b793cb7e11e522a5eb8d303016b" + }, + { + "path": "docs/internal/f03_evidence/f03_f34_ir.lean", + "mode": "100644", + "gitBlob": "4a0274ad4bee6f5dadaff710691bc90dc7d46b17", + "rawBytes": 1444, + "rawSHA256": "8790411cc51cba2b7dc3bf1ac6955e43089eef3dc00f54990fbf1d2ea1d2a12e" + }, + { + "path": "docs/internal/f03_evidence/f03_f34_overhead.lean", + "mode": "100644", + "gitBlob": "4c6e7fa6bb74dbb2a90d2f9d74f207ec6c941c10", + "rawBytes": 4523, + "rawSHA256": "812190dd2e343e1261df21ca1c2fa7450ea72fee8564504c67ceec0b4165f97a" + }, + { + "path": "docs/internal/f03_evidence/f03_f34_reach.lean", + "mode": "100644", + "gitBlob": "5d4bd56cce3c0bca06eb008becf0b5ce30ccd3bb", + "rawBytes": 3642, + "rawSHA256": "e086ecc745815754f5e109c41a167d191177f390ec3563eda67e00b9c5bf6b99" + }, + { + "path": "docs/internal/f03_evidence/f03_interior_geom.lean", + "mode": "100644", + "gitBlob": "bbbc40c93d2ee4efbcca8fca1f57b62907e6ab32", + "rawBytes": 4487, + "rawSHA256": "0783d8ee32aea6522f7175efad08419a471268038b451fd9f20400ed67bcc374" + }, + { + "path": "docs/internal/f03_evidence/f03_inventory.lean", + "mode": "100644", + "gitBlob": "783a3928c07ee4f069196d863f0db3ac0e69875a", + "rawBytes": 5418, + "rawSHA256": "9deeaf33d994fd1dc74a5db8d4a1c0613abc5175e3d0456eb258cf3b9753652e" + }, + { + "path": "docs/internal/f03_evidence/f03_inventory2.lean", + "mode": "100644", + "gitBlob": "ec44b986b684c2ba1e72111140b0175d3e4e0403", + "rawBytes": 7292, + "rawSHA256": "089622dcba16ffba40600ec79f8f20db988e51b34d17776dc0b9f2453bbc6800" + }, + { + "path": "docs/internal/f03_evidence/f03_inventory2_out.txt", + "mode": "100644", + "gitBlob": "f6c6dcbeac2767ddb228b31047834ad285fd0744", + "rawBytes": 4884, + "rawSHA256": "b7853677d2d0bc40420bede0ed3255a15a21b3fd5059e5aa4f2dfd37942ed950" + }, + { + "path": "docs/internal/f03_evidence/f03_inventory_out.txt", + "mode": "100644", + "gitBlob": "a6fae513c50cf3f369c91ad0a2aa04d18b16c878", + "rawBytes": 13069, + "rawSHA256": "24940c9d7d405d7605dc4bc8aba41384fd21da63c6b12a4b6065613177bc3ad4" + }, + { + "path": "docs/internal/f03_evidence/f03_lca_leaf.lean", + "mode": "100644", + "gitBlob": "a42e2d4e526580a24b76205f770d606b292beb4c", + "rawBytes": 3393, + "rawSHA256": "7a5607fce727acfbf5fcc862519ef2a9ad9a580b9718e46d6d1ddb925d2612f2" + }, + { + "path": "docs/internal/f03_evidence/f03_lca_min.lean", + "mode": "100644", + "gitBlob": "47a15334946e6e35551c57ecf9bf4cdde1e82093", + "rawBytes": 2651, + "rawSHA256": "fd261abdbeb58bdc55b579343087b818fb3de1a21c5e0c5aa57ccca317e62445" + }, + { + "path": "docs/internal/f03_evidence/f03_lca_min_128.lean", + "mode": "100644", + "gitBlob": "47a15334946e6e35551c57ecf9bf4cdde1e82093", + "rawBytes": 2651, + "rawSHA256": "fd261abdbeb58bdc55b579343087b818fb3de1a21c5e0c5aa57ccca317e62445" + }, + { + "path": "docs/internal/f03_evidence/f03_lca_min_256.lean", + "mode": "100644", + "gitBlob": "6eedfcbeacfa503d07c1e803b844dafea6051647", + "rawBytes": 2651, + "rawSHA256": "d6fa4d50f083c572fe32c50ec8bcc6c201b59a2706bf05bf1ae34f2eb39ea878" + }, + { + "path": "docs/internal/f03_evidence/f03_lca_small.lean", + "mode": "100644", + "gitBlob": "27b5b63e006b34ebfc7aa25013245d66b34316c6", + "rawBytes": 3385, + "rawSHA256": "7cf60bc044344bd1fda6497fb4ab81e5e0550650c7bbe5312fc161175e798c14" + }, + { + "path": "docs/internal/f03_evidence/f03_longflag.lean", + "mode": "100644", + "gitBlob": "36e5677773418bdffaccf5346afb686107c38a1c", + "rawBytes": 4431, + "rawSHA256": "3c72f2c3c8e6279d99eee4593edc0d5c34540c607ca37d9f91460b0d8d76e9cc" + }, + { + "path": "docs/internal/f03_evidence/f03_probe.lean", + "mode": "100644", + "gitBlob": "5e08bbe10c33e807533a3f86506a8c9a0ee2e03d", + "rawBytes": 454, + "rawSHA256": "07bb8cfdd6c17d901735c9c00f484eb2a5142dcc547e58893f2ebc46dd7fc8ec" + }, + { + "path": "docs/internal/f03_evidence/f03_regimes.lean", + "mode": "100644", + "gitBlob": "38b85bba93964ff7280ff90cabfe99d2f85d426b", + "rawBytes": 3928, + "rawSHA256": "eabf83b15b44f8632b96c0de7a4c75fb1a8277e812f255243bb3d9c23cfefe50" + }, + { + "path": "docs/internal/f03_evidence/f03_sel_n128.lean", + "mode": "100644", + "gitBlob": "30fca7bbbf98422021821312656c1fa1564bfa8a", + "rawBytes": 5138, + "rawSHA256": "9a5a5be37c438b10c400333efff52e97fa604dc451a762b7f23db441d08c81fd" + }, + { + "path": "docs/internal/f03_evidence/f03_sel_n256.lean", + "mode": "100644", + "gitBlob": "7ae7cdf9d3446020818d51ead1ac499f216ead6b", + "rawBytes": 5138, + "rawSHA256": "6f6e8ecf80ea3541a5d9b3b6eee5c229b509085c8279dd4c391f9b54597ab8a2" + }, + { + "path": "docs/internal/f03_evidence/f03_sel_n512.lean", + "mode": "100644", + "gitBlob": "cf4e16759c4e9211d6a7465e959ea4b8038308f5", + "rawBytes": 5138, + "rawSHA256": "346de79677aa63e6ae5c66cf3e0f37e7d839a360c13eefb14b03f007d930c23a" + }, + { + "path": "docs/internal/f03_evidence/f03_sel_n64.lean", + "mode": "100644", + "gitBlob": "5371b6a8a539d651914b941bd98b81d16616e8b2", + "rawBytes": 5137, + "rawSHA256": "9ce2aa8b1430a1fdab315e44253f1971f9e0bfd4b253e9aac6409316b97433d7" + }, + { + "path": "docs/internal/f03_evidence/f03_select_leaf.lean", + "mode": "100644", + "gitBlob": "332e818a483c3c4c647117e64040103086cc563f", + "rawBytes": 5145, + "rawSHA256": "ab974a1ed7c7433b5291b30a2a1ccc34455daba3d98cb24564a0b2c7ce735fd2" + }, + { + "path": "docs/internal/f03_evidence/f03_select_leaf_n8.lean", + "mode": "100644", + "gitBlob": "1926fe2339d94da67c9ab5fd603c5105ed3f2029", + "rawBytes": 5136, + "rawSHA256": "527d203149a86c13cd1012b3504355426b7252fd2443f61d90173cc89d124f37" + }, + { + "path": "docs/internal/f03_evidence/f03_superlong.lean", + "mode": "100644", + "gitBlob": "33078301253b2114dde1d46402ab02524deb2081", + "rawBytes": 6095, + "rawSHA256": "84c5d3614bf005fd5e39d2624c7674ee0a071e02131eb9bf534a50054bef22a2" + }, + { + "path": "docs/internal/f03_evidence/f03_theorem_probe.lean", + "mode": "100644", + "gitBlob": "a40b95b2d71715c239aa559c5cddff51d6b85c31", + "rawBytes": 5483, + "rawSHA256": "e6854514164fa743f37529760f52eec7cbb7974d27fe9086b6918fe1d910a3a7" + }, + { + "path": "docs/internal/f03_evidence/f5_big.lean", + "mode": "100644", + "gitBlob": "0497bc80351badd31e79b2f6323482e682a21dc0", + "rawBytes": 4394, + "rawSHA256": "6a70c05d49a97cdaee6ad98d1b07e5cdf12bca535fb06c92096746e0a5a569e8" + }, + { + "path": "docs/internal/f03_evidence/f5_big_out.txt", + "mode": "100644", + "gitBlob": "ba01b9dc8b276e8a93f411cdf80689b4ac7f7d3c", + "rawBytes": 2208, + "rawSHA256": "540c082aae24f5cffe326d1fc913ca69e9a3808d9b3ed91ec30bb629d9b275c7" + }, + { + "path": "docs/internal/f03_evidence/f5_callers.lean", + "mode": "100644", + "gitBlob": "5e33d2175ebe11156f7c079953a982e8b2c4aa59", + "rawBytes": 4289, + "rawSHA256": "9b76a8eb662bac79d6e16c30290077fd9b96c6be6556ef947dd8ac7b5407b1dd" + }, + { + "path": "docs/internal/f03_evidence/f5_callers_out.txt", + "mode": "100644", + "gitBlob": "4d7345fb66a280a6e6154addb9bea4c920dd0a19", + "rawBytes": 17460, + "rawSHA256": "4c8b8e4938ffd567a9c59f214a3c1ff31abe3adcabd785ab5e9feb2f8847f85b" + }, + { + "path": "docs/internal/f03_evidence/f5_exec.lean", + "mode": "100644", + "gitBlob": "bfa31907bd1d9b921ba6b420afe08fbfa97ba70a", + "rawBytes": 4210, + "rawSHA256": "317675d693b55a28bba97e18a28851e81365398c7ef592f12810f8a77cbeb4cf" + }, + { + "path": "docs/internal/f03_evidence/f5_exec2.lean", + "mode": "100644", + "gitBlob": "7d08b1d97db34699fd49f5c1994e88b8fc9918cc", + "rawBytes": 3429, + "rawSHA256": "07c92d730e1ab45fc5cb89786abf0e845439d0bd20e4797bcf05d2b75d4bee87" + }, + { + "path": "docs/internal/f03_evidence/f5_exec2_out.txt", + "mode": "100644", + "gitBlob": "20194e78b5b81f9f3beb7dc54f3f1b06831405b6", + "rawBytes": 1892, + "rawSHA256": "d1425ffe7c3b699fc5ec709b7792f8539cb9928a5cf3d854f4104cfc9ab4da17" + }, + { + "path": "docs/internal/f03_evidence/f5_ir.lean", + "mode": "100644", + "gitBlob": "30c1a460fb58e66fc44ba3ae698fc2d197394e5b", + "rawBytes": 3485, + "rawSHA256": "f02c499eba77bdf2c8b49133914322c681107649ae2bb9237d5686b8d2d30a0d" + }, + { + "path": "docs/internal/f03_evidence/f5_ir_out.txt", + "mode": "100644", + "gitBlob": "e15b7435d9a722d70c90e3daecf4d34567f49520", + "rawBytes": 1383, + "rawSHA256": "47de9e5862fc60913939b78694b963a1320e64bd7ed7df93db654e091b514db8" + }, + { + "path": "docs/internal/f03_evidence/f5_irdump.lean", + "mode": "100644", + "gitBlob": "6785d35fe058b51a25dc01aebdf49b81d3f99235", + "rawBytes": 1469, + "rawSHA256": "fc930f6f46c87b6377264645f455ce2e17da0c6224bcebdbbcb48d8c9c909a90" + }, + { + "path": "docs/internal/f03_evidence/f5_irdump2_out.txt", + "mode": "100644", + "gitBlob": "163e2ed966a04181124298bb1e910739de6d7a0f", + "rawBytes": 11490, + "rawSHA256": "05522143b255326c82f74b73cdfccedf00a80bef8d206e14d7fba02d050ebbb7" + }, + { + "path": "docs/internal/f03_evidence/f5_irdump_out.txt", + "mode": "100644", + "gitBlob": "67787ae9fa3412120eababd75db80416ca05d43a", + "rawBytes": 9393, + "rawSHA256": "7978db838c50ad9ddcc6a33042aee99ff2691b293464bfe267d4940c31d3771a" + }, + { + "path": "docs/internal/f03_evidence/f5_irpath.lean", + "mode": "100644", + "gitBlob": "73a3d1ef6bd977f1ace93e94f601b83cf793dbbe", + "rawBytes": 3530, + "rawSHA256": "3a90c0a59480c275fc19ac6b909aa67b5c7c2029919470568fe6fdf4373d78f0" + }, + { + "path": "docs/internal/f03_evidence/f5_irpath2_out.txt", + "mode": "100644", + "gitBlob": "93106df0732ca5c5cb52baac5c7d8a04bdb7ed4f", + "rawBytes": 15806, + "rawSHA256": "102626723d15c2a38b802e3fed38a28aede36bc08f731c717b673b3f3d5e2032" + }, + { + "path": "docs/internal/f03_evidence/f5_irpath_out.txt", + "mode": "100644", + "gitBlob": "74b1754797e56dbc388b92584826028967ee9272", + "rawBytes": 6022, + "rawSHA256": "b9f8e9875eba9ee3a4fb4618e453279b008565f01b0b2865eb3b3b7e574a2b2c" + }, + { + "path": "docs/internal/f03_evidence/f5_lemma.lean", + "mode": "100644", + "gitBlob": "80124f4651a810c6d5e4312cd2fcb70dd8b59952", + "rawBytes": 5008, + "rawSHA256": "5f0f2abd47eb14e69e4a7534738e02bd5bff169214848fb02e4720885e360072" + }, + { + "path": "docs/internal/f03_evidence/f5_probe_api.lean", + "mode": "100644", + "gitBlob": "ec80405988a4491d58a13a7de7a6fde25754593f", + "rawBytes": 482, + "rawSHA256": "d6e0e6dca6591be76afea526017b65d0ea0ee0d04955fd034abb5ced09ad9168" + }, + { + "path": "docs/internal/f03_evidence/f5_probe_api2.lean", + "mode": "100644", + "gitBlob": "d909f7ed95447f006f33f3421e1c7d7e04bd6875", + "rawBytes": 173, + "rawSHA256": "b1557d922083c2f7b5bd6a9471ed5528504f01a2d8aaaf39cd1f872b9bbf8cce" + }, + { + "path": "docs/internal/f03_evidence/f5_probe_api3.lean", + "mode": "100644", + "gitBlob": "ed55b160447844d334d004606a69920a62458b78", + "rawBytes": 86, + "rawSHA256": "abe18c884db8b73a7039f9e3488fa185da43d0532a8580c7e4c63a594e7ce979" + }, + { + "path": "docs/internal/f03_evidence/f5_subgraph.lean", + "mode": "100644", + "gitBlob": "d4290a61be01c8a96485eb686adfcffde6546334", + "rawBytes": 3226, + "rawSHA256": "b942b1a2116605858f9f138cbd8018e0f3002e96a5aa7ed1bc45efb6436813f2" + }, + { + "path": "docs/internal/f03_evidence/f5_subgraph_out.txt", + "mode": "100644", + "gitBlob": "1f73429cec2046ddf711e228354e4f4b2a411c41", + "rawBytes": 13185, + "rawSHA256": "1c4b62dee61ae6735c71284137b55071cd4bf69aad337f7beb4a4ec51ca86645" + }, + { + "path": "docs/internal/f03_evidence/f6_bits.lean", + "mode": "100644", + "gitBlob": "c2d68ed0efb2fd549428d231b0cce9fd10d9ee67", + "rawBytes": 5230, + "rawSHA256": "813f4e832e343a0bcb08b566d769ceb1281696398762b24a69ebc763e1ddee3a" + }, + { + "path": "docs/internal/f03_evidence/f6_bits_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/f03_evidence/f6_leafL1.lean", + "mode": "100644", + "gitBlob": "8671df42044ffbacb365c86963b4c275bcf6090e", + "rawBytes": 7097, + "rawSHA256": "330b31b3bc95da93d03bf511d8b1427d711a37430af4a8ffec6375a97f012d11" + }, + { + "path": "docs/internal/f03_evidence/f6_leafL1_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/f03_evidence/f6_proj.lean", + "mode": "100644", + "gitBlob": "3717dfca5e83ebe3b229fb4d95d1912a76a33dd1", + "rawBytes": 3205, + "rawSHA256": "290c1663501829eec6d5da38ca8ded67d1f4ed0921c54848c0450275dd302d59" + }, + { + "path": "docs/internal/f03_evidence/f6_regimes.lean", + "mode": "100644", + "gitBlob": "fdd6dd93b2843b05f57142abf2ff7bdba222b365", + "rawBytes": 4873, + "rawSHA256": "13085cf745918220641a4d26ebcb3e7c94aa32bf1a31b7720e5b8b4fb80451c5" + }, + { + "path": "docs/internal/f03_evidence/f6_rfl.lean", + "mode": "100644", + "gitBlob": "c22f5c8a8bc9f7db571b239ec7c47a44cca12fe8", + "rawBytes": 2185, + "rawSHA256": "a1343e4871b1206bf49c538961244a4e2ea3c75b5d230d133355e44ff23fcf18" + }, + { + "path": "docs/internal/f03_evidence/f6_rfl2.lean", + "mode": "100644", + "gitBlob": "70184be4f0f248776c39e53053e2e44a352abc57", + "rawBytes": 1247, + "rawSHA256": "c69f62dd8f0dc5854d425deea8b12f6ccfd89dd35e68717fa8f536e04e3b380f" + }, + { + "path": "docs/internal/f03_evidence/f6_rfl_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/f03_evidence/hdr_f34_ax.lean", + "mode": "100644", + "gitBlob": "9bf2309ed6e32cefb04b0613d0bfeebb44a6dbf5", + "rawBytes": 3873, + "rawSHA256": "41aa69e1adc1ea1fce304190f054c9815819709355a807f0c1263a8a8c7a494e" + }, + { + "path": "docs/internal/f03_evidence/hdr_f34_thm.lean", + "mode": "100644", + "gitBlob": "c4c9f4d2716d0b5852fe19a2b1141e07c5a67005", + "rawBytes": 3683, + "rawSHA256": "dedc76adb09cfee0e59333e8b6dda34fc7fc043ebc0c0e7ade69d0585527be56" + }, + { + "path": "docs/internal/f03_evidence/hdr_offsets.lean", + "mode": "100644", + "gitBlob": "772b563dbf86cd2a7b039673b63fcd371f386cb7", + "rawBytes": 1319, + "rawSHA256": "d524c6fd0c6b65a033222f34e2ca9b95ea36e05e30a9cb9d66817bf7f386d655" + }, + { + "path": "docs/internal/f03_evidence/hdr_scalars.lean", + "mode": "100644", + "gitBlob": "e59d99ee50c2e11b8c17d0136d69683b67d97cca", + "rawBytes": 3252, + "rawSHA256": "4ef456ffd923b83c1116df75f43649d3896ffa4ed86de4bfd95bd4a9579ee229" + }, + { + "path": "docs/internal/f03_evidence/hdr_scalars_out.txt", + "mode": "100644", + "gitBlob": "5f3eb5a09adb65cdda6c7e4376c786340b3f3f6d", + "rawBytes": 2951, + "rawSHA256": "4890ee0ae3938d0295286d82b17f4b89fa1db0aef16c70623f1121560a30b8cb" + }, + { + "path": "docs/internal/f03_evidence/hdr_schema.lean", + "mode": "100644", + "gitBlob": "805b61fd500ea4901c226dc14bcadc5438ef95d8", + "rawBytes": 4421, + "rawSHA256": "d54aafcd32a0f0a08cc613567c084b035359427dad9cbe21c7b5cfd42adb45fd" + }, + { + "path": "docs/internal/f03_evidence/hdr_schema_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/f03_evidence/hdr_seglen.lean", + "mode": "100644", + "gitBlob": "dae0b5dfe5ac59951e432167fe86c2464e69ac5e", + "rawBytes": 3727, + "rawSHA256": "0de7625f56d03d997d8fdb4d91edf3fd19d0680c062e23f835c88b89e44152bb" + }, + { + "path": "docs/internal/f03_evidence/hdr_seglen2.lean", + "mode": "100644", + "gitBlob": "1fd2b2e52ffcd96a7150bc68314d978d6135e140", + "rawBytes": 3425, + "rawSHA256": "252c1a8dbecb1355ec5cebdf292f9a0478de57ec7f6e188fe2e58b96df81d2e8" + }, + { + "path": "docs/internal/f03_evidence/hdr_seglen3.lean", + "mode": "100644", + "gitBlob": "c58539bb5b291777c377fde1a237c1a41792f105", + "rawBytes": 3452, + "rawSHA256": "896d31245ca12ce438efe3df409dcbe1354728e553fbf2ee593437a4120a7591" + }, + { + "path": "docs/internal/f03_evidence/l2x_l2_crossblock.lean", + "mode": "100644", + "gitBlob": "b4413cf9afdd28aa1100ba33af9098eb880495e9", + "rawBytes": 37772, + "rawSHA256": "2f6794c883c636d715f92c9541bdb1aa88c87aae116bd29c11af7b92561724f0" + }, + { + "path": "docs/internal/f03_evidence/l2x_t4_capstone.lean", + "mode": "100644", + "gitBlob": "9853ce2593e9b5229606ca8c20e22bd493375b89", + "rawBytes": 63283, + "rawSHA256": "cb046722a7492dc69c1ec4acf8d43a93e440255c46d1d0c9248da9f3241ede84" + }, + { + "path": "docs/internal/f03_evidence/qz_int2.lean", + "mode": "100644", + "gitBlob": "8d5d27cd93e1c6f3fe3eeb7b5368c1f1c50bd558", + "rawBytes": 3269, + "rawSHA256": "58d0b95673c711fdc4aa8aebc8b85378121f9678f9aa357438455d304f501e44" + }, + { + "path": "docs/internal/f03_evidence/qz_int2_out.txt", + "mode": "100644", + "gitBlob": "7fd17bb50da1cdaf9d8486481d4341a5c4cc77cc", + "rawBytes": 1419, + "rawSHA256": "a5325f98d2eb5c0b166dd1fc5bfbd568c1990f2f921da4cb59e1e9a60c84d7b1" + }, + { + "path": "docs/internal/f03_evidence/qz_interior.lean", + "mode": "100644", + "gitBlob": "357bf73daa9de5f1c568cfd0b386725277b6db82", + "rawBytes": 5953, + "rawSHA256": "1f11d08f9e6df252b475ee65f45336aa105f9bfa982804714fd5120bfadd2a63" + }, + { + "path": "docs/internal/f03_evidence/qz_interior_out.txt", + "mode": "100644", + "gitBlob": "31196019932a80cf35393f245e25bd901646c846", + "rawBytes": 318, + "rawSHA256": "a357dcff5d8d24a42d99df7f953d386e7162ffa77f4d33686a9e22f6a6be00f0" + }, + { + "path": "docs/internal/f03_evidence/qz_mech.lean", + "mode": "100644", + "gitBlob": "0893b968ac272932af2970ed4104776f6a479523", + "rawBytes": 8325, + "rawSHA256": "a1513d0b146bfdfe5a4f67106c98b74d840fda151449511886e0adf51396455c" + }, + { + "path": "docs/internal/f03_evidence/qz_offsets.lean", + "mode": "100644", + "gitBlob": "f4c2930ce4e7b877ab28bac9136ad4c30b9d1a3e", + "rawBytes": 6013, + "rawSHA256": "da4a9d7d17d32820530259acf60087c94c4c1fb54657de80a4ed8183dfd96397" + }, + { + "path": "docs/internal/f03_evidence/qz_popcount.lean", + "mode": "100644", + "gitBlob": "cd3be9c108bebb6003adca644cc8c206273e983e", + "rawBytes": 2249, + "rawSHA256": "fec09d8422664441c1762e181384fb41224171b8a7e7d24dd409f91f09cc4f2e" + }, + { + "path": "docs/internal/f03_evidence/t1_c06_verify2.lean", + "mode": "100644", + "gitBlob": "84304e4d585f2549eb6e1712054f8a246bdad6d0", + "rawBytes": 14160, + "rawSHA256": "ff5c6486b74a4633d61ad8120f1df04aca0d6bae33764d4807a9ebc98b2f8446" + }, + { + "path": "docs/internal/f03_evidence/t1_readprogram_core.lean", + "mode": "100644", + "gitBlob": "7e5e1851eb13c9a1854fc037d57bfeaabd69cea2", + "rawBytes": 2572, + "rawSHA256": "72dd83def761f62f0cd6fdb8bc27887d4bb79a3a22278db87dc6584076887f53" + }, + { + "path": "docs/internal/f03_evidence/t1map_layer2.lean", + "mode": "100644", + "gitBlob": "5f873a222883ccd63aad70cad11fca8e4224cf52", + "rawBytes": 11131, + "rawSHA256": "a0dd737a57ce39218b2df4bcd3de87125ecb6da9095b41efd9b1b82fdfc1e3f9" + }, + { + "path": "docs/internal/f03_evidence/t1map_obligations.lean", + "mode": "100644", + "gitBlob": "8056c5290f89d73830111c9aca683cb150c8c6f5", + "rawBytes": 7826, + "rawSHA256": "7fc0cb5c4e37ad602555505b60e7f1545d49d112d182434845f82d553a970518" + }, + { + "path": "docs/internal/f03_evidence/t1map_route.lean", + "mode": "100644", + "gitBlob": "09bd3e69dbdc6c7254f3c0c5f04ce11d372b6572", + "rawBytes": 4141, + "rawSHA256": "9ea9c2ad2d43a9edf775a8b5b3fa5aaa0a22aae15b7d611dde7abf56ca67b0f9" + }, + { + "path": "docs/internal/f03_evidence/t2_l2_selector_sameblock.lean", + "mode": "100644", + "gitBlob": "d08c8d26c33644d10eb3f1c7f8d5e162934b4459", + "rawBytes": 24660, + "rawSHA256": "05d87090abe7b05a3327384f4a53bc7a22cb2d66b0ce3b4bcf5e5db029f59160" + }, + { + "path": "docs/internal/f03_evidence/t4pub_audit.lean", + "mode": "100644", + "gitBlob": "e5793847f92b1f2789aecab22523516c9e7ed090", + "rawBytes": 83344, + "rawSHA256": "e6b61fd59cd36369f05a884e1e9280979b15132d4184a5d1fe0dd23bef2503ce" + }, + { + "path": "docs/internal/f03_evidence/t4pub_public_entry.lean", + "mode": "100644", + "gitBlob": "a37e36481d35e44e985b319b5ed5ae0228ad4019", + "rawBytes": 77302, + "rawSHA256": "64b9a67209449f6ca0921fc74713ac12a776943058e3ce9c6619308c49f59c90" + }, + { + "path": "docs/internal/f03_evidence/w2_l2_l3_interior.lean", + "mode": "100644", + "gitBlob": "56545e891420ab77683e01cf43ec9d7deb18cc46", + "rawBytes": 47927, + "rawSHA256": "631d9d5fe11a515de500c4bf0fcd4bea09fc16809f8eeeaa7b7767966004ab9d" + }, + { + "path": "docs/internal/f03_evidence/wq_branches.lean", + "mode": "100644", + "gitBlob": "a462d271c3a74b24a266199079f7fe6a179364f8", + "rawBytes": 4531, + "rawSHA256": "9832f911566e06191fce1f7381760928312c51193f69cc621442b17c99171120" + }, + { + "path": "docs/internal/f03_evidence/wq_branches_out.txt", + "mode": "100644", + "gitBlob": "d123b254e7edef8fccbc4bfeb037e656e724a223", + "rawBytes": 2795, + "rawSHA256": "224646a2e624f7448486cbb14caee72eccfa755dd6cf56f4ff88140d3f7bc5b6" + }, + { + "path": "docs/internal/f03_evidence/wq_checked.lean", + "mode": "100644", + "gitBlob": "f8f1567aab48bd05beac97dfc7c87338222b47f5", + "rawBytes": 4720, + "rawSHA256": "67ae1e9655f3b5f550e8d7208c11d3618bffb8a038c5c85d0e4f283fa5d07681" + }, + { + "path": "docs/internal/f03_evidence/wq_checked2.lean", + "mode": "100644", + "gitBlob": "71188940371a4f662b56312130b33d6c66ea6ce3", + "rawBytes": 5591, + "rawSHA256": "f095b01b77eb28dbf70e3252bcbbc48fad1688ae083e7b69aff96c2cc8a6d183" + }, + { + "path": "docs/internal/f03_evidence/wq_checked2_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/f03_evidence/wq_checked3.lean", + "mode": "100644", + "gitBlob": "d39bb0a960ab2a53c6c8f3cf18772e6997d2687f", + "rawBytes": 2602, + "rawSHA256": "17b5a551bac25c43e866c73a332f8e74c148fcc4a3fcac7e49fc2324b387df2a" + }, + { + "path": "docs/internal/f03_evidence/wq_collapse.lean", + "mode": "100644", + "gitBlob": "3cff617de194f3726122079ed60b791cbb178141", + "rawBytes": 5844, + "rawSHA256": "a4d5586fe84e4703714feab6b7d524753d352ccefae26ecf39a5f60406ca1c14" + }, + { + "path": "docs/internal/f03_evidence/wq_collapse_log.txt", + "mode": "100644", + "gitBlob": "0fb4f17846405abae42e640476cd0743ce51d3dc", + "rawBytes": 1443, + "rawSHA256": "5d9543c8c0490e79e5d7e4d614ef5a9e09b95e6d598592db3300a7c1f6efa086" + }, + { + "path": "docs/internal/f03_evidence/wq_collapse_out.txt", + "mode": "100644", + "gitBlob": "0fb4f17846405abae42e640476cd0743ce51d3dc", + "rawBytes": 1443, + "rawSHA256": "5d9543c8c0490e79e5d7e4d614ef5a9e09b95e6d598592db3300a7c1f6efa086" + }, + { + "path": "docs/internal/f03_evidence/wq_extrap.lean", + "mode": "100644", + "gitBlob": "4e1a8f81f7cf0bb1ebeeccdcd311cdeeddbb03df", + "rawBytes": 2469, + "rawSHA256": "f427a2b28415ed299a5b86f855655141beacc75b67f1335ec14a1de587167c08" + }, + { + "path": "docs/internal/f03_evidence/wq_extrap_log.txt", + "mode": "100644", + "gitBlob": "0cd66bc2dc647588151825dde6a3e98e362d5497", + "rawBytes": 1240, + "rawSHA256": "7ee572d596211234d260452ac67695e72cfa585a65904fc7d587d3295456572b" + }, + { + "path": "docs/internal/f03_evidence/wq_extrap_out.txt", + "mode": "100644", + "gitBlob": "0cd66bc2dc647588151825dde6a3e98e362d5497", + "rawBytes": 1240, + "rawSHA256": "7ee572d596211234d260452ac67695e72cfa585a65904fc7d587d3295456572b" + }, + { + "path": "docs/internal/f03_evidence/wq_longfront.lean", + "mode": "100644", + "gitBlob": "715737df3df482e603c320b08133b20a6ba83967", + "rawBytes": 7122, + "rawSHA256": "f244273c60f92a2d826b6a42738f619556bf8cb7746a4476a79641aee4405c17" + }, + { + "path": "docs/internal/f03_evidence/wq_longfront_log.txt", + "mode": "100644", + "gitBlob": "42eb5b8133f13fe8e06b4ec2e3f0dffea71cd3ac", + "rawBytes": 8462, + "rawSHA256": "dec58c8c7f66109663de0cad2e339f1b704b3e7f47304586fffc59f06b9e1b83" + }, + { + "path": "docs/internal/f03_evidence/wq_longfront_out.txt", + "mode": "100644", + "gitBlob": "42eb5b8133f13fe8e06b4ec2e3f0dffea71cd3ac", + "rawBytes": 8462, + "rawSHA256": "dec58c8c7f66109663de0cad2e339f1b704b3e7f47304586fffc59f06b9e1b83" + }, + { + "path": "docs/internal/f03_evidence/wq_mismatch.lean", + "mode": "100644", + "gitBlob": "0aa0c089b80c62f6929969aef66097321f1f57e6", + "rawBytes": 5680, + "rawSHA256": "00838213f9eab6dc51bd98ca6f8a15199565d019f21b1289eca1155119422291" + }, + { + "path": "docs/internal/f03_evidence/wq_mismatch_log.txt", + "mode": "100644", + "gitBlob": "b2e43246214b29336f78c7df3165c65dd62b340f", + "rawBytes": 424, + "rawSHA256": "b750b6858c0ca552647fef31e6f89932c6e908b999ba6176c310e744dee55e5c" + }, + { + "path": "docs/internal/f03_evidence/wq_mismatch_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/f03_evidence/wq_regimemember.lean", + "mode": "100644", + "gitBlob": "4535f5df9f0448a8b907c788fc33571a6b3b28dc", + "rawBytes": 5280, + "rawSHA256": "059333fe2d9eef1d906991abdf5cc3f0565573308faa5d1a586e70bf1afddff6" + }, + { + "path": "docs/internal/f03_evidence/wq_regimemember_out.txt", + "mode": "100644", + "gitBlob": "f6a1b783eb4c357ed1d9841448ad7bc9c7367a7d", + "rawBytes": 2177, + "rawSHA256": "2bee1fea839f1f50ff218641a286a90c247ae5bee6811117a63f0bc9d1148f56" + }, + { + "path": "docs/internal/f03_evidence/wq_sens.lean", + "mode": "100644", + "gitBlob": "6e4143d4fa343f9a4856b75c8176a3402ec68b92", + "rawBytes": 2935, + "rawSHA256": "f4f0273f22676c6799dcce30616adef75229e465205ce63f8cc318c31fa327fc" + }, + { + "path": "docs/internal/f03_evidence/wq_smoke.lean", + "mode": "100644", + "gitBlob": "3265600418e221b59cbe5e3fed563595a88ff605", + "rawBytes": 1459, + "rawSHA256": "6acff6a4dffc7e05c95f2c4b143f13a0d31ece267d0d8f127be53437e1d70d0a" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_a.lean", + "mode": "100644", + "gitBlob": "156af0058260edf382e8735c4a211bf11f574713", + "rawBytes": 7123, + "rawSHA256": "1ece28bc27659f94e89d659919498f465a659e071957f2bab9a7e5fc35d629c5" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_a2.lean", + "mode": "100644", + "gitBlob": "ff5e0c5cb303041e136b0726da99035cb5297772", + "rawBytes": 6581, + "rawSHA256": "f93a8f51c794c447966bb867d64ab4714158f417c4e46cb0125737db0570e3e2" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_a2_log.txt", + "mode": "100644", + "gitBlob": "8c0b068c596cedb7691bdc2115012ed738ae10ed", + "rawBytes": 1568, + "rawSHA256": "d286701517febeef11a1793146098c1988a74f44156c5009f8fb66301b44371f" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_a2_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_a_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_b.lean", + "mode": "100644", + "gitBlob": "db4df154bac5195905e33d61e136cf539439cb99", + "rawBytes": 4505, + "rawSHA256": "b854af791e6a3502e9ef0ac6cc7a586f515de4347a5dd85f422a406acba5a625" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_b_log.txt", + "mode": "100644", + "gitBlob": "ac95899c085c5f1e74e81dd09518e37c3aec55c0", + "rawBytes": 110, + "rawSHA256": "4f0b9afde1dd8ef28a97106418d093891b2dd456600185ad07a26b75efee53df" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_b_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_big.lean", + "mode": "100644", + "gitBlob": "799596eadc4bdf80176777ea1764ecd880c073f3", + "rawBytes": 4517, + "rawSHA256": "38f8cb62bc35111cf3edb9ad36ea09429d605d3e42968635bfa85bc0d942ed14" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_big_log.txt", + "mode": "100644", + "gitBlob": "67b38de33dbc11f0df0daaab99983e9ddbd2f2f5", + "rawBytes": 47, + "rawSHA256": "cd431bd6eab1afc189996103eb8618bc63bd0011cf10d73b2c9a14662f03a120" + }, + { + "path": "docs/internal/f03_evidence/wq_sweep_big_out.txt", + "mode": "100644", + "gitBlob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "rawBytes": 0, + "rawSHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "docs/internal/f03_evidence/wq_thresh.lean", + "mode": "100644", + "gitBlob": "31711fe4452df471ffa21014e32d0375f2537de1", + "rawBytes": 5393, + "rawSHA256": "52e0095b21b5d4e0f4335ad1c720ccfcbf2cbe717033454709e3a79504b98d80" + }, + { + "path": "docs/internal/f03_evidence/wq_thresh2.lean", + "mode": "100644", + "gitBlob": "09a6aadeb60a8640dd77ba206e4e7a7071a0881e", + "rawBytes": 2336, + "rawSHA256": "29b0b34760fea04b957596c2d2dfbb9944067511507751e984274ef599f44095" + }, + { + "path": "docs/internal/f03_evidence/wq_time.lean", + "mode": "100644", + "gitBlob": "3adea40fea9430f513db739c554841fc24249fb1", + "rawBytes": 961, + "rawSHA256": "ca5ddebadd082318a6a5c3d5e56fc7da45d1d363f19a428861ddda2dd5ced30c" + }, + { + "path": "docs/internal/f03_evidence/zz_blind_diff.lean", + "mode": "100644", + "gitBlob": "b5d90987a13c90a2b2f45656c1d5cba911b8efe0", + "rawBytes": 2277, + "rawSHA256": "c10520ea13913cb583840a6c1c814429366fcb6b0c9b79f7f23c6814bc203659" + }, + { + "path": "docs/internal/f03_evidence/zz_blind_elim.lean", + "mode": "100644", + "gitBlob": "dfbccf01062c03244099186fb73d5d98d984017d", + "rawBytes": 7111, + "rawSHA256": "560c5b8adf710c4bf453867d1a4229378d15a531b499de87e5e80d7703639d96" + }, + { + "path": "docs/internal/f03_evidence/zz_blind_elim_out.txt", + "mode": "100644", + "gitBlob": "ae5b87cfb1999fa8175ff9f354065c3a099f0709", + "rawBytes": 22198, + "rawSHA256": "17f3ea3fb57fbabee3676304bd0c5f58e4409d0fb6853cdcd36758fe2231c0c5" + }, + { + "path": "docs/internal/f03_evidence/zz_blind_invisible.lean", + "mode": "100644", + "gitBlob": "c342506905e21c51315fbf28b95ea84c8995edff", + "rawBytes": 4339, + "rawSHA256": "0e519a145fbbe318a05080cfdd2f116ca0110adaaf4c08e36480e63475644d6f" + }, + { + "path": "docs/internal/f03_evidence/zz_blind_invisible_out.txt", + "mode": "100644", + "gitBlob": "2558921679801824c8e3d60e97f415ce3836d2fc", + "rawBytes": 5666, + "rawSHA256": "2aba2832a7378eb42ffa1105e8e78e44ef43e0ce2adbffbdd7c1461a6003e86a" + }, + { + "path": "docs/internal/f03_evidence/zz_blind_modes.lean", + "mode": "100644", + "gitBlob": "abddb928b720d2fc1f02dd54a4253c36a27df7f9", + "rawBytes": 6662, + "rawSHA256": "e69c1a28202794b6e6c28d217a9585dd91d903551f50d81b8785a1b1ccd4c921" + }, + { + "path": "docs/internal/f03_evidence/zz_blind_modes_out.txt", + "mode": "100644", + "gitBlob": "1f9aa1ce5c41ad176f1c1aef8f01225021c13b51", + "rawBytes": 1132, + "rawSHA256": "45e751da968f7a4a92eb124311ef3770a46616e6325d14eeea556b6c178aad13" + }, + { + "path": "docs/internal/f03_evidence/zz_blind_rev.lean", + "mode": "100644", + "gitBlob": "66fd0ed69c81b5a92a42c4d7659a13c75b6fd7a8", + "rawBytes": 6624, + "rawSHA256": "1326b9233cd7b439d78ee8a7d9d44cbb662f16d58985e2908c62733e2e62c6a9" + }, + { + "path": "docs/internal/f03_evidence/zz_blind_rev_out.txt", + "mode": "100644", + "gitBlob": "bf8ecb27cc308791dad4088e1860c2de7c9a682b", + "rawBytes": 6744, + "rawSHA256": "1d7f93e5fa1c03b5fb8ef2d3de92a1da8dac2fac2e846ce720dbb6364e97a063" + }, + { + "path": "docs/internal/packed_query/PQ1_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "d49e00a7c4838ba66d9ac9685abef7ec25598d04", + "rawBytes": 47712, + "rawSHA256": "e9045cbbe821ecc10187fd06bffa024e69bca9dc76c93578f271a33d47d55c48" + }, + { + "path": "docs/internal/packed_query/PQ1_CALCULUS_MATRIX.md", + "mode": "100644", + "gitBlob": "7499ee1923d5447d61a5d562816be1dc4f834d15", + "rawBytes": 10206, + "rawSHA256": "28270074afd2964440c24b5a70c36656949d561a61201c212e319e40df304a40" + }, + { + "path": "docs/internal/packed_query/PQ1_CALCULUS_PROMPT.md", + "mode": "100644", + "gitBlob": "d65f1754227c5ceb2e4c9bc3a30ecef9765d0b9e", + "rawBytes": 6946, + "rawSHA256": "3660477f7b9ca7b25bad6c50626b9915cbed798ed81c0a9c532aefe8d46912bb" + }, + { + "path": "docs/internal/packed_query/PQ1_CALCULUS_REPORT.md", + "mode": "100644", + "gitBlob": "7f213c2e8a8df16b13d354fb5396f67071f19cd2", + "rawBytes": 16173, + "rawSHA256": "2e6311896fd3de13a687a3b43d4853642ac04a2179d8eb5d05f99daf8057d943" + }, + { + "path": "docs/internal/packed_query/PQ1_COMPILER_MATRIX.md", + "mode": "100644", + "gitBlob": "ca6341967dde11922e43b89673e58acbbf65e0a8", + "rawBytes": 12970, + "rawSHA256": "0db706ae9c0bd18e51c1bd83e2fab6425d696cd81ec9a11e60a696fa66c210c8" + }, + { + "path": "docs/internal/packed_query/PQ1_COMPILER_PROMPT.md", + "mode": "100644", + "gitBlob": "9ff8cda9170d7e94bd7c070c69193548fd57b56f", + "rawBytes": 7174, + "rawSHA256": "7333c26e9d2e6979b63f3b63085cd910d705dc239d82046fde9f6ef3a6ef443c" + }, + { + "path": "docs/internal/packed_query/PQ1_COMPILER_REPORT.md", + "mode": "100644", + "gitBlob": "9ce167073696a052118107c3bfa3b58ff4281127", + "rawBytes": 18792, + "rawSHA256": "9c325166b6645726f9c76325580da55aefc2274766fa5f5e2d3c25966d517b7f" + }, + { + "path": "docs/internal/packed_query/PQ1_CONTINUATION_AUDIT_20260911.md", + "mode": "100644", + "gitBlob": "7dfa53241b60d4517e93ab49d42bac0f2a75c5d1", + "rawBytes": 18939, + "rawSHA256": "4cbb80dfff4bdf33fc857004dfdd94ecd1d62814fe1268f6bd0a08509b808d5e" + }, + { + "path": "docs/internal/packed_query/PQ1_COORDINATOR_ACCEPTANCE.md", + "mode": "100644", + "gitBlob": "9bb5d43e7bb67d8a447ebe683f31860f380c87c7", + "rawBytes": 14134, + "rawSHA256": "c1fd55b51457e89f8f46f8ea13424f3d2b26c8cd95fe45362a22cfa368c9390d" + }, + { + "path": "docs/internal/packed_query/PQ1_FRINGE_SAFETY_MATRIX.md", + "mode": "100644", + "gitBlob": "c1a481c9026907c9488d274d66742be8ea3237d0", + "rawBytes": 13359, + "rawSHA256": "08e5f53f226840d68ba243efb013a65acf0dd9fc5b22c5150a3fd78f070b9006" + }, + { + "path": "docs/internal/packed_query/PQ1_FRINGE_SAFETY_PROMPT.md", + "mode": "100644", + "gitBlob": "5e1836b2b16f3d3da0c4dd8dc48eac44c1f033ac", + "rawBytes": 7434, + "rawSHA256": "8f5482648c701350ae2d38b5c8c38fbfdd054be4ed7ccca2f3ee0e789af8b3a9" + }, + { + "path": "docs/internal/packed_query/PQ1_FRINGE_SAFETY_REPORT.md", + "mode": "100644", + "gitBlob": "ebb751059b9f144ea22f34ebc71b6935cf525159", + "rawBytes": 26960, + "rawSHA256": "add862cc9a746e4dd4fcdc9d6cbe9bacefef598bc9d15f485ab648083a3a9656" + }, + { + "path": "docs/internal/packed_query/PQ1_INTERIOR_CANDIDATE_MATRIX.md", + "mode": "100644", + "gitBlob": "bf5833efa949b8b2fbe9e19bce18647709d16147", + "rawBytes": 21548, + "rawSHA256": "c04900132448055926f4ac21efe96a6f68a0d7ac5c6437eb9cfcaf4290c38a05" + }, + { + "path": "docs/internal/packed_query/PQ1_INTERIOR_CANDIDATE_PROMPT.md", + "mode": "100644", + "gitBlob": "7a32b274722ba7ae1d64bf26c16c5ec3b9269cbb", + "rawBytes": 9322, + "rawSHA256": "58762a10341fe9251721d3ef49349c854f37340d868c7b34fb5a729f947924b7" + }, + { + "path": "docs/internal/packed_query/PQ1_INTERIOR_CANDIDATE_REPORT.md", + "mode": "100644", + "gitBlob": "0dfdebbd3d8fa2612fcb86cad6dc722336c0e931", + "rawBytes": 17883, + "rawSHA256": "a93310a7dd3ab42154a47620a91e130f50c21ce0029e18d1512dbf2dbada4ad5" + }, + { + "path": "docs/internal/packed_query/PQ1_INTERIOR_SAFETY_MATRIX.md", + "mode": "100644", + "gitBlob": "55985de18b41d8f3faa1dfc2fe26d5eb1a5c3e03", + "rawBytes": 14258, + "rawSHA256": "ff1d6698a3825e270b29478bb85e0e355d36330a07f5f25ab004f0cd1287831a" + }, + { + "path": "docs/internal/packed_query/PQ1_INTERIOR_SAFETY_PROMPT.md", + "mode": "100644", + "gitBlob": "20ab5873f389eda7f17ba2f07e609222edafe4b4", + "rawBytes": 7417, + "rawSHA256": "9852763d4d2dd75d50f8e245e78314ff1da4ec3252eb53d00beed80cbb456e28" + }, + { + "path": "docs/internal/packed_query/PQ1_LOAD_SAFETY_MATRIX.md", + "mode": "100644", + "gitBlob": "f7d1db209f9d6881becb829282d07f8e5c267662", + "rawBytes": 14193, + "rawSHA256": "5d065a6ecd97eb4f5314c3bcd6ee71a4fe560a4979383f50c1c9ac0f25d5062c" + }, + { + "path": "docs/internal/packed_query/PQ1_LOAD_SAFETY_PROMPT.md", + "mode": "100644", + "gitBlob": "64ebc2996a01f3d364f78ff9bcb41244d8860e68", + "rawBytes": 6822, + "rawSHA256": "651e99c38d12f1ce0e4ae4168bd939368b5584b7459926bdc9433b5f88962a40" + }, + { + "path": "docs/internal/packed_query/PQ1_LOAD_SAFETY_REPORT.md", + "mode": "100644", + "gitBlob": "0b40cc7ee506c574414b57a0c29a2771822ccd73", + "rawBytes": 18443, + "rawSHA256": "eec357153e0c787b52dffbabfac4b7d790415a75d6611a17ab309b9816a52b49" + }, + { + "path": "docs/internal/packed_query/PQ1_LOCATE_MATRIX.md", + "mode": "100644", + "gitBlob": "d5f92c16a43a73216f953f4c52e879e021702bf2", + "rawBytes": 12658, + "rawSHA256": "241979f668395e7d970f21bdc2f6204617dd9a7471a733e1d7bdae0229ae38cc" + }, + { + "path": "docs/internal/packed_query/PQ1_LOCATE_PROMPT.md", + "mode": "100644", + "gitBlob": "21af554a383e9a860da359ee7e81252852089ca2", + "rawBytes": 7430, + "rawSHA256": "8ff76786c878d9c98d32a9ec0f4b53a1747f264372c74a0c8db0bae67dae9395" + }, + { + "path": "docs/internal/packed_query/PQ1_LOCATE_REPORT.md", + "mode": "100644", + "gitBlob": "650c00512242e125e3909d46f47302830d598d12", + "rawBytes": 13885, + "rawSHA256": "f8b8926f322d2bd0d4a8a2b749026631fb386431a328dfa3934b8e33163680f5" + }, + { + "path": "docs/internal/packed_query/PQ1_LOGICAL_SPAN_MATRIX.md", + "mode": "100644", + "gitBlob": "11f2c86fd20d6601b98a11499e6865caf6c1f642", + "rawBytes": 16343, + "rawSHA256": "8afc390e2e932a5c759fa9909f9ce1905d14a9492736949f1dd4df069704f3c7" + }, + { + "path": "docs/internal/packed_query/PQ1_LOGICAL_SPAN_PROMPT.md", + "mode": "100644", + "gitBlob": "e736aea7770042f4912bc95eba769f013dc7266b", + "rawBytes": 7443, + "rawSHA256": "d6df64ee82819b246918c0e9515fcc2a59b417ff2b7973cc72d7d8e5459843fe" + }, + { + "path": "docs/internal/packed_query/PQ1_LOGICAL_SPAN_REPORT.md", + "mode": "100644", + "gitBlob": "f7301043413cd355d2ba4161eb51151ef20e463e", + "rawBytes": 12880, + "rawSHA256": "68215d91fb55c69eaefc0bfe2307ce71cf21e23b3fab00088ce558e1cbf7890b" + }, + { + "path": "docs/internal/packed_query/PQ1_MODEL_AND_PROOF_DAG.md", + "mode": "100644", + "gitBlob": "c2529c547e9f3d40f36131b18b61c769ba1afe2e", + "rawBytes": 8139, + "rawSHA256": "0d484a3520831346c9c71822a3c378d4b1a0a2b4e7796332b7849a9fe6c9b655" + }, + { + "path": "docs/internal/packed_query/PQ1_QUERY_SAFETY_MATRIX.md", + "mode": "100644", + "gitBlob": "4be2096b3246af25351767af95abad5b41bc2569", + "rawBytes": 11702, + "rawSHA256": "de0310ef3d2e918f6bf3405bc033a5f54af478b34e50b043a1e738791b0a65e0" + }, + { + "path": "docs/internal/packed_query/PQ1_QUERY_SAFETY_PROMPT.md", + "mode": "100644", + "gitBlob": "b7f8ee3b36b0f5737922579d2155e8df0d739e2c", + "rawBytes": 8511, + "rawSHA256": "e6367a8e0f9f5771af38a0dda2bb730dab5eef9bf57f04c30671b6c165f0bb31" + }, + { + "path": "docs/internal/packed_query/PQ1_RANK_PROOF_MATRIX.md", + "mode": "100644", + "gitBlob": "cd5b24afe9f035664f45075fea158ca1a822843d", + "rawBytes": 17006, + "rawSHA256": "be669eea3534f49557eb7e884e1d12bab15df204f6834ef18fe8de30d47031d7" + }, + { + "path": "docs/internal/packed_query/PQ1_RANK_PROOF_PROMPT.md", + "mode": "100644", + "gitBlob": "8d50811ba44e49e37d8d51eba8a55567c032e816", + "rawBytes": 8311, + "rawSHA256": "6f2a2f67fc6c9a484df5454aa4829c695d9a57759ea3c3c091970cc5ea23d4ca" + }, + { + "path": "docs/internal/packed_query/PQ1_RANK_PROOF_REPORT.md", + "mode": "100644", + "gitBlob": "59c6a465c4c3c8879bc83123f04403e6d15766f5", + "rawBytes": 11905, + "rawSHA256": "8ca7fa347a9408023ddb50d0812f933bf53088001aa3c8bb16e69cf70c6d3f8b" + }, + { + "path": "docs/internal/packed_query/PQ1_RANK_SAFETY_MATRIX.md", + "mode": "100644", + "gitBlob": "865adf10e226b5a8e89d212d42ce8d92b301cf23", + "rawBytes": 13659, + "rawSHA256": "3717c1552a1e815912d359c1dbb0e2e82db129d56866f9b9a581d2bf1ab68fe5" + }, + { + "path": "docs/internal/packed_query/PQ1_RANK_SAFETY_PROMPT.md", + "mode": "100644", + "gitBlob": "019f4b2f5466a9d23b2e8efcb9cf35db076c610b", + "rawBytes": 6694, + "rawSHA256": "4d3260a3a206d665e4ec9a26dfeed2d20035f07e8758d31f2b2365b9f1dfbd77" + }, + { + "path": "docs/internal/packed_query/PQ1_RANK_SAFETY_REPORT.md", + "mode": "100644", + "gitBlob": "162d6b05ca77522b4ef3f33e3f0de6794bdc3471", + "rawBytes": 34791, + "rawSHA256": "d8a04b76f040366ba52dc18982872fb2d0076c54af0d7ca0451f418319a9a20a" + }, + { + "path": "docs/internal/packed_query/PQ1_READER_SAFETY_MATRIX.md", + "mode": "100644", + "gitBlob": "13d6f93a3bdfc1001bfafea03d78976e4475fe07", + "rawBytes": 14991, + "rawSHA256": "ef7ebd2edf9de2ac7e19ed24d6e125862eaea3fd9d73b336fdb4ef64099adcc4" + }, + { + "path": "docs/internal/packed_query/PQ1_READER_SAFETY_PROMPT.md", + "mode": "100644", + "gitBlob": "8c92eac6024cc6b1b069a6e52eec263f20d478ba", + "rawBytes": 8348, + "rawSHA256": "e05457e0485a08cc233cff160f2bf35c0ac9ece7f75fd32a2ada811613f6a16e" + }, + { + "path": "docs/internal/packed_query/PQ1_READER_SAFETY_REPORT.md", + "mode": "100644", + "gitBlob": "6fb4f29022244e8d8618d71e6e939e358b18725b", + "rawBytes": 16403, + "rawSHA256": "5da7013165d2e8fa768e4e8b720a7911f48b85eeebd37fcaed4b0281dcfb511a" + }, + { + "path": "docs/internal/packed_query/PQ1_SAFETY_MATRIX.md", + "mode": "100644", + "gitBlob": "5e9020c691c78b8e1874124c1596ebe96b3132f4", + "rawBytes": 13788, + "rawSHA256": "2f3e9aafb9ba4bb768a1f2d5922867a9574861b4eeb3c60d9b6dfec0d6c5d2a9" + }, + { + "path": "docs/internal/packed_query/PQ1_SAFETY_PROMPT.md", + "mode": "100644", + "gitBlob": "a7f7c4428f9b29f044a9f9b925cb2f77b8d14ecb", + "rawBytes": 6776, + "rawSHA256": "0a811dae7269a0dc850f1ca504ea1e5dc982fcac7d565806270a60967b6a853b" + }, + { + "path": "docs/internal/packed_query/PQ1_SAFETY_REPORT.md", + "mode": "100644", + "gitBlob": "f1a77d387d1d1d8c6153de08c8844f3e5f31f745", + "rawBytes": 19959, + "rawSHA256": "e48166421af238635e31e86445eea5ce7a07b4a7c153f5c4d18f6dd7d2e91ae4" + }, + { + "path": "docs/internal/packed_query/PQ1_SCOUT_CONTROL_PROMPT.md", + "mode": "100644", + "gitBlob": "117e3b4deea78463604ab5d87172e7f8d5f26665", + "rawBytes": 4752, + "rawSHA256": "da6366bd7a35e4ac956cda221cb5954b796d144d3b2fb1a9a5f3c60141cd702d" + }, + { + "path": "docs/internal/packed_query/PQ1_SCOUT_MEMORY_PROMPT.md", + "mode": "100644", + "gitBlob": "af706c9efd3c056cde15d388882f8c8863f9d47b", + "rawBytes": 4471, + "rawSHA256": "86c2690ebd7c6e54971a2a80175034b708e6fa6453ee1cab3e2b61fa279dd555" + }, + { + "path": "docs/internal/packed_query/PQ1_SELECT_PROOF_MATRIX.md", + "mode": "100644", + "gitBlob": "b319481fa6e815287d758cea2c68e69c53d420f9", + "rawBytes": 20822, + "rawSHA256": "384094c13da955a6d9fe7776a57e9c09a98dd0263a2127543f26c0fac398073f" + }, + { + "path": "docs/internal/packed_query/PQ1_SELECT_PROOF_PROMPT.md", + "mode": "100644", + "gitBlob": "d363a1eb11a9c2a6cc48cb92f7e48af1e2da38de", + "rawBytes": 8311, + "rawSHA256": "a6f262915c579e5da632200138ad5239373b395bd82e4f91165479d6afd1b6ef" + }, + { + "path": "docs/internal/packed_query/PQ1_SELECT_PROOF_REPORT.md", + "mode": "100644", + "gitBlob": "d13d929fb066c7cc1fe4d4e06e44250a5b793598", + "rawBytes": 13634, + "rawSHA256": "b357bd67bf7420233c4c2fdf68a1d6a24991020ba048500660b0ab9caa0a3278" + }, + { + "path": "docs/internal/packed_query/PQ1_SELECT_SAFETY_MATRIX.md", + "mode": "100644", + "gitBlob": "c2977a1e49b80f43f7ef4080af21405d706da20a", + "rawBytes": 27631, + "rawSHA256": "1d376afeb2fbade82b58f67c15c8dd2d95e3ac840884c09d1d0fd6cea9e6ea37" + }, + { + "path": "docs/internal/packed_query/PQ1_SELECT_SAFETY_PROMPT.md", + "mode": "100644", + "gitBlob": "5fb75dfae88a292ae40da193438307090e01e0c4", + "rawBytes": 6967, + "rawSHA256": "ddb29ab58e22ae76eb966d6983504b5197f03dcdc3cfa867a51962a1f2e1fc50" + }, + { + "path": "docs/internal/packed_query/PQ1_SELECT_SAFETY_REPORT.md", + "mode": "100644", + "gitBlob": "0b28955ca38ad7a963307ed669c168b8465403fc", + "rawBytes": 10974, + "rawSHA256": "125bea3e2589cb556daaddade31f4b909d593dbb0c373e756411ba74160cc8b6" + }, + { + "path": "docs/internal/packed_query/PQ1_SETUP_MATRIX.md", + "mode": "100644", + "gitBlob": "51cc65369f443d5594f3e8d25989bd4e506595b9", + "rawBytes": 15160, + "rawSHA256": "5dabaff48f2e952ff42d31e9be0e9654fa905e8cff0ee7d1f49f88818b0faf89" + }, + { + "path": "docs/internal/packed_query/PQ1_SETUP_PROMPT.md", + "mode": "100644", + "gitBlob": "0103507552f7c5fa6f05b0aac1b354cf36321fb9", + "rawBytes": 6238, + "rawSHA256": "f9e0304b95219ae40eaf839b1c98cf9c9c1a0e9b16649b73b4e9c2754481248d" + }, + { + "path": "docs/internal/packed_query/PQ1_SETUP_REPORT.md", + "mode": "100644", + "gitBlob": "378699114923e5c02b9d2fc00be6a5e21da1901c", + "rawBytes": 8323, + "rawSHA256": "03bb82397a6d6a5917facac71bb00e051cefe1ca2298989ab758254f5b1a0df6" + }, + { + "path": "docs/internal/packed_query/PQ1_SOURCE_INVENTORY.md", + "mode": "100644", + "gitBlob": "02fe5c84bbd50e78e00ac52e2a717fe985ebeece", + "rawBytes": 7143, + "rawSHA256": "5b07395933de75678bca9f2fabe42f63949e27994aa9ff6f3973a66f35fcd6b7" + }, + { + "path": "docs/internal/packed_query/PQ1_SPAN_ASSEMBLY_MATRIX.md", + "mode": "100644", + "gitBlob": "ce6b994a0310d634745b4b0c3987531191583486", + "rawBytes": 17581, + "rawSHA256": "8de87dec805a31ab7815968a1e4ebda0af76aaa4f19ceba5551e55d8f1e3e32c" + }, + { + "path": "docs/internal/packed_query/PQ1_SPAN_ASSEMBLY_PROMPT.md", + "mode": "100644", + "gitBlob": "bf687762c4c2125a6470a5906501e29e67482bdb", + "rawBytes": 7392, + "rawSHA256": "44a8a6f58bf4cf5282ac89b80d46b28dbfd12ebc4108dfa5bc251973e01493fd" + }, + { + "path": "docs/internal/packed_query/PQ1_SPAN_ASSEMBLY_REPORT.md", + "mode": "100644", + "gitBlob": "bb463938cd6a6a8d827a0949448783c42161e546", + "rawBytes": 13371, + "rawSHA256": "fff6a3f404e506d2f7afe1c29df7fdf331a63cfdd720850e70fa29287fc864a7" + }, + { + "path": "docs/internal/packed_query/PQ1_SPAN_MATRIX.md", + "mode": "100644", + "gitBlob": "863a43610bc481325a398e1f416a162c903507ca", + "rawBytes": 15781, + "rawSHA256": "f7cc8e7fa8afb6c4a2ea067f888f318d6fc93d666744d1f28c5234eec9915d0e" + }, + { + "path": "docs/internal/packed_query/PQ1_SPAN_PROMPT.md", + "mode": "100644", + "gitBlob": "b57550c81e534c29e8c456e4c7e4b2b186201eb2", + "rawBytes": 6941, + "rawSHA256": "e77950a68bab1d572b1171dd4950ad243ddebef5b87429f9f90df2aef0171e5a" + }, + { + "path": "docs/internal/packed_query/PQ1_SPAN_REPORT.md", + "mode": "100644", + "gitBlob": "2ccddc96cebbd3380297457f5b976fa42ef82ac8", + "rawBytes": 11489, + "rawSHA256": "3b7327c6f3ece0f16909099b6d978b0ed10e0e0753b6a3bdf60c1fd7826ade13" + }, + { + "path": "docs/internal/packed_query/PQ1_VALIDATION_PLAN.md", + "mode": "100644", + "gitBlob": "b14a64c1bd8a595bdec301768fabb807f67c76c9", + "rawBytes": 21486, + "rawSHA256": "19e58d6ffe48ebefaf4a80e7a3ea9c56b53429b0839cc71b667013c01f8cb3a2" + }, + { + "path": "docs/internal/packed_query/PQ1_WIDTH_MATRIX.md", + "mode": "100644", + "gitBlob": "402dd21d065be5bd0d570038066d4fb42b5cfbb5", + "rawBytes": 12742, + "rawSHA256": "0bc62713892b85337359e33b9cd138cbd642eac5c3cca522bc8c310dc142fae6" + }, + { + "path": "docs/internal/packed_query/PQ1_WIDTH_PROMPT.md", + "mode": "100644", + "gitBlob": "6a497241f03f7e8e6b689c5e469236acdec612df", + "rawBytes": 6376, + "rawSHA256": "6174bbfa2de26e83f3584b9f20182f9a37178570a6ec35ecf1048534cf6196c8" + }, + { + "path": "docs/internal/packed_query/PQ1_WIDTH_REPORT.md", + "mode": "100644", + "gitBlob": "881e14b2a7063ad103a26bc6dbfb784bef864a63", + "rawBytes": 8189, + "rawSHA256": "6313fff421f5ab80eb27df92488445a26391c9f376693d6bf22751a54f82c111" + }, + { + "path": "docs/internal/packed_query/RC6_SOURCE_SYNTHESIS.md", + "mode": "100644", + "gitBlob": "ff522886495a8a000691fef69201a7af4ed60efb", + "rawBytes": 8121, + "rawSHA256": "ca924475da674923ef364684ffd712d3d55ace726c70caddf7140d8dd8c151cf" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/.gitattributes", + "mode": "100644", + "gitBlob": "41378e904c4e2223772820f0bd21d409c48a53e3", + "rawBytes": 229, + "rawSHA256": "1914cb5d7d14a932fa54941a9aa497f6059361e5c4011a18e1e52db94d2b4fd5" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/ASSESSMENT.md", + "mode": "100644", + "gitBlob": "57f6c8b014617cec4194848588d5a36ecbd08195", + "rawBytes": 13392, + "rawSHA256": "bf8f4bb30728365412c70563fd3bf9f3646267fa71d12286e9e9f80ee8cfd287" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/CONTRACT.md", + "mode": "100644", + "gitBlob": "09f16c2aa95093874c4083a8ed53de13341866b7", + "rawBytes": 4924, + "rawSHA256": "16dd79cf147ad1cd871d748fb6961ff72f2136a473dd15133bf5251ccbc4d105" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/CheckMachine.lean", + "mode": "100644", + "gitBlob": "1df3778afc40208e34e5763593918c7772efdc7c", + "rawBytes": 5870, + "rawSHA256": "207d314aff59552c725ab54f9e20573c62e17696c4a4ffb9c368ef682dabd6e5" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/ExportFixture.lean", + "mode": "100644", + "gitBlob": "097d348bc0a070c0553d7125e64e1008263f5203", + "rawBytes": 15764, + "rawSHA256": "feae2ccf257629a89bb0567d7f2cf8143bf3366cda0ad84b12dc239a19e013e7" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/README.md", + "mode": "100644", + "gitBlob": "e77ed169f020cc5cc33aabe28599e20ddcceae70", + "rawBytes": 1259, + "rawSHA256": "29bb54823bf6168908de2943a19069c5ff61348095ffc32f30880f79ba0e1364" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/compiler_checks.py", + "mode": "100644", + "gitBlob": "b0224c35f879abf79a3d4fe548eb8a773ba56089", + "rawBytes": 838, + "rawSHA256": "286504cfb9d199ae70b7bb3e14763ce6db05c0addf94ac35c62b86a51d2abfa6" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n15-comb-vm.json", + "mode": "100644", + "gitBlob": "b4927d1dbde70bf221d0359c44aaf57c447d7d1b", + "rawBytes": 41372, + "rawSHA256": "1f5c36ca27753655f06a91d3c0f8a4dec10e285536690a1984f30ff1f7d10bff" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n15-comb.json", + "mode": "100644", + "gitBlob": "13a1d094a587553e5ffaa5bcf782fb02a424de7b", + "rawBytes": 84059, + "rawSHA256": "a5ea4b84c31832f8f2303882e2668a016787b6b46e2362c52f08c310fabd5361" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n15-zigzag-vm.json", + "mode": "100644", + "gitBlob": "96136bac482e8e401e4edd82b01918dd59fece59", + "rawBytes": 43930, + "rawSHA256": "2ef8bd8b76f6c5a50740890e0f74293dba02f5742dcee10dc0a7f8ba1784ab2b" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n15-zigzag.json", + "mode": "100644", + "gitBlob": "72b885b6c4e8251b5fbd6f9d1ad8e85b26eedcae", + "rawBytes": 89986, + "rawSHA256": "2db0a1eec22eb2c3ed5c0a1c44117ffc4138a4474844542e500cc252ea0e2173" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n16-balanced-vm.json", + "mode": "100644", + "gitBlob": "6bc956f7b3f2199588556233e196939da09a5422", + "rawBytes": 42736, + "rawSHA256": "a215c657ba75f04db4ea95173858c233dea1d7b8d963cf61d6df1141fc84bed0" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n16-balanced.json", + "mode": "100644", + "gitBlob": "4713f39ae6c8344a622652812eac069cccdd0f8d", + "rawBytes": 88013, + "rawSHA256": "9c18600312f9c0c2abf95de57b935518257fb0a222cf4c0cb2dc088c2dc18c0a" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n29-zigzag-vm.json", + "mode": "100644", + "gitBlob": "aa8f3b502eb0437d94457cd2f93533df85840a39", + "rawBytes": 45389, + "rawSHA256": "959455f0d722993e7920ee789a059df7cddb3a67962fff3bc74907750256742a" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n29-zigzag.json", + "mode": "100644", + "gitBlob": "96c6566a0fb05e60104cc9c3a9db1652fa71112d", + "rawBytes": 94411, + "rawSHA256": "d56fb364f993f90240d32470e76ff1d4bfd97162f89c424f35621bb66f49926f" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-ascending-vm.json", + "mode": "100644", + "gitBlob": "f14a9e5a3c333700b025ef763b790ae0db2d6eef", + "rawBytes": 36788, + "rawSHA256": "826407f5b41e4b28a4a367b46805d174182fb0f4ec6b5426e3323783c3d5f5ed" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-ascending.json", + "mode": "100644", + "gitBlob": "74a101ccb72cf8d49908942381f092b5b8fb3995", + "rawBytes": 73036, + "rawSHA256": "79a3f29acde6be9432c9bd9913a80213b33695cdea33956ac52f1eacf0c54c5a" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-balanced-vm.json", + "mode": "100644", + "gitBlob": "454967f733d16a0cb0bfb79ddb98b3d409f1caf5", + "rawBytes": 38132, + "rawSHA256": "76d8c34be4eeef22409de10fc65e06e6cfecd8b22a810a2fdf245cf0c0511bce" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-balanced.json", + "mode": "100644", + "gitBlob": "280e991c92e2ec84e860010dddab4d55bd565871", + "rawBytes": 75738, + "rawSHA256": "437d9512d3452aa753791cbc1feb5f6850c0162729b932327b8d57c8d68cb697" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-descending-vm.json", + "mode": "100644", + "gitBlob": "845867277bf3864d2e3664166c78c80ec1f3c3ce", + "rawBytes": 29344, + "rawSHA256": "328dfed4a208734e0f8c3f84d858b58a54a1ddafa9cfd2028e0e12438d940dcc" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-descending.json", + "mode": "100644", + "gitBlob": "ac136cd74146687a1ff910541d466b539657cc3c", + "rawBytes": 65253, + "rawSHA256": "f9e6f7d9156ff62fc43d22983ba44128780987863c232ea8449a40404a0ddcc7" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-invalid-vm.json", + "mode": "100644", + "gitBlob": "2cc6f558e44b83ed38ec903c98a96d43482441ae", + "rawBytes": 830, + "rawSHA256": "b681cf928040b6a7615186842b2949e9cf7a1095e96422212429a875a06eefab" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-invalid.json", + "mode": "100644", + "gitBlob": "da97512696bcbb14a1ac1c1c93aa1d05f2769766", + "rawBytes": 7279, + "rawSHA256": "613b3c9fab261b1db929f0c8c3821562309143f3b5129800de91cc828a019cbd" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-ties-vm.json", + "mode": "100644", + "gitBlob": "243d3be0d57a69487740bd9de0a543a0f33c12be", + "rawBytes": 36783, + "rawSHA256": "c395d330c116b63d206652c5a88349dfcc2ab31845d45a061d0c0850a03455c4" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-n9-ties.json", + "mode": "100644", + "gitBlob": "08f5a983b2d8f7fe75b55f7fba38269f8f1523ef", + "rawBytes": 73031, + "rawSHA256": "a14e1b5353fe132eb435d2afa06dc82fd7b6468d4ad6522b6cf65fad93234af9" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/fixture-notes.md", + "mode": "100644", + "gitBlob": "07c6d573c1dda8f7b769f553c9923e85904b0264", + "rawBytes": 7091, + "rawSHA256": "c9fc8654209725e1f8ca34a6c37202a69a6c23be8b5bdf8dc719b2454a03f8cd" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/lca-interior-spec.md", + "mode": "100644", + "gitBlob": "621b43bfefe90cc473a56022d5f95ba8890ec4f6", + "rawBytes": 16013, + "rawSHA256": "edb7599808c25b8a5cf603cbf7a5145b3851495dd18f90307d30185d541b6a3f" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/lca_interior_program.py", + "mode": "100644", + "gitBlob": "25334ca80c2e1c36e177d98669f1fcb7722d7b7b", + "rawBytes": 9390, + "rawSHA256": "8030779301e802313a7e7fd5ee6e7db8bf8267c811fc1e6b07b02e634f4efa7b" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/machine.py", + "mode": "100644", + "gitBlob": "5522c467fd54f4be69abe5aaa2157a3089503a97", + "rawBytes": 15425, + "rawSHA256": "730ef56fd1e8365a41c954fba46881eb450e1bab6918c2e831c6545e860979bf" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/manifest.json", + "mode": "100644", + "gitBlob": "14faf12bf2b9720039031c1fa75332e392d8a309", + "rawBytes": 6198, + "rawSHA256": "83d296a47d365e6710b6c8cb6253bfd9a32c185a3e778f4c194b6f492d28f073" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/package.py", + "mode": "100644", + "gitBlob": "d8c7413f7bfd38725f4eaffe2ad43f4f3a95d76c", + "rawBytes": 957, + "rawSHA256": "85d37ecbd2baa282abd1f9f99baf52c1c673a3e71018b10f41fe893e9aa850c9" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/physical_program.py", + "mode": "100644", + "gitBlob": "5b8814d628e1db14abf95aeeb5a6f6da6454fae0", + "rawBytes": 1599, + "rawSHA256": "9015d68afdf3dbe03245734b554b6155502d626e9c3224791ab7a52622782d19" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/program-n15-source.py", + "mode": "100644", + "gitBlob": "ef1cca46d3c4547fe385e20b8201eb713cabda90", + "rawBytes": 24964, + "rawSHA256": "74afdfba8c4e549a3bc0a0f9c2231dd6ca5811552de0b56d5dfcef6b16d16540" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/program-n15.json", + "mode": "100644", + "gitBlob": "920c3085d0838e685672ccfc30dc4eb67f8035cf", + "rawBytes": 154507, + "rawSHA256": "77ad0f860fba8d04bb3b6a4daa595a5f05c974407087b8691e6aa04b9daf5249" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/program-n16-source.py", + "mode": "100644", + "gitBlob": "6486930abe79985096b578a41963553294709148", + "rawBytes": 24965, + "rawSHA256": "3b671eab457dc3acc4e8e1a8f94a7aed0f19cf24f5835dc8b2672aa913f5f8cf" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/program-n16.json", + "mode": "100644", + "gitBlob": "9f896d976449a8036dd49e78bef5726ea5b448df", + "rawBytes": 154520, + "rawSHA256": "afa03b191e9ff6bfc5c60bb1e343a57e9f5e9fd1db7ba2d785d7112b6e63fb32" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/program-n29-source.py", + "mode": "100644", + "gitBlob": "0fd47ac45d09b4b2503796a52c5e474dce312795", + "rawBytes": 24973, + "rawSHA256": "00c1885ba71646aeda265b28f70c781f786e41bdf8a98f5d5648a97d9b96d1f5" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/program-n29.json", + "mode": "100644", + "gitBlob": "df1eeffc0037293600fcab33d713b6ffaf56e8f9", + "rawBytes": 154529, + "rawSHA256": "a2dc5e9764b4b39911c8474ce7ff709027191b82b4a23567c0f370ab7e9b529b" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/program-n9-source.py", + "mode": "100644", + "gitBlob": "cf5dc3aaba827860b0e2f58ac6b7aadbbf4849a6", + "rawBytes": 24958, + "rawSHA256": "95b95a22f63bc06157a9e3ccae93b6148b352a04cd03591e213827b39062eb1a" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/program-n9.json", + "mode": "100644", + "gitBlob": "2b0f4bc1894092fe5ad5f9f909da09db3865017e", + "rawBytes": 154489, + "rawSHA256": "9ee640e68601b47be82417621c557c688a4bbaa0b1bc061a9e43fa2da0309ab6" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/rank-select-spec.md", + "mode": "100644", + "gitBlob": "49d1c45d9b7ba099e14729defabefd6bded8e986", + "rawBytes": 17432, + "rawSHA256": "2ea0af303b6fd3fcb8a2bf69783ec2f39d952d4a07b80572645a2a93be024c1c" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/rank_select_program.py", + "mode": "100644", + "gitBlob": "5e6c77604a1d3921bf6338375627df33c438b825", + "rawBytes": 5473, + "rawSHA256": "346cba19724cf066e79e2a45a722c465dba8a7afe97432eea0653de2970c8166" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/reproduce.ps1", + "mode": "100644", + "gitBlob": "be869496aa4854c3bb3cce54f83fda7504e3a770", + "rawBytes": 2197, + "rawSHA256": "baf93f3486f80af5d2f41ba406ddb897d65a2755748410ed019b2bdd4aac8859" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/reproduction.log", + "mode": "100644", + "gitBlob": "532a3c8409f61357e8933f8850295a78af4396c0", + "rawBytes": 3735, + "rawSHA256": "e4f48b76bd4736cb8548cd710a5924fada593af7872dac34db1fbce1457713b0" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/run_experiment.py", + "mode": "100644", + "gitBlob": "4ac681a72a72878860db797990c0e54c0686c1d8", + "rawBytes": 6952, + "rawSHA256": "7f057d55da6b3678d8195ea0923858bda6a2dd03b7c58c5392ca28818a3af61f" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/validate.py", + "mode": "100644", + "gitBlob": "d6f86885f09568f6265c67c731e1e2b5014e08de", + "rawBytes": 3818, + "rawSHA256": "f1ec1cd52ed7cb4f836f8dbfe7547ac3304d93524665d5c660f582fe27dd264f" + }, + { + "path": "docs/internal/packed_query/experiment-rc6/validation-results.json", + "mode": "100644", + "gitBlob": "ea24b62d6fe4cef99d47386d3061f1ce37e21e11", + "rawBytes": 7441, + "rawSHA256": "dd1079a76552172aa9546539e577983b1701553c5997371590d98fb5671a2bea" + }, + { + "path": "docs/internal/templates/AUDIT_PROMPT.md", + "mode": "100644", + "gitBlob": "91631d91a01a21027654855bbb3a8699154df7ef", + "rawBytes": 6422, + "rawSHA256": "abac66980e1b9b93a86a64dcaea851448ed3eecf19caf23cd683debd2cf79375" + }, + { + "path": "docs/internal/templates/COORDINATOR_HANDOFF_PACKET.md", + "mode": "100644", + "gitBlob": "a3c5e31e1a42f727a9f675a12b7cc00a9372e1c9", + "rawBytes": 1806, + "rawSHA256": "e5148d09da3465530bb143e69a2cec623b49c70d48d3d8ed3b9577a0390ee736" + }, + { + "path": "docs/internal/templates/COORDINATOR_REENTRY_PROMPT.md", + "mode": "100644", + "gitBlob": "2b9038c3be299a3aacde24f8021ff7d50cbe48a1", + "rawBytes": 3262, + "rawSHA256": "1fdb73903a8e70c206efab2cb669435bf758a2a1d76adc336c802a82e96bae38" + }, + { + "path": "docs/internal/templates/PROOF_ACCEPTANCE_MATRIX.md", + "mode": "100644", + "gitBlob": "6571abf14bebe279b8f1fdfe17b669d07f98a999", + "rawBytes": 6141, + "rawSHA256": "774909ba0467eec29303be6f160123828af02329eab2adc5663719166c016671" + }, + { + "path": "docs/internal/templates/WORKER_PROMPT.md", + "mode": "100644", + "gitBlob": "d77902361cf2931f97053fcf734cf1e0d1a4f877", + "rawBytes": 19040, + "rawSHA256": "ab4b8b3391a45420bab6e92cc60d00d1164b50769f527f5d77e755a61b966256" + }, + { + "path": "docs/internal/wf3_attack.json", + "mode": "100644", + "gitBlob": "91bfeafaf704b1875be745242e73ca5dd1389b11", + "rawBytes": 36004, + "rawSHA256": "f26087549e6ab0b5a8a43423474f42509cca2720de93ed761840dd02660b44e6" + }, + { + "path": "lake-manifest.json", + "mode": "100644", + "gitBlob": "c84e20fca6ea6816a0b342ef8cabf5aa2b203c35", + "rawBytes": 114, + "rawSHA256": "779633b5a9f128f713a68c5a788a50c6b86d558551215b5d046647e692ad046f" + }, + { + "path": "lakefile.toml", + "mode": "100644", + "gitBlob": "b0e72516918125c22272b36c360db7f91182ade5", + "rawBytes": 1176, + "rawSHA256": "b47c7abe3955d1a2e9ba51a4c71fc2e7961423d2bf5f3856f79a24bebc8bdd50" + }, + { + "path": "lean-toolchain", + "mode": "100644", + "gitBlob": "b9994064fbbb081ca94a50384ff5951b50ea5b42", + "rawBytes": 28, + "rawSHA256": "ad3e6363c78908c80953282baf57162702f1134173a5247aad3dbfea108a525f" + }, + { + "path": "native/packed-rmq/.gitattributes", + "mode": "100644", + "gitBlob": "ec999e9d630559366ebf50cd5fa969bcdd39a652", + "rawBytes": 326, + "rawSHA256": "1a8252f52cc8eaaffd8e07ecfc651e5a4dd81b8cbc1f4e3cab030a0b48809778" + }, + { + "path": "native/packed-rmq/.gitignore", + "mode": "100644", + "gitBlob": "99d2bb15a12368587abd95bf1db11297137741fb", + "rawBytes": 17, + "rawSHA256": "6192c78b3a190e1deae3b9235fba123041714ebbb86b43ccb858ba34b26994d5" + }, + { + "path": "native/packed-rmq/Cargo.lock", + "mode": "100644", + "gitBlob": "583bd4fdf5e8f8c35d88a25c04587ed34eca6fb2", + "rawBytes": 154, + "rawSHA256": "5a59da0864cab8e739dc408245df7bf5ed4bc7ad3a11faf2962c3decff1c8aac" + }, + { + "path": "native/packed-rmq/Cargo.toml", + "mode": "100644", + "gitBlob": "fc35c27c001560d5046abbdc4a640efa88e30b91", + "rawBytes": 228, + "rawSHA256": "c641e44960474cf903618a2aa4e9a724623a13bb4609da853efcf21ba58416d8" + }, + { + "path": "native/packed-rmq/README.md", + "mode": "100644", + "gitBlob": "c44fa1fa7f833bf7e850e358b0ae03f8590f5ded", + "rawBytes": 7667, + "rawSHA256": "59978b2abecb8a8884e9c10ac0e976bca65da5d72398daf6cd6be397dac118bd" + }, + { + "path": "native/packed-rmq/examples/native.cpp", + "mode": "100644", + "gitBlob": "1ef6703ddca42866c500502c0eb97e150cdfc354", + "rawBytes": 7428, + "rawSHA256": "a5bfe471012d24a68bf743f2ec76f141f5b7731e66f7002a6f2127485fba3fab" + }, + { + "path": "native/packed-rmq/examples/route.cpp", + "mode": "100644", + "gitBlob": "c33afca71427dbc6d3974469aac56a0109cd5b4d", + "rawBytes": 1207, + "rawSHA256": "5a83460269c79d8288982d747a0020f0cc7f47c9c1230759708e14041d5efc1c" + }, + { + "path": "native/packed-rmq/fixtures/canonical-cross-cell.fixture", + "mode": "100644", + "gitBlob": "ec6fff340ddacb7469351611c7890d05d249fb5d", + "rawBytes": 14859, + "rawSHA256": "de8cb638266ad0d5fdf3f62f511990e9d4a4d6c5311e10a79bd70f1a949a960a" + }, + { + "path": "native/packed-rmq/fixtures/canonical-interior.fixture", + "mode": "100644", + "gitBlob": "aea1778195914584f82491739c67ffb8bd845f9d", + "rawBytes": 13223, + "rawSHA256": "4da0fc04dfa2e12c70d109bef89b973f2d82225b1caac01f47fe969d5f3eeb66" + }, + { + "path": "native/packed-rmq/fixtures/canonical-left-fringe.fixture", + "mode": "100644", + "gitBlob": "3d1acc9848dd0f3c4c06805d4ac8a03561e05ade", + "rawBytes": 13226, + "rawSHA256": "e947ca28c98a87953b31e7d1f95dd8a1808be1bae2ea7aa67cd7186266d1d7ed" + }, + { + "path": "native/packed-rmq/fixtures/canonical-rank-final.fixture", + "mode": "100644", + "gitBlob": "799d3941237ce7363f52cc4e1157b361dc4d3f03", + "rawBytes": 13218, + "rawSHA256": "53781774f1b5438c2593fa960858197927ab746c137f672de972c96dae916cf9" + }, + { + "path": "native/packed-rmq/fixtures/canonical-right-fringe.fixture", + "mode": "100644", + "gitBlob": "381022decc3c27a41f268d5f9e95de790d2f1342", + "rawBytes": 13228, + "rawSHA256": "a30bb0c905f87d3bb4fb0008b4bc894358f4782023d412db24abbd16fa87937a" + }, + { + "path": "native/packed-rmq/fixtures/canonical-select-left.fixture", + "mode": "100644", + "gitBlob": "7e84cc59736508cf331b4e9ceaf542cff7916cd7", + "rawBytes": 13211, + "rawSHA256": "03ddd5a11f37d1db2a1562fb03cb2df8dd7cb392654e01cd3f4839a15090fe6f" + }, + { + "path": "native/packed-rmq/fixtures/canonical-select-right.fixture", + "mode": "100644", + "gitBlob": "0213cae9330c9617e1ea32c1be06da1d70a3e621", + "rawBytes": 13217, + "rawSHA256": "9a518e610469a3b05be1d91d628ec64e8553692c070bda77283137b96346208e" + }, + { + "path": "native/packed-rmq/fixtures/manifest.json", + "mode": "100644", + "gitBlob": "300c5ac9d05e9b9a5d092eb0db5e980ca62edb83", + "rawBytes": 3112, + "rawSHA256": "b744c146c889896dd14badb77bbee53ccf4ecfe6764ab338811853347ae341b0" + }, + { + "path": "native/packed-rmq/fixtures/n12-adjacent.expected", + "mode": "100644", + "gitBlob": "4da0aed54809c29c1e1e91cb900ebad1d752b86f", + "rawBytes": 3884, + "rawSHA256": "e2834d14ff9ba5977cd31869623b91d2e573d8b6117889d2e0f768f21bbce34d" + }, + { + "path": "native/packed-rmq/fixtures/n12-adjacent.fixture", + "mode": "100644", + "gitBlob": "c781c859d0b49eee8797c76e7480b5f690b87a50", + "rawBytes": 774, + "rawSHA256": "159719ffde2dec626239d410671ae0cd4f91833ac5e8214dc7cb9c7633b0a50e" + }, + { + "path": "native/packed-rmq/fixtures/n12-interior.expected", + "mode": "100644", + "gitBlob": "8d9d893c6e992890608244e59b8ab14a605dfc23", + "rawBytes": 4737, + "rawSHA256": "380e25ec977e4234a02184451f9f96e462431be4262f8ef3f3358f7061e65a95" + }, + { + "path": "native/packed-rmq/fixtures/n12-interior.fixture", + "mode": "100644", + "gitBlob": "5a87b6aad2091d277c31aae86d2829437d4311ff", + "rawBytes": 775, + "rawSHA256": "26c204304b119a98efdb099ae830440127fcff8e5ad36422a7aba6b7583a4234" + }, + { + "path": "native/packed-rmq/fixtures/n12-same.expected", + "mode": "100644", + "gitBlob": "f818662c6209284f12895ead51ae2b81f2ea859b", + "rawBytes": 3324, + "rawSHA256": "a3ffcf6bf9fb995bd765a902eee65fb1de70ef52ba5cf9bbb3a032f3c1e1c2d8" + }, + { + "path": "native/packed-rmq/fixtures/n12-same.fixture", + "mode": "100644", + "gitBlob": "56968c9c6cf2f64a77521f388083493cf474dc45", + "rawBytes": 775, + "rawSHA256": "254604deee28105717bc31744d14b9442d1af3a34828beda2756af0d8bfe9930" + }, + { + "path": "native/packed-rmq/fixtures/n9-corrupt.expected", + "mode": "100644", + "gitBlob": "50d2bca892cd47813918b23cd3af35b8aad2c5a4", + "rawBytes": 1059, + "rawSHA256": "237ccc8507b3ab49891946d6129e46eec1d4c98b74d5c19033d10f2ecd17370f" + }, + { + "path": "native/packed-rmq/fixtures/n9-corrupt.fixture", + "mode": "100644", + "gitBlob": "384116849c9c24deba70d1021efb596bc49971b6", + "rawBytes": 720, + "rawSHA256": "c4bca82bbe201fbd8319b1dd24a0582633600d8c8f6e1b4db57d8ac425f1cf76" + }, + { + "path": "native/packed-rmq/fixtures/n9-empty.expected", + "mode": "100644", + "gitBlob": "0af2b219746cbf7556f1b20517705beb04e68d68", + "rawBytes": 17, + "rawSHA256": "3f59b43485a5e120acba4a6c65bd9bf938601835359c6e8df83f311e17273fa1" + }, + { + "path": "native/packed-rmq/fixtures/n9-empty.fixture", + "mode": "100644", + "gitBlob": "efe7705885f1abf3a0e1f9ad612668c2dffc8ecb", + "rawBytes": 720, + "rawSHA256": "63e4b303ac9d518f2672b187be9f3af9e51c65e1ec4e03f8a9e342a78a685785" + }, + { + "path": "native/packed-rmq/fixtures/n9-full.expected", + "mode": "100644", + "gitBlob": "c958c4a1eccd095386f03a5300190e1df62767f9", + "rawBytes": 4516, + "rawSHA256": "fc25f556cd4c4e5804ab580a3fb8b184d98f72cee207f4c4829edd412f418a56" + }, + { + "path": "native/packed-rmq/fixtures/n9-full.fixture", + "mode": "100644", + "gitBlob": "6374a623f176ff84fe3830e4021a68bad94750b9", + "rawBytes": 720, + "rawSHA256": "70216d5e6f5ca5769ebb8d7269da9b74ed867d7b4b7f9b2c4ad7603aa513ddc1" + }, + { + "path": "native/packed-rmq/fixtures/n9-missing.expected", + "mode": "100644", + "gitBlob": "2f6fe97da1271f08c387699644a859d73789c226", + "rawBytes": 26, + "rawSHA256": "d658efeeed82848b94a085b2f3cde29fe5e649449694a422fd6ceb9cf26366ec" + }, + { + "path": "native/packed-rmq/fixtures/n9-missing.fixture", + "mode": "100644", + "gitBlob": "1266c004970a521f3435400330656ce554731715", + "rawBytes": 18, + "rawSHA256": "08637cded478315c117052eef8a3d2fd8a37e972a202a68ae033b168eca3e6c4" + }, + { + "path": "native/packed-rmq/fixtures/n9-range.expected", + "mode": "100644", + "gitBlob": "5ba4ab99feebe0bfdfe4490a0986a0aa9fbe2aea", + "rawBytes": 17, + "rawSHA256": "db477a96c823bcf48b468fd1bcc4ca95804504eadc69991f4e39df56d05a8e54" + }, + { + "path": "native/packed-rmq/fixtures/n9-range.fixture", + "mode": "100644", + "gitBlob": "9aee57b4585b027343402c31b859e6e13b778150", + "rawBytes": 721, + "rawSHA256": "5fb5c9f9b1785a5f873248f7ba1ab7e11048757c0bf3b88bbd97abb47329409c" + }, + { + "path": "native/packed-rmq/fixtures/program.txt.gz", + "mode": "100644", + "gitBlob": "fc36d7beb7bd7fb9f75e762163999d8bd34e1687", + "rawBytes": 1008972, + "rawSHA256": "13ee9e81e17dd25d5f25546b72762a038886ae7545031faf51dc2757e666c011" + }, + { + "path": "native/packed-rmq/include/packed_rmq.h", + "mode": "100644", + "gitBlob": "c69c5a5072646271e455ede3863cbc68fa47508d", + "rawBytes": 2936, + "rawSHA256": "e2ddb51d62b2cbab79e0a64803f38343f4e73d66c91327e55d708cf47a3c993e" + }, + { + "path": "native/packed-rmq/include/packed_rmq_route.h", + "mode": "100644", + "gitBlob": "b92bdd54ca70913bee97167909d8118e6429c595", + "rawBytes": 1061, + "rawSHA256": "57b8d5524be0b479ab65706e0d009dfa9f47dcb5cbafd90fefa27833539a6e13" + }, + { + "path": "native/packed-rmq/native_shim.c", + "mode": "100644", + "gitBlob": "db1e22fdf3b50763f95f699fbb521f1ac0b824ae", + "rawBytes": 3692, + "rawSHA256": "0d395279a803ab9fb796bb1176f5376f59cbf887e0414f09af4d376a78f89780" + }, + { + "path": "native/packed-rmq/packed_rmq.def", + "mode": "100644", + "gitBlob": "cbf10b820efc18352d419ffbabdad6afc84309d8", + "rawBytes": 256, + "rawSHA256": "1fde85ff9210abd57407803250a4348b6f919187d387b0368e76bfa2b4cfb1b9" + }, + { + "path": "native/packed-rmq/packed_route.def", + "mode": "100644", + "gitBlob": "36b303757a541f05bf30142c38170ceaa3ca0c9b", + "rawBytes": 117, + "rawSHA256": "ab40183b646a3ad96727f41555eed46c8e381eff9293fb922fa9264f310845e5" + }, + { + "path": "native/packed-rmq/route-registry.json", + "mode": "100644", + "gitBlob": "ae692b2bf1ad61f7897677ca482b3fb5b9299753", + "rawBytes": 4324, + "rawSHA256": "33609a968052fb37894cacd9721be12ad1fbaff0bf332a0287cd1aa38622f539" + }, + { + "path": "native/packed-rmq/route_shim.c", + "mode": "100644", + "gitBlob": "e54b29b4f8a3df6654df0d34df13a87ea86e573c", + "rawBytes": 1580, + "rawSHA256": "24ffa6075dfe6d0c1afcd89096a60306b794a7cf29c1d98a85d49b4e9b66149d" + }, + { + "path": "native/packed-rmq/src/lib.rs", + "mode": "100644", + "gitBlob": "14b6e9b4f879b982088a9dfbb5b9204884795eba", + "rawBytes": 2606, + "rawSHA256": "cc5a8defc747dc08e855c758e7f6bac5036d6611acb4c2a589be48c2e9090fbe" + }, + { + "path": "native/packed-rmq/src/main.rs", + "mode": "100644", + "gitBlob": "5d6477d1c053b7d825a962a90c09740b6c8182fa", + "rawBytes": 782, + "rawSHA256": "09d2a564311b22309dc0d9e972043124485c47bea302fcfe8d34373af7388bed" + }, + { + "path": "native/packed-rmq/src/native.rs", + "mode": "100644", + "gitBlob": "2274667fdbc986a76091c2469fa37b99afe64d28", + "rawBytes": 5211, + "rawSHA256": "82e7def4f6f67fbc52d0829ff82ba67082d7e68fc8b7a6938eda41802aa1bde7" + }, + { + "path": "native/packed-rmq/src/native_main.rs", + "mode": "100644", + "gitBlob": "bb457d349d8ae70dfa4d1441c7fa431d1407b582", + "rawBytes": 2910, + "rawSHA256": "3251e67ea8339ff7e5339b78a025308b0d031348ba844bdcbaca9c56cfaf1e22" + }, + { + "path": "native/packed-rmq/tests/lifecycle_storage_probe.c", + "mode": "100644", + "gitBlob": "1dbf0fa0b34b77f7aa6e2af120d6a3f816c3edc4", + "rawBytes": 14720, + "rawSHA256": "5f32f4a91b21697f86b4f2fea855cd050e59e330ce6c6ffda28898353b66d7b1" + }, + { + "path": "paper/.gitignore", + "mode": "100644", + "gitBlob": "5303101f1cf6c4745bafdd80e1261823420ecddd", + "rawBytes": 150, + "rawSHA256": "448507af277485b91566f6098af6079e1854d56ae00d3f3e1952fa31c3a517eb" + }, + { + "path": "paper/EVIDENCE_MATRIX.md", + "mode": "100644", + "gitBlob": "bff00359697fa4895fdd9086a086226dd5bf5fea", + "rawBytes": 23874, + "rawSHA256": "c55119c91f4481688f83abf8133470a753ba497dfa14f9d026de6d3e6d0b56d7" + }, + { + "path": "paper/NOVELTY_LOG.md", + "mode": "100644", + "gitBlob": "b8a17d33c984b6a311f2af7da988c28d2f32d261", + "rawBytes": 101342, + "rawSHA256": "3ca0111f985e15ffffbdea6304ef13d46b4818b05c490ac361dd531e7d7bd509" + }, + { + "path": "paper/README.md", + "mode": "100644", + "gitBlob": "5197d6ee8425962a8be7360096401a918287edec", + "rawBytes": 15433, + "rawSHA256": "b318a0087d82514e71938b04282f407357f43198d8d0f3ae379cc1b238e09a9a" + }, + { + "path": "paper/RELATED_WORK_LEDGER.md", + "mode": "100644", + "gitBlob": "74c56d2bb1dc3be0ce924ec4a521f44b17ab4a10", + "rawBytes": 21862, + "rawSHA256": "5a901ccef1ee753fd7882254f056488a2f322bb25f15750789e1cdf75882be71" + }, + { + "path": "paper/THEOREM_LEDGER.md", + "mode": "100644", + "gitBlob": "2173cff1fe884f3f2d6bfccce0e96d3efdf1d4c9", + "rawBytes": 43742, + "rawSHA256": "32a299e6094f7cde4e65af5e23f17a50146dd83bb3b505d11db95f89164c206f" + }, + { + "path": "paper/WORKLOG.md", + "mode": "100644", + "gitBlob": "845f9621da12e9c4f19da7a407366e1a95c482f4", + "rawBytes": 18045, + "rawSHA256": "c2d3e7edd1097047e2d318359aa00f3acfd206dc2d9280484df2348d544d7c8f" + }, + { + "path": "paper/check_citations.ps1", + "mode": "100644", + "gitBlob": "8517110484e0a11edeb0a1ee8523c68005b07061", + "rawBytes": 30833, + "rawSHA256": "7a7a4a3c4c62e826a77e954e1bc4d97207bd4364b950b5f58032d906d1a9624f" + }, + { + "path": "paper/check_paper.ps1", + "mode": "100644", + "gitBlob": "6d728f1d58747b02a659281f6e6df48d5a97459a", + "rawBytes": 39497, + "rawSHA256": "c7efa32146415426e691ac673963e36d35e96d8dcbdbf04dc01a262b0861b26f" + }, + { + "path": "paper/references.bib", + "mode": "100644", + "gitBlob": "2b70ba3c49f42ca53e8a257792103a4781dbefe1", + "rawBytes": 12993, + "rawSHA256": "da043b74a42c7b05f4de31edf2ef9297677642ec7089489216894d43acd8c248" + }, + { + "path": "paper/rmq.tex", + "mode": "100644", + "gitBlob": "5e8b9d2f6b4f533332d52748338e2eeb4fb15828", + "rawBytes": 67318, + "rawSHA256": "3d46820f764594e34703a4c546b20867013a127af96fa91c679df627d855bffb" + }, + { + "path": "scripts/.gitattributes", + "mode": "100644", + "gitBlob": "0a5b864e5c92c10da85b2f61f939cc1d50b460de", + "rawBytes": 748, + "rawSHA256": "7c4b1f2664e8e60ecb8c7fa4e0663f58c240891b96a9edbcb69d41e26b62be33" + }, + { + "path": "scripts/archive_axiom_check.lean", + "mode": "100644", + "gitBlob": "ec6adbb7aea3d241c5dc864a6911602b06bba0c6", + "rawBytes": 945, + "rawSHA256": "2ca5126392155285e8236b3bc0316da0609cce711b3647d500d046910b0d13ab" + }, + { + "path": "scripts/axiom_check.lean", + "mode": "100644", + "gitBlob": "5efb115e73bc90c11bfb39eef5493dd64e2e1213", + "rawBytes": 112880, + "rawSHA256": "ec45ba8eb324fe514d5919b0295c295ff7c8b8906117e6b9f96ca48bfba0d4c2" + }, + { + "path": "scripts/bp_navigation_axiom_check.lean", + "mode": "100644", + "gitBlob": "4e8a2da0dc129314d5eca7761a623c8d4d18e7be", + "rawBytes": 3660, + "rawSHA256": "51036fc6b7c924283865d5da7e76f2e29869685ad83025060b6e7554d270f637" + }, + { + "path": "scripts/claim_drift_policy_regression.ps1", + "mode": "100644", + "gitBlob": "6fd6dc4d2463851666b49f2c7e4a00ea1e4fe3bb", + "rawBytes": 68061, + "rawSHA256": "6746aaaa408194889d451deee348072cf53bda5920318cd228aa7a45835dfc77" + }, + { + "path": "scripts/claim_drift_scan.ps1", + "mode": "100644", + "gitBlob": "62badf7e071447a3f3a3f8db0d47a3970b918ad5", + "rawBytes": 19319, + "rawSHA256": "5310dba1242b3ed4a0b054a15b1b6911c056c228b2711f3d958eab539bb3f6f7" + }, + { + "path": "scripts/constant_sync_check.ps1", + "mode": "100644", + "gitBlob": "85a6d18537eb3fd96edb00c29b413be2490120c1", + "rawBytes": 23256, + "rawSHA256": "78273ed1d7eafcf991882804c761e458c53090eda2afe1a9cc25970edf1a4506" + }, + { + "path": "scripts/design_decision_check.ps1", + "mode": "100644", + "gitBlob": "f3352f2312b746a698b411436d3f126b970b9781", + "rawBytes": 17247, + "rawSHA256": "1099c55f3112cf3d7b93033e5a666a3e9e1c707ba09adb1f71ee69b8039ec4ad" + }, + { + "path": "scripts/design_decision_check_regression.ps1", + "mode": "100644", + "gitBlob": "fcb65d9709e2cfe15389788a9fc1bdf73e2abee0", + "rawBytes": 70080, + "rawSHA256": "bc866c3cebe236fa304adb1dcf4dd2ddbf9a9708c83d60a16ef274c93e7393f8" + }, + { + "path": "scripts/eg_cp_final_falsification_replay.ps1", + "mode": "100644", + "gitBlob": "2e30e5870acec557766a8223b97d9f106e265d84", + "rawBytes": 40608, + "rawSHA256": "0a1cc091c304238c24d5ae1f955511c19440b40e443612b47094230b95c488d3" + }, + { + "path": "scripts/eg_cp_stagea_replay.ps1", + "mode": "100644", + "gitBlob": "a5744329b0bbdfb1e599d24d9a36b92a3fb5c045", + "rawBytes": 45432, + "rawSHA256": "adeeba662c1fb668862dee64653f35daf9fbf1553262a0bfb9734d1c73f52a1e" + }, + { + "path": "scripts/gate.ps1", + "mode": "100644", + "gitBlob": "3bf1baa224b2507cda8bddb3206de89d7265c073", + "rawBytes": 37829, + "rawSHA256": "ced6ed7dd975ffbade7211b8f82de1afc78f3da69a0e2ec706ec5a545a41dd95" + }, + { + "path": "scripts/headline_axiom_check.lean", + "mode": "100644", + "gitBlob": "1b4b1c780289f7a381d803aa1b64f0a871ed614f", + "rawBytes": 41098, + "rawSHA256": "9db73b697645b7c92f460af642a61e9d19dda97225960d8e7a7fc548bd6b9a49" + }, + { + "path": "scripts/headline_check.ps1", + "mode": "100644", + "gitBlob": "145b9c5d0517fa690fd272739638296a112a73c9", + "rawBytes": 1394, + "rawSHA256": "d3a19639864a95ad842aed6d94ef4d1ad1f36c8a83577f2fce2b78969c853c7c" + }, + { + "path": "scripts/host_shell_path.ps1", + "mode": "100644", + "gitBlob": "4beb65a1cdde891603cb6842df269ef6d26dcee6", + "rawBytes": 3467, + "rawSHA256": "47d2f37a0cde2920d08608702f22beee7c1340ac8548368e9289bc08a410aa56" + }, + { + "path": "scripts/hub_axiom_check.lean", + "mode": "100644", + "gitBlob": "829bf6e09aca9566bb6c803e9f35c52d8dc446ef", + "rawBytes": 2521, + "rawSHA256": "bb36646c35b4118fa5284d933de154836718cbaac95e80a2ba1d66592aef96ea" + }, + { + "path": "scripts/hub_closure_lint.ps1", + "mode": "100644", + "gitBlob": "d08d6467b30ad88630a45f1f892db4b93fb2723e", + "rawBytes": 8495, + "rawSHA256": "241fdf677e4ce5aee12cba99d940a6f1c06e08a32b80c86454278f54a9daf200" + }, + { + "path": "scripts/independence_check.lean", + "mode": "100644", + "gitBlob": "adb72eeb5cd46a8027b4a2f305dc7a691321034d", + "rawBytes": 10685, + "rawSHA256": "290bcb30d4284e3d132b2cf6fad04b3fe0c32795c44f9a1c5015b538a9686033" + }, + { + "path": "scripts/ledger_decl_check.lean", + "mode": "100644", + "gitBlob": "704ae9825822e0f2e0b21fb9932e7a6fbc655d65", + "rawBytes": 8133, + "rawSHA256": "50db7f0f27cfbade83b6ce8abe46206f540ae67890ca56497ccba8095b72916a" + }, + { + "path": "scripts/lifecycle_contract_integrity.ps1", + "mode": "100644", + "gitBlob": "a75884897c856177f180e90c359c9d2d2ba0ed5f", + "rawBytes": 8781, + "rawSHA256": "f582fdc21665307b946b41f17eeb95c9bbe96db7b025fde6cc0d7141f5c4a9df" + }, + { + "path": "scripts/lifecycle_dependency_README.md", + "mode": "100644", + "gitBlob": "76cb916bb762b33c16433e84c081f23205cac5f4", + "rawBytes": 5500, + "rawSHA256": "e5a65e69e7d337b11906cf1a5f1a91c15e53d7bc0c1707757aeaa1a01c4a8105" + }, + { + "path": "scripts/lifecycle_dependency_cases.json", + "mode": "100644", + "gitBlob": "57f1d4427f09299814542172b93fe164c098fbea", + "rawBytes": 38490, + "rawSHA256": "003343871e23c93df874a960a8af60ae7a8a2e615adb05b6e581dc4407a1c84b" + }, + { + "path": "scripts/lifecycle_dependency_replay.ps1", + "mode": "100644", + "gitBlob": "2218a00913f0dd8865cd298d81279b0f41b1e998", + "rawBytes": 20989, + "rawSHA256": "4bf287cf5e0715dbe2413de0e842e21781a38d51a94da5873e1cf8a8972003fb" + }, + { + "path": "scripts/lifecycle_inventory.lean", + "mode": "100644", + "gitBlob": "aede16830f7cfcf79c8121fc354f31e2ebf0686d", + "rawBytes": 3790, + "rawSHA256": "a6d2c6b8afa097ba21a5bbb11f529f375e4b1cc5a087f58ab0b143b924790001" + }, + { + "path": "scripts/lifecycle_provenance_contract.lean", + "mode": "100644", + "gitBlob": "f7962d23c57e778daf937a7280e48c5ce5518b64", + "rawBytes": 5660, + "rawSHA256": "767743a4dd79b34377f5f5550bab88693df4a966826b02de7aedda78043fd020" + }, + { + "path": "scripts/lifecycle_validator.ps1", + "mode": "100644", + "gitBlob": "6034e73e8214d0701a6429a4cbde0df9b2ecbc68", + "rawBytes": 8079, + "rawSHA256": "60655b5ecc0aa79e4fb11871c6fd802b57b29ab81491d577f7828f5052cabf63" + }, + { + "path": "scripts/lifecycle_validator_environment.ps1", + "mode": "100644", + "gitBlob": "6204df919a21f2c40d8c3d9f213e675d152a88c3", + "rawBytes": 2071, + "rawSHA256": "2fb2c4d95eaf3f6633ffaa60413d3d798b26e5bf8b4e712e6a254e293e4f9f19" + }, + { + "path": "scripts/m1_certificate_mutation_regression.ps1", + "mode": "100644", + "gitBlob": "2404417ed8dd5790b0b75a7952d906d8644e215b", + "rawBytes": 69107, + "rawSHA256": "9b8ff36330dd2d3c87b24a50196acef6303def9d71723acd6140c8d7a69fb811" + }, + { + "path": "scripts/make_audit_packet.ps1", + "mode": "100644", + "gitBlob": "2bdfc822c43061f49f10793035150eb6d075d763", + "rawBytes": 3398, + "rawSHA256": "1e3ff7bc49accc5016f750c36f5b32b5e0257f9c34685822a809e833b3363753" + }, + { + "path": "scripts/owned_process_tree.ps1", + "mode": "100644", + "gitBlob": "71b2704e9b77af3b55d4b97c626207013938b5b0", + "rawBytes": 47060, + "rawSHA256": "6690ad4f9e3aee9596e53e89d3d242e4be59c0a04733bc50184ae35b292ff90e" + }, + { + "path": "scripts/packed_bitvector_allocation_consumers.lean", + "mode": "100644", + "gitBlob": "2e31e7c41041a53a62634361d940209d3005adc2", + "rawBytes": 2349, + "rawSHA256": "11625c223a9ea1952fe664dfee7d8dc9c2c3ce798a6c74a39ccd24acc42d08de" + }, + { + "path": "scripts/packed_bitvector_axioms.lean", + "mode": "100644", + "gitBlob": "92d7736811aab1c75e7417cb5b88dc721a53218f", + "rawBytes": 955, + "rawSHA256": "505072ca4722c123f65c7184855813ad75c4208763f696222b9127c955c0c145" + }, + { + "path": "scripts/packed_bitvector_crossing.lean", + "mode": "100644", + "gitBlob": "6227be6e6866f6ce75d3a3f9ab5cfa694482f7e1", + "rawBytes": 3638, + "rawSHA256": "33ffd328ebc0f80eebea279b4904f804d5a54e1fe5cbc2c4a017a75807fe279d" + }, + { + "path": "scripts/packed_bitvector_exceptions.lean", + "mode": "100644", + "gitBlob": "931ed6a7e4261c29b278b62652d5df81f9a59903", + "rawBytes": 14618, + "rawSHA256": "dc3a964cde6de9ac1222761bffb89b3d6d783708d3661de20ef9ef77134e136f" + }, + { + "path": "scripts/packed_bitvector_exceptions.ps1", + "mode": "100644", + "gitBlob": "8dda71bd5763e9e2c9f741e83d2e46d52638e8df", + "rawBytes": 11128, + "rawSHA256": "f16edbfc6578043dbad17bee9f97fd2b1a569e2bbbba622958f1f65195a7bd64" + }, + { + "path": "scripts/packed_bitvector_machine_controls.lean", + "mode": "100644", + "gitBlob": "b44cf08967fccc4a4a457f91aa74130c554dc2de", + "rawBytes": 9929, + "rawSHA256": "f8f7ecbb3c6af7023b9f5fd69e9034efb48c1ef29449a288c2395b7b363c2dc5" + }, + { + "path": "scripts/packed_bitvector_machine_controls.ps1", + "mode": "100644", + "gitBlob": "8a32f2afed7f1f181f8e64006379fc5929d40b5e", + "rawBytes": 10320, + "rawSHA256": "19299cd26fdc0050605d8054dd2608723db95e76682ee8f2ddc4a1347ae71f13" + }, + { + "path": "scripts/packed_bitvector_normalization_consumers.lean", + "mode": "100644", + "gitBlob": "f309cbb54fc9ae6a051bc59eaf51e4c04b328d11", + "rawBytes": 1115, + "rawSHA256": "cf7c09f2ce8df5d364933fd0bd982bc1835610f5d2b6ccaebe0edd6374c529a2" + }, + { + "path": "scripts/packed_bitvector_probe.ps1", + "mode": "100644", + "gitBlob": "865e3d38ff8a19904f9bf1fe23b1a9664c4626eb", + "rawBytes": 2384, + "rawSHA256": "fe126c3906cd65ba3ae65ee773ee1b818cd86564cb7190db837151bd0d10a06d" + }, + { + "path": "scripts/packed_bitvector_public_controls.ps1", + "mode": "100644", + "gitBlob": "3fdb45ab92074cf1a215212951cf3af6ce2ee671", + "rawBytes": 31987, + "rawSHA256": "cf2d7c080ad7f4adf42313c693acf474cf87147de1fcaf93a31aa164994ba085" + }, + { + "path": "scripts/packed_bitvector_selector_controls.ps1", + "mode": "100644", + "gitBlob": "db6f8cca8452005208bd62b779eaf47e2045c26f", + "rawBytes": 4287, + "rawSHA256": "601bd8289e805e9abb2b09607c02fd2aa36428f7ea7fb5767b812bc3b578739d" + }, + { + "path": "scripts/packed_bitvector_validation_controls.ps1", + "mode": "100644", + "gitBlob": "94d9831d869ff73950972ac853267a0f5e583432", + "rawBytes": 7561, + "rawSHA256": "fa3e2c3a7f6e329417cb854f8b2b841b543479478b2fb346314f71e84f0818f0" + }, + { + "path": "scripts/packed_native_binary_build.ps1", + "mode": "100644", + "gitBlob": "05f3961aa8e9ad141a5dec2857d2d534c9b14de9", + "rawBytes": 9141, + "rawSHA256": "7fb90cc8af87ad01fd250e8d9a253852e5a954fef0e5fd8e7b48f06dbbfdab87" + }, + { + "path": "scripts/packed_native_binary_cases.json", + "mode": "100644", + "gitBlob": "a5f65a46d14eaf9f39a1c6b6c8bdd31801cf7eb6", + "rawBytes": 133238, + "rawSHA256": "2d38a1002c1e8a72df5e164144ec4e8f5410511f2c585831aefbbc0d1bd4c637" + }, + { + "path": "scripts/packed_native_binary_controls.ps1", + "mode": "100644", + "gitBlob": "9d4ff7d086c611efa400879235b6d5961a4149e6", + "rawBytes": 20304, + "rawSHA256": "edee71ed973fff4bc860e1258c6b7fed315fee43218179c800407998aad58104" + }, + { + "path": "scripts/packed_native_binary_replay.ps1", + "mode": "100644", + "gitBlob": "fb33e0f29e876a7ab90d57eccc1f69b5cd09b55b", + "rawBytes": 20983, + "rawSHA256": "36774810eb0ba670594d11d11dbd22924032ce8f67554027b5ed5f02cb80dcf6" + }, + { + "path": "scripts/packed_native_build.ps1", + "mode": "100644", + "gitBlob": "8c138c52ba1363bc07b5e5b15b71af882159473a", + "rawBytes": 7888, + "rawSHA256": "4dd02865b2965beca93e506bb65ca452a867a4ddb047ba9e8a7a4a01b49e751e" + }, + { + "path": "scripts/packed_native_cases.py", + "mode": "100644", + "gitBlob": "ca521d5e9714902f57f0092ce49f36f550155169", + "rawBytes": 54317, + "rawSHA256": "c6af8167dce972ff220fa5d61b1d528109737fa9bc9d0a7ab625ab06b0391a4c" + }, + { + "path": "scripts/packed_native_command.ps1", + "mode": "100644", + "gitBlob": "e83f9970bcb1c8cf8d2e63bc66bcc446b39cf22a", + "rawBytes": 1612, + "rawSHA256": "afb87a955a63408f5e6e4bfaa32a99fa0be62b16ab81d79ef27654b3b1c31a1e" + }, + { + "path": "scripts/packed_native_contract_cases.json", + "mode": "100644", + "gitBlob": "b4b94a4d978a2eedbcd50c1594858f244ae3c847", + "rawBytes": 64731, + "rawSHA256": "6e0c8e5a73f7de47d14f7298435e7f72f2ac82a5881aebf3effe0388cbf48e2c" + }, + { + "path": "scripts/packed_native_contract_replay.ps1", + "mode": "100644", + "gitBlob": "f376637c88af8f6786c51ab95124cf5414daff19", + "rawBytes": 20036, + "rawSHA256": "ae8bc171667857e693d58e74626d425ab5c7f8ab43bda4d6996a6ff92c8c3687" + }, + { + "path": "scripts/packed_native_controls.ps1", + "mode": "100644", + "gitBlob": "229125631b7387950501a9a080e8ff75cd4e80ed", + "rawBytes": 16520, + "rawSHA256": "cb54568cde80171f868c5d0252eb31c2c5952d1c7ebc586fca78771c9cadba9c" + }, + { + "path": "scripts/packed_native_final_types.lean", + "mode": "100644", + "gitBlob": "e71c26b9cdecad4c16713f3b3d2a5017add4e2d1", + "rawBytes": 493, + "rawSHA256": "cf8239c7ce04a72d87843d4bc1d95fab03b01da909f747dc65b1ee880fb7b3f3" + }, + { + "path": "scripts/packed_native_hydrate.ps1", + "mode": "100644", + "gitBlob": "8fc2df5271e2d765fc14545a426bc68d43982945", + "rawBytes": 15523, + "rawSHA256": "9e98f0db4395bdebe953720140e1bbcc81352ea8a57a649f227cf74d3cd93d83" + }, + { + "path": "scripts/packed_native_identity.ps1", + "mode": "100644", + "gitBlob": "06fec4b50c714cdc473e0fa9167e837c2d0ba295", + "rawBytes": 18289, + "rawSHA256": "a21f67e2edf49c8e218c657e73967e920efb85ff025476e01bd04a83ca50b17a" + }, + { + "path": "scripts/packed_native_identity_controls.ps1", + "mode": "100644", + "gitBlob": "e50b0016308af3f6913067f82f5867d2598c1332", + "rawBytes": 5402, + "rawSHA256": "7fab648df5cb39fd7ede63f7e5e4c1d053f2568ff5e55709df376d4f9e742f91" + }, + { + "path": "scripts/packed_native_identity_v3_controls.ps1", + "mode": "100644", + "gitBlob": "954ea8efbc031540d851a9465cec044cac49b3de", + "rawBytes": 14096, + "rawSHA256": "d8c9c5209d2e4fd738d9f89208a3aedab5fc35916a9f8220ccfd94e94422bbd1" + }, + { + "path": "scripts/packed_native_image.py", + "mode": "100644", + "gitBlob": "9c08992a13a23e91694459d0a7e8a0720dea5e16", + "rawBytes": 5140, + "rawSHA256": "29766c6dd5ba76e7bf6ff22aadb6872f7b69ad07c35ddac79a99b6e5d73abe98" + }, + { + "path": "scripts/packed_native_lifecycle_integrity_check.ps1", + "mode": "100644", + "gitBlob": "54a46986100f39ff0aaf0f3e02a6bb18e7d76977", + "rawBytes": 7857, + "rawSHA256": "4dbde3ff1b030829c89de70effd12d959404181a545117add11ac869be0e426a" + }, + { + "path": "scripts/packed_native_lifecycle_storage_replay.ps1", + "mode": "100644", + "gitBlob": "9dbcb0e417544b5044d9d76568d431e5f6003299", + "rawBytes": 44594, + "rawSHA256": "c35bb6d38eb54562cb1e650d437d0914de72852594dfdb865db04e24104ad345" + }, + { + "path": "scripts/packed_native_lifecycle_stream_check.ps1", + "mode": "100644", + "gitBlob": "b131230876d9f34cd17fef819aec5f780f4960c1", + "rawBytes": 11222, + "rawSHA256": "71084788a6fe3e5662e187e82f74f078c65fc2f9425ecc9a0c23554bb2e641b7" + }, + { + "path": "scripts/packed_native_route.ps1", + "mode": "100644", + "gitBlob": "9c923afd07d68aa31a36ec875495a8c2b7a31a0a", + "rawBytes": 13622, + "rawSHA256": "8e935824c5a2a01450b7affa2e14ce9aa3baf6c503f1fd423bd249987eb32724" + }, + { + "path": "scripts/packed_native_types.lean", + "mode": "100644", + "gitBlob": "b7e86c11ffbc964b4944fb85a7f6f2f219ab4177", + "rawBytes": 2576, + "rawSHA256": "1e4612acb570649d8163f684e8f92b7c56056d1a04d1b1ae3592213c08885712" + }, + { + "path": "scripts/packed_native_validator_controls.cases.json", + "mode": "100644", + "gitBlob": "d4024eb6d0e6487cb598cc4c228750e6f13ff4ba", + "rawBytes": 9532, + "rawSHA256": "60d07ec27d7854feb107ce8a1148f382f17f882cd8f2f18427fbd8bde8d755ec" + }, + { + "path": "scripts/packed_native_validator_controls.ps1", + "mode": "100644", + "gitBlob": "a7beca1726e99c5d78d4d5e6f4fe71007b6d89e8", + "rawBytes": 13716, + "rawSHA256": "719546f3020562c86de8169caa17fb1ab0580255e7e9faec4da3bc70d62baf9f" + }, + { + "path": "scripts/packed_native_validator_import.lean", + "mode": "100644", + "gitBlob": "1bad2e5002a84aa9a2e9ae1ae0828c3cf67a17e5", + "rawBytes": 327, + "rawSHA256": "1c1b1f8229a2f1b564e9ab5a5a255d9334fea044e2900d1948e228960b16c6ac" + }, + { + "path": "scripts/packed_native_warm.ps1", + "mode": "100644", + "gitBlob": "845d3ffb5d863e926ab6c67bccd03ab24169da6a", + "rawBytes": 4822, + "rawSHA256": "b891df9382edb15ba1cd8e7a513d0e9e7006719771534b6b13dabe3097716abf" + }, + { + "path": "scripts/packed_optimized_axiom_check.ps1", + "mode": "100644", + "gitBlob": "a7b702b2df4d8c584448076f5d05b0970f8da353", + "rawBytes": 4142, + "rawSHA256": "afe0fb40abe0db38cc002b702a795c3e85096fc448f04af979fd4b9ba7fa7224" + }, + { + "path": "scripts/packed_optimized_axiom_union.lean", + "mode": "100644", + "gitBlob": "e333a4cd1665817af0ffd2eef7e0f4131d84ca63", + "rawBytes": 10580, + "rawSHA256": "d0a44ecd5f2851661a3036b641fbf42bb6d10f1acd55a96c3879d86dfb6fc041" + }, + { + "path": "scripts/packed_optimized_axioms.lean", + "mode": "100644", + "gitBlob": "84376e2c104630d0ffbecc4bea354f8f781d9112", + "rawBytes": 9870, + "rawSHA256": "ffdedb3f171a347e47a84d3064c7f5e146f9e270fd02fbbe719d2d325ffdc908" + }, + { + "path": "scripts/packed_optimized_build.ps1", + "mode": "100644", + "gitBlob": "6f5dcec5d0d49cb0dc280604cf0aab7116e6419f", + "rawBytes": 4701, + "rawSHA256": "56160475202428b1d1fd7a25190743e1eda3a0fcc2cd98fe568c388e32acbe6d" + }, + { + "path": "scripts/packed_optimized_certificate_replay.ps1", + "mode": "100644", + "gitBlob": "e1b38040f24b8c227afc486c63c745b2bb61303c", + "rawBytes": 40661, + "rawSHA256": "a37ca628267371275f200c0a0bce8db9dec9663ba1ffdce76bb9509c259fd33b" + }, + { + "path": "scripts/packed_optimized_replay_profile.ps1", + "mode": "100644", + "gitBlob": "5100f8031169156cc6dfe67e342812b6b26b5556", + "rawBytes": 21746, + "rawSHA256": "afebd785f9b38fe08e2652ccf53197180ee4e3bbe088c25545f84663cb573739" + }, + { + "path": "scripts/packed_optimized_replay_regression.ps1", + "mode": "100644", + "gitBlob": "481cb96714d463fedb3b59107b9f2fe3d50e7896", + "rawBytes": 26660, + "rawSHA256": "b88f91393fcde7395cc1e0b2634c572f8fbbc4aa162f0ada08f87a7146ed72dd" + }, + { + "path": "scripts/packed_optimized_runtime.ps1", + "mode": "100644", + "gitBlob": "aef90cc789ec25f265d2c645b1d39fcaa4e319b9", + "rawBytes": 25286, + "rawSHA256": "394aa523adc06d1602ce6f97e7446cdaa2cd36929e96f8d1e80d5564c25a57bb" + }, + { + "path": "scripts/packed_query_inventory_check.lean", + "mode": "100644", + "gitBlob": "6665a12079277057fd63ca483e080ce05e23df2b", + "rawBytes": 2900, + "rawSHA256": "bbdd774e8ffef0e82857350fc918d2ca11d1bad2e56e1809e0e2d301bc2d5e2e" + }, + { + "path": "scripts/packed_query_replay.ps1", + "mode": "100644", + "gitBlob": "c006567c7aba8a736eca5e92986224ff5ccebe8f", + "rawBytes": 51332, + "rawSHA256": "9d119a4406057e0a34bc89a2dfcc3facf98eaffbe8cb410065fd170c3a3ac1c6" + }, + { + "path": "scripts/paper_topology_lint.ps1", + "mode": "100644", + "gitBlob": "6c2174705132dbb8672cc8feca90fcb38967a64b", + "rawBytes": 39461, + "rawSHA256": "8bb5604311f569334f7ebcf9bdc76bd1115604efe735bc3c097508283a14d876" + }, + { + "path": "scripts/paper_topology_lint_regression.ps1", + "mode": "100644", + "gitBlob": "f0c6c17858fc09fd29cd5fd31080ec1eafbaf65b", + "rawBytes": 23673, + "rawSHA256": "a51f7025d2f1ac7001605c74b7961724ad770acd0a64569c03b681bb6faf7f24" + }, + { + "path": "scripts/preprocessing_builder_check.lean", + "mode": "100644", + "gitBlob": "4f3570cbd8ae3220f784b5c5a2f3abf46c8bc088", + "rawBytes": 34095, + "rawSHA256": "fd38d26cc5e165dcde1db860c35892f9bed798277ddb989e7e6251e6cba4ae49" + }, + { + "path": "scripts/preprocessing_builder_firewall.ps1", + "mode": "100644", + "gitBlob": "27c45086a1ed82531dddb3782624844694e00b3e", + "rawBytes": 10591, + "rawSHA256": "658118e815d994babaef68e383a385dff6b8732100726b27463260b29c73ecc8" + }, + { + "path": "scripts/preprocessing_builder_gate.ps1", + "mode": "100644", + "gitBlob": "79044f143123f7540c9de91a75ced935140f63e3", + "rawBytes": 7676, + "rawSHA256": "dbdbd15332577c6226dc639ff7a79d76b38bc0e3717314ee340198d9c4e6d787" + }, + { + "path": "scripts/preprocessing_builder_replay.ps1", + "mode": "100644", + "gitBlob": "4885ebe233eb6bc3f09a467da74244c2c29a3d68", + "rawBytes": 58256, + "rawSHA256": "a1a1427531be41317f232ccaf7d73481e4c96b57aca4d585ff451149e04c4006" + }, + { + "path": "scripts/preprocessing_contract_check.lean", + "mode": "100644", + "gitBlob": "c71b2e6cdf8f6ae58e6cd57a2b470ca63cf78d02", + "rawBytes": 10146, + "rawSHA256": "f2d4d89fc175a0dbb16764a0ffa0b67bebb413732f20036f590aabf9e2559ee9" + }, + { + "path": "scripts/preprocessing_contract_firewall.ps1", + "mode": "100644", + "gitBlob": "63b8fb96dfcaf7475d47abd8a2a6f02f5b727310", + "rawBytes": 4456, + "rawSHA256": "88255ec83f8f319a909fbb5d98daf0e8dfdb1a68fc0f15c72fd8a986723b48fe" + }, + { + "path": "scripts/preprocessing_contract_gate.ps1", + "mode": "100644", + "gitBlob": "f83d41824db3d785e65fd83cf9bbf6de9dfd1d70", + "rawBytes": 3783, + "rawSHA256": "707a4d82544ab476d00f103fa780a7b803eeca63b078bf3bf86c97fe27ec1c39" + }, + { + "path": "scripts/preprocessing_contract_replay.ps1", + "mode": "100644", + "gitBlob": "593f4f1a935c4fb8ca8ab31b8c9c772265a9b559", + "rawBytes": 32111, + "rawSHA256": "12bb6e8a802f9a60151b75609e182002ea2d70582168980a7683eff64dfb6322" + }, + { + "path": "scripts/preprocessing_spec_check.lean", + "mode": "100644", + "gitBlob": "9a74c2b2c7418345c797d40081c0f8c3e8979ea1", + "rawBytes": 42504, + "rawSHA256": "3e4e62dcdc61319b7ae9f33db691857075fed0dc1c8ef11cc0116990e022129d" + }, + { + "path": "scripts/preprocessing_stage_check.lean", + "mode": "100644", + "gitBlob": "c91f5adb1d18e08b235bf4a1351892a495a01a09", + "rawBytes": 316353, + "rawSHA256": "a312530c7cad2ec61e2aab220bdf3d3333c92b80feaa8e26a6f9cd405c7e0e4b" + }, + { + "path": "scripts/project_skill_preflight.ps1", + "mode": "100644", + "gitBlob": "090b205b5b292b5c1565da86ea27e69fe5b78f0b", + "rawBytes": 7551, + "rawSHA256": "3dd5b60e7c1c08102485f9d25a18647c643bf0cbd4bc00d57a01b8558b7e8fb2" + }, + { + "path": "scripts/project_skill_preflight_regression.ps1", + "mode": "100644", + "gitBlob": "95d142911cdd960f6172c74e33ac0ed79ec27037", + "rawBytes": 8250, + "rawSHA256": "f1f7646be10e0e20bc05a3f75cdff9ef04eda859473319bb6d03735fdde334c2" + }, + { + "path": "scripts/rank_select_axiom_check.lean", + "mode": "100644", + "gitBlob": "2067eadc2a6898174cb1e5c296bc78542089280d", + "rawBytes": 28465, + "rawSHA256": "5e5a3d0ff05bbbbc07cadeaf63a77e58c0ce98e4f827cc601c47afea8f2586bf" + }, + { + "path": "scripts/reproduce_artifact.sh", + "mode": "100755", + "gitBlob": "726f7e7f7790786309c3891263f836eb9025d4a2", + "rawBytes": 3313, + "rawSHA256": "a3a98ffc9f9c096ad3724947dff96b3e456cf7b553ad8c3951bf850f6c8dfce4" + }, + { + "path": "scripts/review_wordram.ps1", + "mode": "100644", + "gitBlob": "a290108523bd25b7cf2fb72169c30734743c2441", + "rawBytes": 1588, + "rawSHA256": "6303e50b700f0119bb1e1bc455706c11f17753f51260c4fcdb42d4c3368cb566" + }, + { + "path": "scripts/shim_lint.ps1", + "mode": "100644", + "gitBlob": "e521b5491aca0c310ca7aec8b42be32cf1f3069e", + "rawBytes": 1440, + "rawSHA256": "fb970bf0ea46bcbace5c6d64314f96f4b64e7817ead8c0d05883ade4cf1a7ac5" + }, + { + "path": "scripts/succinct_cost_lint.ps1", + "mode": "100644", + "gitBlob": "f857e99bcd1d58d51dde42f5e5fd715abbd6ed88", + "rawBytes": 1910, + "rawSHA256": "9838cd745b6eaaafc6f9110827b8815d94a02d76cbb806638942180bb2b30811" + }, + { + "path": "scripts/tag_annotation_check.ps1", + "mode": "100644", + "gitBlob": "d7767fb1330e2545ceae77f8d0f2753f15c6caf1", + "rawBytes": 10420, + "rawSHA256": "d712e33694609f72e64632d58f02a28b8a9bbfb21508c28ebbfcc1292cbf4ec9" + }, + { + "path": "scripts/union_find_axiom_check.lean", + "mode": "100644", + "gitBlob": "ea0f009480c0660d8521925695d88a354b39f0dc", + "rawBytes": 23011, + "rawSHA256": "36b0ccc2a56f344639abb2ec26948114afe7e238824cfd544cd119d5dead5df1" + }, + { + "path": "scripts/variable_payload_axioms.lean", + "mode": "100644", + "gitBlob": "75739ba081dc4b7122b8005845c5eb0e7ec3ef76", + "rawBytes": 1877, + "rawSHA256": "6c1a1acd79d0e218dc27c4b4330cd67c296f022795e3bf567221813cb61c65e6" + }, + { + "path": "scripts/variable_payload_build.ps1", + "mode": "100644", + "gitBlob": "d7e12dd66ecb97e460d53bf06f0c320092d946bd", + "rawBytes": 6712, + "rawSHA256": "b87170fb5780dfe9d503b04e11a2ea31c03c0746abb278f350949a4061e93acd" + }, + { + "path": "scripts/variable_payload_contract_check.ps1", + "mode": "100644", + "gitBlob": "bf91c9afbfce0910fce98d874f620925b47d769c", + "rawBytes": 12385, + "rawSHA256": "5504e3e41000f9e91eb12853a34db02c52b928d65f118a8b699893ea917aa0d2" + }, + { + "path": "scripts/variable_payload_generic_consumer.lean", + "mode": "100644", + "gitBlob": "0bc23412318dc5c0741255f92cb6c0abdbfb3cf0", + "rawBytes": 2648, + "rawSHA256": "ed02747bdbfb75e82782616361c7f3c365362c88b70d3e252fe6adf05f49d3a5" + }, + { + "path": "scripts/variable_payload_inventory.lean", + "mode": "100644", + "gitBlob": "c946c5fea2cd687d3f60be948c1400686cef795b", + "rawBytes": 5638, + "rawSHA256": "3c6be8c594634d8b59bc315ab991d934938df787782403f78c1bc2d43509ed7a" + }, + { + "path": "scripts/variable_payload_replay.ps1", + "mode": "100644", + "gitBlob": "3d56f627e52e25ed56b05a5d119ee725401e0a38", + "rawBytes": 28041, + "rawSHA256": "21278eeb94044b85529a6c28b4f4009800aa50a31dd8371ee71a61e0751a6cd1" + }, + { + "path": "scripts/wordram_axiom_check.lean", + "mode": "100644", + "gitBlob": "130176585c08cbd74c3801077de417efd19228e8", + "rawBytes": 42031, + "rawSHA256": "09439193560121ce14c42666023b8847ace7643152c179835d5bf063e01558ba" + }, + { + "path": "scripts/worker_prompt_preflight.ps1", + "mode": "100644", + "gitBlob": "e3335a3648ac36cb656366cd7827e1d55c30612e", + "rawBytes": 23117, + "rawSHA256": "c0c68d7d78480d50644aa8c29352e77dfd12f4b0ced3cacaf955a63ccbbf2a40" + }, + { + "path": "scripts/worker_prompt_preflight_regression.ps1", + "mode": "100644", + "gitBlob": "ab6f1709a5303d40a008c5de18a42f81e0ad514c", + "rawBytes": 30419, + "rawSHA256": "b38c72c838d82c8ffcc7b96007cb1fad4cb6c83d7f313485efb66a82a2813caa" + } + ] +} diff --git a/docs/internal/extensions/lifecycle-native1/CHANGED_FILES.md b/docs/internal/extensions/lifecycle-native1/CHANGED_FILES.md new file mode 100644 index 00000000..c722f8e8 --- /dev/null +++ b/docs/internal/extensions/lifecycle-native1/CHANGED_FILES.md @@ -0,0 +1,120 @@ +# Complete changed-file inventory + +Compared with `3dbdebedcc6ba6b2a864df0d46dcc09ccaaa7536`: 95 changed or new paths. + +The two predecessor Lean files contain only the five expressly approved +`macro_inline` insertions. Existing Cargo/lib glue and public entries are +additive; both decision ledgers preserve their original raw prefixes. +The report and external delivery receipt carry verification and final +commit identities. Raw transcripts, build artifacts and archives stay +in the ignored `.lake/lifecycle-native1/` evidence directories. + +## Lean source and independent consumers (14) + +- `RMQ/Core/SuccinctClose/EndpointFringe/InteriorCandidate/InteriorDirectory/SparseLevelWidth.lean` +- `RMQ/Core/SuccinctFinal/RAM/ReviewerReachabilitySmall.lean` +- `RMQ/Core/WordRAM/Native/Lifecycle.lean` +- `RMQ/Core/WordRAM/Native/Lifecycle/Admission.lean` +- `RMQ/Core/WordRAM/Native/Lifecycle/AdmissionContract.lean` +- `RMQ/Core/WordRAM/Native/Lifecycle/BoundaryProofs.lean` +- `RMQ/Core/WordRAM/Native/Lifecycle/Codec.lean` +- `RMQ/Core/WordRAM/Native/Lifecycle/Contract.lean` +- `RMQ/Core/WordRAM/Native/Lifecycle/Entry.lean` +- `RMQ/Core/WordRAM/Native/Lifecycle/Observations.lean` +- `RMQ/Core/WordRAM/Native/Lifecycle/Repack.lean` +- `RMQ/Core/WordRAM/Native/Lifecycle/Run.lean` +- `RMQ/Core/WordRAM/Native/Lifecycle/ThinRun.lean` +- `RMQ/Validation/LifecycleNativeContract.lean` + +## Native ABI, ownership facade and clients (11) + +- `native/packed-rmq/Cargo.toml` +- `native/packed-rmq/README.md` +- `native/packed-rmq/examples/lifecycle.cpp` +- `native/packed-rmq/include/packed_rmq_lifecycle.h` +- `native/packed-rmq/lifecycle_shim.c` +- `native/packed-rmq/packed_rmq_lifecycle.def` +- `native/packed-rmq/src/lib.rs` +- `native/packed-rmq/src/lifecycle.rs` +- `native/packed-rmq/src/lifecycle_main.rs` +- `native/packed-rmq/tests/lifecycle_owner.c` +- `native/packed-rmq/tests/lifecycle_rust.rs` + +## Build, replay and source identity scripts (4) + +- `scripts/lifecycle_native_build.ps1` +- `scripts/lifecycle_native_cases.json` +- `scripts/lifecycle_native_identity.ps1` +- `scripts/lifecycle_native_replay.ps1` + +## Public explanations and append-only decision records (4) + +- `docs/DIGESTION_LOG.md` +- `docs/FAMILY_SUMMARY.md` +- `docs/internal/DESIGN_DECISIONS.md` +- `docs/internal/WORKFLOW_DESIGN_DECISIONS.md` + +## Local contract, replay sources and compact evidence (62) + +- `docs/internal/extensions/lifecycle-native1/ACCEPTANCE_MATRIX.frozen.md` +- `docs/internal/extensions/lifecycle-native1/ACCEPTANCE_MATRIX.md` +- `docs/internal/extensions/lifecycle-native1/AXIOMS.json` +- `docs/internal/extensions/lifecycle-native1/BASE_IDENTITY.json` +- `docs/internal/extensions/lifecycle-native1/CHANGED_FILES.md` +- `docs/internal/extensions/lifecycle-native1/COMMANDS.md` +- `docs/internal/extensions/lifecycle-native1/COMPILED_ROUTE_EVIDENCE.md` +- `docs/internal/extensions/lifecycle-native1/CONTINUITY.md` +- `docs/internal/extensions/lifecycle-native1/CONTRACT_AMENDMENT_01.json` +- `docs/internal/extensions/lifecycle-native1/CONTRACT_REQUIREMENTS.json` +- `docs/internal/extensions/lifecycle-native1/EXPORT_DIAGNOSTICS.json` +- `docs/internal/extensions/lifecycle-native1/EXPORT_MUTATIONS.json` +- `docs/internal/extensions/lifecycle-native1/FINAL_STREAM_CONTROL_MAP.json` +- `docs/internal/extensions/lifecycle-native1/FINAL_STREAM_MAPPING_EVIDENCE.md` +- `docs/internal/extensions/lifecycle-native1/GUIDE.md` +- `docs/internal/extensions/lifecycle-native1/NATIVE_CLIENT_SELECTOR_EVIDENCE.md` +- `docs/internal/extensions/lifecycle-native1/NATIVE_COMMENT_AMENDMENT.json` +- `docs/internal/extensions/lifecycle-native1/NATIVE_CONTROL_EVIDENCE.md` +- `docs/internal/extensions/lifecycle-native1/NATIVE_EXECUTION_EVIDENCE.md` +- `docs/internal/extensions/lifecycle-native1/NATIVE_EXPECTATIONS.json` +- `docs/internal/extensions/lifecycle-native1/NATIVE_REFRESH_EVIDENCE.md` +- `docs/internal/extensions/lifecycle-native1/NATIVE_REFRESH_PLAN.md` +- `docs/internal/extensions/lifecycle-native1/NATIVE_SELECTOR_CONTROL_EVIDENCE.md` +- `docs/internal/extensions/lifecycle-native1/OWNED_DESCENDANT_CONTROL_EVIDENCE.md` +- `docs/internal/extensions/lifecycle-native1/PAUSE_CHECKPOINT.md` +- `docs/internal/extensions/lifecycle-native1/PREDECESSOR_DLL_REUSE.md` +- `docs/internal/extensions/lifecycle-native1/PROOF_EVIDENCE.md` +- `docs/internal/extensions/lifecycle-native1/REPORT.md` +- `docs/internal/extensions/lifecycle-native1/ROUTE_COVERAGE_EVIDENCE.md` +- `docs/internal/extensions/lifecycle-native1/RUNTIME_LAYOUT_SOURCES.json` +- `docs/internal/extensions/lifecycle-native1/RUNTIME_LAYOUT_SOURCES.md` +- `docs/internal/extensions/lifecycle-native1/RUST_DIAGNOSTICS.json` +- `docs/internal/extensions/lifecycle-native1/RUST_MISUSE_EVIDENCE.md` +- `docs/internal/extensions/lifecycle-native1/START.json` +- `docs/internal/extensions/lifecycle-native1/STARTUP_AMENDMENT.md` +- `docs/internal/extensions/lifecycle-native1/STARTUP_AMENDMENT.patch` +- `docs/internal/extensions/lifecycle-native1/STARTUP_AMENDMENT_RESULT.json` +- `docs/internal/extensions/lifecycle-native1/VALIDATION_APPLICABILITY.md` +- `docs/internal/extensions/lifecycle-native1/VERIFICATION_PLAN.md` +- `docs/internal/extensions/lifecycle-native1/axiom_inventory.ps1` +- `docs/internal/extensions/lifecycle-native1/default_build.ps1` +- `docs/internal/extensions/lifecycle-native1/export_mutation_replay.ps1` +- `docs/internal/extensions/lifecycle-native1/final_checks.ps1` +- `docs/internal/extensions/lifecycle-native1/final_stream_controls.ps1` +- `docs/internal/extensions/lifecycle-native1/final_stream_controls.scope_seed.json` +- `docs/internal/extensions/lifecycle-native1/final_stream_mapping_controls.ps1` +- `docs/internal/extensions/lifecycle-native1/final_streams.ps1` +- `docs/internal/extensions/lifecycle-native1/init_probe.c` +- `docs/internal/extensions/lifecycle-native1/loader_probe.c` +- `docs/internal/extensions/lifecycle-native1/native_client_selector_controls.ps1` +- `docs/internal/extensions/lifecycle-native1/native_clients.json` +- `docs/internal/extensions/lifecycle-native1/native_clients.ps1` +- `docs/internal/extensions/lifecycle-native1/native_control_selector_controls.ps1` +- `docs/internal/extensions/lifecycle-native1/native_controls.json` +- `docs/internal/extensions/lifecycle-native1/native_controls.ps1` +- `docs/internal/extensions/lifecycle-native1/native_recipe_controls.ps1` +- `docs/internal/extensions/lifecycle-native1/native_selector_controls.json` +- `docs/internal/extensions/lifecycle-native1/native_selector_controls.ps1` +- `docs/internal/extensions/lifecycle-native1/owned_descendant_control.ps1` +- `docs/internal/extensions/lifecycle-native1/rust_misuse_replay.ps1` +- `docs/internal/extensions/lifecycle-native1/rust_misuse_selector_controls.ps1` +- `docs/internal/extensions/lifecycle-native1/scope_check.ps1` diff --git a/docs/internal/extensions/lifecycle-native1/COMMANDS.md b/docs/internal/extensions/lifecycle-native1/COMMANDS.md new file mode 100644 index 00000000..6269c65f --- /dev/null +++ b/docs/internal/extensions/lifecycle-native1/COMMANDS.md @@ -0,0 +1,174 @@ +# LIFE-NATIVE-1 command-to-row ledger + +This is a local execution index, not coordinator acceptance. `PASS` below means +the named completed receipt reports success, integrity and cleanup. `PENDING` +does not infer success from an earlier source, discovery or command plan. Update +only the status/receipt cell after inspecting the complete actual result. + +## Common invocation and frozen inputs + +Working directory: `C:/Users/poin/.codex/worktrees/44d6/RMQ`. +Base: `3dbdebedcc6ba6b2a864df0d46dcc09ccaaa7536`. +Governance: `7b227c49ef2ec044b702126cc41c9add847eed01`. + +Each command cell below gives `