Reset alias preview scroll for each explicit destination

.gitattributes

@@ -71,3 +71,7 @@ harness/history/2026-09-11-state-before-gitea-migration/** -text whitespace=cr-a
 harness/experiments/contextual-prerelease-20260911/native/**/*.arcadia whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
 harness/experiments/contextual-prerelease-20260911/producer/package*.log whitespace=-blank-at-eof,cr-at-eol
 harness/experiments/contextual-prerelease-20260911/producer/source-push.log -whitespace
+harness/experiments/source-alias-rename-native-20260912/** -text whitespace=cr-at-eol
+harness/experiments/source-alias-rename-completed-20260912/** -text whitespace=cr-at-eol
+harness/experiments/source-alias-rename-refresh-20260912/** -text whitespace=cr-at-eol
+harness/experiments/source-alias-rename-native-closure-20260912/** -text whitespace=cr-at-eol

AGENTS.md

@@ -48,7 +48,15 @@ Use Gitea MCP for shared coordination. If unavailable, report the failure, buffe
 
 Use GPT-6 Astra exclusively. Delegate bounded independent research, design, implementation, or review when it improves progress, judgment, or preserves the parent's context. Give subagents the relevant context, ownership boundaries, result format, and evidence requirements. Use fresh critics when practical. The parent owns synthesis and integration and normally consolidates results into Gitea. Choose concurrency according to useful independent work and available resources, including other sessions; there is no agent-count quota.
 
-Use the highest available reasoning effort for orchestration and foundational semantic, methodological, formal, or cross-domain decisions. For subagents, use extra-high for difficult design, adversarial review, or unusually hard implementation; high for normal implementation, targeted research, correctness review, debugging, and runtime evaluation; medium for routine exploration, mechanical changes, builds, and tests; and lower for trivial work. Allocate by difficulty, not length, using supported controls; do not claim an unapplied change or alter global configuration merely to enforce these preferences.
+Optimize reasoning effort for verified outcomes per cost, including review, retries, and repair:
+
+Main agent: default to high for planning, synthesis, integration, and acceptance decisions; medium for dispatching a settled plan and routine coordination.
+
+Subagents: default to medium for bounded implementation and targeted research; low for straightforward retrieval, mechanical edits, and running established checks; high for complex debugging, correctness review, adversarial analysis, or ambiguous design.
+
+Use extra-high selectively for difficult foundational semantic, methodological, formal, or cross-domain decisions. Reserve max for exceptional unresolved problems where additional reasoning is likely to justify its cost. Retain higher settings when evidence supports their value.
+
+Allocate by task difficulty and consequences, not role or length alone. Start higher when a clearly difficult decision has expensive downstream consequences. Escalate for concrete reasoning difficulties; resolve missing evidence or unclear requirements at their source. Set subagent effort explicitly through supported controls to avoid unintended inheritance. Do not claim an unapplied change or alter global configuration merely to enforce these preferences.
 
 ## Memory and maintenance
 

crates/oa-desktop/src/app.rs

@@ -7,6 +7,7 @@ mod diagram_selection_tests;
 mod hosted;
 #[cfg(test)]
 mod review_navigation_tests;
+pub(crate) mod source_rename;
 mod source_symbols;
 #[cfg(test)]
 mod transition_context_tests;
@@ -422,6 +423,8 @@ pub enum Message {
         crate::source_navigation::SymbolEvent,
     ),
     SourceSymbolsReady(crate::source_navigation::Completion),
+    SourceRename(source_rename::Event),
+    SourceRenameReady(source_rename::Completion),
     SourceForSelection,
     SourceNavigation(crate::source_navigation::Event),
     SourceFindClose(crate::source_navigation::SymbolContext, Id),
@@ -500,6 +503,7 @@ pub struct App {
     pub source_navigation: crate::source_navigation::State,
     source_find_instance: Id,
     pub source_symbols: crate::source_navigation::SymbolState,
+    pub source_rename: source_rename::State,
     pub model_issues: Vec<validation::Issue>,
     pub migration: Option<persistence::MigrationReport>,
     source_version: u64,
@@ -607,6 +611,7 @@ impl App {
             source_navigation: crate::source_navigation::State::default(),
             source_find_instance: Id::new_v4(),
             source_symbols: crate::source_navigation::SymbolState::default(),
+            source_rename: source_rename::State::default(),
             model_issues,
             migration: None,
             source_version: 0,
@@ -653,19 +658,37 @@ impl App {
             || self.behavior.has_pending()
     }
     fn sync_source(&mut self) {
+        self.sync_source_with_alias_editor(None);
+    }
+    fn sync_source_with_alias_editor(&mut self, hint: Option<source_rename::EditorRefresh<'_>>) {
         self.source_workspace.accept(self.document.bundle());
-        self.show_source_file(false);
+        self.show_source_file_with_alias_editor(false, hint);
         self.source_diagnostics = self.document.compiled().diagnostics.clone();
         self.source_version += 1;
         self.lint_requested = None;
     }
     fn show_source_file(&mut self, restore_cursor: bool) {
+        self.show_source_file_with_alias_editor(restore_cursor, None);
+    }
+    fn show_source_file_with_alias_editor(
+        &mut self,
+        restore_cursor: bool,
+        hint: Option<source_rename::EditorRefresh<'_>>,
+    ) {
         self.source_symbols.reveal = None;
         self.source_tree.reveal(&self.source_workspace.active);
         self.source_select_line = false;
         let source = self.source_workspace.text().to_owned();
         self.source_navigation.refresh(&source);
-        self.source_editor = text_editor::Content::with_text(&source);
+        if !hint.is_some_and(|hint| {
+            hint.apply(
+                &mut self.source_editor,
+                &self.source_workspace.active,
+                &source,
+            )
+        }) {
+            self.source_editor = text_editor::Content::with_text(&source);
+        }
         self.source_snapshot = Arc::from(source);
         self.source_jump = restore_cursor
             .then(|| {
@@ -710,6 +733,9 @@ impl App {
         }
     }
     fn sync(&mut self) {
+        self.sync_with_alias_editor(None);
+    }
+    fn sync_with_alias_editor(&mut self, hint: Option<source_rename::EditorRefresh<'_>>) {
         self.explorer_index = crate::explorer::Index::new(self.project(), self.layer);
         self.model_issues = validate(self.project());
         self.normalize_creation();
@@ -739,7 +765,7 @@ impl App {
                 .map(|d| d.id);
         }
         self.refresh_draft();
-        self.sync_source();
+        self.sync_source_with_alias_editor(hint);
     }
     fn normalize_creation(&mut self) {
         if !self.create_kind.supports(self.layer) {
@@ -932,6 +958,7 @@ impl App {
         let source_version = self.source_version + 1;
         let lint_running = self.lint_running;
         let navigation_in_flight = self.source_symbols.in_flight;
+        let rename_in_flight = self.source_rename.in_flight;
         let guide = std::mem::take(&mut self.guide);
         let mut hosted = std::mem::take(&mut self.hosted);
         hosted.leave_document();
@@ -944,6 +971,7 @@ impl App {
         self.source_version = source_version;
         self.lint_running = lint_running;
         self.source_symbols.in_flight = navigation_in_flight;
+        self.source_rename.in_flight = rename_in_flight;
         self.guide = guide;
         self.path = path;
         self.status = "Project ready".into();
@@ -1061,7 +1089,9 @@ impl App {
                 self.behavior.creation.has_pending()
                     || self.behavior.source_active()
                     || (self.page == Page::Text
-                        && (self.source_symbols.open || self.source_navigation.open)
+                        && (self.source_symbols.open
+                            || self.source_navigation.open
+                            || self.source_rename.open())
                         && self.architecture.is_none()),
             )
             .map(|()| Message::Escape),
@@ -1109,6 +1139,11 @@ impl App {
         ])
     }
     pub fn update(&mut self, message: Message) -> Task<Message> {
+        if let Message::SourceRename(event) = &message
+            && !self.source_rename_envelope(event)
+        {
+            return Task::none();
+        }
         let message = match message {
             Message::SourceFindClose(context, instance) => {
                 if context != self.source_symbol_context()
@@ -1138,6 +1173,9 @@ impl App {
         if let Message::SourceSymbolsReady(completion) = message {
             return self.source_symbols_ready(completion);
         }
+        if let Message::SourceRenameReady(completion) = message {
+            return self.source_rename_ready(completion);
+        }
         if !matches!(
             &message,
             Message::CheckpointTick
@@ -1328,6 +1366,18 @@ impl App {
         {
             return Task::none();
         }
+        if self.source_rename.open() {
+            if matches!(
+                message,
+                Message::Escape | Message::Request(Pending::Close(_))
+            ) {
+                self.close_source_rename();
+                return Task::none();
+            }
+            if !modal_event && !matches!(message, Message::SourceRename(_)) {
+                return Task::none();
+            }
+        }
         if matches!(
             message,
             Message::Page(_) | Message::Layer(_) | Message::Diagram(_)
@@ -1372,6 +1422,7 @@ impl App {
             self.last_workspace_page = self.page;
         }
         let mut task = self.handle(message);
+        self.refresh_source_rename_context();
         self.route_state_diagram_workspace();
         if self.page != Page::Home {
             self.last_workspace_page = self.page;
@@ -2917,6 +2968,7 @@ impl App {
                         if self.pending_recovery.as_ref() != Some(&receipt.target) {
                             return Task::none();
                         }
+                        self.invalidate_source_rename("Disk recovery changed this source context. Your replacement is retained; close and invoke Rename again.");
                         self.pending_recovery = None;
                         self.source_diagnostics
                             .retain(|issue| issue.diagnostic.code != "pending_save");
@@ -3004,6 +3056,8 @@ impl App {
             Message::SourceViewport(ticket) => return self.source_viewport(ticket),
             Message::SourceFindClose(..) => return Task::none(), // update checks and unwraps it
             Message::SourceSymbols(_, event) => return self.source_symbol_event(event),
+            Message::SourceRename(event) => return self.source_rename_event(event),
+            Message::SourceRenameReady(completion) => return self.source_rename_ready(completion),
             Message::SourceSymbolsReady(completion) => {
                 return self.source_symbols_ready(completion);
             }

crates/oa-desktop/src/app/source_rename/alias_input.rs

@@ -0,0 +1,219 @@
+//! Keep Iced's single-line input from silently filtering pasted control bytes.
+//! Only the alias field uses this adapter. The child retains editing and focus.
+use iced::advanced::{
+    Clipboard, Layout, Shell, Widget, clipboard, layout, overlay, renderer, text, widget,
+};
+use iced::{Element, Event, Length, Rectangle, Size, Vector, keyboard, mouse};
+
+pub(super) fn guard<'a, Message: Clone + 'a, Theme: 'a, R: text::Renderer + 'a>(
+    input: Element<'a, Message, Theme, R>,
+    rejected: Option<Message>,
+) -> Element<'a, Message, Theme, R> {
+    Element::new(AliasInput { input, rejected })
+}
+
+struct AliasInput<'a, Message, Theme, R> {
+    input: Element<'a, Message, Theme, R>,
+    rejected: Option<Message>,
+}
+
+#[derive(Default)]
+struct State {
+    modifiers: keyboard::Modifiers,
+}
+
+// Each fresh child clipboard read uses the checked snapshot. Iced may reuse its
+// previously admitted paste while V is held, until KeyReleased clears that cache.
+struct CapturedClipboard<'a> {
+    content: Option<String>,
+    original: &'a mut dyn Clipboard,
+}
+impl Clipboard for CapturedClipboard<'_> {
+    fn read(&self, kind: clipboard::Kind) -> Option<String> {
+        if kind == clipboard::Kind::Standard {
+            self.content.clone()
+        } else {
+            self.original.read(kind)
+        }
+    }
+    fn write(&mut self, kind: clipboard::Kind, contents: String) {
+        self.original.write(kind, contents);
+    }
+}
+
+impl<Message: Clone, Theme, R: text::Renderer> Widget<Message, Theme, R>
+    for AliasInput<'_, Message, Theme, R>
+{
+    fn size(&self) -> Size<Length> {
+        self.input.as_widget().size()
+    }
+    fn size_hint(&self) -> Size<Length> {
+        self.input.as_widget().size_hint()
+    }
+    fn tag(&self) -> widget::tree::Tag {
+        widget::tree::Tag::of::<State>()
+    }
+    fn state(&self) -> widget::tree::State {
+        widget::tree::State::new(State::default())
+    }
+    fn children(&self) -> Vec<widget::Tree> {
+        vec![widget::Tree::new(self.input.as_widget())]
+    }
+    fn diff(&self, tree: &mut widget::Tree) {
+        tree.diff_children(std::slice::from_ref(&self.input));
+    }
+    fn layout(
+        &mut self,
+        tree: &mut widget::Tree,
+        renderer: &R,
+        limits: &layout::Limits,
+    ) -> layout::Node {
+        self.input
+            .as_widget_mut()
+            .layout(&mut tree.children[0], renderer, limits)
+    }
+    fn draw(
+        &self,
+        tree: &widget::Tree,
+        renderer: &mut R,
+        theme: &Theme,
+        style: &renderer::Style,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        viewport: &Rectangle,
+    ) {
+        self.input.as_widget().draw(
+            &tree.children[0],
+            renderer,
+            theme,
+            style,
+            layout,
+            cursor,
+            viewport,
+        );
+    }
+    fn operate(
+        &mut self,
+        tree: &mut widget::Tree,
+        layout: Layout<'_>,
+        renderer: &R,
+        operation: &mut dyn widget::Operation,
+    ) {
+        self.input
+            .as_widget_mut()
+            .operate(&mut tree.children[0], layout, renderer, operation);
+    }
+    fn update(
+        &mut self,
+        tree: &mut widget::Tree,
+        event: &Event,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        renderer: &R,
+        clipboard: &mut dyn Clipboard,
+        shell: &mut Shell<'_, Message>,
+        viewport: &Rectangle,
+    ) {
+        let focused = tree.children[0]
+            .state
+            .downcast_ref::<iced::widget::text_input::State<R::Paragraph>>()
+            .is_focused();
+        let state = tree.state.downcast_mut::<State>();
+        // Iced 0.14.2 uses stored ModifiersChanged state, not KeyPressed.modifiers.
+        // Mirror its Escape reset and its Latin/physical-key paste shortcut.
+        if let Event::Keyboard(keyboard::Event::ModifiersChanged(modifiers)) = event {
+            state.modifiers = *modifiers;
+        }
+        let paste = matches!(event,
+            Event::Keyboard(keyboard::Event::KeyPressed { key, physical_key, .. })
+                if key.to_latin(*physical_key) == Some('v')
+                    && state.modifiers.command() && !state.modifiers.alt());
+        if focused
+            && paste
+            && let Some(rejected) = &self.rejected
+        {
+            let content = clipboard.read(clipboard::Kind::Standard);
+            if content
+                .as_ref()
+                .is_some_and(|value| value.chars().any(char::is_control))
+            {
+                // Do not invoke the child: even an empty replacement would erase
+                // its selection. Approval invalidation is an explicit App event.
+                shell.publish(rejected.clone());
+                shell.capture_event();
+                return;
+            }
+            self.input.as_widget_mut().update(
+                &mut tree.children[0],
+                event,
+                layout,
+                cursor,
+                renderer,
+                &mut CapturedClipboard {
+                    content,
+                    original: clipboard,
+                },
+                shell,
+                viewport,
+            );
+            return;
+        }
+        self.input.as_widget_mut().update(
+            &mut tree.children[0],
+            event,
+            layout,
+            cursor,
+            renderer,
+            clipboard,
+            shell,
+            viewport,
+        );
+        // In Iced 0.14.2 the only KeyPressed branch that removes focus is its
+        // Escape branch, which also resets stored modifiers. Observe that branch
+        // after its text/shortcut early returns and effective-key conversion.
+        if focused
+            && matches!(event, Event::Keyboard(keyboard::Event::KeyPressed { .. }))
+            && !tree.children[0]
+                .state
+                .downcast_ref::<iced::widget::text_input::State<R::Paragraph>>()
+                .is_focused()
+        {
+            tree.state.downcast_mut::<State>().modifiers = keyboard::Modifiers::default();
+        }
+    }
+    fn mouse_interaction(
+        &self,
+        tree: &widget::Tree,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        viewport: &Rectangle,
+        renderer: &R,
+    ) -> mouse::Interaction {
+        self.input.as_widget().mouse_interaction(
+            &tree.children[0],
+            layout,
+            cursor,
+            viewport,
+            renderer,
+        )
+    }
+    fn overlay<'a>(
+        &'a mut self,
+        tree: &'a mut widget::Tree,
+        layout: Layout<'a>,
+        renderer: &R,
+        viewport: &Rectangle,
+        translation: Vector,
+    ) -> Option<overlay::Element<'a, Message, Theme, R>> {
+        self.input.as_widget_mut().overlay(
+            &mut tree.children[0],
+            layout,
+            renderer,
+            viewport,
+            translation,
+        )
+    }
+}
+
+#[cfg(all(test, debug_assertions))]
+mod tests;

crates/oa-desktop/src/app/source_rename/alias_input/tests.rs

@@ -0,0 +1,220 @@
+use super::*;
+use crate::views::source_tests::FontLayout;
+use iced::keyboard::{
+    Key, Modifiers,
+    key::{Code, Named, Physical},
+};
+use std::cell::Cell;
+
+#[derive(Debug, Clone, PartialEq)]
+enum Signal {
+    Input(String),
+    Rejected,
+}
+
+struct ClipboardText {
+    text: String,
+    reads: Cell<usize>,
+}
+impl Clipboard for ClipboardText {
+    fn read(&self, _: clipboard::Kind) -> Option<String> {
+        self.reads.set(self.reads.get() + 1);
+        Some(self.text.clone())
+    }
+    fn write(&mut self, _: clipboard::Kind, _: String) {}
+}
+type InputState = iced::widget::text_input::State<<FontLayout as text::Renderer>::Paragraph>;
+
+struct Mounted {
+    input: Element<'static, Signal, iced::Theme, FontLayout>,
+    tree: widget::Tree,
+    node: layout::Node,
+    clipboard: ClipboardText,
+    messages: Vec<Signal>,
+}
+impl Mounted {
+    fn new(focused: bool, enabled: bool, modifiers: Modifiers) -> Self {
+        let mut child = iced::widget::text_input("Alias", "send_water");
+        if enabled {
+            child = child.on_input(Signal::Input);
+        }
+        let mut input = guard(child.into(), enabled.then_some(Signal::Rejected));
+        let mut tree = widget::Tree::new(input.as_widget());
+        let node = input.as_widget_mut().layout(
+            &mut tree,
+            &FontLayout,
+            &layout::Limits::new(Size::ZERO, Size::new(500., 40.)),
+        );
+        if focused {
+            let state = tree.children[0].state.downcast_mut::<InputState>();
+            state.focus();
+            state.select_range(0, 10);
+        }
+        let mut mounted = Self {
+            input,
+            tree,
+            node,
+            clipboard: ClipboardText {
+                text: "foo\nbar".into(),
+                reads: Cell::new(0),
+            },
+            messages: vec![],
+        };
+        mounted.event(Event::Keyboard(keyboard::Event::ModifiersChanged(
+            modifiers,
+        )));
+        mounted
+    }
+    fn state(&self) -> &InputState {
+        self.tree.children[0].state.downcast_ref::<InputState>()
+    }
+    fn event(&mut self, event: Event) -> bool {
+        let mut shell = Shell::new(&mut self.messages);
+        self.input.as_widget_mut().update(
+            &mut self.tree,
+            &event,
+            Layout::new(&self.node),
+            mouse::Cursor::Unavailable,
+            &FontLayout,
+            &mut self.clipboard,
+            &mut shell,
+            &Rectangle::new(iced::Point::ORIGIN, Size::new(500., 40.)),
+        );
+        shell.is_event_captured()
+    }
+}
+fn key(key: Key, modified_key: Key, code: Code) -> Event {
+    Event::Keyboard(keyboard::Event::KeyPressed {
+        key,
+        modified_key,
+        physical_key: Physical::Code(code),
+        location: keyboard::Location::Standard,
+        modifiers: Modifiers::empty(),
+        text: None,
+        repeat: false,
+    })
+}
+fn paste() -> Event {
+    key(
+        Key::Character("v".into()),
+        Key::Character("v".into()),
+        Code::KeyV,
+    )
+}
+
+#[test]
+fn paste_refusal_matches_child_focus_enabled_and_stored_modifier_protocol() {
+    for focused in [false, true] {
+        for enabled in [false, true] {
+            for modifiers in [
+                Modifiers::empty(),
+                Modifiers::SHIFT,
+                Modifiers::COMMAND,
+                Modifiers::COMMAND | Modifiers::ALT,
+                Modifiers::COMMAND | Modifiers::SHIFT,
+            ] {
+                let mut mounted = Mounted::new(focused, enabled, modifiers);
+                let before = mounted.state().cursor();
+                let expected = focused && enabled && modifiers.command() && !modifiers.alt();
+                let captured = mounted.event(paste());
+                assert_eq!(
+                    mounted.messages,
+                    if expected {
+                        vec![Signal::Rejected]
+                    } else {
+                        vec![]
+                    }
+                );
+                assert_eq!(mounted.clipboard.reads.get(), usize::from(expected));
+                assert_eq!(mounted.state().cursor(), before);
+                if expected {
+                    assert!(captured);
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn effective_escape_reset_follows_child_after_early_returns() {
+    // Raw Escape mapped to Home must not clear only the guard's Command state.
+    let mut mounted = Mounted::new(true, true, Modifiers::COMMAND);
+    mounted.event(key(
+        Key::Named(Named::Escape),
+        Key::Named(Named::Home),
+        Code::Escape,
+    ));
+    assert!(mounted.state().is_focused());
+    assert!(mounted.event(paste()));
+    assert_eq!(mounted.messages, vec![Signal::Rejected]);
+
+    // Effective Escape clears both states; a later focus operation does not
+    // invent a new ModifiersChanged event or revive the previous Command state.
+    let mut mounted = Mounted::new(true, true, Modifiers::COMMAND);
+    mounted.event(key(
+        Key::Named(Named::Home),
+        Key::Named(Named::Escape),
+        Code::Home,
+    ));
+    assert!(!mounted.state().is_focused());
+    mounted.tree.children[0]
+        .state
+        .downcast_mut::<InputState>()
+        .focus();
+    mounted.event(paste());
+    assert!(mounted.messages.is_empty());
+    assert_eq!(mounted.clipboard.reads.get(), 0);
+
+    // Printable text returns before effective Escape and leaves modifiers live.
+    let mut mounted = Mounted::new(true, true, Modifiers::COMMAND);
+    let mut event = key(
+        Key::Named(Named::Home),
+        Key::Named(Named::Escape),
+        Code::Home,
+    );
+    if let Event::Keyboard(keyboard::Event::KeyPressed { text, .. }) = &mut event {
+        *text = Some("x".into());
+    }
+    mounted.event(event);
+    assert!(mounted.state().is_focused());
+    assert_eq!(mounted.messages, vec![Signal::Input("x".into())]);
+    mounted.messages.clear();
+    mounted.event(paste());
+    assert_eq!(mounted.messages, vec![Signal::Rejected]);
+}
+
+#[test]
+fn held_paste_cache_contains_only_previously_admitted_text() {
+    let mut mounted = Mounted::new(true, true, Modifiers::COMMAND);
+    mounted.clipboard.text = "water".into();
+    mounted.event(paste());
+    assert_eq!(mounted.messages, vec![Signal::Input("water".into())]);
+    mounted.messages.clear();
+    mounted.clipboard.text = "other".into();
+    mounted.event(paste());
+    assert_eq!(
+        mounted.messages,
+        vec![Signal::Input("waterwater".into())],
+        "Iced reuses its first admitted paste while the key is held"
+    );
+    mounted.messages.clear();
+    let before = mounted.state().cursor();
+    mounted.clipboard.text = "bad\tvalue".into();
+    mounted.event(paste());
+    assert_eq!(mounted.messages, vec![Signal::Rejected]);
+    assert_eq!(mounted.state().cursor(), before);
+    mounted.messages.clear();
+    mounted.event(Event::Keyboard(keyboard::Event::KeyReleased {
+        key: Key::Character("v".into()),
+        modified_key: Key::Character("v".into()),
+        physical_key: Physical::Code(Code::KeyV),
+        location: keyboard::Location::Standard,
+        modifiers: Modifiers::empty(),
+    }));
+    mounted.clipboard.text = "later".into();
+    mounted.event(paste());
+    assert_eq!(
+        mounted.messages,
+        vec![Signal::Input("waterwaterlater".into())]
+    );
+}

crates/oa-desktop/src/app/source_rename/editor_patch.rs

@@ -0,0 +1,303 @@
+//! Display-only reuse after a guarded alias rename. This is not model authority.
+use iced::{advanced::text::Renderer, widget::text_editor};
+use std::sync::Arc;
+
+/// Replace exact, unchanged-line-count source in an existing editor.
+///
+/// The caller must first authorize/commit the model change and must reconstruct
+/// from accepted source on false. Preflight failures do not mutate the editor;
+/// a failed final readback can leave it changed. On changing success the cursor
+/// is at 0:0 without selection; the caller restores its approved origin/reveal.
+/// Direct Content actions deliberately bypass App draft edits and Undo history.
+pub(super) fn replace<R: Renderer>(
+    editor: &mut text_editor::Content<R>,
+    before: &str,
+    after: &str,
+) -> bool {
+    if editor.text() != before {
+        return false;
+    }
+    let Some(old_lines) = lines(before) else {
+        return false;
+    };
+    let Some(new_lines) = lines(after) else {
+        return false;
+    };
+    if old_lines.len() != new_lines.len() || old_lines.len() != editor.line_count() {
+        return false;
+    }
+    let mut patches = Vec::new();
+    for (line, ((old, old_ending), (new, new_ending))) in
+        old_lines.into_iter().zip(new_lines).enumerate()
+    {
+        let Some(actual) = editor.line(line) else {
+            return false;
+        };
+        // Cosmic also recognizes bare CR and LFCR. Comparing the actual lines
+        // catches its greedy LFCR interpretation of e.g. "x\n\r\ny" too.
+        if old_ending != new_ending || actual.text != old || actual.ending != old_ending {
+            return false;
+        }
+        if old == new {
+            continue;
+        }
+        let mut start = old
+            .bytes()
+            .zip(new.bytes())
+            .take_while(|(a, b)| a == b)
+            .count();
+        while !old.is_char_boundary(start) || !new.is_char_boundary(start) {
+            start -= 1;
+        }
+        let mut suffix = old[start..]
+            .bytes()
+            .rev()
+            .zip(new[start..].bytes().rev())
+            .take_while(|(a, b)| a == b)
+            .count();
+        while !old.is_char_boundary(old.len() - suffix) || !new.is_char_boundary(new.len() - suffix)
+        {
+            suffix -= 1;
+        }
+        // All positions and owned payloads are prepared before the first edit.
+        patches.push((
+            line,
+            start,
+            old.len() - suffix,
+            Arc::new(new[start..new.len() - suffix].to_owned()),
+        ));
+    }
+    if patches.is_empty() {
+        return true;
+    }
+    let empty = Arc::new(String::new());
+    for (line, start, end, replacement) in patches.into_iter().rev() {
+        select(editor, line, start, end);
+        editor.perform(text_editor::Action::Edit(text_editor::Edit::Paste(
+            replacement,
+        )));
+    }
+    // Iced overwrites its earliest-change marker on each Edit. An explicit
+    // zero-width selection + empty Paste changes no bytes, but marks line zero.
+    // This also refreshes previously unhighlighted lines before the first patch.
+    // It resets only line zero's text cache; other unchanged lines retain theirs.
+    select(editor, 0, 0, 0);
+    editor.perform(text_editor::Action::Edit(text_editor::Edit::Paste(empty)));
+    editor.text() == after
+}
+
+fn select<R: Renderer>(
+    editor: &mut text_editor::Content<R>,
+    line: usize,
+    start: usize,
+    end: usize,
+) {
+    editor.move_to(text_editor::Cursor {
+        position: text_editor::Position {
+            line,
+            column: start,
+        },
+        // move_to(None) does not clear a previous selection in this Iced version.
+        selection: Some(text_editor::Position { line, column: end }),
+    });
+}
+
+fn lines(source: &str) -> Option<Vec<(&str, text_editor::LineEnding)>> {
+    use text_editor::LineEnding;
+    let mut result = Vec::new();
+    let mut parts = source.split('\n').peekable();
+    while let Some(part) = parts.next() {
+        let (text, ending) = if parts.peek().is_none() {
+            (part, LineEnding::None)
+        } else if let Some(text) = part.strip_suffix('\r') {
+            (text, LineEnding::CrLf)
+        } else {
+            (part, LineEnding::Lf)
+        };
+        if text.contains('\r')
+            || (text.is_empty()
+                && ending == LineEnding::CrLf
+                && result
+                    .last()
+                    .is_some_and(|(_, previous)| *previous == LineEnding::Lf))
+        {
+            return None;
+        }
+        result.push((text, ending));
+    }
+    Some(result)
+}
+
+#[cfg(all(test, debug_assertions))]
+mod tests {
+    use super::*;
+    use crate::views::source_tests::FontLayout;
+    use iced::advanced::{layout, text::Highlighter, widget::Tree};
+    use iced::{Element, Font, Length, Size};
+    use std::{cell::RefCell, ops::Range};
+
+    #[test]
+    fn exact_text_matrix_and_reverse_preserve_endings() {
+        for (before, after) in [
+            ("", ""),
+            ("", "alias"),
+            ("alias", ""),
+            ("same", "same"),
+            ("a\n", "alias\n"),
+            ("a\r\n", "alias\r\n"),
+            ("\r\na\r\n\r\n", "\r\nlong_alias\r\n\r\n"),
+            ("\na\n\n", "\nlong_alias\n\n"),
+            ("a\r\nb\nc", "long_a\r\nlong_b\nlong_c"),
+            (
+                "雨🙂 e\u{301} @a @a // a",
+                "雨🙂 e\u{301} @a_long @a_long // a",
+            ),
+            ("@abc", "@abcdef"),
+            ("@abcdef", "@abc"),
+            ("@abc_suffix", "@def_suffix"),
+            ("@none", "@identifier"),
+            // Shared prefix/suffix bytes inside distinct UTF-8 codepoints must
+            // not be used as String split positions, even outside alias scope.
+            ("雨xé", "雪xê"),
+            ("é", "©"),
+            (
+                "unchanged\n@a\nunchanged\n@a\n",
+                "unchanged\n@long\nunchanged\n@long\n",
+            ),
+        ] {
+            let mut editor = text_editor::Content::<FontLayout>::with_text(before);
+            assert!(
+                replace(&mut editor, before, after),
+                "{before:?} -> {after:?}"
+            );
+            assert_eq!(editor.text(), after);
+            let expected = text_editor::Content::<FontLayout>::with_text(after);
+            assert_eq!(editor.line_count(), expected.line_count());
+            for (actual, expected) in editor.lines().zip(expected.lines()) {
+                assert_eq!(actual.text, expected.text);
+                assert_eq!(actual.ending, expected.ending);
+            }
+            if before != after {
+                assert_eq!(
+                    editor.cursor().position,
+                    text_editor::Position { line: 0, column: 0 }
+                );
+                assert_eq!(editor.cursor().selection, None);
+            }
+            assert!(replace(&mut editor, after, before));
+            assert_eq!(editor.text(), before);
+        }
+    }
+
+    #[test]
+    fn all_preflight_refusals_leave_text_cursor_and_selection_unchanged() {
+        for (actual, before, after) in [
+            ("live", "stale", "changed"),
+            ("a\nb", "a\nb", "long\nb\nc"),
+            ("a\nb", "a\nb", "long\r\nb"),
+            // Refusal on a later line must not apply the earlier planned edit.
+            ("a\nb\r\n", "a\nb\r\n", "long\nb\n"),
+            ("a\rb", "a\rb", "long\rb"),
+            ("a\n\rb", "a\n\rb", "long\n\rb"),
+            ("a\n\r\nb", "a\n\r\nb", "long\n\r\nb"),
+            // The replacement must not introduce a greedy LFCR boundary either.
+            ("a\nx\r\n", "a\nx\r\n", "a\n\r\n"),
+            ("a", "a", "long\r"),
+        ] {
+            let mut editor = text_editor::Content::<FontLayout>::with_text(actual);
+            select(&mut editor, 0, 0, 1);
+            let cursor = editor.cursor();
+            let selection = editor.selection();
+            assert!(
+                !replace(&mut editor, before, after),
+                "{before:?} -> {after:?}"
+            );
+            assert_eq!(editor.text(), actual);
+            assert_eq!(editor.cursor(), cursor);
+            assert_eq!(editor.selection(), selection);
+        }
+    }
+
+    #[test]
+    fn unchanged_content_preserves_selection_and_next_direct_edit_works() {
+        let mut editor = text_editor::Content::<FontLayout>::with_text("@a");
+        select(&mut editor, 0, 1, 2);
+        let cursor = editor.cursor();
+        assert!(replace(&mut editor, "@a", "@a"));
+        assert_eq!(editor.cursor(), cursor);
+        assert!(replace(&mut editor, "@a", "@long"));
+        editor.move_to(text_editor::Cursor {
+            position: text_editor::Position { line: 0, column: 5 },
+            selection: None,
+        });
+        editor.perform(text_editor::Action::Edit(text_editor::Edit::Insert('!')));
+        assert_eq!(editor.text(), "@long!");
+    }
+
+    thread_local! {
+        static CHANGES: RefCell<Vec<usize>> = const { RefCell::new(Vec::new()) };
+    }
+
+    struct Tracked(crate::highlight::ArcadiaHighlighter);
+    impl Highlighter for Tracked {
+        type Settings = Arc<str>;
+        type Highlight = oa_core::language::TokenClass;
+        type Iterator<'a> = std::vec::IntoIter<(Range<usize>, Self::Highlight)>;
+        fn new(settings: &Self::Settings) -> Self {
+            Self(crate::highlight::ArcadiaHighlighter::new(settings))
+        }
+        fn update(&mut self, settings: &Self::Settings) {
+            self.0.update(settings);
+        }
+        fn change_line(&mut self, line: usize) {
+            CHANGES.with(|changes| changes.borrow_mut().push(line));
+            self.0.change_line(line);
+        }
+        fn highlight_line(&mut self, line: &str) -> Self::Iterator<'_> {
+            self.0.highlight_line(line)
+        }
+        fn current_line(&self) -> usize {
+            self.0.current_line()
+        }
+    }
+
+    fn view(
+        editor: &text_editor::Content<FontLayout>,
+        source: Arc<str>,
+    ) -> Element<'_, (), iced::Theme, FontLayout> {
+        text_editor(editor)
+            .font(Font::MONOSPACE)
+            .size(14)
+            .height(Length::Fill)
+            .highlight_with::<Tracked>(source, crate::highlight::format)
+            .into()
+    }
+
+    #[test]
+    fn already_laid_out_editor_notifies_highlighter_from_zero_after_later_line_patch() {
+        let before = "// earlier\n// unmodified\n@a";
+        let after = "// earlier\n// unmodified\n@none";
+        let mut editor = text_editor::Content::<FontLayout>::with_text(before);
+        let limits = layout::Limits::new(Size::ZERO, Size::new(400., 60.));
+        let mut tree = {
+            let mut widget = view(&editor, Arc::from(before));
+            let mut tree = Tree::new(widget.as_widget());
+            let _ = widget
+                .as_widget_mut()
+                .layout(&mut tree, &FontLayout, &limits);
+            tree
+        };
+        CHANGES.with(|changes| changes.borrow_mut().clear());
+        assert!(replace(&mut editor, before, after));
+        {
+            let mut widget = view(&editor, Arc::from(after));
+            let _ = widget
+                .as_widget_mut()
+                .layout(&mut tree, &FontLayout, &limits);
+        }
+        // Font/metrics/bounds are already stable. This notification must come
+        // from the helper's empty edit, not a fresh renderer initialization.
+        CHANGES.with(|changes| assert_eq!(*changes.borrow(), [0]));
+        assert_eq!(editor.text(), after);
+    }
+}

crates/oa-desktop/src/app/source_rename/preview_glyph_tests.rs

@@ -0,0 +1,449 @@
+//! Real paragraph advances and clipping through the actual preview dialog.
+//! Native screenshots additionally check raster ink and the platform renderer.
+use super::*;
+use crate::views::source_tests::FontLayout;
+use iced::advanced::{Layout, layout, renderer, text as shaped, widget};
+use iced::{Background, Color, Font, Pixels, Point, Rectangle, Size, Transformation, Vector};
+use std::collections::{BTreeMap, BTreeSet};
+
+struct Glyph {
+    text: String,
+    paragraph_y: u32,
+    line: usize,
+    bytes: std::ops::Range<usize>,
+    bounds: Rectangle,
+    clip: Rectangle,
+}
+
+struct GlyphRecorder {
+    wanted: BTreeSet<String>,
+    transforms: Vec<Transformation>,
+    clips: Vec<Rectangle>,
+    glyphs: Vec<Glyph>,
+    quads: Vec<Rectangle>,
+}
+impl GlyphRecorder {
+    fn new(wanted: BTreeSet<String>, viewport: Rectangle) -> Self {
+        Self {
+            wanted,
+            transforms: vec![Transformation::IDENTITY],
+            clips: vec![viewport],
+            glyphs: vec![],
+            quads: vec![],
+        }
+    }
+    fn transform(&self) -> Transformation {
+        *self.transforms.last().unwrap()
+    }
+    fn clip(&self, bounds: Rectangle) -> Rectangle {
+        self.clips
+            .last()
+            .unwrap()
+            .intersection(&(bounds * self.transform()))
+            .unwrap_or(Rectangle::with_size(Size::ZERO))
+    }
+}
+impl renderer::Renderer for GlyphRecorder {
+    fn start_layer(&mut self, bounds: Rectangle) {
+        self.clips.push(self.clip(bounds));
+    }
+    fn end_layer(&mut self) {
+        self.clips.pop().unwrap();
+    }
+    fn start_transformation(&mut self, transform: Transformation) {
+        self.transforms.push(self.transform() * transform);
+    }
+    fn end_transformation(&mut self) {
+        self.transforms.pop().unwrap();
+    }
+    fn reset(&mut self, bounds: Rectangle) {
+        self.transforms = vec![Transformation::IDENTITY];
+        self.clips = vec![bounds];
+        self.glyphs.clear();
+        self.quads.clear();
+    }
+    fn fill_quad(&mut self, quad: renderer::Quad, _: impl Into<Background>) {
+        self.quads.push(quad.bounds * self.transform());
+    }
+    fn allocate_image(
+        &mut self,
+        handle: &iced::advanced::image::Handle,
+        callback: impl FnOnce(Result<iced::advanced::image::Allocation, iced::advanced::image::Error>)
+        + Send
+        + 'static,
+    ) {
+        renderer::Renderer::allocate_image(&mut FontLayout, handle, callback);
+    }
+}
+impl shaped::Renderer for GlyphRecorder {
+    type Font = Font;
+    type Paragraph = <FontLayout as shaped::Renderer>::Paragraph;
+    type Editor = <FontLayout as shaped::Renderer>::Editor;
+    const ICON_FONT: Font = <FontLayout as shaped::Renderer>::ICON_FONT;
+    const CHECKMARK_ICON: char = <FontLayout as shaped::Renderer>::CHECKMARK_ICON;
+    const ARROW_DOWN_ICON: char = <FontLayout as shaped::Renderer>::ARROW_DOWN_ICON;
+    const SCROLL_UP_ICON: char = <FontLayout as shaped::Renderer>::SCROLL_UP_ICON;
+    const SCROLL_DOWN_ICON: char = <FontLayout as shaped::Renderer>::SCROLL_DOWN_ICON;
+    const SCROLL_LEFT_ICON: char = <FontLayout as shaped::Renderer>::SCROLL_LEFT_ICON;
+    const SCROLL_RIGHT_ICON: char = <FontLayout as shaped::Renderer>::SCROLL_RIGHT_ICON;
+    const ICED_LOGO: char = <FontLayout as shaped::Renderer>::ICED_LOGO;
+    fn default_font(&self) -> Font {
+        shaped::Renderer::default_font(&FontLayout)
+    }
+    fn default_size(&self) -> Pixels {
+        shaped::Renderer::default_size(&FontLayout)
+    }
+    fn fill_paragraph(
+        &mut self,
+        paragraph: &Self::Paragraph,
+        position: Point,
+        _: Color,
+        clip: Rectangle,
+    ) {
+        let buffer = paragraph.buffer();
+        let text = buffer
+            .lines
+            .iter()
+            .map(|line| line.text())
+            .collect::<Vec<_>>()
+            .join("\n");
+        if !self.wanted.contains(&text) {
+            return;
+        }
+        let clip = self.clip(clip);
+        for run in buffer.layout_runs() {
+            for glyph in run.glyphs {
+                if run.text[glyph.start..glyph.end]
+                    .chars()
+                    .all(char::is_whitespace)
+                {
+                    continue;
+                }
+                let bounds = Rectangle {
+                    x: position.x + glyph.x + glyph.x_offset * glyph.font_size,
+                    y: position.y + run.line_top,
+                    width: glyph.w,
+                    height: run.line_height,
+                } * self.transform();
+                self.glyphs.push(Glyph {
+                    text: text.clone(),
+                    paragraph_y: position.y.to_bits(),
+                    line: run.line_i,
+                    bytes: glyph.start..glyph.end,
+                    bounds,
+                    clip,
+                });
+            }
+        }
+    }
+    fn fill_editor(
+        &mut self,
+        editor: &Self::Editor,
+        position: Point,
+        color: Color,
+        clip: Rectangle,
+    ) {
+        shaped::Renderer::fill_editor(&mut FontLayout, editor, position, color, clip);
+    }
+    fn fill_text(&mut self, text: shaped::Text, position: Point, color: Color, clip: Rectangle) {
+        shaped::Renderer::fill_text(&mut FontLayout, text, position, color, clip);
+    }
+}
+
+#[derive(Default)]
+struct ScrollGeometry {
+    id: Option<widget::Id>,
+    bounds: Option<Rectangle>,
+    content: Option<Rectangle>,
+    offset: Vector,
+}
+impl widget::Operation for ScrollGeometry {
+    fn traverse(&mut self, visit: &mut dyn FnMut(&mut dyn widget::Operation)) {
+        visit(self);
+    }
+    fn scrollable(
+        &mut self,
+        id: Option<&widget::Id>,
+        bounds: Rectangle,
+        content: Rectangle,
+        offset: Vector,
+        _: &mut dyn widget::operation::Scrollable,
+    ) {
+        if id == self.id.as_ref() {
+            self.bounds = Some(bounds);
+            self.content = Some(content);
+            self.offset = offset;
+        }
+    }
+}
+fn normalized(text: &str) -> String {
+    text.replace("\r\n", "\n").replace('\r', "\n")
+}
+fn required_chars(text: &str) -> BTreeSet<(usize, usize)> {
+    text.split('\n')
+        .enumerate()
+        .flat_map(|(line, text)| {
+            text.char_indices()
+                .filter(|(_, ch)| !ch.is_whitespace())
+                .map(move |(byte, _)| (line, byte))
+        })
+        .collect()
+}
+
+fn declarations(long: bool) -> App {
+    let name = if long {
+        format!("Assess {} request", "界🚀".repeat(90))
+    } else {
+        "Assess 救援 request".into()
+    };
+    let source = SourceBundle { entry: "project.arcadia".into(), files: BTreeMap::from([
+        ("project.arcadia".into(), "arcadia 7;\r\nproject navigation_trial \"Navigation — 救援\" id \"9e8f0000-0000-4000-8000-000000000001\" {\r\n include \"救援/assess.arcadia\";\r\n}\r\n".into()),
+        ("救援/assess.arcadia".into(), format!("// Comment @assess must not be a lexical use.\r\noa_activity assess \"{name}\" id \"9e8f0000-0000-4000-8000-000000000002\" {{\r\n    description \"Keep @assess as prose, not a use.\";\r\n}}\r\n")),
+    ]) };
+    let mut app = fixture();
+    app.document = Document::from_bundle(source, LIMITS).unwrap();
+    app.source_workspace = Workspace::new(app.document.bundle(), true);
+    app.source_workspace.active = "救援/assess.arcadia".into();
+    app.selected = app.project().id;
+    app.refresh_draft();
+    app.show_source_file(false);
+    let start = app
+        .source_workspace
+        .text()
+        .find("oa_activity assess")
+        .unwrap()
+        + "oa_activity ".len();
+    app.source_editor.move_to(cursor(
+        app.source_workspace.text(),
+        start,
+        start + "assess".len(),
+    ));
+    begin(&mut app);
+    let replacement = if long {
+        "a".repeat(255)
+    } else {
+        "assess_damage".into()
+    };
+    input(&mut app, &replacement);
+    let _ = preview(&mut app);
+    app
+}
+
+fn assert_page_glyphs_visible(app: &App, host: Size) {
+    let form = app.source_rename.form.as_ref().unwrap();
+    let ready = form.approval.as_ref().unwrap();
+    let file = &ready.preview.files()[form.file];
+    let mut expected = BTreeMap::<String, usize>::new();
+    for line in file.hunks()[form.hunk]
+        .lines()
+        .iter()
+        .skip(form.line)
+        .take(LINES_PER_PAGE)
+    {
+        for source in [
+            line.before_text(&ready.prepared.before().bundle.files[file.path()])
+                .unwrap(),
+            line.after_text(&ready.prepared.after().bundle.files[file.path()])
+                .unwrap(),
+        ] {
+            if let Some(fragment) = preview::text_segment(source, form.segment) {
+                let text = normalized(fragment);
+                if !required_chars(&text).is_empty() {
+                    *expected.entry(text).or_default() += 1;
+                }
+            }
+        }
+    }
+    assert!(!expected.is_empty());
+    let viewport = Rectangle::new(Point::ORIGIN, host);
+    let mut renderer = GlyphRecorder::new(expected.keys().cloned().collect(), viewport);
+    let editor = text_editor::Content::<GlyphRecorder>::new();
+    let mut view = dialog_content(app, &editor);
+    let mut tree = widget::Tree::new(view.as_widget());
+    let node =
+        view.as_widget_mut()
+            .layout(&mut tree, &renderer, &layout::Limits::new(Size::ZERO, host));
+    let mut geometry = ScrollGeometry {
+        id: Some(preview_scroll_id(form, ready.id)),
+        ..ScrollGeometry::default()
+    };
+    view.as_widget_mut()
+        .operate(&mut tree, Layout::new(&node), &renderer, &mut geometry);
+    let bounds = geometry.bounds.unwrap();
+    let content = geometry.content.unwrap();
+    assert!(bounds.height >= 40.);
+    let maximum = (content.height - bounds.height).max(0.);
+    let steps = (maximum / (bounds.height * 0.5)).ceil() as usize;
+    let mut visible = BTreeMap::<(String, u32), BTreeSet<(usize, usize)>>::new();
+    let mut reserved_bar_gap = true;
+    for step in 0..=steps {
+        let offset = (step as f32 * bounds.height * 0.5).min(maximum);
+        view.as_widget_mut().operate(
+            &mut tree,
+            Layout::new(&node),
+            &renderer,
+            &mut widget::operation::scrollable::scroll_to(
+                preview_scroll_id(form, ready.id),
+                widget::operation::scrollable::AbsoluteOffset {
+                    x: None,
+                    y: Some(offset),
+                },
+            ),
+        );
+        view.as_widget_mut()
+            .operate(&mut tree, Layout::new(&node), &renderer, &mut geometry);
+        assert!(
+            (geometry.offset.y - offset).abs() <= 0.5,
+            "actual scroll operation reaches the requested source offset"
+        );
+        renderer::Renderer::reset(&mut renderer, viewport);
+        view.as_widget().draw(
+            &tree,
+            &mut renderer,
+            &iced::Theme::Light,
+            &renderer::Style::default(),
+            Layout::new(&node),
+            iced::mouse::Cursor::Unavailable,
+            &viewport,
+        );
+        // The vertical scrollbar's actual painted thumb fixes its excluded x
+        // region; the outer scroll clip alone cannot detect overpainting.
+        let scrollbar_left = renderer
+            .quads
+            .iter()
+            .filter(|quad| {
+                quad.width > 0.
+                    && quad.width <= 16.
+                    && quad.height > 0.
+                    && quad.x >= bounds.x + bounds.width - 18.
+                    && quad.x + quad.width <= bounds.x + bounds.width + 0.5
+                    && quad.y >= bounds.y - 0.5
+                    && quad.y + quad.height <= bounds.y + bounds.height + 0.5
+            })
+            .map(|quad| quad.x)
+            .min_by(f32::total_cmp);
+        if maximum > 0. {
+            let left = scrollbar_left.expect("overflowing actual preview must paint its scrollbar");
+            reserved_bar_gap &= content.x + content.width <= left - 7.5;
+        }
+        for glyph in &renderer.glyphs {
+            let right = glyph.bounds.x + glyph.bounds.width;
+            if let Some(left) = scrollbar_left {
+                assert!(
+                    right <= left - 0.5,
+                    "source glyph under scrollbar: text={:?} cluster={:?} glyph={:?} bar x={left}",
+                    glyph.text,
+                    glyph.bytes,
+                    glyph.bounds
+                );
+            }
+            assert!(
+                glyph.bounds.x >= content.x - 0.5 && right <= content.x + content.width + 0.5,
+                "source glyph escaped reserved width: {:?} {:?}",
+                glyph.text,
+                glyph.bounds
+            );
+            assert!(
+                glyph.bounds.x >= glyph.clip.x - 0.5
+                    && right <= glyph.clip.x + glyph.clip.width + 0.5,
+                "source glyph horizontally clipped: {:?} {:?} {:?}",
+                glyph.text,
+                glyph.bounds,
+                glyph.clip
+            );
+            if glyph.bounds.y >= glyph.clip.y - 0.5
+                && glyph.bounds.y + glyph.bounds.height <= glyph.clip.y + glyph.clip.height + 0.5
+            {
+                let logical_line = glyph.text.split('\n').nth(glyph.line).unwrap();
+                let chars = logical_line
+                    .char_indices()
+                    .filter(|(byte, ch)| glyph.bytes.contains(byte) && !ch.is_whitespace())
+                    .map(|(byte, _)| (glyph.line, byte));
+                visible
+                    .entry((glyph.text.clone(), glyph.paragraph_y))
+                    .or_default()
+                    .extend(chars);
+            }
+        }
+    }
+    assert!(
+        reserved_bar_gap,
+        "source content must reserve actual scrollbar width plus gap"
+    );
+    assert!(
+        bounds.width >= host.width - 30.,
+        "preview must use available dialog width: {bounds:?} / {host:?}"
+    );
+    for (text, count) in expected {
+        let required = required_chars(&text);
+        let instances: Vec<_> = visible
+            .iter()
+            .filter(|((value, _), _)| value == &text)
+            .collect();
+        assert_eq!(
+            instances.len(),
+            count,
+            "all before/after occurrences must be seen: {text:?}"
+        );
+        for (_, seen) in instances {
+            assert_eq!(
+                seen, &required,
+                "every non-whitespace source cluster must be fully visible at some vertical offset: {text:?}"
+            );
+        }
+    }
+}
+
+#[test]
+fn actual_preview_source_glyphs_clear_scrollbar_and_all_long_fragments_are_reachable() {
+    for long in [false, true] {
+        let mut app = declarations(long);
+        let ready = app
+            .source_rename
+            .form
+            .as_ref()
+            .unwrap()
+            .approval
+            .as_ref()
+            .unwrap()
+            .clone();
+        let invocation = app.source_rename.form.as_ref().unwrap().invocation;
+        let before = evidence(&app);
+        for (width, height) in [(1100., 700.), (580., 700.)] {
+            app.window_size = Size::new(width, height);
+            let host = Size::new((width - 84.).min(708.), height - 120.);
+            let total = segment_total(app.source_rename.form.as_ref().unwrap());
+            if long {
+                assert!(
+                    total >= 3,
+                    "include unbroken ASCII and wide Unicode across segments"
+                );
+            }
+            for segment in 0..total {
+                assert_page_glyphs_visible(&app, host);
+                if segment + 1 < total {
+                    event(&mut app, Event::Segment(invocation, ready.id, true));
+                }
+            }
+            for _ in 1..total {
+                event(&mut app, Event::Segment(invocation, ready.id, false));
+            }
+        }
+        assert_eq!(
+            evidence(&app),
+            before,
+            "preview geometry/paging cannot alter transaction inputs"
+        );
+        assert_eq!(
+            app.source_rename
+                .form
+                .as_ref()
+                .unwrap()
+                .approval
+                .as_ref()
+                .unwrap()
+                .id,
+            ready.id
+        );
+    }
+}

crates/oa-desktop/src/app/source_rename/preview_scroll_tests.rs

@@ -0,0 +1,310 @@
+//! Execute the controller's scroll operations on a retained, scrolled dialog.
+use super::*;
+use crate::views::source_tests::FontLayout;
+use iced::advanced::{Layout, layout, widget};
+use iced::futures::StreamExt;
+use iced::{Rectangle, Size, Vector};
+
+const HOST: Size = Size::new(720., 660.);
+
+fn paged_fixture() -> App {
+    let mut source = bundle();
+    let name = "Long engineering name 雨 ".repeat(18);
+    source.files.get_mut("defs.arcadia").unwrap().replace_range(
+        ..,
+        &format!(
+            "oa_activity pump \"{name}\" id \"00000000-0000-0000-0000-000000000002\" {{}}\r\n\
+            oa_activity backup \"Backup\" id \"00000000-0000-0000-0000-000000000004\" {{}}\r\n"
+        ),
+    );
+    let mut uses = String::new();
+    for index in 0..16 {
+        if index == 12 {
+            uses.push_str(&"// unchanged gap\r\n".repeat(10));
+        }
+        uses.push_str(&format!(
+            "interaction use_{index} \"{name}\" id \"00000000-0000-0000-0001-{index:012}\" {{ source @pump; target @backup; }}\r\n"
+        ));
+    }
+    source.files.insert("uses.arcadia".into(), uses);
+    let mut app = fixture();
+    app.window_size = HOST;
+    app.document = Document::from_bundle(source, LIMITS).unwrap();
+    app.source_workspace = Workspace::new(app.document.bundle(), true);
+    app.source_workspace.active = "uses.arcadia".into();
+    app.show_source_file(false);
+    let start = app.source_workspace.text().find("source @pump").unwrap() + "source @".len();
+    app.source_editor
+        .move_to(cursor(app.source_workspace.text(), start, start + 4));
+    begin(&mut app);
+    input(&mut app, "pump_long");
+    let _ = preview(&mut app);
+    app
+}
+
+fn scroll_id(app: &App) -> widget::Id {
+    let form = app.source_rename.form.as_ref().unwrap();
+    preview_scroll_id(form, form.approval.as_ref().unwrap().id)
+}
+
+struct Geometry {
+    id: widget::Id,
+    offset: Option<Vector>,
+}
+impl widget::Operation for Geometry {
+    fn traverse(&mut self, visit: &mut dyn FnMut(&mut dyn widget::Operation)) {
+        visit(self);
+    }
+    fn scrollable(
+        &mut self,
+        id: Option<&widget::Id>,
+        _: Rectangle,
+        _: Rectangle,
+        offset: Vector,
+        _: &mut dyn widget::operation::Scrollable,
+    ) {
+        if id == Some(&self.id) {
+            self.offset = Some(offset);
+        }
+    }
+}
+
+struct Mounted {
+    editor: text_editor::Content<FontLayout>,
+    tree: widget::Tree,
+}
+impl Mounted {
+    fn new(app: &App) -> Self {
+        let editor = text_editor::Content::<FontLayout>::new();
+        let tree = widget::Tree::new(dialog_content(app, &editor).as_widget());
+        Self { editor, tree }
+    }
+    fn operate(&mut self, app: &App, operation: &mut dyn widget::Operation) {
+        let mut view = dialog_content(app, &self.editor);
+        // Preserve the actual scroll state across the new page's view diff.
+        self.tree.diff(view.as_widget());
+        let node = view.as_widget_mut().layout(
+            &mut self.tree,
+            &FontLayout,
+            &layout::Limits::new(Size::ZERO, HOST),
+        );
+        view.as_widget_mut()
+            .operate(&mut self.tree, Layout::new(&node), &FontLayout, operation);
+    }
+    fn offset(&mut self, app: &App) -> f32 {
+        let mut geometry = Geometry {
+            id: scroll_id(app),
+            offset: None,
+        };
+        self.operate(app, &mut geometry);
+        geometry.offset.expect("mounted preview scrollable").y
+    }
+    fn scroll_down(&mut self, app: &App) -> f32 {
+        self.operate(
+            app,
+            &mut widget::operation::scrollable::scroll_to(
+                scroll_id(app),
+                widget::operation::scrollable::AbsoluteOffset {
+                    x: None,
+                    y: Some(10_000.),
+                },
+            ),
+        );
+        let offset = self.offset(app);
+        assert!(offset > 10., "fixture must really be scrolled");
+        offset
+    }
+    async fn execute(&mut self, app: &App, task: Task<Message>) -> usize {
+        let mut count = 0;
+        if let Some(mut actions) = iced_runtime::task::into_stream(task) {
+            while let Some(action) = actions.next().await {
+                let iced_runtime::Action::Widget(mut operation) = action else {
+                    panic!("preview paging must only schedule a widget operation");
+                };
+                self.operate(app, operation.as_mut());
+                count += 1;
+            }
+        }
+        count
+    }
+}
+
+#[tokio::test]
+async fn explicit_navigation_resets_retained_scroll_but_id_change_alone_does_not() {
+    let mut app = paged_fixture();
+    let before = evidence(&app);
+    let form = app.source_rename.form.as_ref().unwrap();
+    let invocation = form.invocation;
+    let approval = form.approval.as_ref().unwrap().id;
+    let mut mounted = Mounted::new(&app);
+    mounted.scroll_down(&app);
+    let old_id = scroll_id(&app);
+    let task = app.update(Message::SourceRename(Event::File(
+        invocation, approval, true,
+    )));
+    assert_ne!(old_id, scroll_id(&app));
+    // Negative control: even after diff/layout with the new id and new file,
+    // Iced retains the previous offset until the returned operation executes.
+    assert!(mounted.offset(&app) > 10.);
+    assert_eq!(mounted.execute(&app, task).await, 1);
+    assert_eq!(mounted.offset(&app), 0.);
+
+    for navigation in [
+        Event::Line(invocation, approval, true),
+        Event::Segment(invocation, approval, true),
+        Event::Hunk(invocation, approval, true),
+        Event::File(invocation, approval, false),
+        Event::Search(invocation, "uses".into()),
+        Event::Search(invocation, "no-path-match".into()),
+        Event::Search(invocation, String::new()),
+    ] {
+        mounted.scroll_down(&app);
+        let task = app.update(Message::SourceRename(navigation));
+        assert_eq!(mounted.execute(&app, task).await, 1);
+        assert_eq!(mounted.offset(&app), 0.);
+        assert_eq!(evidence(&app), before);
+    }
+    // Passive redraw and unchanged filter input preserve deliberate scrolling.
+    let offset = mounted.scroll_down(&app);
+    assert_eq!(mounted.offset(&app), offset);
+    let task = app.update(Message::SourceRename(Event::Search(
+        invocation,
+        String::new(),
+    )));
+    assert_eq!(mounted.execute(&app, task).await, 0);
+    assert_eq!(mounted.offset(&app), offset);
+    let task = app.update(Message::SourceRename(Event::Input(
+        invocation,
+        "pump_long".into(),
+    )));
+    assert_eq!(mounted.execute(&app, task).await, 0);
+    assert_eq!(mounted.offset(&app), offset);
+    let task = app.update(Message::SourceRename(Event::File(
+        invocation, approval, false,
+    )));
+    assert_eq!(
+        mounted.execute(&app, task).await,
+        0,
+        "clamped first-page request is a no-op"
+    );
+    assert_eq!(mounted.offset(&app), offset);
+    assert_eq!(evidence(&app), before);
+}
+
+#[tokio::test]
+async fn delayed_page_and_approval_operations_cannot_reset_a_new_destination() {
+    let mut app = paged_fixture();
+    let before = evidence(&app);
+    let form = app.source_rename.form.as_ref().unwrap();
+    let invocation = form.invocation;
+    let old_approval = form.approval.as_ref().unwrap().id;
+    let mut mounted = Mounted::new(&app);
+    let old_page_task = app.update(Message::SourceRename(Event::File(
+        invocation,
+        old_approval,
+        true,
+    )));
+    let next_page_task = app.update(Message::SourceRename(Event::Line(
+        invocation,
+        old_approval,
+        true,
+    )));
+    assert_eq!(mounted.execute(&app, next_page_task).await, 1);
+    let offset = mounted.scroll_down(&app);
+    assert_eq!(mounted.execute(&app, old_page_task).await, 1);
+    assert_eq!(mounted.offset(&app), offset, "old page target is absent");
+
+    let old_approval_task = app.update(Message::SourceRename(Event::Search(
+        invocation,
+        "defs".into(),
+    )));
+    input(&mut app, "pump_new");
+    let _ = preview(&mut app); // Real new approval in the same invocation/page.
+    assert_ne!(
+        app.source_rename
+            .form
+            .as_ref()
+            .unwrap()
+            .approval
+            .as_ref()
+            .unwrap()
+            .id,
+        old_approval
+    );
+    let offset = mounted.scroll_down(&app);
+    assert_eq!(mounted.execute(&app, old_approval_task).await, 1);
+    assert_eq!(
+        mounted.offset(&app),
+        offset,
+        "old approval target is absent"
+    );
+    let task = app.update(Message::SourceRename(Event::File(
+        invocation,
+        old_approval,
+        true,
+    )));
+    assert_eq!(
+        mounted.execute(&app, task).await,
+        0,
+        "stale envelope is rejected before scheduling"
+    );
+    assert_eq!(mounted.offset(&app), offset);
+    assert_eq!(evidence(&app), before);
+}
+
+#[tokio::test]
+async fn repeated_page_visits_filters_and_fast_preview_completion_have_distinct_destinations() {
+    let mut app = paged_fixture();
+    let before = evidence(&app);
+    let form = app.source_rename.form.as_ref().unwrap();
+    let invocation = form.invocation;
+    let approval = form.approval.as_ref().unwrap().id;
+    let mut mounted = Mounted::new(&app);
+
+    let first_visit = app.update(Message::SourceRename(Event::File(
+        invocation, approval, true,
+    )));
+    let next_page = app.update(Message::SourceRename(Event::Line(
+        invocation, approval, true,
+    )));
+    assert_eq!(mounted.execute(&app, next_page).await, 1);
+    let return_visit = app.update(Message::SourceRename(Event::Line(
+        invocation, approval, false,
+    )));
+    assert_eq!(mounted.execute(&app, return_visit).await, 1);
+    let offset = mounted.scroll_down(&app);
+    assert_eq!(mounted.execute(&app, first_visit).await, 1);
+    assert_eq!(
+        mounted.offset(&app),
+        offset,
+        "old visit to the identical page is stale"
+    );
+
+    let old_filter = app.update(Message::SourceRename(Event::Search(
+        invocation,
+        "uses".into(),
+    )));
+    let new_filter = app.update(Message::SourceRename(Event::Search(
+        invocation,
+        "us".into(),
+    )));
+    assert_eq!(mounted.execute(&app, new_filter).await, 1);
+    let offset = mounted.scroll_down(&app);
+    assert_eq!(mounted.execute(&app, old_filter).await, 1);
+    assert_eq!(
+        mounted.offset(&app),
+        offset,
+        "old filter on the same page is stale"
+    );
+
+    input(&mut app, "pump_new");
+    let job = start_preview(&mut app);
+    let completion = preview_completion(&app, job);
+    // No intermediate frame mounts the temporary no-approval view. The old
+    // Scrollable survives even though the new approval has a different id.
+    let ready = app.update(Message::SourceRenameReady(completion));
+    assert!(mounted.offset(&app) > 10.);
+    assert_eq!(mounted.execute(&app, ready).await, 1);
+    assert_eq!(mounted.offset(&app), 0.);
+    assert_eq!(evidence(&app), before);
+}

crates/oa-desktop/src/app/source_rename_layout_timing_tests.rs

@@ -0,0 +1,313 @@
+//! Manual replacement + next-layout/highlight evaluator; no GPU or native paint.
+//! Child of source_rename_timing_tests, preserving the separate real App test.
+use super::*;
+use crate::{highlight, views::source_tests::FontLayout};
+use iced::advanced::widget::operation::Focusable;
+use iced::advanced::{Layout, graphics, layout, renderer, text as shaped, widget::Tree};
+use iced::{
+    Background, Color, Element, Font, Length, Pixels, Point, Rectangle, Size, Transformation,
+};
+
+// The same real Paragraph and Editor as FontLayout. During draw, retain only a
+// Weak and fixed geometry; inspect glyphs after timing, never in fill_editor.
+#[derive(Default)]
+struct ObservedFontLayout {
+    drawn: Option<(graphics::text::editor::Weak, Point, Rectangle)>,
+}
+impl renderer::Renderer for ObservedFontLayout {
+    fn start_layer(&mut self, _: Rectangle) {}
+    fn end_layer(&mut self) {}
+    fn start_transformation(&mut self, _: Transformation) {}
+    fn end_transformation(&mut self) {}
+    fn reset(&mut self, _: Rectangle) {
+        self.drawn = None;
+    }
+    fn fill_quad(&mut self, _: renderer::Quad, _: impl Into<Background>) {}
+    fn allocate_image(
+        &mut self,
+        handle: &iced::advanced::image::Handle,
+        callback: impl FnOnce(Result<iced::advanced::image::Allocation, iced::advanced::image::Error>)
+        + Send
+        + 'static,
+    ) {
+        renderer::Renderer::allocate_image(&mut FontLayout, handle, callback);
+    }
+}
+impl shaped::Renderer for ObservedFontLayout {
+    type Font = Font;
+    type Paragraph = <FontLayout as shaped::Renderer>::Paragraph;
+    type Editor = <FontLayout as shaped::Renderer>::Editor;
+    const ICON_FONT: Font = <FontLayout as shaped::Renderer>::ICON_FONT;
+    const CHECKMARK_ICON: char = <FontLayout as shaped::Renderer>::CHECKMARK_ICON;
+    const ARROW_DOWN_ICON: char = <FontLayout as shaped::Renderer>::ARROW_DOWN_ICON;
+    const SCROLL_UP_ICON: char = <FontLayout as shaped::Renderer>::SCROLL_UP_ICON;
+    const SCROLL_DOWN_ICON: char = <FontLayout as shaped::Renderer>::SCROLL_DOWN_ICON;
+    const SCROLL_LEFT_ICON: char = <FontLayout as shaped::Renderer>::SCROLL_LEFT_ICON;
+    const SCROLL_RIGHT_ICON: char = <FontLayout as shaped::Renderer>::SCROLL_RIGHT_ICON;
+    const ICED_LOGO: char = <FontLayout as shaped::Renderer>::ICED_LOGO;
+    fn default_font(&self) -> Font {
+        shaped::Renderer::default_font(&FontLayout)
+    }
+    fn default_size(&self) -> Pixels {
+        shaped::Renderer::default_size(&FontLayout)
+    }
+    fn fill_paragraph(&mut self, _: &Self::Paragraph, _: Point, _: Color, _: Rectangle) {}
+    fn fill_editor(&mut self, editor: &Self::Editor, position: Point, _: Color, clip: Rectangle) {
+        self.drawn = Some((editor.downgrade(), position, clip));
+    }
+    fn fill_text(&mut self, _: shaped::Text, _: Point, _: Color, _: Rectangle) {}
+}
+
+type Content = text_editor::Content<ObservedFontLayout>;
+const HOST: Size = Size::new(640., 350.);
+
+fn view(editor: &Content, source: Arc<str>) -> Element<'_, (), iced::Theme, ObservedFontLayout> {
+    text_editor(editor)
+        .on_action(|_| ())
+        .font(Font::MONOSPACE)
+        .size(14)
+        .padding(16)
+        .height(Length::Fill)
+        .highlight_with::<highlight::ArcadiaHighlighter>(source, highlight::format)
+        .into()
+}
+
+fn check_text(editor: &Content, expected: &str, cursor: text_editor::Cursor) {
+    assert_eq!(editor.text(), expected);
+    assert_eq!(editor.cursor(), cursor);
+    let lines: Vec<_> = expected.split('\n').collect();
+    assert_eq!(editor.line_count(), lines.len());
+    for (index, part) in lines.iter().enumerate() {
+        let (text, ending) = if index + 1 == lines.len() {
+            (*part, text_editor::LineEnding::None)
+        } else if let Some(text) = part.strip_suffix('\r') {
+            (text, text_editor::LineEnding::CrLf)
+        } else {
+            (*part, text_editor::LineEnding::Lf)
+        };
+        let actual = editor.line(index).unwrap();
+        assert_eq!(actual.text, text);
+        assert_eq!(actual.ending, ending);
+    }
+}
+
+fn check_draw(renderer: &ObservedFontLayout, cursor: text_editor::Cursor, alias: &str) {
+    let (weak, position, clip) = renderer.drawn.as_ref().expect("real editor draw");
+    let editor = weak.upgrade().expect("drawn editor is still live");
+    let buffer = editor.buffer();
+    assert_eq!(weak.bounds, Size::new(608., 318.));
+    assert_eq!(buffer.size(), (Some(608.), Some(318.)));
+    assert_eq!(buffer.metrics().font_size, 14.);
+    assert_eq!(
+        buffer.scroll().horizontal,
+        0.,
+        "fixture origin fits the viewport"
+    );
+    let start = cursor.position;
+    let end = cursor.selection.expect("approved alias selection");
+    assert_eq!(start.line, end.line);
+    assert_eq!(end.column - start.column, alias.len());
+    let line = &buffer.lines[start.line];
+    assert_eq!(&line.text()[start.column..end.column], alias);
+    let color = graphics::text::to_color(Color::from_rgb8(20, 93, 139));
+    let font = graphics::text::to_attributes(Font::MONOSPACE);
+    for byte in start.column..end.column {
+        let attrs = line.attrs_list().get_span(byte);
+        assert_eq!(
+            attrs.color_opt,
+            Some(color),
+            "accepted alias syntax attributes"
+        );
+        assert_eq!(attrs.family, font.family);
+    }
+    let mut covered = vec![false; alias.len()];
+    for run in buffer.layout_runs().filter(|run| run.line_i == start.line) {
+        for glyph in run.glyphs {
+            let from = glyph.start.max(start.column);
+            let to = glyph.end.min(end.column);
+            if from >= to {
+                continue;
+            }
+            assert_eq!(glyph.color_opt, Some(color), "drawn alias glyph color");
+            let x = position.x + glyph.x + glyph.x_offset * glyph.font_size;
+            let y = position.y + run.line_top;
+            assert!(x >= clip.x - 0.5 && x + glyph.w <= clip.x + clip.width + 0.5);
+            assert!(y + run.line_height > clip.y && y < clip.y + clip.height);
+            covered[from - start.column..to - start.column].fill(true);
+        }
+    }
+    assert!(
+        covered.into_iter().all(|seen| seen),
+        "entire alias has visible shaped glyphs"
+    );
+    // This temporary strong upgrade is dropped before the next editor mutation.
+}
+
+#[derive(Clone, Copy)]
+enum Arm {
+    Constructor,
+    Reuse,
+}
+impl Arm {
+    fn name(self) -> &'static str {
+        match self {
+            Self::Constructor => "with_text",
+            Self::Reuse => "same_line_reuse",
+        }
+    }
+    fn phases(self) -> [&'static str; 4] {
+        match self {
+            Self::Constructor => [
+                "constructor_replace_origin",
+                "constructor_next_layout",
+                "constructor_highlight_draw",
+                "constructor_combined",
+            ],
+            Self::Reuse => [
+                "reuse_replace_origin",
+                "reuse_next_layout",
+                "reuse_highlight_draw",
+                "reuse_combined",
+            ],
+        }
+    }
+}
+
+fn trial(
+    fixture: &Fixture,
+    cursor: text_editor::Cursor,
+    arm: Arm,
+    trial: usize,
+    samples: &mut Samples,
+) {
+    let before = &fixture.bundle.files[ORIGIN];
+    let after = &fixture.expected_bundle.files[ORIGIN];
+    let mut editor = Content::with_text(before);
+    editor.move_to(fixture.cursor);
+    let mut renderer = ObservedFontLayout::default();
+    let theme = iced::Theme::Light;
+    let defaults = renderer::Style::default();
+    let viewport = Rectangle::with_size(HOST);
+    let limits = layout::Limits::new(Size::ZERO, HOST);
+    let mut tree = {
+        let mut widget = view(&editor, Arc::from(before.as_str()));
+        let mut tree = Tree::new(widget.as_widget());
+        let node = widget.as_widget_mut().layout(&mut tree, &renderer, &limits);
+        tree.state
+            .downcast_mut::<text_editor::State<highlight::ArcadiaHighlighter>>()
+            .focus();
+        widget.as_widget().draw(
+            &tree,
+            &mut renderer,
+            &theme,
+            &defaults,
+            Layout::new(&node),
+            iced::mouse::Cursor::Unavailable,
+            &viewport,
+        );
+        tree
+    };
+    check_text(&editor, before, fixture.cursor);
+    check_draw(&renderer, fixture.cursor, OLD);
+    // No recorder Weak/Strong from setup may perturb replacement ownership.
+    renderer.drawn = None;
+    let next_source: Arc<str> = Arc::from(after.as_str());
+
+    // Only normal operations and four timestamps occur between start and end.
+    // Source/model oracles, logging and recorder glyph inspection are outside.
+    let started = Instant::now();
+    let replaced = match arm {
+        Arm::Constructor => {
+            editor = Content::with_text(after);
+            true
+        }
+        Arm::Reuse => super::super::editor_patch::replace(&mut editor, before, after),
+    };
+    editor.move_to(cursor);
+    let replaced_at = Instant::now();
+    let mut widget = view(&editor, next_source);
+    let node = widget.as_widget_mut().layout(&mut tree, &renderer, &limits);
+    let laid_out_at = Instant::now();
+    widget.as_widget().draw(
+        &tree,
+        &mut renderer,
+        &theme,
+        &defaults,
+        Layout::new(&node),
+        iced::mouse::Cursor::Unavailable,
+        &viewport,
+    );
+    let drawn_at = Instant::now();
+    drop(widget);
+
+    assert!(replaced, "reuse must not silently time a fallback/refusal");
+    check_text(&editor, after, cursor);
+    check_draw(&renderer, cursor, NEW);
+    renderer.drawn = None;
+    for (phase, duration) in arm.phases().into_iter().zip([
+        replaced_at.duration_since(started),
+        laid_out_at.duration_since(replaced_at),
+        drawn_at.duration_since(laid_out_at),
+        drawn_at.duration_since(started),
+    ]) {
+        println!(
+            "{}",
+            serde_json::json!({
+                "record": "editor_layout_timing", "arm": arm.name(), "phase": phase,
+                "trial": trial, "warmup": trial == 0,
+                "elapsed_ns": duration.as_nanos().to_string(),
+                "elapsed_ms": duration.as_secs_f64() * 1000.0,
+            })
+        );
+        if trial != 0 {
+            samples.0.entry(phase).or_default().push(duration);
+        }
+    }
+}
+
+#[test]
+#[ignore = "manual Windows dev/debug editor replacement + layout/highlight trial; run alone with --ignored --nocapture --test-threads=1"]
+fn accepted_release1_constructor_vs_reuse_through_next_highlight() {
+    let fixture = Fixture::load();
+    // Resolve the exact production approval and verify full Project/source once,
+    // outside all intervals. The actual App Confirm evaluator remains separate.
+    let cursor = {
+        let app = fixture.app();
+        let target = resolve(&app, &app.rename_context());
+        let prepared = app
+            .document
+            .alias_rename_request(target.id, NEW.into())
+            .unwrap()
+            .prepare()
+            .unwrap();
+        fixture.check_candidate(&prepared);
+        prepare_approval(prepared, &target, ORIGIN).unwrap().cursor
+    };
+    println!(
+        "{}",
+        serde_json::json!({
+            "record": "editor_layout_fixture", "host_width": HOST.width, "host_height": HOST.height,
+            "font": "MONOSPACE", "font_size": 14, "padding": 16, "height": "Fill",
+            "active_file": ORIGIN, "before_bytes": fixture.bundle.files[ORIGIN].len(),
+            "after_bytes": fixture.expected_bundle.files[ORIGIN].len(), "warmups_per_arm": 1,
+            "measured_trials_per_arm": 5, "debug_assertions": cfg!(debug_assertions),
+            "scope": "real editor replacement, retained Tree layout and Widget draw/highlight; no GPU, native paint or App Confirm",
+        })
+    );
+    let mut samples = Samples::default();
+    for index in 0..=5 {
+        let arms = if index % 2 == 0 {
+            [Arm::Constructor, Arm::Reuse]
+        } else {
+            [Arm::Reuse, Arm::Constructor]
+        };
+        println!(
+            "{}",
+            serde_json::json!({"record": "editor_layout_order", "trial": index, "first": arms[0].name()})
+        );
+        for arm in arms {
+            trial(&fixture, cursor, arm, index, &mut samples);
+        }
+    }
+    samples.report();
+}

crates/oa-desktop/src/app/source_rename_timing_tests.rs

@@ -0,0 +1,347 @@
+//! Manual timing through the real Document and App paths. No disk writes,
+//! executor polling, layout, GPU work or first-paint measurement occurs here.
+//! Register as a test child of app::source_rename to use its actual worker helpers.
+use super::*;
+use crate::source_workspace::Workspace;
+use oa_core::source_project::SourceBundle;
+use std::{
+    collections::BTreeMap,
+    path::PathBuf,
+    time::{Duration, Instant},
+};
+
+#[cfg(debug_assertions)]
+#[path = "source_rename_layout_timing_tests.rs"]
+mod layout_timing_tests;
+
+const OLD: &str = "oa_restore_work";
+const NEW: &str = "oa_restore_pressure";
+const DECLARATIONS: &str = "oa/activities/activity_oa_restore_work.arcadia";
+const ORIGIN: &str = "traceability.arcadia";
+
+struct Fixture {
+    bundle: SourceBundle,
+    project: Project,
+    expected_bundle: SourceBundle,
+    expected_project: Project,
+    target: Id,
+    cursor: text_editor::Cursor,
+}
+
+impl Fixture {
+    fn load() -> Self {
+        // The optional entry selects a parent-pinned copy of this exact fixture,
+        // not an arbitrary performance generator or a mutable GUI destination.
+        let entry = std::env::var_os("ARCADIA_RENAME_TIMING_ENTRY")
+            .map(PathBuf::from)
+            .unwrap_or_else(|| {
+                PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+                    .join("../../examples/release1/project.arcadia")
+            });
+        let loaded = oa_core::source_files::load_project(&entry, LIMITS).unwrap();
+        let bundle = loaded.reachable_bundle();
+        assert_eq!(
+            bundle.files.len(),
+            30,
+            "use the preserved release1 walkthrough"
+        );
+        let document = Document::from_bundle(bundle.clone(), LIMITS).unwrap();
+        assert_eq!(
+            document.bundle(),
+            &bundle,
+            "fixture must need no stabilization/migration"
+        );
+        assert!(!document.dirty());
+        let project = document.project().clone();
+        let target = Id::parse_str("1b91f8a7-0bdb-514e-b1cd-955658e09927").unwrap();
+        assert_eq!(project.elements[&target].alias, OLD);
+        assert!(!project.identities().iter().any(|(_, alias)| *alias == NEW));
+        let mut expected_project = project.clone();
+        expected_project.elements.get_mut(&target).unwrap().alias = NEW.into();
+
+        // Independent literal source oracle, authored before running the rename.
+        // Do not replace the alias substring in filenames or the trace's alias.
+        let mut expected_bundle = bundle.clone();
+        let declarations = expected_bundle.files.get_mut(DECLARATIONS).unwrap();
+        assert_eq!(
+            declarations.matches("oa_activity oa_restore_work ").count(),
+            1
+        );
+        assert_eq!(declarations.matches("parent @oa_restore_work;").count(), 4);
+        *declarations = declarations
+            .replace(
+                "oa_activity oa_restore_work ",
+                "oa_activity oa_restore_pressure ",
+            )
+            .replace("parent @oa_restore_work;", "parent @oa_restore_pressure;");
+        let traces = expected_bundle.files.get_mut(ORIGIN).unwrap();
+        assert_eq!(traces.matches("oa @oa_restore_work;").count(), 1);
+        *traces = traces.replace("oa @oa_restore_work;", "oa @oa_restore_pressure;");
+        let source = &bundle.files[ORIGIN];
+        let start = source.rfind("@oa_restore_work;").unwrap() + 1;
+        let position = |offset| {
+            let prefix = &source[..offset];
+            text_editor::Position {
+                line: prefix.bytes().filter(|byte| *byte == b'\n').count(),
+                column: prefix
+                    .rsplit_once('\n')
+                    .map_or(prefix.len(), |(_, tail)| tail.len()),
+            }
+        };
+        let cursor = text_editor::Cursor {
+            position: position(start),
+            selection: Some(position(start + OLD.len())),
+        };
+        assert!(nav::exact_cursor(source, cursor));
+        println!(
+            "{}",
+            serde_json::json!({
+                "record": "fixture", "entry": entry, "reachable_files": bundle.files.len(),
+                "source_bytes": bundle.files.values().map(String::len).sum::<usize>(),
+                "identities": project.identities().len(), "active_file": ORIGIN,
+                "active_file_bytes": source.len(), "old": OLD, "new": NEW,
+                "warmups": 1, "measured_trials": 5, "debug_assertions": cfg!(debug_assertions),
+                "scope": "real worker helpers, guarded Document commit, App sync and Confirm update; no task polling or rendering"
+            })
+        );
+        Self {
+            bundle,
+            project,
+            expected_bundle,
+            expected_project,
+            target,
+            cursor,
+        }
+    }
+
+    fn app(&self) -> App {
+        let mut app = App::with_project(Project::empty());
+        app.document = Document::from_bundle(self.bundle.clone(), LIMITS).unwrap();
+        app.source_workspace = Workspace::new(app.document.bundle(), true);
+        app.source_workspace.active = ORIGIN.into();
+        app.selected = app.project().id;
+        app.page = Page::Text;
+        app.sync();
+        app.source_editor.move_to(self.cursor);
+        assert_eq!(app.project(), &self.project);
+        assert_eq!(app.document.bundle(), &self.bundle);
+        assert_eq!(app.document.revision(), 0);
+        assert!(!app.document.dirty() && !app.document.can_undo() && !app.document.can_redo());
+        assert!(app.rename_admission().is_ok());
+        app
+    }
+
+    fn check_candidate(&self, prepared: &PreparedAliasRename) {
+        assert!(prepared.changed());
+        assert_eq!(prepared.before().bundle, self.bundle);
+        assert_eq!(prepared.before().decoded.project, self.project);
+        assert_eq!(prepared.after().bundle, self.expected_bundle);
+        assert_eq!(prepared.after().decoded.project, self.expected_project);
+    }
+
+    fn check_adopted(&self, app: &mut App, candidate_address: *const CompiledSourceProject) {
+        assert!(
+            std::ptr::eq(app.document.compiled(), candidate_address),
+            "adopt exact candidate allocation"
+        );
+        assert_eq!(app.project(), &self.expected_project);
+        assert_eq!(app.document.bundle(), &self.expected_bundle);
+        assert_eq!(app.source_workspace.bundle(), self.expected_bundle);
+        assert_eq!(app.source_editor.text(), self.expected_bundle.files[ORIGIN]);
+        assert_eq!(app.document.revision(), 1);
+        assert!(app.document.dirty() && app.document.can_undo() && !app.document.can_redo());
+        assert!(app.document.undo());
+        assert_eq!(app.project(), &self.project);
+        assert_eq!(app.document.bundle(), &self.bundle);
+        assert!(
+            !app.document.dirty(),
+            "live known saved baseline remains authoritative"
+        );
+        assert!(
+            !app.document.can_undo(),
+            "exactly one preceding model transaction"
+        );
+        assert!(app.document.redo());
+        assert_eq!(app.project(), &self.expected_project);
+        assert_eq!(app.document.bundle(), &self.expected_bundle);
+        assert!(std::ptr::eq(app.document.compiled(), candidate_address));
+    }
+}
+
+#[derive(Default)]
+struct Samples(BTreeMap<&'static str, Vec<Duration>>);
+
+impl Samples {
+    fn time<T>(&mut self, phase: &'static str, trial: usize, action: impl FnOnce() -> T) -> T {
+        let started = Instant::now();
+        let result = action();
+        let elapsed = started.elapsed();
+        // Printing, assertions and dropping the returned value are outside this
+        // interval. Full Confirm still includes production's own local drops.
+        println!(
+            "{}",
+            serde_json::json!({
+                "record": "timing", "phase": phase, "trial": trial,
+                "warmup": trial == 0, "elapsed_ns": elapsed.as_nanos().to_string(),
+                "elapsed_ms": elapsed.as_secs_f64() * 1000.0
+            })
+        );
+        if trial != 0 {
+            self.0.entry(phase).or_default().push(elapsed);
+        }
+        result
+    }
+
+    fn report(mut self) {
+        for (phase, values) in &mut self.0 {
+            assert_eq!(values.len(), 5);
+            values.sort();
+            println!(
+                "{}",
+                serde_json::json!({
+                    "record": "summary", "phase": phase, "samples": values.len(),
+                    "min_ms": values[0].as_secs_f64() * 1000.0,
+                    "median_ms": values[2].as_secs_f64() * 1000.0,
+                    "max_ms": values[4].as_secs_f64() * 1000.0
+                })
+            );
+        }
+    }
+}
+
+fn resolve(app: &App, context: &Context) -> Target {
+    let snapshot = app
+        .with_source_input(|input| query::admit_owned(input, query::Limits::default()))
+        .unwrap()
+        .capture()
+        .unwrap();
+    let offset = nav::cursor_offset(app.source_workspace.text(), context.begin.cursor).unwrap();
+    resolve_target(&snapshot, context, offset).unwrap()
+}
+
+fn active_job(app: &App) -> Job {
+    let form = app.source_rename.form.as_ref().unwrap();
+    let id = form.pending.unwrap();
+    assert_eq!(app.source_rename.in_flight, Some(id));
+    Job {
+        id,
+        invocation: form.invocation,
+        generation: form.generation,
+        context: form.context.clone(),
+    }
+}
+
+fn separate_phases(fixture: &Fixture, samples: &mut Samples, trial: usize) {
+    let mut app = fixture.app();
+    let target = resolve(&app, &app.rename_context());
+    assert_eq!(target.id, fixture.target);
+    let request = samples
+        .time("document_request_mint", trial, || {
+            app.document.alias_rename_request(target.id, NEW.into())
+        })
+        .unwrap();
+    let prepared = samples
+        .time("worker_document_prepare", trial, || request.prepare())
+        .unwrap();
+    fixture.check_candidate(&prepared);
+    let approval = samples
+        .time("worker_preview_and_origin", trial, || {
+            prepare_approval(prepared, &target, ORIGIN)
+        })
+        .unwrap();
+    assert_eq!(approval.preview.files().len(), 2);
+    assert_eq!(approval.preview.changed_line_count(), 6);
+    let candidate_address = approval.prepared.after() as *const CompiledSourceProject;
+    // Same-destination save completion is a legitimate live update after Preview.
+    app.document.mark_saved(app.document.snapshot());
+    let changed = samples
+        .time("document_guarded_commit", trial, || {
+            app.document.commit_alias_rename(&approval.prepared)
+        })
+        .unwrap();
+    assert!(changed);
+    samples.time("app_sync", trial, || app.sync());
+    fixture.check_adopted(&mut app, candidate_address);
+}
+
+fn whole_confirm(fixture: &Fixture, samples: &mut Samples, trial: usize) {
+    let mut app = fixture.app();
+    let begin = app.source_rename_message();
+    // These Tasks are deliberately not polled: deterministic worker helpers
+    // supply the same results through the real readiness messages below.
+    drop(app.update(begin));
+    let target_job = active_job(&app);
+    let target = Arc::new(resolve(&app, &target_job.context));
+    assert_eq!(target.id, fixture.target);
+    drop(app.update(Message::SourceRenameReady(Completion {
+        job: target_job,
+        payload: Payload::Target(Ok(target.clone())),
+    })));
+    let invocation = app.source_rename.form.as_ref().unwrap().invocation;
+    drop(app.update(Message::SourceRename(Event::Input(invocation, NEW.into()))));
+    let generation = app.source_rename.form.as_ref().unwrap().generation;
+    drop(app.update(Message::SourceRename(Event::Preview(
+        invocation, generation,
+    ))));
+    let preview_job = active_job(&app);
+    let prepared = app
+        .document
+        .alias_rename_request(target.id, NEW.into())
+        .unwrap()
+        .prepare()
+        .unwrap();
+    fixture.check_candidate(&prepared);
+    let approval = Arc::new(prepare_approval(prepared, &target, ORIGIN).unwrap());
+    drop(target);
+    let candidate_address = approval.prepared.after() as *const CompiledSourceProject;
+    let expected_cursor = approval.cursor;
+    let approval_id = approval.id;
+    drop(app.update(Message::SourceRenameReady(Completion {
+        job: preview_job,
+        payload: Payload::Preview(Ok(approval)),
+    })));
+    assert_eq!(
+        app.source_rename
+            .form
+            .as_ref()
+            .unwrap()
+            .approval
+            .as_ref()
+            .unwrap()
+            .id,
+        approval_id
+    );
+    app.document.mark_saved(app.document.snapshot());
+    let confirm = Message::SourceRename(Event::Confirm(invocation, generation, approval_id));
+    let task = samples.time("app_confirm_update", trial, || app.update(confirm));
+    samples.time("confirm_returned_task_drop_without_polling", trial, || {
+        drop(task)
+    });
+    assert!(!app.source_rename.open());
+    assert!(app.source_rename.in_flight.is_none());
+    assert!(app.source_rename_undo_message().is_some());
+    assert_eq!(app.source_editor.cursor(), expected_cursor);
+    fixture.check_adopted(&mut app, candidate_address);
+}
+
+#[test]
+#[ignore = "manual Windows dev/debug rename latency trial; run alone with --ignored --nocapture --test-threads=1"]
+fn accepted_release1_prepare_commit_sync_and_confirm_timing() {
+    let fixture = Fixture::load();
+    let mut samples = Samples::default();
+    for trial in 0..=5 {
+        println!(
+            "{}",
+            serde_json::json!({ "record": "order", "trial": trial,
+            "warmup": trial == 0, "separate_phases_first": trial % 2 == 0 })
+        );
+        if trial % 2 == 0 {
+            separate_phases(&fixture, &mut samples, trial);
+            whole_confirm(&fixture, &mut samples, trial);
+        } else {
+            whole_confirm(&fixture, &mut samples, trial);
+            separate_phases(&fixture, &mut samples, trial);
+        }
+    }
+    samples.report();
+}

crates/oa-desktop/src/app/source_symbols.rs

@@ -52,7 +52,7 @@ impl App {
         }
     }
 
-    fn with_source_input<T>(&self, use_input: impl FnOnce(query::Input<'_>) -> T) -> T {
+    pub(super) fn with_source_input<T>(&self, use_input: impl FnOnce(query::Input<'_>) -> T) -> T {
         let files: Vec<_> = self
             .source_workspace
             .files
@@ -83,13 +83,14 @@ impl App {
         })
     }
 
-    fn source_snapshot_matches(&self, snapshot: &query::Snapshot) -> bool {
+    pub(super) fn source_snapshot_matches(&self, snapshot: &query::Snapshot) -> bool {
         snapshot.key() == self.source_key()
             && self.with_source_input(|input| snapshot.matches(input))
     }
 
     pub fn source_navigation_available(&self) -> bool {
         self.page == Page::Text
+            && !self.source_rename.open()
             && !self.busy
             && self.pending.is_none()
             && self.file_prompt.is_none()

crates/oa-desktop/src/document.rs

@@ -10,6 +10,10 @@ use std::{fmt, sync::Arc};
 const HISTORY_LIMIT: usize = 100;
 const HISTORY_BYTES: usize = 32 * 1024 * 1024;
 
+#[path = "document_alias_rename.rs"]
+mod alias_rename;
+pub use alias_rename::PreparedAliasRename;
+
 struct HistoryEntry {
     snapshot: Arc<CompiledSourceProject>,
     bytes: usize,
@@ -91,6 +95,8 @@ impl From<Vec<SourceDiagnostic>> for DocumentError {
 }
 
 pub struct Document {
+    // Distinguishes equal accepted snapshots belonging to different documents.
+    alias_owner: Arc<()>,
     current: Arc<CompiledSourceProject>,
     past: Vec<HistoryEntry>,
     future: Vec<HistoryEntry>,
@@ -121,6 +127,7 @@ impl Document {
         let current = Arc::new(source_project::compile_bundle(&bundle, limits)?);
         let current_bytes = estimated_bytes(&current);
         Ok(Self {
+            alias_owner: Arc::new(()),
             current,
             current_bytes,
             past: Vec::new(),
@@ -394,8 +401,17 @@ impl Document {
             return false;
         }
         let bytes = estimated_bytes(&compiled);
+        self.commit_snapshot(Arc::new(compiled), bytes)
+    }
+
+    // Only validated internal paths supply a changed snapshot and its exact
+    // estimate. The ordinary commit wrapper checks bundle inequality; the alias
+    // path checks its private changed flag and exact accepted-snapshot authority.
+    // Alias preparation shares this algorithm while retaining the live save and
+    // history state, and does not clone/recompile the candidate on adoption.
+    fn commit_snapshot(&mut self, compiled: Arc<CompiledSourceProject>, bytes: usize) -> bool {
         self.past.push(HistoryEntry {
-            snapshot: std::mem::replace(&mut self.current, Arc::new(compiled)),
+            snapshot: std::mem::replace(&mut self.current, compiled),
             bytes: std::mem::replace(&mut self.current_bytes, bytes),
         });
         self.future.clear();

crates/oa-desktop/src/document_alias_rename.rs

@@ -0,0 +1,233 @@
+//! Alias-only worker preparation and guarded adoption. Public compiled DTOs do
+//! not authorize adoption; only this module can mint a prepared rename.
+use super::*;
+use std::collections::BTreeMap;
+
+/// A pinned intent minted by its owning Document. Move it to a worker and call
+/// `prepare`; preparation has no access to the live Document or its histories.
+#[derive(Debug)]
+pub struct AliasRenameRequest {
+    owner: Arc<()>,
+    before: Arc<CompiledSourceProject>,
+    revision: u64,
+    limits: ProjectLimits,
+    target: Id,
+    old_alias: String,
+    new_alias: String,
+}
+
+#[derive(Debug)]
+struct PreparedData {
+    request: AliasRenameRequest,
+    after: Arc<CompiledSourceProject>,
+    before_bytes: usize,
+    after_bytes: usize,
+    changed: bool,
+}
+
+/// Immutable, Clone-compatible transport for preview and approval. Neither
+/// mutable candidate access nor deserialization can manufacture this authority.
+#[derive(Debug, Clone)]
+pub struct PreparedAliasRename(Arc<PreparedData>);
+
+impl PreparedAliasRename {
+    pub fn before(&self) -> &CompiledSourceProject {
+        &self.0.request.before
+    }
+
+    pub fn after(&self) -> &CompiledSourceProject {
+        &self.0.after
+    }
+
+    pub fn target(&self) -> Id {
+        self.0.request.target
+    }
+
+    pub fn old_alias(&self) -> &str {
+        &self.0.request.old_alias
+    }
+
+    pub fn new_alias(&self) -> &str {
+        &self.0.request.new_alias
+    }
+
+    pub fn revision(&self) -> u64 {
+        self.0.request.revision
+    }
+
+    pub fn changed(&self) -> bool {
+        self.0.changed
+    }
+}
+
+fn refusal(message: &str) -> DocumentError {
+    ModelError(message.into()).into()
+}
+
+fn check_history_capacity(before_bytes: usize, after_bytes: usize) -> Result<(), DocumentError> {
+    if before_bytes.saturating_add(after_bytes) > HISTORY_BYTES {
+        return Err(refusal(
+            "This rename exceeds the model Undo budget. No rename was applied.",
+        ));
+    }
+    Ok(())
+}
+
+impl Document {
+    pub fn alias_rename_request(
+        &self,
+        target: Id,
+        replacement: String,
+    ) -> Result<AliasRenameRequest, DocumentError> {
+        if self.revision == u64::MAX {
+            return Err(refusal(
+                "The document revision is exhausted. Reopen before renaming.",
+            ));
+        }
+        let old_alias = self
+            .project()
+            .identities()
+            .into_iter()
+            .find_map(|(id, alias)| (id == target).then(|| alias.to_owned()))
+            .ok_or_else(|| refusal("The alias target is no longer present."))?;
+        // A candidate has a nonzero estimate. Avoid expensive preparation when
+        // even the current snapshot leaves no room for its immediate Undo.
+        if old_alias != replacement && self.current_bytes >= HISTORY_BYTES {
+            return Err(refusal(
+                "This rename exceeds the model Undo budget. No rename was applied.",
+            ));
+        }
+        Ok(AliasRenameRequest {
+            owner: self.alias_owner.clone(),
+            before: self.current.clone(),
+            revision: self.revision,
+            limits: self.limits,
+            target,
+            old_alias,
+            new_alias: replacement,
+        })
+    }
+
+    /// App must separately consume its current approval and check workspace,
+    /// invocation and draft freshness. This checks accepted Document authority.
+    pub fn commit_alias_rename(
+        &mut self,
+        prepared: &PreparedAliasRename,
+    ) -> Result<bool, DocumentError> {
+        let data = &prepared.0;
+        let request = &data.request;
+        if self.revision == u64::MAX
+            || self.revision != request.revision
+            || !Arc::ptr_eq(&self.alias_owner, &request.owner)
+            || !Arc::ptr_eq(&self.current, &request.before)
+        {
+            return Err(refusal(
+                "This rename preview is stale. Preview the current alias again.",
+            ));
+        }
+        if !data.changed {
+            return Ok(false);
+        }
+        if self.current_bytes != data.before_bytes {
+            return Err(refusal(
+                "The rename history estimate is stale. Preview again.",
+            ));
+        }
+        check_history_capacity(self.current_bytes, data.after_bytes)?;
+        Ok(self.commit_snapshot(data.after.clone(), data.after_bytes))
+    }
+}
+
+impl AliasRenameRequest {
+    /// Run on the preparation worker. The typed command and source updater are
+    /// the only candidate construction path, followed by alias-only invariants.
+    pub fn prepare(self) -> Result<PreparedAliasRename, DocumentError> {
+        let before_project = &self.before.decoded.project;
+        let candidate = prepare_command(
+            before_project,
+            &Command::SetAlias(self.target, self.new_alias.clone()),
+        )?;
+        let mut expected = before_project.clone();
+        assign_expected_alias(&mut expected, self.target, &self.new_alias)?;
+        let identities: BTreeMap<_, _> = before_project
+            .identities()
+            .into_iter()
+            .map(|(id, _)| (id, id))
+            .collect();
+        if candidate.project != expected || candidate.identity_map != identities {
+            return Err(refusal(
+                "Alias preparation changed unrelated model data or identities.",
+            ));
+        }
+        let after = source_project::update_bundle_with_identity_map(
+            &self.before,
+            &candidate.project,
+            &candidate.identity_map,
+            self.limits,
+        )?;
+        let before = &self.before;
+        if after.decoded.project != expected
+            || before.bundle.entry != after.bundle.entry
+            || !before.bundle.files.keys().eq(after.bundle.files.keys())
+            || before.index.lexical_owners != after.index.lexical_owners
+            || !before
+                .index
+                .declarations
+                .iter()
+                .map(|(id, loc)| (id, &loc.path))
+                .eq(after
+                    .index
+                    .declarations
+                    .iter()
+                    .map(|(id, loc)| (id, &loc.path)))
+        {
+            return Err(refusal(
+                "Alias preparation changed source membership or ownership.",
+            ));
+        }
+        let changed = before.bundle != after.bundle;
+        let before_bytes = estimated_bytes(before);
+        let after_bytes = estimated_bytes(&after);
+        if changed {
+            check_history_capacity(before_bytes, after_bytes)?;
+        }
+        Ok(PreparedAliasRename(Arc::new(PreparedData {
+            request: self,
+            after: Arc::new(after),
+            before_bytes,
+            after_bytes,
+            changed,
+        })))
+    }
+}
+
+// Independent full-model expectation: SetAlias may change exactly one header
+// field, across every supported identity family. Do not reuse command execution
+// to derive the expected result, which would hide collateral command changes.
+fn assign_expected_alias(project: &mut Project, id: Id, alias: &str) -> Result<(), DocumentError> {
+    if project.id == id {
+        project.alias = alias.to_owned();
+    } else if let Some(record) = project.elements.get_mut(&id) {
+        record.alias = alias.to_owned();
+    } else if let Some(record) = project.relations.get_mut(&id) {
+        record.alias = alias.to_owned();
+    } else if let Some(record) = project.diagrams.get_mut(&id) {
+        record.alias = alias.to_owned();
+    } else if let Some(record) = project.artifact_links.get_mut(&id) {
+        record.alias = alias.to_owned();
+    } else if let Some(record) = project.traces.get_mut(&id) {
+        record.alias = alias.to_owned();
+    } else {
+        project
+            .diagrams
+            .values_mut()
+            .find_map(|diagram| diagram.nodes.get_mut(&id))
+            .ok_or_else(|| refusal("The alias target is no longer present."))?
+            .alias = alias.to_owned();
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+#[path = "document_alias_rename_tests.rs"]
+mod tests;

crates/oa-desktop/src/document_alias_rename_tests.rs

@@ -0,0 +1,459 @@
+use super::*;
+
+fn fixture() -> Document {
+    let bundle = SourceBundle {
+        entry: "project.arcadia".into(),
+        files: BTreeMap::from([
+            ("project.arcadia".into(), r#"arcadia 7;
+project mission "Испытание" id "10000000-0000-4000-8000-000000000001" {
+ include "work.arcadia"; include "views.arcadia";
+}
+"#.replace('\n', "\r\n")),
+            ("work.arcadia".into(), r#"// @assess and assess are explanatory prose.
+oa_activity assess "Оценка\u0020ущерба" id "10000000-0000-4000-8000-000000000002" { description "Keep @assess and assess"; }
+oa_activity assist "Оценка\u0020ущерба" id "10000000-0000-4000-8000-000000000003" { parent @ // owner evidence
+ assess; }
+sa_function service "Service" id "10000000-0000-4000-8000-000000000004" {}
+interaction transfer "Transfer" id "10000000-0000-4000-8000-000000000005" { source @assess; target @assist; }
+trace review "Reviewed correspondence" id "10000000-0000-4000-8000-000000000006" { oa @assess; sa @service; kind Refinement; baseline { oa { name "Old assess"; description "@assess"; }; sa { name "Old service"; description "Kept"; }; }; }
+artifact evidence "Evidence" id "10000000-0000-4000-8000-000000000007" { owner @review; uri "docs/assess.md"; }
+"#.replace('\n', "\r\n")),
+            ("views.arcadia".into(), r#"diagram overview "Overview" id "10000000-0000-4000-8000-000000000008" { layer Oa; routes [{ edge @ // routed identity
+ transfer; waypoints [{ x 4.20e2; y -16; }]; }]; }
+node placement id "10000000-0000-4000-8000-000000000009" { diagram @overview; element @assess; position { x -0.0; y 12.375; }; size { width 260; height 94; }; }
+"#.replace('\n', "\r\n")),
+        ]),
+    };
+    let document = Document::from_bundle(bundle.clone(), ProjectLimits::default()).unwrap();
+    assert_eq!(
+        document.bundle(),
+        &bundle,
+        "fixture must need no migration or ID insertion"
+    );
+    document
+}
+
+fn id(number: u8) -> Id {
+    Id::parse_str(&format!("10000000-0000-4000-8000-{number:012}")).unwrap()
+}
+
+fn prepare(document: &Document, target: Id, replacement: &str) -> PreparedAliasRename {
+    document
+        .alias_rename_request(target, replacement.into())
+        .unwrap()
+        .prepare()
+        .unwrap()
+}
+
+// Capture every live Document state relevant to refusal/no-op. Arc identity also
+// catches replacing an equal snapshot or saved marker behind the user's back.
+struct Unchanged {
+    current: Arc<CompiledSourceProject>,
+    saved: Option<Arc<SourceBundle>>,
+    past: Vec<(Arc<CompiledSourceProject>, usize)>,
+    future: Vec<(Arc<CompiledSourceProject>, usize)>,
+    revision: u64,
+    current_bytes: usize,
+    recovered: bool,
+}
+
+impl Unchanged {
+    fn capture(document: &Document) -> Self {
+        Self {
+            current: document.snapshot(),
+            saved: document.saved.clone(),
+            past: document
+                .past
+                .iter()
+                .map(|h| (h.snapshot.clone(), h.bytes))
+                .collect(),
+            future: document
+                .future
+                .iter()
+                .map(|h| (h.snapshot.clone(), h.bytes))
+                .collect(),
+            revision: document.revision,
+            current_bytes: document.current_bytes,
+            recovered: document.recovered_unsaved,
+        }
+    }
+
+    fn assert(&self, document: &Document) {
+        assert!(Arc::ptr_eq(&self.current, &document.current));
+        match (&self.saved, &document.saved) {
+            (Some(before), Some(after)) => assert!(Arc::ptr_eq(before, after)),
+            (None, None) => {}
+            _ => panic!("saved baseline changed"),
+        }
+        for (before, after) in [
+            (&self.past, &document.past),
+            (&self.future, &document.future),
+        ] {
+            assert_eq!(before.len(), after.len());
+            for ((snapshot, bytes), entry) in before.iter().zip(after) {
+                assert!(Arc::ptr_eq(snapshot, &entry.snapshot));
+                assert_eq!(*bytes, entry.bytes);
+            }
+        }
+        assert_eq!(self.revision, document.revision);
+        assert_eq!(self.current_bytes, document.current_bytes);
+        assert_eq!(self.recovered, document.recovered_unsaved);
+    }
+}
+
+#[test]
+fn each_identity_family_changes_only_authored_alias_roles_and_one_history_entry() {
+    // Literal role-specific replacements are independent of the updater/tokenizer.
+    // They deliberately exclude prose, historical review text and URI spelling.
+    type AliasCase<'a> = (u8, &'a str, &'a str, &'a [(&'a str, &'a str)]);
+    let cases: &[AliasCase<'_>] = &[
+        (
+            1,
+            "mission",
+            "renamed",
+            &[("project mission ", "project renamed ")],
+        ),
+        (
+            2,
+            "assess",
+            "renamed",
+            &[
+                ("oa_activity assess ", "oa_activity renamed "),
+                ("\r\n assess;", "\r\n renamed;"),
+                ("@assess;", "@renamed;"),
+            ],
+        ),
+        (
+            5,
+            "transfer",
+            "renamed",
+            &[
+                ("interaction transfer ", "interaction renamed "),
+                ("\r\n transfer;", "\r\n renamed;"),
+            ],
+        ),
+        (
+            6,
+            "review",
+            "renamed",
+            &[
+                ("trace review ", "trace renamed "),
+                ("owner @review;", "owner @renamed;"),
+            ],
+        ),
+        (
+            7,
+            "evidence",
+            "renamed",
+            &[("artifact evidence ", "artifact renamed ")],
+        ),
+        (
+            8,
+            "overview",
+            "renamed",
+            &[
+                ("diagram overview ", "diagram renamed "),
+                ("diagram @overview;", "diagram @renamed;"),
+            ],
+        ),
+        (
+            9,
+            "placement",
+            "renamed",
+            &[("node placement ", "node renamed ")],
+        ),
+    ];
+    for &(number, old, new, replacements) in cases {
+        let mut document = fixture();
+        let original = document.snapshot();
+        let mut expected_model = document.project().clone();
+        // Explicit per-family oracle, separate from production expectation helper.
+        match number {
+            1 => expected_model.alias = new.into(),
+            2 => expected_model.elements.get_mut(&id(2)).unwrap().alias = new.into(),
+            5 => expected_model.relations.get_mut(&id(5)).unwrap().alias = new.into(),
+            6 => expected_model.traces.get_mut(&id(6)).unwrap().alias = new.into(),
+            7 => expected_model.artifact_links.get_mut(&id(7)).unwrap().alias = new.into(),
+            8 => expected_model.diagrams.get_mut(&id(8)).unwrap().alias = new.into(),
+            9 => {
+                expected_model
+                    .diagrams
+                    .get_mut(&id(8))
+                    .unwrap()
+                    .nodes
+                    .get_mut(&id(9))
+                    .unwrap()
+                    .alias = new.into()
+            }
+            _ => unreachable!(),
+        }
+        let mut expected_bundle = document.bundle().clone();
+        for source in expected_bundle.files.values_mut() {
+            for &(before, after) in replacements {
+                *source = source.replace(before, after);
+            }
+        }
+        let state = Unchanged::capture(&document);
+        let prepared = prepare(&document, id(number), new);
+        state.assert(&document);
+        assert!(prepared.changed());
+        assert_eq!(prepared.old_alias(), old);
+        assert_eq!(prepared.new_alias(), new);
+        assert_eq!(prepared.target(), id(number));
+        assert_eq!(prepared.revision(), 0);
+        assert_eq!(prepared.before().bundle, original.bundle);
+        assert_eq!(prepared.after().bundle, expected_bundle);
+        assert_eq!(prepared.after().decoded.project, expected_model);
+        assert!(document.commit_alias_rename(&prepared).unwrap());
+        assert!(
+            Arc::ptr_eq(&document.current, &prepared.0.after),
+            "adopt the exact prepared Arc"
+        );
+        assert_eq!(document.past.len(), 1);
+        assert!(document.dirty());
+        let after = Unchanged::capture(&document);
+        assert!(document.commit_alias_rename(&prepared.clone()).is_err());
+        after.assert(&document);
+        assert!(document.undo());
+        assert!(Arc::ptr_eq(&document.current, &original));
+        assert!(!document.dirty());
+        assert!(!document.can_undo());
+        assert!(document.redo());
+        assert_eq!(document.bundle(), &expected_bundle);
+        assert_eq!(document.project(), &expected_model);
+        document.mark_saved(document.snapshot());
+        let reopened =
+            Document::from_bundle(document.bundle().clone(), ProjectLimits::default()).unwrap();
+        assert_eq!(reopened.project(), &expected_model);
+        assert_eq!(reopened.bundle(), &expected_bundle);
+        assert!(!reopened.dirty());
+    }
+}
+
+#[test]
+fn highlighted_keyword_alias_is_valid_without_normalizing_input() {
+    assert!(matches!(
+        language::tokenize("oa_activity")[0].class,
+        language::TokenClass::Keyword
+    ));
+    let mut document = fixture();
+    let prepared = prepare(&document, id(2), "oa_activity");
+    document.commit_alias_rename(&prepared).unwrap();
+    assert_eq!(document.project().elements[&id(2)].alias, "oa_activity");
+    assert_eq!(document.project().elements[&id(2)].name, "Оценка ущерба");
+}
+
+#[test]
+fn invalid_and_identical_aliases_preserve_live_state_and_redo() {
+    let mut document = fixture();
+    let first = prepare(&document, id(2), "changed");
+    document.commit_alias_rename(&first).unwrap();
+    assert!(document.undo());
+    document.invalidate_saved_baseline();
+    document.mark_recovered();
+    let state = Unchanged::capture(&document);
+    for replacement in ["", "has space", "project", "assist", " assess", "assess "] {
+        assert!(
+            document
+                .alias_rename_request(id(2), replacement.into())
+                .unwrap()
+                .prepare()
+                .is_err()
+        );
+        state.assert(&document);
+    }
+    assert!(
+        document
+            .alias_rename_request(Id::nil(), "new".into())
+            .is_err()
+    );
+    let no_op = prepare(&document, id(2), "assess");
+    assert!(!no_op.changed());
+    assert!(!document.commit_alias_rename(&no_op).unwrap());
+    state.assert(&document);
+    assert!(document.redo());
+    assert_eq!(document.project().elements[&id(2)].alias, "changed");
+}
+
+#[test]
+fn equal_bytes_undo_replay_cross_document_and_exhausted_revision_refuse() {
+    let mut document = fixture();
+    let old = prepare(&document, id(2), "renamed");
+    let mut second = fixture();
+    let second_state = Unchanged::capture(&second);
+    assert!(second.commit_alias_rename(&old).is_err());
+    second_state.assert(&second);
+    // Even an identical shared accepted Arc cannot confer this Document's owner.
+    second.current = document.current.clone();
+    let second_state = Unchanged::capture(&second);
+    assert!(second.commit_alias_rename(&old).is_err());
+    second_state.assert(&second);
+    document
+        .execute(Command::Rename(id(2), "Later name".into()))
+        .unwrap();
+    let edited = Unchanged::capture(&document);
+    assert!(document.commit_alias_rename(&old).is_err());
+    edited.assert(&document);
+    assert!(document.undo());
+    assert!(Arc::ptr_eq(&document.current, &old.0.request.before));
+    let undone = Unchanged::capture(&document);
+    assert!(document.commit_alias_rename(&old).is_err());
+    undone.assert(&document);
+    document.revision = u64::MAX - 1;
+    let last = prepare(&document, id(2), "renamed");
+    document
+        .execute(Command::Rename(id(2), "Exhaust revision".into()))
+        .unwrap();
+    document.undo();
+    assert!(Arc::ptr_eq(&document.current, &last.0.request.before));
+    let exhausted = Unchanged::capture(&document);
+    assert!(document.commit_alias_rename(&last).is_err());
+    assert!(
+        document
+            .alias_rename_request(id(2), "renamed".into())
+            .is_err()
+    );
+    assert!(
+        document
+            .alias_rename_request(id(2), "assess".into())
+            .is_err()
+    );
+    exhausted.assert(&document);
+}
+
+#[test]
+fn preview_retains_latest_saved_baseline_and_recovery_state() {
+    for baseline in ["saved_before", "unknown", "raw_repair", "recovered"] {
+        let mut document = fixture();
+        let prepared = prepare(&document, id(2), "renamed");
+        let original = document.snapshot();
+        match baseline {
+            "saved_before" => document.mark_saved(original.clone()),
+            "unknown" => document.invalidate_saved_baseline(),
+            "raw_repair" => {
+                let mut raw = document.bundle().clone();
+                raw.files
+                    .insert("project.arcadia".into(), "invalid repair source".into());
+                document.bind_repair_baseline(raw);
+            }
+            "recovered" => document.mark_recovered(),
+            _ => unreachable!(),
+        }
+        let saved = document.saved.clone();
+        let recovered = document.recovered_unsaved;
+        assert!(document.commit_alias_rename(&prepared).unwrap());
+        assert_eq!(document.saved, saved);
+        assert_eq!(document.recovered_unsaved, recovered);
+        assert!(document.dirty());
+        assert!(document.undo());
+        assert_eq!(document.saved, saved);
+        assert_eq!(document.recovered_unsaved, recovered);
+        assert_eq!(document.dirty(), baseline != "saved_before");
+    }
+    // A completed save after Preview remains authoritative, including when it
+    // clears recovery; a worker must not restore its earlier state on Confirm.
+    let mut document = fixture();
+    document.mark_recovered();
+    document.invalidate_saved_baseline();
+    let prepared = prepare(&document, id(2), "renamed");
+    document.mark_saved(document.snapshot());
+    document.commit_alias_rename(&prepared).unwrap();
+    assert!(!document.recovered_unsaved);
+    document.undo();
+    assert!(!document.dirty());
+    // Undo from saved C to B, then a new B->C rename can correctly finish clean.
+    document.redo();
+    document.mark_saved(document.snapshot());
+    document.undo();
+    let return_to_saved = prepare(&document, id(2), "renamed");
+    document.commit_alias_rename(&return_to_saved).unwrap();
+    assert!(!document.dirty());
+    assert!(!document.can_redo());
+}
+
+#[test]
+fn mutable_public_preview_copies_cannot_change_prepared_authority() {
+    let mut document = fixture();
+    let prepared = prepare(&document, id(2), "renamed");
+    let exact = prepared.after().clone();
+    let mut counterfeit = prepared.after().clone();
+    counterfeit.decoded.project.name = "Injected unrelated edit".into();
+    counterfeit.index.declarations.clear();
+    let unchanged = Unchanged::capture(&document);
+    assert!(document.apply_compiled(counterfeit).is_err());
+    unchanged.assert(&document);
+    let mut unrelated = exact.decoded.project.clone();
+    unrelated.name = "A self-consistent unrelated candidate".into();
+    let forged_dto = source_project::compile_bundle(
+        &source_project::format_bundle(&unrelated),
+        ProjectLimits::default(),
+    )
+    .unwrap();
+    assert_ne!(forged_dto.decoded.project, prepared.after().decoded.project);
+    // No API converts either DTO to PreparedAliasRename. Mutating owned copies
+    // leaves the opaque capability and its exact adopted model/source intact.
+    document.commit_alias_rename(&prepared).unwrap();
+    assert_eq!(document.project(), &exact.decoded.project);
+    assert_eq!(document.bundle(), &exact.bundle);
+}
+
+#[test]
+fn exact_history_capacity_admits_immediate_undo_and_rejects_larger_candidate() {
+    let mut document = fixture();
+    let mut bundle = document.bundle().clone();
+    let padding = HISTORY_BYTES / 2 - document.current_bytes;
+    bundle
+        .files
+        .get_mut("views.arcadia")
+        .unwrap()
+        .push_str(&format!("//{}\r\n", "x".repeat(padding - 4)));
+    document.apply_bundle(bundle).unwrap();
+    assert_eq!(document.current_bytes, HISTORY_BYTES / 2);
+    // A same-length alias retains the exact estimate; older history is evictable.
+    let boundary = prepare(&document, id(2), "rating");
+    assert_eq!(
+        boundary.0.before_bytes + boundary.0.after_bytes,
+        HISTORY_BYTES
+    );
+    let unchanged = Unchanged::capture(&document);
+    assert!(
+        document
+            .alias_rename_request(id(2), "longer_alias".into())
+            .unwrap()
+            .prepare()
+            .is_err()
+    );
+    unchanged.assert(&document);
+    document.commit_alias_rename(&boundary).unwrap();
+    assert_eq!(document.past.len(), 1);
+    assert!(document.undo());
+    assert!(Arc::ptr_eq(&document.current, &boundary.0.request.before));
+    assert!(!document.can_undo());
+    assert!(document.redo());
+    assert!(Arc::ptr_eq(&document.current, &boundary.0.after));
+    assert!(check_history_capacity(usize::MAX, 1).is_err());
+    assert!(check_history_capacity(HISTORY_BYTES, 1).is_err());
+}
+
+#[test]
+fn mint_and_commit_refuse_exhausted_or_inconsistent_live_history_estimate() {
+    let mut document = fixture();
+    let prepared = prepare(&document, id(2), "renamed");
+    // Inject cache corruption to falsify the commit-side check independently of
+    // the preparation admission. Normal edits also change revision and Arc.
+    document.current_bytes = HISTORY_BYTES;
+    let unchanged = Unchanged::capture(&document);
+    assert!(
+        document
+            .alias_rename_request(id(2), "renamed".into())
+            .is_err()
+    );
+    assert!(document.commit_alias_rename(&prepared).is_err());
+    // No-op intent needs no Undo reservation even at the admission boundary.
+    assert!(
+        document
+            .alias_rename_request(id(2), "assess".into())
+            .is_ok()
+    );
+    unchanged.assert(&document);
+}

crates/oa-desktop/src/guide.rs

@@ -785,7 +785,7 @@ fn article(topic: Topic) -> Article {
             const {
                 Article {
                     summary: "The text editor and graphical forms edit the same model. Source projects preserve file organization and comments for human review, automation and version control.",
-                    keywords: "text textual source language syntax highlighting lint parser git aliases uuid identity rename diff merge restructuredtext spec canonical parity definition references lexical navigation F12 back",
+                    keywords: "text textual source language syntax highlighting lint parser git aliases uuid identity rename F2 preview diff merge restructuredtext spec canonical parity definition references lexical navigation F12 back",
                     sections: &[
                         walkthrough(
                             "Edit and review source",
@@ -810,6 +810,15 @@ fn article(topic: Topic) -> Article {
                             "Names, aliases and IDs serve different purposes",
                             "The displayed name is engineering prose. A stable @alias is the readable source reference and need not change when the name changes. UUID identity distinguishes the persistent record. Preserve IDs when revising the same engineering object; changing identity is a deliberate operation that affects references.",
                         ),
+                        walkthrough(
+                            "Rename a source alias",
+                            &[
+                                "Place the caret on a declaration alias or live @reference, then choose Rename alias or press F2 in the source editor. First finish or revert pending source, property and behavior drafts; close or reattach any extra loaded detached files. Accepted edits do not need to be saved first.",
+                                "Edit Source alias and choose Preview (Enter also previews). Pasting line breaks, tabs or other control characters is rejected without changing the field; choose Preview again after correcting the paste. Review the changed files, hunks and lines; long lines have additional segments. The engineering name and UUID stay unchanged. Comments and quoted prose keep their original spelling. This preview covers the rename; a later Save can include earlier accepted edits too.",
+                                "Choose Rename alias to accept the complete preview, or Cancel/Escape to leave everything unchanged. An invalid, unchanged, stale or oversized preview cannot be confirmed. After editing the replacement, choose Preview again. If the source context changes, close the form and invoke Rename again on the current alias.",
+                                "Use Undo rename immediately, or the model Undo/Redo controls, to restore the complete source/model snapshot. Ctrl+Z in Text still undoes source drafting. Save all and reopen use the normal project workflow; an unconfirmed preview is not saved.",
+                            ],
+                        ),
                         example(
                             "Readable references",
                             "For example, renaming an activity does not require renaming @assess_incident. A related record can still refer to that alias.",

crates/oa-desktop/src/main.rs

@@ -24,6 +24,7 @@ mod recovery;
 mod route_edit;
 mod semantic_review;
 mod source_navigation;
+mod source_rename;
 mod source_tree;
 mod source_workspace;
 mod style;

crates/oa-desktop/src/source_navigation/query.rs

@@ -220,12 +220,22 @@ pub struct ReferenceRow {
     pub evidence: Evidence,
 }
 
+/// Exact lexical occurrence that answered the query, independent of row limits.
+/// The optional @ marker is separate from the alias; comments between them do
+/// not become part of either hit.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Origin {
+    pub span: Span,
+    pub marker: Option<Span>,
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Results {
     pub stamp: QueryStamp,
     pub action: Action,
     pub origin_path: String,
     pub origin_offset: usize,
+    pub origin: Option<Origin>,
     pub alias: Option<String>,
     pub scope: Scope,
     pub disposition: Disposition,
@@ -823,10 +833,28 @@ impl Snapshot {
             .ok_or(QueryError::MissingFile)?;
         let index = self.index()?;
         let hit = index.hit(file, query.byte_offset)?;
-        let alias = match hit {
-            Some(symbols::Hit::Definition(handle)) => Some(index.definition(handle)?.alias),
-            Some(symbols::Hit::Reference(handle)) => Some(index.reference(handle)?.alias),
-            None => None,
+        let (alias, origin) = match hit {
+            Some(symbols::Hit::Definition(handle)) => {
+                let definition = index.definition(handle)?;
+                (
+                    Some(definition.alias),
+                    Some(Origin {
+                        span: definition.alias_location.span,
+                        marker: None,
+                    }),
+                )
+            }
+            Some(symbols::Hit::Reference(handle)) => {
+                let reference = index.reference(handle)?;
+                (
+                    Some(reference.alias),
+                    Some(Origin {
+                        span: reference.alias_location.span,
+                        marker: Some(reference.at.span),
+                    }),
+                )
+            }
+            None => (None, None),
         };
         let mut budget = RowBudget {
             rows: self.limits.result_rows,
@@ -840,6 +868,7 @@ impl Snapshot {
             action: query.action,
             origin_path: query.path.to_owned(),
             origin_offset: query.byte_offset,
+            origin,
             alias: alias.map(str::to_owned),
             scope: self.scope.clone(),
             disposition: Disposition::NoSymbol,

crates/oa-desktop/src/source_navigation/query_tests.rs

@@ -107,6 +107,65 @@ fn reference_offset(fixture: &Fixture) -> usize {
     fixture.text("links.arcadia").find("source @").unwrap() + "source ".len()
 }
 
+#[test]
+fn origin_keeps_exact_hit_when_display_rows_are_omitted() {
+    let mut fixture = Fixture::standard();
+    fixture
+        .text_mut("links.arcadia")
+        .push_str("// no @pump hit\r\n@pump @pump @ // intervening @pump\r\n pump");
+    let source = fixture.text("links.arcadia");
+    let start = source.rfind("pump").unwrap();
+    let marker = source.rfind("@ // intervening").unwrap();
+    let limits = Limits {
+        result_rows: 0,
+        ..Limits::default()
+    };
+    let snapshot = fixture.snapshot(None, false, limits);
+    let expected = Some(Origin {
+        span: Span {
+            start,
+            end: start + 4,
+        },
+        marker: Some(Span {
+            start: marker,
+            end: marker + 1,
+        }),
+    });
+    for offset in [start, start + 3, marker] {
+        let result = query(&snapshot, "links.arcadia", offset, Action::References);
+        assert_eq!(result.origin, expected);
+        assert!(result.references.is_empty());
+        assert!(result.omitted_references > 2);
+    }
+    let comment = source.rfind("intervening @pump").unwrap() + "intervening @".len();
+    assert_eq!(
+        query(&snapshot, "links.arcadia", comment, Action::Definition).origin,
+        None
+    );
+    assert_eq!(
+        query(&snapshot, "links.arcadia", start + 4, Action::Definition).origin,
+        None
+    );
+    let definition_source = fixture.text("模块/活動.arcadia");
+    let definition_start = definition_source.find("pump").unwrap();
+    assert_eq!(
+        query(
+            &snapshot,
+            "模块/活動.arcadia",
+            definition_start,
+            Action::Definition
+        )
+        .origin,
+        Some(Origin {
+            span: Span {
+                start: definition_start,
+                end: definition_start + 4
+            },
+            marker: None
+        })
+    );
+}
+
 #[test]
 fn exact_multifile_unicode_crlf_definition_and_repeated_lexical_references() {
     let fixture = Fixture::standard();

crates/oa-desktop/src/source_navigation/symbols.rs

@@ -191,13 +191,6 @@ pub struct AuthoredAnchor {
 }
 
 impl AuthoredAnchor {
-    #[cfg_attr(
-        not(test),
-        expect(
-            dead_code,
-            reason = "Tested authored-anchor API; editor Back uses exact buffer generations."
-        )
-    )]
     pub fn id(self) -> Id {
         self.id
     }

crates/oa-desktop/src/source_rename.rs

@@ -0,0 +1,3 @@
+//! Pure preview and exact origin mapping for the guarded alias-rename controller.
+pub mod origin;
+pub mod preview;

crates/oa-desktop/src/source_rename/origin.rs

@@ -0,0 +1,278 @@
+//! Map a role-proven alias occurrence through the exact prepared source change.
+//! This is cursor restoration, not target resolution or commit authority.
+use oa_core::language::{self, Outline, OutlineLimits, Span, TokenClass};
+use std::fmt;
+
+const LIMITS: OutlineLimits = OutlineLimits {
+    max_source_bytes: 64 * 1024 * 1024,
+    max_tokens: 1_000_000,
+    max_declarations: 250_000,
+};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum OriginError {
+    Budget,
+    InvalidSource,
+    MissingOrigin,
+    ChangedStructure,
+}
+
+impl fmt::Display for OriginError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            Self::Budget => "The alias cursor preview exceeds its source scan budget. No rename was applied.",
+            Self::InvalidSource => "The alias cursor could not be verified in this source. No rename was applied.",
+            Self::MissingOrigin => "The original alias occurrence no longer matches. Preview again; no rename was applied.",
+            Self::ChangedStructure => "The preview changed source outside the expected alias tokens. No rename was applied.",
+        })
+    }
+}
+
+impl std::error::Error for OriginError {}
+
+fn word(class: TokenClass) -> bool {
+    matches!(class, TokenClass::Identifier | TokenClass::Keyword)
+}
+
+/// The controller passes the exact alias span returned by the admitted symbol
+/// hit. `marker` is Some only for a reference (its separate @ span), including
+/// invocation with the caret on @. A declaration passes None.
+pub fn map(
+    before: &str,
+    after: &str,
+    old_alias: &str,
+    new_alias: &str,
+    origin: Span,
+    marker: Option<Span>,
+) -> Result<Span, OriginError> {
+    let old = language::outline(before, LIMITS).map_err(|_| OriginError::Budget)?;
+    let new = language::outline(after, LIMITS).map_err(|_| OriginError::Budget)?;
+    if old.has_lexical_errors || new.has_lexical_errors {
+        return Err(OriginError::InvalidSource);
+    }
+    if old.tokens.len() != new.tokens.len() {
+        return Err(OriginError::ChangedStructure);
+    }
+    let roles_before = roles(&old);
+    let roles_after = roles(&new);
+    let mut mapped = None;
+    for (index, (a, b)) in old.tokens.iter().zip(&new.tokens).enumerate() {
+        let left = &before[a.span.start..a.span.end];
+        let right = &after[b.span.start..b.span.end];
+        let alias_pair = word(a.class)
+            && word(b.class)
+            && left == old_alias
+            && right == new_alias
+            && roles_before[index].is_some()
+            && roles_after[index].is_some()
+            && roles_before[index].map(|role| role.is_some())
+                == roles_after[index].map(|role| role.is_some());
+        if a.span == origin {
+            if !alias_pair || roles_before[index] != Some(marker) {
+                return Err(OriginError::MissingOrigin);
+            }
+            mapped = Some(b.span);
+        }
+        if !alias_pair && (left != right || a.class != b.class) {
+            return Err(OriginError::ChangedStructure);
+        }
+    }
+    mapped.ok_or(OriginError::MissingOrigin)
+}
+
+/// Outer None is not an alias role; Some(None) is a declaration alias;
+/// Some(Some(span)) is a live @ reference with its exact separate marker.
+/// Scan sorted declaration spans and tokens together, without repeated searches.
+fn roles(outline: &Outline<'_>) -> Vec<Option<Option<Span>>> {
+    let mut result = vec![None; outline.tokens.len()];
+    let mut declarations = outline.declarations.iter().peekable();
+    let mut significant = None;
+    for (index, token) in outline.tokens.iter().enumerate() {
+        while declarations
+            .peek()
+            .is_some_and(|d| d.alias_span.start < token.span.start)
+        {
+            declarations.next();
+        }
+        if word(token.class) {
+            if declarations
+                .peek()
+                .is_some_and(|d| d.alias_span == token.span)
+            {
+                result[index] = Some(None);
+            } else if let Some(previous) = significant {
+                let span: Span = previous;
+                if &outline.source[span.start..span.end] == "@" {
+                    result[index] = Some(Some(span));
+                }
+            }
+        }
+        if !matches!(token.class, TokenClass::Whitespace | TokenClass::Comment) {
+            significant = Some(token.span);
+        }
+    }
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn occurrence(source: &str, needle: &str, which: usize) -> Span {
+        let start = source.match_indices(needle).nth(which).unwrap().0;
+        Span {
+            start,
+            end: start + needle.len(),
+        }
+    }
+
+    #[test]
+    fn maps_last_repeated_reference_with_unicode_crlf_and_comment_separator() {
+        let before =
+            "oa_activity a \"救援\" {}\r\n// @a is prose\r\nsource @a; target @ // a\r\n a;\r\n";
+        let after = "oa_activity renamed \"救援\" {}\r\n// @a is prose\r\nsource @renamed; target @ // a\r\n renamed;\r\n";
+        let start = before.rfind(" a;").unwrap() + 1;
+        let marker = before.rfind("@ //").unwrap();
+        let mapped = map(
+            before,
+            after,
+            "a",
+            "renamed",
+            Span {
+                start,
+                end: start + 1,
+            },
+            Some(Span {
+                start: marker,
+                end: marker + 1,
+            }),
+        )
+        .unwrap();
+        assert_eq!(&after[mapped.start..mapped.end], "renamed");
+        assert_eq!(mapped.start, after.rfind(" renamed;").unwrap() + 1);
+        assert_eq!(
+            before[..start].bytes().filter(|b| *b == b'\n').count(),
+            after[..mapped.start]
+                .bytes()
+                .filter(|b| *b == b'\n')
+                .count()
+        );
+    }
+
+    #[test]
+    fn preserves_final_same_line_occurrence_not_first_or_prose() {
+        let before = "oa_activity a \"a @a\" {} source @a; target @a;";
+        let after = "oa_activity longer \"a @a\" {} source @longer; target @longer;";
+        let start = before.rfind("@a").unwrap();
+        let result = map(
+            before,
+            after,
+            "a",
+            "longer",
+            Span {
+                start: start + 1,
+                end: start + 2,
+            },
+            Some(Span {
+                start,
+                end: start + 1,
+            }),
+        )
+        .unwrap();
+        assert_eq!(result.start, after.rfind("@longer").unwrap() + 1);
+        let prose = occurrence(before, "a @a", 0);
+        assert!(
+            map(
+                before,
+                after,
+                "a",
+                "longer",
+                Span {
+                    start: prose.start,
+                    end: prose.start + 1
+                },
+                None
+            )
+            .is_err()
+        );
+    }
+
+    #[test]
+    fn permits_identifier_keyword_transitions_in_alias_roles() {
+        let before = "oa_activity a \"Name\" {} source @a;";
+        let alias = occurrence(before, "a \"Name", 0);
+        let origin = Span {
+            start: alias.start,
+            end: alias.start + 1,
+        };
+        for replacement in ["none", "include", "oa_activity"] {
+            assert!(oa_core::valid_alias(replacement));
+            assert_eq!(
+                language::tokenize(replacement)[0].class,
+                TokenClass::Keyword
+            );
+            let after = format!("oa_activity {replacement} \"Name\" {{}} source @{replacement};");
+            let mapped = map(before, &after, "a", replacement, origin, None).unwrap();
+            assert_eq!(&after[mapped.start..mapped.end], replacement);
+            assert_eq!(
+                map(&after, before, replacement, "a", mapped, None).unwrap(),
+                origin
+            );
+        }
+    }
+
+    #[test]
+    fn rejects_changed_trivia_non_alias_words_and_wrong_marker() {
+        let before = "oa_activity a \"Name\" {} source @a;";
+        let after = "oa_activity b \"Name\" {} source @b;";
+        let start = before.rfind("@a").unwrap();
+        let span = Span {
+            start: start + 1,
+            end: start + 2,
+        };
+        let marker = Some(Span {
+            start,
+            end: start + 1,
+        });
+        assert_eq!(
+            map(
+                before,
+                &after.replace("Name", "Other"),
+                "a",
+                "b",
+                span,
+                marker
+            ),
+            Err(OriginError::ChangedStructure)
+        );
+        assert_eq!(
+            map(
+                before,
+                &after.replace(" source", "  source"),
+                "a",
+                "b",
+                span,
+                marker
+            ),
+            Err(OriginError::ChangedStructure)
+        );
+        assert_eq!(
+            map(before, after, "a", "b", span, None),
+            Err(OriginError::MissingOrigin)
+        );
+        assert!(
+            map(
+                before,
+                after,
+                "a",
+                "b",
+                Span {
+                    start: 0,
+                    end: usize::MAX
+                },
+                marker
+            )
+            .is_err()
+        );
+    }
+}

crates/oa-desktop/src/source_rename/preview.rs

@@ -0,0 +1,578 @@
+//! Complete, bounded line-ordinal previews of an already prepared alias rename.
+//!
+//! Source text remains in the caller's immutable before/after snapshots. This
+//! module owns only paths and indexes; it is not rename or commit authority.
+use oa_core::source_project::SourceBundle;
+use std::{fmt, ops::Range};
+
+const CONTEXT: usize = 3;
+// A byte-grid boundary can move back by at most three UTF-8 continuation bytes,
+// so a 252-byte grid yields fragments of at most 255 bytes, independent of input.
+const SEGMENT_GRID: usize = 252;
+
+/// Count all bounded fragments of exact source text; an empty line has one
+/// empty fragment. Page these as well as lines, never mount an unbounded line.
+pub fn segment_count(text: &str) -> usize {
+    text.len().div_ceil(SEGMENT_GRID).max(1)
+}
+
+/// Constant-time UTF-8-safe page lookup. Concatenating every fragment gives the
+/// original bytes, including CRLF. No ellipsis or truncation replaces content.
+pub fn text_segment(text: &str, index: usize) -> Option<&str> {
+    if index >= segment_count(text) {
+        return None;
+    }
+    let mut start = index.checked_mul(SEGMENT_GRID)?;
+    let mut end = start.saturating_add(SEGMENT_GRID).min(text.len());
+    while !text.is_char_boundary(start) {
+        start -= 1;
+    }
+    while !text.is_char_boundary(end) {
+        end -= 1;
+    }
+    text.get(start..end)
+}
+const LIMITS: Limits = Limits {
+    files: 256,
+    changed_lines: 50_000,
+    display_bytes: 8 * 1024 * 1024,
+};
+
+#[derive(Clone, Copy)]
+struct Limits {
+    files: usize,
+    changed_lines: usize,
+    display_bytes: usize,
+}
+
+#[derive(Debug)]
+pub struct Preview {
+    files: Vec<File>,
+    changed_lines: usize,
+    display_bytes: usize,
+}
+
+#[derive(Debug)]
+pub struct File {
+    path: String,
+    hunks: Vec<Hunk>,
+}
+
+#[derive(Debug)]
+pub struct Hunk {
+    lines: Vec<Line>,
+}
+
+#[derive(Debug)]
+pub struct Line {
+    number: usize,
+    before: Range<usize>,
+    after: Range<usize>,
+    changed: bool,
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum PreviewError {
+    MembershipChanged,
+    LineCountChanged(String),
+    LineEndingChanged { path: String, line: usize },
+    TooManyFiles { limit: usize },
+    TooManyChangedLines { limit: usize },
+    TooManyDisplayBytes { limit: usize },
+}
+
+impl fmt::Display for PreviewError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::MembershipChanged => write!(
+                f,
+                "Rename preview refused: the entry or source file membership changed. No rename was applied."
+            ),
+            Self::LineCountChanged(path) => write!(
+                f,
+                "Rename preview refused: the line count changed in {path}. No rename was applied."
+            ),
+            Self::LineEndingChanged { path, line } => write!(
+                f,
+                "Rename preview refused: the line ending changed in {path}:{line}. No rename was applied."
+            ),
+            Self::TooManyFiles { limit } => write!(
+                f,
+                "Rename preview exceeds {limit} changed files. A complete preview is required; no rename was applied."
+            ),
+            Self::TooManyChangedLines { limit } => write!(
+                f,
+                "Rename preview exceeds {limit} changed source lines. A complete preview is required; no rename was applied."
+            ),
+            Self::TooManyDisplayBytes { limit } => write!(
+                f,
+                "Rename preview exceeds {limit} display bytes (paths and both versions of changed/context lines). A complete preview is required; no rename was applied."
+            ),
+        }
+    }
+}
+
+impl std::error::Error for PreviewError {}
+
+impl Preview {
+    pub fn build(before: &SourceBundle, after: &SourceBundle) -> Result<Self, PreviewError> {
+        Self::with_limits(before, after, LIMITS)
+    }
+
+    fn with_limits(
+        before: &SourceBundle,
+        after: &SourceBundle,
+        limits: Limits,
+    ) -> Result<Self, PreviewError> {
+        if before.entry != after.entry
+            || !before.files.contains_key(&before.entry)
+            || !before.files.keys().eq(after.files.keys())
+        {
+            return Err(PreviewError::MembershipChanged);
+        }
+        let mut preview = Self {
+            files: Vec::new(),
+            changed_lines: 0,
+            display_bytes: 0,
+        };
+        for ((path, old), (_, new)) in before.files.iter().zip(&after.files) {
+            if old == new {
+                continue;
+            }
+            if preview.files.len() == limits.files {
+                return Err(PreviewError::TooManyFiles {
+                    limit: limits.files,
+                });
+            }
+            // A changed source line can contain arbitrarily many renamed tokens.
+            // Count the line once; this count is never a semantic-reference count.
+            let mut changed = Vec::new();
+            let mut old_lines = Lines::new(old);
+            let mut new_lines = Lines::new(new);
+            let mut count = 0;
+            loop {
+                match (old_lines.next(), new_lines.next()) {
+                    (None, None) => break,
+                    (Some(a), Some(b)) => {
+                        count += 1;
+                        if old[a.content_end..a.end] != new[b.content_end..b.end] {
+                            return Err(PreviewError::LineEndingChanged {
+                                path: path.clone(),
+                                line: count,
+                            });
+                        }
+                        if old[a.start..a.end] != new[b.start..b.end] {
+                            if preview.changed_lines == limits.changed_lines {
+                                return Err(PreviewError::TooManyChangedLines {
+                                    limit: limits.changed_lines,
+                                });
+                            }
+                            preview.changed_lines += 1;
+                            changed.push(count - 1);
+                        }
+                    }
+                    _ => return Err(PreviewError::LineCountChanged(path.clone())),
+                }
+            }
+
+            // Merge touching context intervals in order, without pairwise diff.
+            // At most 7 indexed lines per changed line are retained; unchanged
+            // lines outside these intervals are scanned but never indexed.
+            let mut ranges: Vec<Range<usize>> = Vec::new();
+            for line in changed {
+                let range =
+                    line.saturating_sub(CONTEXT)..line.saturating_add(CONTEXT + 1).min(count);
+                if let Some(previous) = ranges.last_mut()
+                    && range.start <= previous.end
+                {
+                    previous.end = previous.end.max(range.end);
+                    continue;
+                }
+                ranges.push(range);
+            }
+            preview.charge(path.len(), limits)?;
+            let mut file = File {
+                path: path.clone(),
+                hunks: Vec::new(),
+            };
+            let mut pairs = Lines::new(old).zip(Lines::new(new)).enumerate();
+            for range in ranges {
+                let mut hunk = Hunk { lines: Vec::new() };
+                for (ordinal, (a, b)) in pairs.by_ref() {
+                    if ordinal < range.start {
+                        continue;
+                    }
+                    // Charge exact UTF-8 bytes, including preserved endings and
+                    // both copies of shared context, before adding the index.
+                    // No render-time omission or shortening grants admission.
+                    preview.charge(a.end - a.start, limits)?;
+                    preview.charge(b.end - b.start, limits)?;
+                    hunk.lines.push(Line {
+                        number: ordinal + 1,
+                        changed: old[a.start..a.end] != new[b.start..b.end],
+                        before: a.start..a.end,
+                        after: b.start..b.end,
+                    });
+                    if ordinal + 1 == range.end {
+                        break;
+                    }
+                }
+                file.hunks.push(hunk);
+            }
+            preview.files.push(file);
+        }
+        Ok(preview)
+    }
+
+    fn charge(&mut self, bytes: usize, limits: Limits) -> Result<(), PreviewError> {
+        let Some(total) = self.display_bytes.checked_add(bytes) else {
+            return Err(PreviewError::TooManyDisplayBytes {
+                limit: limits.display_bytes,
+            });
+        };
+        if total > limits.display_bytes {
+            return Err(PreviewError::TooManyDisplayBytes {
+                limit: limits.display_bytes,
+            });
+        }
+        self.display_bytes = total;
+        Ok(())
+    }
+
+    /// All admitted files in source path order; suitable for a file picker/search.
+    pub fn files(&self) -> &[File] {
+        &self.files
+    }
+
+    /// Changed source lines, not occurrences, declarations or semantic uses.
+    pub fn changed_line_count(&self) -> usize {
+        self.changed_lines
+    }
+
+    /// Exact displayed source bytes for both sides plus each stored path once.
+    /// Index metadata is separately bounded by 7 lines per changed line.
+    pub fn display_bytes(&self) -> usize {
+        self.display_bytes
+    }
+
+    #[cfg(test)]
+    pub fn is_empty(&self) -> bool {
+        self.files.is_empty()
+    }
+}
+
+impl File {
+    pub fn path(&self) -> &str {
+        &self.path
+    }
+
+    /// Every hunk is present; the caller may page these indexes, never truncate.
+    pub fn hunks(&self) -> &[Hunk] {
+        &self.hunks
+    }
+}
+
+impl Hunk {
+    /// The complete ordered line slice supports paging even a large single hunk.
+    pub fn lines(&self) -> &[Line] {
+        &self.lines
+    }
+}
+
+impl Line {
+    /// One-based source line number, identical on both sides.
+    pub fn number(&self) -> usize {
+        self.number
+    }
+
+    pub fn changed(&self) -> bool {
+        self.changed
+    }
+
+    /// Borrow from the immutable original file; includes its exact line ending.
+    pub fn before_text<'a>(&self, original: &'a str) -> Option<&'a str> {
+        original.get(self.before.clone())
+    }
+
+    /// Borrow from the immutable candidate file; includes its exact line ending.
+    pub fn after_text<'a>(&self, candidate: &'a str) -> Option<&'a str> {
+        candidate.get(self.after.clone())
+    }
+}
+
+struct RawLine {
+    start: usize,
+    content_end: usize,
+    end: usize,
+}
+
+struct Lines<'a> {
+    bytes: &'a [u8],
+    offset: usize,
+}
+
+impl<'a> Lines<'a> {
+    fn new(text: &'a str) -> Self {
+        Self {
+            bytes: text.as_bytes(),
+            offset: 0,
+        }
+    }
+}
+
+impl Iterator for Lines<'_> {
+    type Item = RawLine;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.offset == self.bytes.len() {
+            return None;
+        }
+        let start = self.offset;
+        // The compiler and source navigation count LF, not bare CR, as a line
+        // boundary. Preserve CRLF as an ending and bare CR as source content.
+        while self.offset < self.bytes.len() && self.bytes[self.offset] != b'\n' {
+            self.offset += 1;
+        }
+        let mut content_end = self.offset;
+        if self.offset < self.bytes.len() {
+            if self.offset > start && self.bytes[self.offset - 1] == b'\r' {
+                content_end -= 1;
+            }
+            self.offset += 1;
+        }
+        Some(RawLine {
+            start,
+            content_end,
+            end: self.offset,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn bundle(source: &str) -> SourceBundle {
+        SourceBundle {
+            entry: "救援.arcadia".into(),
+            files: [("救援.arcadia".into(), source.into())].into(),
+        }
+    }
+
+    #[test]
+    fn long_unicode_lines_are_fully_reachable_as_bounded_fragments() {
+        let text = format!("{}救援🙂{}\r\n", "a".repeat(251), "🙂".repeat(200));
+        let pieces: Vec<_> = (0..segment_count(&text))
+            .map(|i| text_segment(&text, i).unwrap())
+            .collect();
+        assert!(pieces.len() > 2);
+        assert!(pieces.iter().all(|part| part.len() <= 255));
+        assert_eq!(pieces.concat(), text);
+        assert_eq!(text_segment(&text, segment_count(&text)), None);
+        assert_eq!(text_segment(&text, usize::MAX), None);
+        assert_eq!(segment_count(""), 1);
+        assert_eq!(text_segment("", 0), Some(""));
+    }
+
+    #[test]
+    fn preserves_unicode_mixed_endings_and_counts_lines_not_repeated_uses() {
+        let old = bundle("// 救援\r\n@a @a\ncontext\r@a");
+        let new = bundle("// 救援\r\n@long @long\ncontext\r@long");
+        let preview = Preview::build(&old, &new).unwrap();
+        assert_eq!(preview.changed_line_count(), 2);
+        let file = &preview.files()[0];
+        assert_eq!(file.path(), "救援.arcadia");
+        assert_eq!(file.hunks().len(), 1);
+        let lines = file.hunks()[0].lines();
+        assert_eq!(
+            lines.iter().map(Line::number).collect::<Vec<_>>(),
+            [1, 2, 3]
+        );
+        assert_eq!(
+            lines[0].before_text(&old.files[&old.entry]),
+            Some("// 救援\r\n")
+        );
+        assert_eq!(
+            lines[1].after_text(&new.files[&new.entry]),
+            Some("@long @long\n")
+        );
+        assert_eq!(
+            lines[2].after_text(&new.files[&new.entry]),
+            Some("context\r@long")
+        );
+        assert!(lines[1].changed() && lines[2].changed());
+        assert!(!lines[0].changed());
+        assert_eq!(
+            preview.display_bytes(),
+            old.entry.len() + old.files[&old.entry].len() + new.files[&new.entry].len()
+        );
+    }
+
+    #[test]
+    fn first_and_last_lines_form_complete_separate_hunks_and_pages() {
+        let old = bundle("a\n1\n2\n3\n4\n5\n6\n7\n8\n9\na");
+        let new = bundle("long\n1\n2\n3\n4\n5\n6\n7\n8\n9\nlong");
+        let preview = Preview::build(&old, &new).unwrap();
+        let hunks = preview.files()[0].hunks();
+        assert_eq!(hunks.len(), 2);
+        let page_numbers: Vec<_> = hunks
+            .iter()
+            .flat_map(|h| h.lines().chunks(2))
+            .flat_map(|page| page.iter().map(Line::number))
+            .collect();
+        assert_eq!(page_numbers, [1, 2, 3, 4, 8, 9, 10, 11]);
+        assert_eq!(
+            hunks[1].lines()[3].after_text(&new.files[&new.entry]),
+            Some("long")
+        );
+    }
+
+    #[test]
+    fn nearby_changes_merge_and_all_changed_files_are_reachable() {
+        let mut old = bundle("a\n1\n2\n3\n4\n5\na\n");
+        let mut new = bundle("b\n1\n2\n3\n4\n5\nb\n");
+        old.files.insert("other.arcadia".into(), "a a a".into());
+        new.files.insert("other.arcadia".into(), "b b b".into());
+        let preview = Preview::build(&old, &new).unwrap();
+        assert_eq!(preview.changed_line_count(), 3);
+        assert_eq!(preview.files().len(), 2);
+        assert_eq!(preview.files()[0].path(), "other.arcadia");
+        assert_eq!(preview.files()[0].hunks()[0].lines().len(), 1);
+        assert_eq!(preview.files()[1].hunks().len(), 1);
+        assert_eq!(preview.files()[1].hunks()[0].lines().len(), 7);
+    }
+
+    #[test]
+    fn unchanged_and_empty_sources_have_no_preview() {
+        for source in ["", "a\r\nb\n", "a"] {
+            let original = bundle(source);
+            let preview = Preview::build(&original, &original).unwrap();
+            assert!(preview.is_empty());
+            assert_eq!(preview.changed_line_count(), 0);
+            assert_eq!(preview.display_bytes(), 0);
+        }
+    }
+
+    #[test]
+    fn refuses_membership_entry_line_count_and_line_ending_changes() {
+        let old = bundle("a\nb");
+        let mut new = old.clone();
+        new.files.insert("extra.arcadia".into(), "".into());
+        assert_eq!(
+            Preview::build(&old, &new).unwrap_err(),
+            PreviewError::MembershipChanged
+        );
+        let mut new = old.clone();
+        new.entry = "missing.arcadia".into();
+        assert_eq!(
+            Preview::build(&old, &new).unwrap_err(),
+            PreviewError::MembershipChanged
+        );
+        assert!(matches!(
+            Preview::build(&old, &bundle("a\nb\nc")),
+            Err(PreviewError::LineEndingChanged { .. }) | Err(PreviewError::LineCountChanged(_))
+        ));
+        assert!(matches!(
+            Preview::build(&bundle("a\nb\n"), &bundle("a\n")),
+            Err(PreviewError::LineCountChanged(_))
+        ));
+        for (a, b) in [("a\r\n", "a\n"), ("a\r", "a\n"), ("a", "a\n")] {
+            assert_eq!(
+                Preview::build(&bundle(a), &bundle(b)).unwrap_err(),
+                PreviewError::LineEndingChanged {
+                    path: old.entry.clone(),
+                    line: 1
+                }
+            );
+        }
+    }
+
+    #[test]
+    fn each_bound_is_exact_and_overflow_never_returns_a_partial_preview() {
+        let old = bundle("a\ncontext\na");
+        let new = bundle("bbb\ncontext\nbbb");
+        let exact = old.entry.len() + old.files[&old.entry].len() + new.files[&new.entry].len();
+        let limits = Limits {
+            files: 1,
+            changed_lines: 2,
+            display_bytes: exact,
+        };
+        assert!(Preview::with_limits(&old, &new, limits).is_ok());
+        assert_eq!(
+            Preview::with_limits(&old, &new, Limits { files: 0, ..limits }).unwrap_err(),
+            PreviewError::TooManyFiles { limit: 0 }
+        );
+        assert_eq!(
+            Preview::with_limits(
+                &old,
+                &new,
+                Limits {
+                    changed_lines: 1,
+                    ..limits
+                }
+            )
+            .unwrap_err(),
+            PreviewError::TooManyChangedLines { limit: 1 }
+        );
+        assert_eq!(
+            Preview::with_limits(
+                &old,
+                &new,
+                Limits {
+                    display_bytes: exact - 1,
+                    ..limits
+                }
+            )
+            .unwrap_err(),
+            PreviewError::TooManyDisplayBytes { limit: exact - 1 }
+        );
+        let long = bundle(&"a".repeat(LIMITS.display_bytes));
+        assert!(matches!(
+            Preview::build(&bundle("b"), &long),
+            Err(PreviewError::TooManyDisplayBytes { .. })
+        ));
+    }
+
+    #[test]
+    fn limits_apply_to_the_whole_preview_not_each_file() {
+        let mut old = bundle("a");
+        let mut new = bundle("b");
+        old.files.insert("second.arcadia".into(), "a".into());
+        new.files.insert("second.arcadia".into(), "b".into());
+        let limits = Limits {
+            files: 2,
+            changed_lines: 2,
+            display_bytes: old.entry.len() + "second.arcadia".len() + 4,
+        };
+        let complete = Preview::with_limits(&old, &new, limits).unwrap();
+        assert_eq!(complete.files().len(), 2);
+        assert_eq!(complete.changed_line_count(), 2);
+        assert_eq!(complete.display_bytes(), limits.display_bytes);
+        assert!(matches!(
+            Preview::with_limits(&old, &new, Limits { files: 1, ..limits }),
+            Err(PreviewError::TooManyFiles { limit: 1 })
+        ));
+        assert!(matches!(
+            Preview::with_limits(
+                &old,
+                &new,
+                Limits {
+                    changed_lines: 1,
+                    ..limits
+                }
+            ),
+            Err(PreviewError::TooManyChangedLines { limit: 1 })
+        ));
+        assert!(matches!(
+            Preview::with_limits(
+                &old,
+                &new,
+                Limits {
+                    display_bytes: limits.display_bytes - 1,
+                    ..limits
+                }
+            ),
+            Err(PreviewError::TooManyDisplayBytes { .. })
+        ));
+    }
+}

crates/oa-desktop/src/views.rs

@@ -350,6 +350,13 @@ pub fn view(app: &App) -> View<'_, Message> {
     if app.pending.is_some() {
         return modal(root,column![text("Keep your changes?").size(21),text("Save the model and pending edits before continuing. Invalid drafts stay available for correction.").size(13),row![action("Cancel",Message::Cancel),action("Discard changes",Message::Discard),button("Save & continue").padding(10).on_press(Message::SaveAndContinue)].spacing(8)].spacing(16).into());
     }
+    if app.source_rename.open() {
+        return modal_width(
+            root,
+            crate::app::source_rename::dialog(app),
+            (app.window_size.width - 32.).clamp(120., 760.),
+        );
+    }
     root
 }
 fn modal<'a>(base: View<'a, Message>, content: View<'a, Message>) -> View<'a, Message> {
@@ -1004,6 +1011,13 @@ fn source_files(app: &App) -> View<'_, Message> {
 
 fn source(app: &App) -> View<'_, Message> {
     use crate::source_navigation::Event as SourceEvent;
+    let (undo_label, undo_message) = match app.source_rename_undo_message() {
+        Some(message) => ("Undo rename", Some(message)),
+        None => (
+            "Undo model",
+            (app.document.can_undo() && !app.source_dirty()).then_some(Message::Undo),
+        ),
+    };
     let navigation: View<'_, Message> = if app.source_navigation.open {
         column![
             row![
@@ -1118,7 +1132,8 @@ fn source(app: &App) -> View<'_, Message> {
         .on_action(Message::SourceEdit)
         .key_binding({
             let context = app.source_symbol_context();
-            move |press| source_binding(press, &context)
+            let rename = app.source_rename_begin();
+            move |press| source_binding(press, &context, Some(&rename))
         })
         .font(Font::MONOSPACE)
         .size(14)
@@ -1146,8 +1161,8 @@ fn source(app: &App) -> View<'_, Message> {
                 row![
                     action("Undo text", Message::SourceUndo),
                     action("Redo text", Message::SourceRedo),
-                    button(text("Undo model").size(12)).padding([8,10]).style(style::nav)
-                        .on_press_maybe((app.document.can_undo() && !app.source_dirty()).then_some(Message::Undo)),
+                    button(text(undo_label).size(12)).padding([8,10]).style(style::nav)
+                        .on_press_maybe(undo_message),
                     button(text("Redo model").size(12)).padding([8,10]).style(style::nav)
                         .on_press_maybe((app.document.can_redo() && !app.source_dirty()).then_some(Message::Redo)),
                     action("Find / go to…", Message::SourceNavigation(SourceEvent::Open(false))),
@@ -1174,6 +1189,7 @@ fn source(app: &App) -> View<'_, Message> {
                 row![
                     action("Definition · F12", app.source_symbol_message(crate::source_navigation::SymbolEvent::Query(crate::source_navigation::query::Action::Definition))),
                     action("References · Shift F12", app.source_symbol_message(crate::source_navigation::SymbolEvent::Query(crate::source_navigation::query::Action::References))),
+                    action("Rename alias · F2", app.source_rename_message()),
                     button(text("Back · Alt ←").size(12)).padding([8, 10]).style(style::nav)
                         .on_press_maybe((app.source_symbols.back.iter().any(|entry| entry.session == app.source_workspace.session())).then(|| app.source_symbol_message(crate::source_navigation::SymbolEvent::Back))),
                 ].spacing(7),
@@ -1225,13 +1241,23 @@ fn source_layout<'a, Renderer: iced::advanced::text::Renderer + 'a>(
     .height(Fill)
     .into()
 }
-fn source_binding(
+pub(crate) fn source_binding(
     press: widget::text_editor::KeyPress,
     context: &crate::source_navigation::SymbolContext,
+    rename: Option<&crate::app::source_rename::Begin>,
 ) -> Option<widget::text_editor::Binding<Message>> {
     use crate::source_navigation::{SymbolEvent, query::Action};
     use iced::keyboard::{Key, key::Named};
     use widget::text_editor::{Binding, Status};
+    if matches!(press.status, Status::Focused { .. })
+        && press.modifiers.is_empty()
+        && press.key == Key::Named(Named::F2)
+        && let Some(begin) = rename
+    {
+        return Some(Binding::Custom(Message::SourceRename(
+            crate::app::source_rename::Event::Begin(begin.clone()),
+        )));
+    }
     // Windows owns Alt+Space for its window menu. Iced's default binding would
     // otherwise insert a supplied space payload, even after that menu closes.
     // Keep Ctrl+Alt (AltGr), shifted input, and ordinary Space unchanged.
@@ -1273,7 +1299,7 @@ fn source_binding(
 }
 
 #[cfg(all(test, debug_assertions))]
-mod source_tests {
+pub(crate) mod source_tests {
     use super::*;
     use iced::advanced::{
         Layout, Shell, graphics, layout, renderer, text as shaped, widget as core_widget,
@@ -1282,7 +1308,7 @@ mod source_tests {
     use iced::{Background, Color, Pixels, Point, Rectangle, Size, Transformation, Vector};
 
     // Measure real Iced paragraphs/editor text without constructing a window or GPU.
-    struct FontLayout;
+    pub(crate) struct FontLayout;
     impl renderer::Renderer for FontLayout {
         fn start_layer(&mut self, _: Rectangle) {}
         fn end_layer(&mut self) {}
@@ -1612,7 +1638,7 @@ mod source_tests {
                         .size(14)
                         .padding(16)
                         .height(Fill)
-                        .key_binding(|press| source_binding(press, &context))
+                        .key_binding(|press| source_binding(press, &context, None))
                         .into();
                 let mut tree = core_widget::Tree::new(editor.as_widget());
                 let size = Size::new(600., 240.);

docs/language.html

@@ -2650,6 +2650,45 @@ limits. If sources change, stale rows cannot navigate: run the query again.
 Navigation MUST preserve the accepted model and every source draft, and select
 locations in the original UTF-8 bytes. Displayed locations use one-based lines
 and UTF-8 byte columns.</p>
+<p><strong>Rename alias</strong> (<span class="docutils literal">F2</span> while the source editor has focus) changes the alias
+under the caret or its exact selection. It requires a unique authored identity
+in the complete accepted source bundle, with no pending source, property or
+behavior drafts and no extra loaded detached files. Accepted but unsaved source
+is eligible. The operation MUST NOT implicitly apply a draft or allocate an ID.
+The engineering name and UUID remain unchanged.</p>
+<p>The <strong>Source alias</strong> field does not trim or normalize the entered alias. Pasting
+line breaks, tabs or other control characters is explicitly rejected as a whole:
+the field and its selection remain unchanged, and any previous preview approval
+is invalidated. <strong>Preview</strong>
+prepares a typed alias change and displays every changed file and source line;
+comments, strings, engineering data, file membership and declaration ownership
+remain unchanged. Enter in the field requests Preview, never confirmation.
+The preview is for this operation against accepted source, so a later Save may
+also contain earlier accepted edits. A changing rename requires enough model
+history capacity to retain its immediate Undo. An invalid, identical, stale or
+oversized candidate cannot enable confirmation.</p>
+<p>The preview MUST provide access to all admitted files, hunks, lines and long-line
+segments. Refuse a candidate whose complete preview exceeds the editor's bounds:
+256 changed files, 50,000 changed lines or 8 MiB of displayed source bytes
+(both versions of changed/context lines and file paths). Index metadata is
+separately bounded to seven retained line records per changed line. These
+limits do not restrict the language itself. A changed-line count is not a count
+of semantic references. Cancel, Preview and Rename alias remain reachable
+outside the independently scrolling source preview.</p>
+<p>Explicit <strong>Rename alias</strong> confirms the current preview once, as one accepted
+model/source transaction. A source, document, recovery or replacement change
+invalidates its approval even if later bytes match the old preview. Closing the
+form cancels approval; a late worker result MUST NOT reopen it. Rejected,
+canceled and unchanged operations preserve accepted bytes, drafts, save state,
+revisions, selection and both histories. Successful rename selects the new alias
+at the original occurrence rather than the first matching spelling in the file.
+Editing the replacement permits a new Preview in the same form. After a source
+context change, close the form and invoke Rename again on the current alias.</p>
+<p><strong>Undo rename</strong> is guarded against intervening edits and uses model history;
+the persistent <strong>Undo model</strong> and <strong>Redo model</strong> controls restore the complete
+accepted snapshots. Text <span class="docutils literal">Ctrl+Z</span> remains <strong>Undo text</strong>. Save is separate and
+uses the ordinary guarded source-save contract. An unconfirmed preview and Undo
+history are not persisted on reopening.</p>
 <p>Changing a graphical UUID must atomically update map keys and every reference.
 Alias changes preserve UUID identity. Deletion must account for owned elements,
 incident relationships, ordered occurrences, and diagram placements without

docs/language.rst

@@ -2073,6 +2073,50 @@ Navigation MUST preserve the accepted model and every source draft, and select
 locations in the original UTF-8 bytes. Displayed locations use one-based lines
 and UTF-8 byte columns.
 
+**Rename alias** (``F2`` while the source editor has focus) changes the alias
+under the caret or its exact selection. It requires a unique authored identity
+in the complete accepted source bundle, with no pending source, property or
+behavior drafts and no extra loaded detached files. Accepted but unsaved source
+is eligible. The operation MUST NOT implicitly apply a draft or allocate an ID.
+The engineering name and UUID remain unchanged.
+
+The **Source alias** field does not trim or normalize the entered alias. Pasting
+line breaks, tabs or other control characters is explicitly rejected as a whole:
+the field and its selection remain unchanged, and any previous preview approval
+is invalidated. **Preview**
+prepares a typed alias change and displays every changed file and source line;
+comments, strings, engineering data, file membership and declaration ownership
+remain unchanged. Enter in the field requests Preview, never confirmation.
+The preview is for this operation against accepted source, so a later Save may
+also contain earlier accepted edits. A changing rename requires enough model
+history capacity to retain its immediate Undo. An invalid, identical, stale or
+oversized candidate cannot enable confirmation.
+
+The preview MUST provide access to all admitted files, hunks, lines and long-line
+segments. Refuse a candidate whose complete preview exceeds the editor's bounds:
+256 changed files, 50,000 changed lines or 8 MiB of displayed source bytes
+(both versions of changed/context lines and file paths). Index metadata is
+separately bounded to seven retained line records per changed line. These
+limits do not restrict the language itself. A changed-line count is not a count
+of semantic references. Cancel, Preview and Rename alias remain reachable
+outside the independently scrolling source preview.
+
+Explicit **Rename alias** confirms the current preview once, as one accepted
+model/source transaction. A source, document, recovery or replacement change
+invalidates its approval even if later bytes match the old preview. Closing the
+form cancels approval; a late worker result MUST NOT reopen it. Rejected,
+canceled and unchanged operations preserve accepted bytes, drafts, save state,
+revisions, selection and both histories. Successful rename selects the new alias
+at the original occurrence rather than the first matching spelling in the file.
+Editing the replacement permits a new Preview in the same form. After a source
+context change, close the form and invoke Rename again on the current alias.
+
+**Undo rename** is guarded against intervening edits and uses model history;
+the persistent **Undo model** and **Redo model** controls restore the complete
+accepted snapshots. Text ``Ctrl+Z`` remains **Undo text**. Save is separate and
+uses the ordinary guarded source-save contract. An unconfirmed preview and Undo
+history are not persisted on reopening.
+
 Changing a graphical UUID must atomically update map keys and every reference.
 Alias changes preserve UUID identity. Deletion must account for owned elements,
 incident relationships, ordered occurrences, and diagram placements without

harness/STATE.md

@@ -1,6 +1,6 @@
 # Integrated checkpoint — first release
 
-Updated 2026-09-11 by Codex-9e8r6t `/root`, Windows host.
+Updated 2026-09-12 by Codex-9e8r6t `/root`, Windows host.
 **Full OA/SA release acceptance is incomplete. Linux work remains user-paused.**
 
 [PROJECT_GOAL.md](../PROJECT_GOAL.md) owns the application requirements.
@@ -10,41 +10,42 @@ Instruction synchronization `b70bf1d` preserves the user specification and
 
 ## Delivered Windows milestone
 
-[Contextual authoring prerelease](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/releases/tag/v0.2.0-preview.contextual.20260911)
-was published and read back at 17:03:29 UTC. Extract the whole ZIP and run
+[Source navigation prerelease](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/releases/tag/v0.2.0-preview.navigation.20260911)
+was published and read back on September 12 at 10:54:02 UTC. Extract the whole ZIP and run
 `arcadia-studio.exe`; keep its sibling `libunwind.dll`. Studio, the optional REST
 server, examples, offline help and dependency notices are included.
 
-The tag points to verified source checkpoint **b2c3e540**. Exact raw-input
-reconstruction **d5650309** is distinct from the original build commit. The
-package pairs GUI5657 with the unchanged, separately verified EFEE server.
+The tag points to exact raw-input reconstruction **802855f7**, based on corrected
+source **33c6d83** and distinct from the original build capture. The
+package pairs GUI B183 with the unchanged, separately verified EFEE server.
 All 559 package files and all three downloaded release assets were verified.
 The binaries use the development profile; this is a prerelease.
 
-The GUI supports named behavior creation and contextual missing-source creation
-without abandoning the parent draft. All 679 desktop tests passed, with focused
-layout checks, strict desktop Clippy, formatting and a matching build. Real
-Windows workflows verified minimum-size layout, recovery/cancellation, lifeline
-and state-machine creation, one-step Undo/Redo and exact source/identity reopen.
-Fresh package acceptance additionally verified Home/help, native Open and
-contextual Create/Save/Close with complete model/source/identity comparison.
-Independent packaged-server checks cover exact API content and persistence
-across process restart. These are bounded milestone results.
+The GUI adds Definition/References/Back for current Text drafts and corrects
+repair/recovery saved-state handling. All 755 desktop tests passed (one ignored),
+with strict Clippy, formatting and a matching build. Earlier navigation native
+checks cover minimum-size interaction, ambiguous/partial scope and the 30-file
+engineering workflow; the corrected binary separately passed repair/rollback,
+Close/Cancel and exact Save checks. Fresh package acceptance verified Home/help,
+native Open, navigation, edit/Undo, Apply, Save and complete saved-model/source
+equality. Independent server checks verified exact API content and persistence
+across restart. Each result retains its specific build and workflow scope.
 
 Authoritative records:
 
-- [Publication, artifacts and limitations](release-contextual-source-prerelease-published-20260911.md)
-- [Per-binary preparation](release-contextual-source-prerelease-preparation-20260911.md)
-  and [independent archive/server review](release-contextual-source-prerelease-review-20260911.md)
-- [Fresh native package acceptance](release-contextual-source-prerelease-gui-20260911.md)
-  and [broader GUI5657 native acceptance](release-contextual-source-native-v2-20260911.md)
+- [Publication, artifacts and limitations](release-navigation-prerelease-published-20260912.md)
+- [Per-binary preparation](release-navigation-prerelease-preparation-20260911.md)
+  and [independent archive/server review](release-navigation-prerelease-review-20260911.md)
+- [Fresh native package acceptance](release-navigation-prerelease-native-20260911.md)
+  and [integrated navigation evidence](release-text-navigation-integrated-20260911.md)
+- [Previous contextual authoring milestone](release-contextual-source-prerelease-published-20260911.md)
 - [Verified code/evidence checkpoint](release-postboot-checkpoint-review-20260911.md)
 - [Standalone CLI prerelease](release-cli-prerelease-published-20260911.md),
   supplying checked source stabilization and typed alias rename separately
 
 ## Material unfinished scope
 
-Current-draft Definition/References/Back is implemented in source checkpoint
+Current-draft Definition/References/Back was implemented in source checkpoint
 **[36db9356](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/commit/36db9356cce3c7614ae37eec9fe17678ca210afe)**.
 The [initial native trial](release-text-navigation-native-initial-20260911.md)
 found four interaction defects. Their [correction](release-text-navigation-native-corrections-20260911.md)
@@ -55,15 +56,19 @@ fixes, ambiguous/partial source navigation, and the 30-file engineering workflow
 explicit Save preserved complete models, identities and source bytes. It also
 found a repair-mode false-clean status against the prior saved destination.
 Its [saved-baseline correction](release-text-repair-save-state-20260911.md)
-passes the full 755-test suite, strict Clippy and matching GUI B183 build;
-new native repair/closing and package acceptance remain required.
+at **33c6d83** passes the full 755-test suite, strict Clippy and matching GUI B183
+build. Its [native repair verification](release-text-repair-save-native-v4-20260911.md)
+passed missing-include and duplicate-alias repairs plus interrupted-save rollback:
+Apply/Recover retain unsaved status, Close warns, Cancel retains work, and explicit
+Save yields exact complete model/identity/source equality. The fresh package
+passed its separate native and independent server checks and is now delivered above.
 The [integrated evaluation](release-text-navigation-integrated-20260911.md) links
 exact input archives, earlier full-test scope and independent findings.
 The published contextual preview remains unchanged.
 
-The integrated release does not yet contain newer peer canvas/chooser and
+The integrated release does not yet contain Text alias rename, newer peer canvas/chooser and
 scenario-lifetime work, complete constraints/calculations, dimensional quantities,
-maintained model libraries, or the new source-navigation contribution.
+maintained model libraries.
 Those additions require coherent graphical/text/REST realization and validation.
 Some scenario forms retain old scroll positions and dense labels remain crowded.
 Local SA action/state/reuse/fragment and supplementary camera/focus tasks retain

harness/experiments/navigation-prerelease-20260911/.gitattributes

@@ -0,0 +1 @@
+** -text whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol

harness/experiments/navigation-prerelease-20260911/.gitignore

@@ -0,0 +1 @@
+!**/*.log

harness/experiments/navigation-prerelease-20260911/README.md

@@ -0,0 +1,22 @@
+# Navigation prerelease producer preparation
+
+This archive preserves the initial failed reconstruction, independently reviewed retry, successful preparation and producer package readback. [The preparation report](../../release-navigation-prerelease-preparation-20260911.md) gives current interpretation. No executable, package ZIP, clone, cache or private profile is copied here.
+
+| Directory | Scope |
+| --- | --- |
+| `initial-failed/` | Exact helpers, static admission and failed checkout result. Original Git stderr was not retained; later path-length correlation is a hypothesis. |
+| `producer/` | Exact retry helpers, initial failure audit, successful prepare/metadata/package receipts, root-state checks, 500-file/15-newline source reconstruction and producer 559-file package readback. |
+| `reviews/` | Both independent static reviews, preserving their pre-execution scope. |
+| `source-identity/` | Actual initial/retry commit objects: same tree/parent/message and only author/committer timestamps differ; exact reconstructed newline attributes. |
+| `historical-server/` | Fresh 120-file equality to published b2c3e540 Git blobs and original tar, original workspace Cargo/build files, full tar member hashes, and unique historical dependency notice inventory. |
+| `package-metadata/` | Exact package metadata, current dependency notices, notices summary, documentation check, checksums and launch text. |
+
+The final preparation used reconstruction 802855f7e6f2f00a107a12196b458b267f586b8d; initial failed 613c480a remains separate. Neither is relabeled as the GUI's original build commit. GUI B183 and historical server EFEE retain distinct build provenance. The original 459-file tar identity is recorded, but its bytes are external; the cited published Git commit reconstructs the proven 120 core/server input set, not the entire tar or original executable. Five original workspace/build files are included to preserve their separate historical scope. See the [committed contextual review](../../release-contextual-source-prerelease-review-20260911.md).
+
+`references.json` maps reused GUI gate and historical build records to byte-verified committed equivalents, avoiding duplicate archives. The unique historical notice inventory is retained because it differs from the previous contextual package's generated notice file. Original absolute paths in receipts describe actual execution. Preserved README/VALIDATION.pending files are historical adapter instructions; their original future/pending wording is not edited into a result.
+
+Producer package: 559 files, ZIP SHA256 d7228c542f162663933ea002739a78c722bcca41e437df63b7c868ea2af201f1, 32,971,712 bytes. Readback passed; independent extracted artifact/server/native acceptance and release publication are separate. Native-v4 B183 repair checks already have their own [archive](../text-navigation-native-20260911/repair-save-native-v4/README.md); they do not imply this package was launched. Linux remains paused.
+
+The source-only branch was published and read back at 21:17:00 UTC: [exact reconstruction802855f7](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/src/commit/802855f7e6f2f00a107a12196b458b267f586b8d). `producer/push-source.py` and `source-push-result.json` retain that bounded normal push; no tag, release or artifact upload occurred in that operation.
+
+`manifest.json` is the raw payload whitelist. `verify_archive.py` reads hashes, reconstructible references and actual receipt consistency without executing adapters, applications, Cargo or an oracle. No originals were deleted or changed.

harness/experiments/navigation-prerelease-20260911/historical-server/git-inputs.json

@@ -0,0 +1,727 @@
+{
+  "commit": "b2c3e54001fc19a05423bcd5808ceea78d13ff59",
+  "publishedCommitConfirmedViaGiteaFileRead": true,
+  "scope": "120 core/server input blobs; not full tar, original whole workspace, compiler or rebuilt-server proof",
+  "inputs": [
+    {
+      "path": "crates/oa-core/Cargo.toml",
+      "sha256": "64824ec447be777841a972bf06c894ef2624a37e4725583bcfe0389deb9f00a3",
+      "gitBlob": "df5452b58465cca1db7f3a29529db50e612dcd3a",
+      "bytes": 342
+    },
+    {
+      "path": "crates/oa-core/build.rs",
+      "sha256": "ab1be6ae1fd8bf3ebaeef6348347a9d5e666bde693126f199e041659e0b094a9",
+      "gitBlob": "f182d7d00d235f431ad9153215f0b5d2698af781",
+      "bytes": 45
+    },
+    {
+      "path": "crates/oa-core/examples/generate_demo.rs",
+      "sha256": "e26f432c95331aeca50985dbb3ad2c558affd43023b585811f0f7bfaa59f6661",
+      "gitBlob": "75cd36db4917a6cd2bf53fa50d32e8e9503b2da8",
+      "bytes": 795
+    },
+    {
+      "path": "crates/oa-core/examples/generate_release1.rs",
+      "sha256": "1d5f11165d74893e4bc18dbf3a2f2111f4026bd89fd06ee7f0bae69e45c4d4b5",
+      "gitBlob": "4f2e945121143733f098c4be38ed4d5dc956f80b",
+      "bytes": 1798
+    },
+    {
+      "path": "crates/oa-core/examples/release_dense_views.rs",
+      "sha256": "a83158488ef9b7394f136c52b1496719be935c4e5bdfe457cab5c9894f5f9412",
+      "gitBlob": "acc62bacd19eb21fb5de149535d5ea4db97345d5",
+      "bytes": 14664
+    },
+    {
+      "path": "crates/oa-core/examples/routing_workshop.rs",
+      "sha256": "571307b18b6d4fa04700c5a4d4b0c2154c419e93a21292b2028e7b6f46a2faa7",
+      "gitBlob": "8d02fa13f4523a97cddcf7cb0377bbf010dc0acc",
+      "bytes": 17248
+    },
+    {
+      "path": "crates/oa-core/src/data.rs",
+      "sha256": "7f9c7c7dd8353cb5a38597b92cde6d3e890203d392473187eb387d41ff37414a",
+      "gitBlob": "df061a8cfa0d90a4f94679dc888cdc00c11156a3",
+      "bytes": 42696
+    },
+    {
+      "path": "crates/oa-core/src/demo.rs",
+      "sha256": "ad62123f96c20ff023cafc1a9849b0fa06bc62edd1fb9701799e4599b458600c",
+      "gitBlob": "93cb45e909528991dcc12551e882d68850e352ce",
+      "bytes": 20657
+    },
+    {
+      "path": "crates/oa-core/src/language.rs",
+      "sha256": "638f08a42e9cf4996b5d07f69b4d6f517a518369f3604d25be1006e40e080765",
+      "gitBlob": "37d42e7fe51eeec5e17be45174c9bdc3f93d0c35",
+      "bytes": 99938
+    },
+    {
+      "path": "crates/oa-core/src/language/semantic_source.rs",
+      "sha256": "584b5bb59d87a7b8d44d5dd2d124c3a1323b21492b138a17bc9526c0087c9e29",
+      "gitBlob": "fad23ef92becf595691437240a8ddb2ee52a2523",
+      "bytes": 7326
+    },
+    {
+      "path": "crates/oa-core/src/language_nesting_tests.rs",
+      "sha256": "bd061611e8cb6f28ab203c73e544ac98bf275eb464cd314ad5fbd25f773df33b",
+      "gitBlob": "11df0b3b3175021a2aab977a3d291ab8cd4d94f7",
+      "bytes": 20639
+    },
+    {
+      "path": "crates/oa-core/src/lib.rs",
+      "sha256": "52cb6ee7a4ffc00711ecf121c1a1b14ca154863f7ca27b0d2a8e239edce8aca7",
+      "gitBlob": "7197328c5bc9d91d0adf369d32ffc945e5873898",
+      "bytes": 523
+    },
+    {
+      "path": "crates/oa-core/src/migration_v2/README.md",
+      "sha256": "fb61d3faa33d7bdfba73415415a0882c0fbd3e0b45df42f972a19aec6da927b9",
+      "gitBlob": "767b7a324e47bd3c7f979a760123a6884d0b4a76",
+      "bytes": 1515
+    },
+    {
+      "path": "crates/oa-core/src/migration_v2/adapter.rs",
+      "sha256": "66741b4c8354a23b8a932ecc5bf1bc3bb6e74279558757b8c35bc2157a7e51b5",
+      "gitBlob": "76d97cd771bf3f0c74fbc638873792f676dbb07c",
+      "bytes": 9490
+    },
+    {
+      "path": "crates/oa-core/src/migration_v2/mod.rs",
+      "sha256": "857d8bb13b6814daba6780ca770c16352943c01cb130245d055f11b3b957b3e9",
+      "gitBlob": "ba05ca8b35f26b447558f0c1df3c5cdc3fa11c75",
+      "bytes": 1158
+    },
+    {
+      "path": "crates/oa-core/src/migration_v2/model.rs",
+      "sha256": "8ac63eb59b2e57bdecff2477ee0634096090924d3dd1851e1c454880a889dacb",
+      "gitBlob": "ff5da7b810a352ce916fc619584f6b93488d6ebc",
+      "bytes": 52059
+    },
+    {
+      "path": "crates/oa-core/src/migration_v2/references.rs",
+      "sha256": "33a6819abc83139fdaebeebd1b553238a328637106cce7dd5a535f1791d43e20",
+      "gitBlob": "e363dedb7301daf3eef471e065b24be0eec861f7",
+      "bytes": 13369
+    },
+    {
+      "path": "crates/oa-core/src/migration_v2/source.rs",
+      "sha256": "74fee9b24e7c912182c998ab9d9aeec125e2009c3214959229e844c67afe2bf6",
+      "gitBlob": "28814b107a9c7d6ccc3f72dc18ae45bc1023121c",
+      "bytes": 21946
+    },
+    {
+      "path": "crates/oa-core/src/migration_v2/state_validation.rs",
+      "sha256": "e29ef071bab0a68460ddf55c46131c6f66c022d52c3c602c37c013c3649da1b0",
+      "gitBlob": "75b5839658154f06ac16ad1bb8aa05785e35f415",
+      "bytes": 15769
+    },
+    {
+      "path": "crates/oa-core/src/migration_v2/transitions.rs",
+      "sha256": "f74174c532ba56b57c80b719a11fb4adea0a78ccc2828fff72fe2b9eda5a10b1",
+      "gitBlob": "f4d895db08682d9dce55165894a948eb0a62868b",
+      "bytes": 704
+    },
+    {
+      "path": "crates/oa-core/src/migration_v2/validation.rs",
+      "sha256": "6d5e4a4e2805ae5045bf789a0485e14a61c63346587bace2b4a91173a688f780",
+      "gitBlob": "75a18a99c3ef75a0fcf3b7c6a5cc477425d63f70",
+      "bytes": 98736
+    },
+    {
+      "path": "crates/oa-core/src/migration_v3/README.md",
+      "sha256": "3755a63f840d7f0eadf68afa7a9d587877a9468ff982d3610539e8a0bb067a82",
+      "gitBlob": "290a5a78909c1c4ffc342156ea5e2465555b16de",
+      "bytes": 2128
+    },
+    {
+      "path": "crates/oa-core/src/migration_v3/mod.rs",
+      "sha256": "f4edb6a0b50ecfe8670973776d703047b064420cb1f05913129c00fc656b3722",
+      "gitBlob": "2d1ef1060e16d84b04401b4bc909d023643155ef",
+      "bytes": 23023
+    },
+    {
+      "path": "crates/oa-core/src/migration_v4.rs",
+      "sha256": "50c652964f0f309e7f3f54b6ef12c40d42fcecc0490f005995c713df1179af70",
+      "gitBlob": "6127f7243899e29638c46b5229865c13f8650dc1",
+      "bytes": 4020
+    },
+    {
+      "path": "crates/oa-core/src/model.rs",
+      "sha256": "4585c895c64c4a183941c92cf047a9e52ff0cbe41971e16e78d229ea9dc101fb",
+      "gitBlob": "041639a6366378f094f4d6a46edbdfe374bb5baa",
+      "bytes": 66352
+    },
+    {
+      "path": "crates/oa-core/src/operations.rs",
+      "sha256": "a5ffbbf54cd440316a106d1188bfb699b57dae59f466edcb33618c333cd19f41",
+      "gitBlob": "90f4bfc149174683e9f51f9f7497cccd5e6fb791",
+      "bytes": 11405
+    },
+    {
+      "path": "crates/oa-core/src/persistence.rs",
+      "sha256": "1c01474f906a63e552c0d590b272c95821c00a100b3e79e58e67dbbeac341a14",
+      "gitBlob": "39f496d701a73358bcb6d770fb053c9abd187a28",
+      "bytes": 31774
+    },
+    {
+      "path": "crates/oa-core/src/ports.rs",
+      "sha256": "5cac12eea70a54ebebbd6be77b63ce92e3195325c4bc7d27705c518686cbac80",
+      "gitBlob": "2c5b09a9d1348e240ed8e59a7f34a4f8e01a92b2",
+      "bytes": 45413
+    },
+    {
+      "path": "crates/oa-core/src/projection.rs",
+      "sha256": "69ed12bace2cc5024e151752a174ab14034ac2d05eb741fcf13e9a27521c059b",
+      "gitBlob": "befb027b5299cfb3c7f39cf59da99bd366767a02",
+      "bytes": 21374
+    },
+    {
+      "path": "crates/oa-core/src/projection/port_layout.rs",
+      "sha256": "a08d17d10a58bb8b206dd001b19b91d5aa3a9f743b298a4da57d503223c20079",
+      "gitBlob": "c8ec61dff36bfd6cde9031212fc9d007a61c04de",
+      "bytes": 13474
+    },
+    {
+      "path": "crates/oa-core/src/projection/state.rs",
+      "sha256": "73a607bac713ec7ff49a509fefb1a53c7686dca93ee241ffc835564d743afb28",
+      "gitBlob": "1419b0339de9965fb6aefd4265cff2ce5328dbd6",
+      "bytes": 5233
+    },
+    {
+      "path": "crates/oa-core/src/references.rs",
+      "sha256": "93553c234f32da35f1f41a7b83ad81c471c9803efa78ca222cf7de3c2f86c0bb",
+      "gitBlob": "470337f671926871c8c6ef617776b0287ebfbe0b",
+      "bytes": 21957
+    },
+    {
+      "path": "crates/oa-core/src/routing.rs",
+      "sha256": "c5ebb350ba76f731f5c48d968bfbba4b6ef68ec046eb5893d116c4637ef15080",
+      "gitBlob": "16d9dd0122dbed617512983c93af6970625d56c5",
+      "bytes": 50309
+    },
+    {
+      "path": "crates/oa-core/src/semantic.rs",
+      "sha256": "f9895dd5b8fb27d10d4cfbb41c3542ef2018365a589b8d5778e5674ae5a1f239",
+      "gitBlob": "517a1854f0ce655a72ff4b3596f1da4b5e72c8cc",
+      "bytes": 540
+    },
+    {
+      "path": "crates/oa-core/src/semantic/catalog.rs",
+      "sha256": "1ff74fcca18084d178681d7ff38ee1ccac632c27c4de0595ba1ceab8067ab3a4",
+      "gitBlob": "1e1f44e408cb8cd8b0e846a0214bf7938f3b2de7",
+      "bytes": 49407
+    },
+    {
+      "path": "crates/oa-core/src/semantic/historical.rs",
+      "sha256": "eaf3284bf234312698514cdb636bc8348e1b5d746cb16b18df777e77d312abfb",
+      "gitBlob": "e2283cfeb05ebcc203244064d9b74af26ff4cabf",
+      "bytes": 15271
+    },
+    {
+      "path": "crates/oa-core/src/semantic/linked.rs",
+      "sha256": "6f335b14e809aecfc35defcaf77cb821b080d1506dbc46297912b25af98c07a2",
+      "gitBlob": "41741e0334ecfddf1f63d9499ce9181b446735cb",
+      "bytes": 6035
+    },
+    {
+      "path": "crates/oa-core/src/semantic/mutate.rs",
+      "sha256": "dc2b4c4a6eb156fe468eaa8c85fd37a505c0cd8ea1f226cb69cd01689afd3d9d",
+      "gitBlob": "8d80d6f94b4c9f1f13f62e4559c9a0e1b788a640",
+      "bytes": 22683
+    },
+    {
+      "path": "crates/oa-core/src/semantic/review.rs",
+      "sha256": "0c157d2c327e72e89cca3b423e71ee73798105c5bb7271439c1a101642c91e3e",
+      "gitBlob": "c77d2f893edb2cdcb1260926ce132ed7f3c11de6",
+      "bytes": 51116
+    },
+    {
+      "path": "crates/oa-core/src/semantic/types.rs",
+      "sha256": "6922fe35089f12fad43ab0ce1c6886d01a3855f90b8e2543e99802ac5e6f1bbb",
+      "gitBlob": "69a3d758fc23edf87c67c60cb24c33a3eb3e634d",
+      "bytes": 10405
+    },
+    {
+      "path": "crates/oa-core/src/session.rs",
+      "sha256": "1eb77b329b2986fc6f5dc0171e77fd860375cdfd8c769a1367b445d6c49ebe00",
+      "gitBlob": "0e740810c0a74f2217220c57b6c303dd84299e53",
+      "bytes": 35237
+    },
+    {
+      "path": "crates/oa-core/src/source_files.rs",
+      "sha256": "669491dbddb8e8e6556161426dffa1a49ac1c826d31020bff0956d81a4d84683",
+      "gitBlob": "524ec44e66e73f9548d2681ee0f9f5f062b81987",
+      "bytes": 74803
+    },
+    {
+      "path": "crates/oa-core/src/source_project.rs",
+      "sha256": "1394370bcc5908873b830c2c11312e6e1611af41f46c4f43ca0a6bcb713bb466",
+      "gitBlob": "4d3e377f616154aae32bcaf85aaf1f284e137388",
+      "bytes": 61843
+    },
+    {
+      "path": "crates/oa-core/src/source_project/source_migration.rs",
+      "sha256": "add463ae85c420f853d324b00a221f0f874164cc3f3ed6bbb07557a9ed7a8c95",
+      "gitBlob": "05ce86d18272459c6c2cfd54e2811d21fbdc7499",
+      "bytes": 4700
+    },
+    {
+      "path": "crates/oa-core/src/source_project/source_structure.rs",
+      "sha256": "9f1f83315856a7025fe662c0fbb13452f31613224a03663150d6225d1ddc162f",
+      "gitBlob": "da13ea994d07509c59c164ceadc76cf0091e7dd6",
+      "bytes": 20225
+    },
+    {
+      "path": "crates/oa-core/src/state_validation.rs",
+      "sha256": "e28d7f74385e2a78763716b34491bd73a00bfeccc085970ceb130627e3faee18",
+      "gitBlob": "5a8a2f19f79dafc584c493ccb8ef1d7fdba4646a",
+      "bytes": 15665
+    },
+    {
+      "path": "crates/oa-core/src/topology_context.rs",
+      "sha256": "16de69b297de95d93c73808621607833b713af811dd082f0169186ae1e5c3e2d",
+      "gitBlob": "72acf368a7ebab64b5af6849850c24361f653abe",
+      "bytes": 13734
+    },
+    {
+      "path": "crates/oa-core/src/topology_context/analysis.rs",
+      "sha256": "dead6194f0aa60cc46045c0e5ee10dbdbb689158c38634dfbbbc45d2ba88ac65",
+      "gitBlob": "f2c7bf9bd8906208818e20a5d8cd1cecb7ff439f",
+      "bytes": 20036
+    },
+    {
+      "path": "crates/oa-core/src/topology_context/analysis_tests.rs",
+      "sha256": "17839263410815e96fe027d4eba3aae0a9ab3b82b16947e2b29ebe0d09782b56",
+      "gitBlob": "05695d9dc8a4f41319af6bbe5b46c9c0ed56d26d",
+      "bytes": 5258
+    },
+    {
+      "path": "crates/oa-core/src/transitions.rs",
+      "sha256": "fadd1b07b89cae4117b91abb4f1ac9ea81ff818ef20f2175e76ee8cf21fb708d",
+      "gitBlob": "2abc00c2decfa93fd927982d8d91f8fab47ea3a2",
+      "bytes": 51998
+    },
+    {
+      "path": "crates/oa-core/src/transitions/communication.rs",
+      "sha256": "2b476630a88edd9021b9156ca12a5402e01604095f0d4002afb452671903a028",
+      "gitBlob": "500a571d9268aa13c9b78bf863cffe53338f73cc",
+      "bytes": 8634
+    },
+    {
+      "path": "crates/oa-core/src/validation.rs",
+      "sha256": "7c1b4ae5e4ebba13e99af9158ccde138dfc5e9a7afb580e76fba72d0b64ba74e",
+      "gitBlob": "3a121067c981520ef9e8699e8776ca28b4e84707",
+      "bytes": 112792
+    },
+    {
+      "path": "crates/oa-core/src/validation/coverage.rs",
+      "sha256": "b08e4b344ecad055714168c83beff7fe29ba4edc53edbffa2eae04e5580a4d5f",
+      "gitBlob": "c22863ab8e3ccd385ec65c633e275db2296b69ae",
+      "bytes": 6478
+    },
+    {
+      "path": "crates/oa-core/src/view_options.rs",
+      "sha256": "421ede0a04c593ca1df0e6e0d06fabcfcc8113cdbcfb0adc7f5c8ef4d1724208",
+      "gitBlob": "e57d4f33f763a47a80a9c94d68c7a28941eacb7c",
+      "bytes": 24481
+    },
+    {
+      "path": "crates/oa-core/src/view_options_tests.rs",
+      "sha256": "64aac44de2df42a1012239a3dd75c473daf0c8990b3170b7bf7e78a556080208",
+      "gitBlob": "27825385949e210db29473ad730061a3a9ea45a2",
+      "bytes": 21433
+    },
+    {
+      "path": "crates/oa-core/tests/communication_boundary_scenarios.rs",
+      "sha256": "e1100b8f363910a487d90c73acc7df543dc6d532158c3c63ad11cd3d40d8e12b",
+      "gitBlob": "acb6ee8aae7afc273c97e5d273492a09ac919552",
+      "bytes": 8816
+    },
+    {
+      "path": "crates/oa-core/tests/communication_means.rs",
+      "sha256": "a25f2749180bc6f4beb1445bfad3351eedf0669131a7439b633ab804439e95a4",
+      "gitBlob": "fd1eaa04961b9680115aff000c5d2b8614d103b0",
+      "bytes": 18102
+    },
+    {
+      "path": "crates/oa-core/tests/coverage_diagnostics.rs",
+      "sha256": "e2e9c3996daab47f2bd23f5d8c48b4e372af33331152f5fc85b76f06d04fcdf4",
+      "gitBlob": "6d38588683b7967cb2715ec13d47566c43a78eb7",
+      "bytes": 20527
+    },
+    {
+      "path": "crates/oa-core/tests/fixtures/v2-coastal-rescue.arcadia",
+      "sha256": "f0df129c1914bfc01d0b047b0cd4b520d8cf0c249ea9ced085de400c0be87ff3",
+      "gitBlob": "13395396888a8571d4216be7d5acf0bbf61b523d",
+      "bytes": 29220
+    },
+    {
+      "path": "crates/oa-core/tests/fixtures/v2-coastal-rescue.json",
+      "sha256": "3ed53508eb544bbd788832f7bebea2ec31b3d66191f24f45098cc9750ec4c005",
+      "gitBlob": "b98ce4277da6dc87d10cb3ec3b3858ede06f9465",
+      "bytes": 43990
+    },
+    {
+      "path": "crates/oa-core/tests/fixtures/v3-data-contract.arcadia",
+      "sha256": "305f19d1b79f99f8d4cf627ba2e9ca6836bb7959cc0070227815937a699eafea",
+      "gitBlob": "f581eca2a8f302ede5485a4697384034ac71b0b0",
+      "bytes": 2450
+    },
+    {
+      "path": "crates/oa-core/tests/fixtures/v3-data-contract.json",
+      "sha256": "1b41299c53204e6232397d25a58d5bccdbbc16e770c75e8edb55ce36ccfe58a2",
+      "gitBlob": "e854c1d5048cb5bb6050685346eaa5cf3523daa9",
+      "bytes": 8240
+    },
+    {
+      "path": "crates/oa-core/tests/fixtures/v4-reviewed-prose.arcadia",
+      "sha256": "5fa53a26a5ad010c8e59eb56d9b2b52003569e66c0377ffb58840590168ad0c1",
+      "gitBlob": "39d340042cacf741a6e5e7429930d95e2fad1510",
+      "bytes": 1222
+    },
+    {
+      "path": "crates/oa-core/tests/fixtures/v4-reviewed-prose.json",
+      "sha256": "2808088afcc165f4bd6da5129151143411c997041c3de61d600ab76e05d24a47",
+      "gitBlob": "7b792aaefd68c6fe2775a21b81421712a6209185",
+      "bytes": 1734
+    },
+    {
+      "path": "crates/oa-core/tests/language.rs",
+      "sha256": "77f6cb2a69976bfb5f60b243b71c07fb0edc7505002c1e9e73fcd6ddf6d9496e",
+      "gitBlob": "b598ed8a13b4330e3b3c6f72899e51c224a1cb73",
+      "bytes": 56482
+    },
+    {
+      "path": "crates/oa-core/tests/port_anchors.rs",
+      "sha256": "efbc0fa18733b1aaac501f9785a4c392fc49c05c45a5778d26e9b5dd951ca6fa",
+      "gitBlob": "bb92f098078494cec973b363cddb124b3d8ea8b3",
+      "bytes": 26893
+    },
+    {
+      "path": "crates/oa-core/tests/port_migration.rs",
+      "sha256": "1801c376a5435ac7efb2a8342348b2c7ffef930bba65deca4acb66b06e0483d7",
+      "gitBlob": "4a724508e4d6d52d5f6566fd016509386093f243",
+      "bytes": 15620
+    },
+    {
+      "path": "crates/oa-core/tests/port_source.rs",
+      "sha256": "8d2ddaca4045d330f6eda2591561497b858aad53769a823249d0bea4f5916e12",
+      "gitBlob": "b98aba04c75de75fd7d6d105ef8b34768c1e3742",
+      "bytes": 4858
+    },
+    {
+      "path": "crates/oa-core/tests/prepared_commands.rs",
+      "sha256": "52cab1c668064777412df0a6a3c20d74d579b33794b4b00525b9f151c06eac9b",
+      "gitBlob": "e4d372ead6b07f992c54acb83409df5181f64852",
+      "bytes": 9555
+    },
+    {
+      "path": "crates/oa-core/tests/process_diagnostics.rs",
+      "sha256": "1dbbc590239ef7542be4a2bdc9543aaa64d108417b03dd312a0894e364745906",
+      "gitBlob": "afd06471966416a1d94ca9a19a4c43c46c50489f",
+      "bytes": 1104
+    },
+    {
+      "path": "crates/oa-core/tests/r3_constructor_ack.rs",
+      "sha256": "e5c44676ea0aab97f2e091ddac2f4bc4a4a90f5877f7bbf08b61229600944dd0",
+      "gitBlob": "d580986633bce3b263485d1b8f6b0b7954d617de",
+      "bytes": 24163
+    },
+    {
+      "path": "crates/oa-core/tests/r3_migration.rs",
+      "sha256": "ebd04120f5215b3956fdc79ee78f6e38734c7d13392f1fc28aaba957912265bd",
+      "gitBlob": "4956ec9d6a25041dcc48998f72ca93e48d0b965c",
+      "bytes": 6590
+    },
+    {
+      "path": "crates/oa-core/tests/r3_semantic.rs",
+      "sha256": "49c3763eaf2131070a7c46cc23a84f917d292d41610b6404510e5607f8890c32",
+      "gitBlob": "4f330a4134ee53de52d99f47f484ba8eabfcacbf",
+      "bytes": 77473
+    },
+    {
+      "path": "crates/oa-core/tests/r3_source.rs",
+      "sha256": "f31f60659df3c7ef601650d1cff140589d8729f01a3f65a4a6a6c2272f15c408",
+      "gitBlob": "e8396d7faf925a6303c1dd00f4a4e9daf34c8bbf",
+      "bytes": 15311
+    },
+    {
+      "path": "crates/oa-core/tests/r6_data.rs",
+      "sha256": "5f7ffb3bc73c3c85423623fe56f8680646dc97040327bdbead9d47a37e80f155",
+      "gitBlob": "70191d2b10900d2cd8cb26e1079876562cbb11b2",
+      "bytes": 41437
+    },
+    {
+      "path": "crates/oa-core/tests/r6_migration.rs",
+      "sha256": "81519bc1512f5e069432e9a1cdad04c10216d492df01b4b75b02102480ebd6a1",
+      "gitBlob": "d989913ae39161c064bd04975edb2b647bff7064",
+      "bytes": 9174
+    },
+    {
+      "path": "crates/oa-core/tests/r6_source.rs",
+      "sha256": "88a0aa087a7678e2898ff6057538072ca92072190712f05fff08372cc56ebed6",
+      "gitBlob": "6f67338bccc87d1bd148c3395ce9d0c94ca1f152",
+      "bytes": 9519
+    },
+    {
+      "path": "crates/oa-core/tests/release1_teaching.rs",
+      "sha256": "be179290d871125dc97cfd2a3067c7ac89c8a538fdb0afafc5b825bcdfb2bef2",
+      "gitBlob": "3b75d61e6166b72b47c98ca58a253f5f192b5e46",
+      "bytes": 10010
+    },
+    {
+      "path": "crates/oa-core/tests/release_capabilities.rs",
+      "sha256": "b92cba2a562e78287ddd7dc3e94557848d17faa0c8a102601b50286b9af48a30",
+      "gitBlob": "d22101abfca29bd213756c730fef665126773b5d",
+      "bytes": 19422
+    },
+    {
+      "path": "crates/oa-core/tests/release_diagrams.rs",
+      "sha256": "cefcc0582d91266d5de6ee5daefcfe41b606ab971ab235b59034a8e1dbc24b7d",
+      "gitBlob": "32a9c5e34d7ebdb7ea2c2647d16399a33db7a585",
+      "bytes": 7689
+    },
+    {
+      "path": "crates/oa-core/tests/release_language_limits.rs",
+      "sha256": "8578da4f76bbd2d0e1bfe295ab1259e2162a3fe3d0d2ba8901915d7a40942806",
+      "gitBlob": "334500fb0218ca9de5b90ae249ec6da81898aad7",
+      "bytes": 5204
+    },
+    {
+      "path": "crates/oa-core/tests/release_ports.rs",
+      "sha256": "506e62beab0c7ec0cece83e9e0c1a810fa1f99285c9e1cab0c77f06de55a40e1",
+      "gitBlob": "9673b478bc80621e6ded50be4732d080dfc9eee1",
+      "bytes": 32740
+    },
+    {
+      "path": "crates/oa-core/tests/release_routing.rs",
+      "sha256": "ae168faaba23769b7ca1fd65f217b9db671726e67276eb5a04e5e72b1447a462",
+      "gitBlob": "c7e596c1f914b23ce56169f247ecb8c1620cc718",
+      "bytes": 23165
+    },
+    {
+      "path": "crates/oa-core/tests/release_scenarios.rs",
+      "sha256": "0f5d876badeec653fc7b12610a77d867e9a53582e605253deff8d379da21572f",
+      "gitBlob": "7cdb00b1c1a894e653bbd8724fef374b1157aaf5",
+      "bytes": 41067
+    },
+    {
+      "path": "crates/oa-core/tests/release_states.rs",
+      "sha256": "b1a26acee95eaba7f9920f9da738a1e33606552eb078e6d298895daff7e3d811",
+      "gitBlob": "c82311ae75f072739bd33c88805679d7bab08d99",
+      "bytes": 26873
+    },
+    {
+      "path": "crates/oa-core/tests/release_topology.rs",
+      "sha256": "c51dbe5aa5a038f9ed830daa02aa67714472179eb7fd6da5ce36dc6931c8b3a9",
+      "gitBlob": "caac7fb403643744b91050d5901e2a8649541e3a",
+      "bytes": 17643
+    },
+    {
+      "path": "crates/oa-core/tests/review_regressions.rs",
+      "sha256": "f154e5c88d35e31512e2b07733a1327ea3e2fcfd1ef8eb23066a4e9573f387c1",
+      "gitBlob": "fc5ff8646751c8c8ea13a7f80d2c868eaedcc0c6",
+      "bytes": 21823
+    },
+    {
+      "path": "crates/oa-core/tests/route_source.rs",
+      "sha256": "1a73fdbac0d0ae0e84d8d67b6ad398e11223958f5dca007f73757c91827decfb",
+      "gitBlob": "8861d66f0d286a08097bf73614d58bfc3fe6b40f",
+      "bytes": 7270
+    },
+    {
+      "path": "crates/oa-core/tests/routing_geometry.rs",
+      "sha256": "2d8eea4a2bba535ed0ea6daabccdaf87b375828c404baa10518c7bd7fd6253d3",
+      "gitBlob": "f242e799f2710f448da6014a95ff1a82f1421c7d",
+      "bytes": 31890
+    },
+    {
+      "path": "crates/oa-core/tests/routing_labels.rs",
+      "sha256": "dff884d799c3c5c9257210248c55767e294e3cb317c605cbd0ddc9600c216eb6",
+      "gitBlob": "a6299a5e265b7c50656f7dfd4fc2b880bd296459",
+      "bytes": 5530
+    },
+    {
+      "path": "crates/oa-core/tests/semantic_artifact_absence_oracle.rs",
+      "sha256": "d93eaf9667f4221232168bef0fe9f069e5be1b1f23410bda5dd67010b96e5c8a",
+      "gitBlob": "e17536904031350c2431fd0bd24759893df6b226",
+      "bytes": 4640
+    },
+    {
+      "path": "crates/oa-core/tests/semantic_attachments_gui_oracle.rs",
+      "sha256": "7f526d363ba05e7ac89faf0fead0796e419c34ee204edf44a1b46c78308b0970",
+      "gitBlob": "611cc1c60f97cce705262119017df59520eade28",
+      "bytes": 14957
+    },
+    {
+      "path": "crates/oa-core/tests/source6_view_contract.rs",
+      "sha256": "fa566de53946d40bbbd9033edfeed177180c4dc44afa2f2f4667ffdc622eb3bb",
+      "gitBlob": "ac25c8feacd7ed9e5938dddf09dcb124fb8e674d",
+      "bytes": 14307
+    },
+    {
+      "path": "crates/oa-core/tests/source7_contract.rs",
+      "sha256": "cad4f1a135ddbd947bdf3c71d1b44f1e438725095ea8c4d893464bc721c2363f",
+      "gitBlob": "d33a2ea74cc084bfeb3bdf8355d282be86e005e2",
+      "bytes": 43262
+    },
+    {
+      "path": "crates/oa-core/tests/source_files.rs",
+      "sha256": "f0429a0b89a443458ea9af7083c1e4e7411417a7e6b47e618bfbb9266dc164f9",
+      "gitBlob": "8749684acca054b972813976ef1c12502f2d0b3d",
+      "bytes": 13168
+    },
+    {
+      "path": "crates/oa-core/tests/source_identity_updates.rs",
+      "sha256": "f52aa38b4d317e532c641ad7463472e4b40e802e60052cf0017556ffc63da06c",
+      "gitBlob": "757b06ba9b7263f7fee8b672f0b59725dc36c798",
+      "bytes": 5139
+    },
+    {
+      "path": "crates/oa-core/tests/source_nested_updates.rs",
+      "sha256": "9ac3390936c0d250651ea94a1b8faf0adfb680f061ececc56f2a52909b5ba855",
+      "gitBlob": "0e706df036b648dfb9a0be3313db3265085050f5",
+      "bytes": 16892
+    },
+    {
+      "path": "crates/oa-core/tests/source_project.rs",
+      "sha256": "cef58adb16aa4d2527ddc0628aec3e26f0b42b4be70014a7e360fafdac13a942",
+      "gitBlob": "0171cc852816a0886d01ab3fc38630937c09fc50",
+      "bytes": 45910
+    },
+    {
+      "path": "crates/oa-core/tests/state_diagrams.rs",
+      "sha256": "6b02b387a3ae559cb3ad72de24292a5abcb76aaac0adbab5d2aa5211b22cd2e5",
+      "gitBlob": "959dc9409839d84377c46be6bc79d20054aea3cf",
+      "bytes": 23973
+    },
+    {
+      "path": "crates/oa-core/tests/workflows.rs",
+      "sha256": "bd843dfddbd5724ec08f657571f887496203056fe2fa5864ef50a168a613b89b",
+      "gitBlob": "c9b5f01d30cceac341507d83db8eb8a12fa8e70a",
+      "bytes": 33426
+    },
+    {
+      "path": "crates/oa-server/Cargo.toml",
+      "sha256": "527ff5e15010a8b560a6659aa1ae4bf0c8df0d9e019f03c47529ec6a750c0982",
+      "gitBlob": "2da96b186173354b55d1c08790b712ce66ed41ee",
+      "bytes": 778
+    },
+    {
+      "path": "crates/oa-server/build.rs",
+      "sha256": "ab1be6ae1fd8bf3ebaeef6348347a9d5e666bde693126f199e041659e0b094a9",
+      "gitBlob": "f182d7d00d235f431ad9153215f0b5d2698af781",
+      "bytes": 45
+    },
+    {
+      "path": "crates/oa-server/src/error.rs",
+      "sha256": "93817f1502386e4662c96ee1c7d1c4afc4e33bda6fd64e46c86c8e1afd5a9368",
+      "gitBlob": "1b4d7659255968b85f2f4e34e2a544fc963708af",
+      "bytes": 5610
+    },
+    {
+      "path": "crates/oa-server/src/lib.rs",
+      "sha256": "20bef350350ed6339588b23af684abf745f97916c7edf3853ee042abe687e664",
+      "gitBlob": "16150bf16a505846dee8bcb0712e94c6536f90c3",
+      "bytes": 7743
+    },
+    {
+      "path": "crates/oa-server/src/main.rs",
+      "sha256": "d59a6a2b5c7034bd2e00a516d2d49abb16391bf0316c1c357ddafb9c82d2d1e3",
+      "gitBlob": "7d9bc73ac22d89f11fe241086c993e11218e72a4",
+      "bytes": 4163
+    },
+    {
+      "path": "crates/oa-server/src/preparation_http_tests.rs",
+      "sha256": "454b90d0055d35644c8d990cd7576ddf675a9b271ca07fe9b0efce25d8ddbc07",
+      "gitBlob": "93c2cc4cf77016e0783eccb66dda66a6e5b12cef",
+      "bytes": 5523
+    },
+    {
+      "path": "crates/oa-server/src/routes.rs",
+      "sha256": "3f9a0c22043dbf28f7a8e587d2fc3abf869f76f4d23a46fe0aeb9c4392454a4b",
+      "gitBlob": "775b7b13868ff1bbc96d04dbb9f3f34fa236442b",
+      "bytes": 46053
+    },
+    {
+      "path": "crates/oa-server/src/store.rs",
+      "sha256": "37dcfb845b7993d5bced2bcf25fedfcd2a9c20a748f9315afe6cca1f41f89ae5",
+      "gitBlob": "577a0321cc3b17d8502fee22093aa4bd27e64427",
+      "bytes": 25524
+    },
+    {
+      "path": "crates/oa-server/src/store_preparation_gate.rs",
+      "sha256": "427c390da3c0281ba1fe115a93ea90800e3b45fce6bcb9185e71982ddd885fec",
+      "gitBlob": "977de2fa1e126be308273bef875782982377fc2a",
+      "bytes": 4440
+    },
+    {
+      "path": "crates/oa-server/tests/http.rs",
+      "sha256": "50daa6a90e96ad6fe3c6a27df2eaebe486270599c203892d09769c547a194975",
+      "gitBlob": "c4a1524874614e29aa3dbd75dba3f8aa3c1b3e62",
+      "bytes": 71892
+    },
+    {
+      "path": "crates/oa-server/tests/http/communication_limits.rs",
+      "sha256": "ba5474dd8e494a0176fffb4548c8e3deb2081b15de33bfce82394c764e0a2c16",
+      "gitBlob": "3871d6c32264aa7e7b58baeca81dc14a8a49c451",
+      "bytes": 5790
+    },
+    {
+      "path": "crates/oa-server/tests/http/data_contracts.rs",
+      "sha256": "8cd456db83f301baca380acf025a5a99db4edf7d8839537dfbd02c4307e10e6b",
+      "gitBlob": "f47a7fc370c840464ca7d77bfd8c43e0097418d9",
+      "bytes": 25949
+    },
+    {
+      "path": "crates/oa-server/tests/http/port_anchors.rs",
+      "sha256": "7199d0a208ddad9e1518b6e3fb390d64da111716d7505ba5c995deae19ad1258",
+      "gitBlob": "33c424563eee4a73acdec9fab4875bba31090245",
+      "bytes": 15086
+    },
+    {
+      "path": "crates/oa-server/tests/http/semantic_transitions.rs",
+      "sha256": "856d1c9b633ffb581e3e631f4e5a607789a02181dbf060667f208a569bfa4920",
+      "gitBlob": "a16e9ab8898331b938fadd0b612bc332f8017859",
+      "bytes": 22832
+    },
+    {
+      "path": "crates/oa-server/tests/http/source6_views.rs",
+      "sha256": "867bccda0e030eeeb9976b4ceeb47b21ab5044d700278022d5fb495bbb64ca07",
+      "gitBlob": "5ece6f56a563efb726255853ecd046ca0a430ea5",
+      "bytes": 13023
+    },
+    {
+      "path": "crates/oa-server/tests/http/source7_contracts.rs",
+      "sha256": "0e0a467186da7263c0754890aff69ebd0d92d36b5224e4865bb6854b18dab7e8",
+      "gitBlob": "d2d7ac45c8cc7a38f69d7980093ff3ee6a8acefc",
+      "bytes": 11000
+    },
+    {
+      "path": "crates/oa-server/tests/http/source_projects.rs",
+      "sha256": "8ff580f317ec267d1cd72ae14d8638f74a77cdf99ca4c78f66f4290c2d77460a",
+      "gitBlob": "96e5ebc39e80c7fd71079257a2e78a65a48a2105",
+      "bytes": 30907
+    },
+    {
+      "path": "crates/oa-server/tests/semantic_http_contract.py",
+      "sha256": "4737ff94f10761f94151a694414c5c62737e0391ec820bca132830652bc4cca2",
+      "gitBlob": "4af7a777faff716de50612f69e0be6263128f71e",
+      "bytes": 7251
+    },
+    {
+      "path": "crates/oa-server/tests/semantic_schema.py",
+      "sha256": "70c9d267268bd390680f290a585bd4ae0c6d8ef999ee2f32ece6e172293574f7",
+      "gitBlob": "18087f00ebefc4c096b416b7b56f8d7854c98484",
+      "bytes": 25038
+    },
+    {
+      "path": "crates/oa-server/tests/state_representation.rs",
+      "sha256": "6686c826f28248ae4b63ec3f2112e193d4a347724b87974483217fcfee49cd61",
+      "gitBlob": "3bfedc4010b97b7aa776bf15ef75ec456127c7de",
+      "bytes": 12241
+    }
+  ]
+}

harness/experiments/navigation-prerelease-20260911/historical-server/original-workspace/Cargo.toml

@@ -0,0 +1,18 @@
+[workspace]
+members = ["crates/oa-core", "crates/oa-desktop", "crates/oa-server"]
+resolver = "2"
+
+[workspace.package]
+version = "0.2.0"
+edition = "2024"
+license = "MIT"
+rust-version = "1.90"
+
+[workspace.dependencies]
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+uuid = { version = "1", features = ["v4", "v5", "serde"] }
+thiserror = "2"
+
+[profile.dev]
+debug = 0

harness/experiments/navigation-prerelease-20260911/historical-server/original-workspace/build/windows.manifest

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
+    <security><requestedPrivileges>
+      <requestedExecutionLevel level="asInvoker" uiAccess="false"/>
+    </requestedPrivileges></security>
+  </trustInfo>
+</assembly>

harness/experiments/navigation-prerelease-20260911/historical-server/original-workspace/build/windows.rc

@@ -0,0 +1 @@
+1 24 "windows.manifest"

harness/experiments/navigation-prerelease-20260911/historical-server/original-workspace/build/windows_manifest.rs

@@ -0,0 +1,35 @@
+// GNU Windows linkers need an explicit normal-user manifest, including tests
+// named "updates", to avoid Windows installer detection. No elevation is needed.
+fn main() {
+    println!("cargo:rerun-if-changed=../../build/windows_manifest.rs");
+    println!("cargo:rerun-if-changed=../../build/windows.manifest");
+    println!("cargo:rerun-if-changed=../../build/windows.rc");
+    println!("cargo:rerun-if-env-changed=RC");
+    let target = std::env::var("TARGET").unwrap_or_default();
+    if !target.ends_with("windows-gnu") && !target.ends_with("windows-gnullvm") {
+        return;
+    }
+    let root = std::path::PathBuf::from(std::env::var_os("CARGO_MANIFEST_DIR").unwrap())
+        .join("../../build");
+    let object = std::path::PathBuf::from(std::env::var_os("OUT_DIR").unwrap())
+        .join("normal-user-manifest.o");
+    let compiler = std::env::var_os("RC").unwrap_or_else(|| {
+        if target.ends_with("gnullvm") {
+            "llvm-windres"
+        } else {
+            "windres"
+        }
+        .into()
+    });
+    let result = std::process::Command::new(compiler)
+        .current_dir(root)
+        .args(["-i", "windows.rc", "-O", "coff", "-o"])
+        .arg(&object)
+        .status()
+        .expect("Windows GNU resource compiler is required (set RC if not on PATH)");
+    assert!(
+        result.success(),
+        "Cannot compile the normal-user Windows manifest"
+    );
+    println!("cargo:rustc-link-arg={}", object.display());
+}

harness/experiments/navigation-prerelease-20260911/initial-failed/README.md

@@ -0,0 +1,27 @@
+# Repaired navigation prerelease adapters — not executed
+
+Codex-9e8r6t /root/release_audit. Root owns execution, independent acceptance and publication of reserved `v0.2.0-preview.navigation.20260911` (#6/comment493). This is a separate adapter set; the earlier `.local/navigation-prerelease-20260911` and its review remain unchanged historical evidence. No clone, metadata, package, application or compiler was run to prepare this set. Only static AST/PowerShell parsing, source/receipt reads and private adapter writes were performed. `adapt.py` records the initial text adaptation; subsequent narrow review corrections are in the final scripts. Do not rerun the generator over the frozen set.
+
+## Exact scope and provenance
+
+The immutable code commit is `33c6d83e9ba9a5b1310b1b627d7c40affcbcf15c`. The 500 raw build inputs are `.local/text-repair-save-20260911/inputs1.json` (SHA256 `75a282fd3d4cb2dec6763046ea45d0caa015b998281fbdd6f222d8e3a175b13f`) and its ZIP `213fdb39ea7c3601b4baac674c3ab3ecc863ac44db1b092d922d3e24f26887b7`. Gates were actually captured on eeeaa126 with the repair delta; 33c6d83 commits those exact code bytes. The adapter proves normalized Git equivalence and raw-file identity; it never relabels the original gate HEAD as 33c6d83.
+
+The actual five successful command receipts and their hash-bound logs plus complete.json are required. Full suite must report 755 passed, 0 failed, 1 ignored, no filtering. Preserved gui-repair.exe must match actual gui-build-result.json: SHA256 `b183ef31f16b3986538b3f2aba8435eab45978635c47f99ca01be6e72b168848`, 113,206,272 bytes. Old GUI5478 is not accepted. Native-v4 is separately root-owned and pending here; no native pass is inferred from these gates or an application launch.
+
+EFEE server remains the historical September 7 artifact (`efeeb89c0d2e0f93df4472cb3e9f48b2b722a37ae1043c90a5a56f2e845fe665`); runtime remains F456 (`f45604a12e8bcd839fd86f667c1be1cc7c4f9da2b3c69ff381ac708f0e1ae7d4`). The server's original tar, build/hash records and source/notice inventory are copied separately. Current core language.rs differs and language_outline_tests.rs is added. The server is not rebuilt and must never be described as a current-source server. Historical registry checksums must still be locked; readback additionally requires historical package features, license/font notice identities and actual notice bytes in the ZIP. An unexpected difference refuses and requires review rather than a blanket licensing fallback.
+
+## Future explicitly authorized sequence
+
+From repository cwd, use bundled Python `C:/Users/User/.cache/codex-runtimes/codex-primary-runtime/dependencies/python/python.exe`:
+
+1. `python .local/navigation-repair-prerelease-20260911/prepare.py`
+2. With root's metadata lease: `pwsh -NoProfile -File .local/navigation-repair-prerelease-20260911/package2.ps1`
+3. `python .local/navigation-repair-prerelease-20260911/readback.py`
+
+Replace `python` with the absolute bundled executable. These are instructions, not executed results. Preparation exclusively creates source/, source-roundtrip/, bin/, evidence/ and receipts. It uses a separate local clone and branch `codex/navigation-repair-prerelease-source-20260911`; no root index/refs mutation. All 500 paths and bytes must match current working inputs and the designated Git tree. Newline-only restorations are measured afresh, scoped -text rules applied only in the clone, committed locally and checked byte-for-byte in a fresh checkout. No former 11/15-path count is assumed. Original evidence is copied byte-exact; no executable is compiled.
+
+Root may have later **record-only** commits: the designated source must be an ancestor and every changed path must be under harness/ excluding harness/fixtures/. Those paths and the actual root HEAD are recorded separately, never substituted into binary provenance. Any later source, docs, dependency, script or instruction change refuses. Tracked WIP also refuses. Root HEAD/index/status must remain unchanged throughout preparation. Later record files are not silently included in the clone based at 33c6d83.
+
+Packaging retains existing strict scripts, explicit x86_64-pc-windows-gnullvm and one exact locked/offline Cargo metadata invocation. It never builds or downloads. PS7 avoids the prior PS5 native stderr failure. Refusal-to-overwrite remains; a failed attempt preserves partial outputs and needs a fresh reviewed retry directory. Readback derives actual ZIP hash/counts and verifies every stage/checksum/source/evidence/binary entry. It is producer integrity evidence only, not independent package/server/native acceptance.
+
+Do not execute old adapters, publish a source branch/tag/release, or treat VALIDATION.pending.md as final acceptance. No WSL operations are included. All output actions await root's explicit execution after native acceptance; final package GUI/server checks remain root/reviewer-owned.

harness/experiments/navigation-prerelease-20260911/initial-failed/VALIDATION.pending.md

@@ -0,0 +1,9 @@
+# Pending repaired navigation Windows milestone
+
+Draft only. Planned version: 0.2.0-preview.navigation.20260911. No ZIP or packaged acceptance exists from these adapters.
+
+GUI: 33c6d83 committed equivalent of the 500 raw repair inputs, ZIP213fdb39; actual B183 preserved GUI. Recorded headless gates: 755 passed, 0 failed, 1 ignored; strict all-target Clippy, scoped format, diff check and GUI build succeeded. Original build captured eeeaa126 plus the repair delta; exact receipts retain that distinction.
+
+Server: retained historical EFEE September 7 binary with its own source snapshot/build/notices. It is not built from 33c6d83. Runtime F456 unchanged. Current metadata collection is not retroactive server build provenance.
+
+Pending: root's repaired native recovery/save acceptance; actual package creation/readback; independent historical/current notice coverage and packaged server restart/model oracle; packaged GUI launch/save/package-integrity acceptance; final source/tag/asset publication and byte readback. Earlier native5478 passed navigation checks but exposed false-clean Apply status; those passes do not close the repaired candidate's native gate. Root owns replacing this draft with actual results.

harness/experiments/navigation-prerelease-20260911/initial-failed/adapt.py

@@ -0,0 +1,110 @@
+"""Static text adaptation only; never imports or runs the prepared adapters."""
+from pathlib import Path
+import ast
+import hashlib
+import json
+
+BASE = Path(__file__).resolve().parent
+ROOT = BASE.parents[1]
+OLD = ROOT / '.local/navigation-prerelease-20260911'
+def sha(p):
+    return hashlib.sha256(p.read_bytes()).hexdigest()
+old_inventory = {p.name: sha(p) for p in OLD.iterdir() if p.is_file()}
+native = (ROOT / '.local/text-repair-save-native-20260911/helper.py').read_text(encoding='utf-8')
+commands = native[native.index('COMMANDS = {'):native.index('\n\n\ndef now')]
+p = (OLD / 'prepare.py').read_text(encoding='utf-8')
+p = p.replace('import traceback', 'import traceback\nimport sys\nimport tomllib')
+p = p.replace("COMMIT = 'eeeaa1262748800c4c9aaa1eca79a7de96757358'", "COMMIT = '33c6d83e9ba9a5b1310b1b627d7c40affcbcf15c'")
+p = p.replace("BRANCH = 'codex/navigation-prerelease-source-20260911'", "BRANCH = 'codex/navigation-repair-prerelease-source-20260911'")
+p = p.replace("GATES = ROOT / '.local/text-navigation-native-fixes-20260911'\nDESKTOP = ROOT / '.local/text-navigation-desktop-20260911'", "GATES = ROOT / '.local/text-repair-save-20260911'")
+p = p.replace('72c2e8154f9945aa87d0cbf9cc148934a84614e15576673496aa5a5907c12154', '75a282fd3d4cb2dec6763046ea45d0caa015b998281fbdd6f222d8e3a175b13f')
+p = p.replace('7ff9e5703e33bd72e5c2186dd61125e965b82b8dfbf085961d514b005e716798', '213fdb39ea7c3601b4baac674c3ab3ecc863ac44db1b092d922d3e24f26887b7')
+p = p.replace('\n\n\ndef now', '\n\n' + commands + '\n\n\ndef now', 1)
+p = p.replace('inputs4', 'inputs1')
+a = p.index("    gate_path = GATES / 'final-gate-result.json'")
+b = p.index("    server = ROOT /", a)
+p = p[:a] + '''    assert len(expected) == 500
+    complete = load(GATES / 'complete.json')
+    assert complete['archiveSha256'] == ZIP_SHA and complete['inputsUnchanged'] is True
+    assert complete['gates'] == list(COMMANDS) and complete['sourceHead'] == manifest['head']
+    # The gates captured eeeaa126 plus the repair delta; COMMIT commits those
+    # exact raw inputs. Never relabel the captured sourceHead as a clean build.
+    assert manifest['head'] == 'eeeaa1262748800c4c9aaa1eca79a7de96757358'
+    for name, command in COMMANDS.items():
+        receipt = load(GATES / (name + '-result.json'))
+        assert receipt['exitCode'] == 0 and receipt['inputsUnchanged'] is True and receipt['command'] == command
+        assert sha(GATES / (name + '-stdout.log')) == receipt['stdoutSha256']
+        assert sha(GATES / (name + '-stderr.log')) == receipt['stderrSha256']
+    build = load(GATES / 'gui-build-result.json')['binary']
+    artifact = build['artifact']
+    assert artifact['target']['name'] == 'arcadia-studio' and artifact['profile']['test'] is False
+    assert artifact['profile']['opt_level'] == '0' and artifact['profile']['debug_assertions'] is True
+    assert Path(artifact['executable']).resolve() == Path(build['path']).resolve()
+    assert Path(build['path']).resolve().is_relative_to(ROOT / '.local/target-gnullvm')
+    gui = GATES / 'gui-repair.exe'
+    assert sha(gui) == build['sha256'] == 'b183ef31f16b3986538b3f2aba8435eab45978635c47f99ca01be6e72b168848'
+    assert gui.stat().st_size == build['bytes'] == 113206272
+    summaries = re.findall(r'test result: ok\\. (\\d+) passed; (\\d+) failed; (\\d+) ignored; (\\d+) measured; (\\d+) filtered out;',
+                           (GATES / 'desktop-tests-stdout.log').read_text(encoding='utf-8'))
+    assert summaries == [('755', '0', '1', '0', '0')]
+    counts = dict(zip(('passed', 'failed', 'ignored', 'measured', 'filtered'), map(int, summaries[0])))
+''' + p[b:]
+p = p.replace("    manifest, frozen, build, gui, counts, server, dll, old = admission()", """    # Later root commits may record evidence only. Do not silently package later
+    # production/docs/dependency or instruction changes under the tested source.
+    git(ROOT, 'merge-base', '--is-ancestor', COMMIT, before['head'])
+    later = git(ROOT, 'diff', '--name-only', '-z', COMMIT, before['head']).decode().split('\\0')[:-1]
+    assert all(p.startswith('harness/') and not p.startswith('harness/fixtures/') for p in later), later
+    manifest, frozen, build, gui, counts, server, dll, old = admission()
+    for path, raw in frozen.items():
+        assert ordinary(ROOT / path).read_bytes() == raw, f'Current frozen input changed: {path}'""")
+p = p.replace("    # Local clone has its own index/refs", """    registry = {(x['name'], x['version'], x['source']): x['registry_checksum']
+                for x in notice['packages'] if x['source']}
+    locked = {(x['name'], x['version'], x.get('source')): x.get('checksum')
+              for x in tomllib.loads(frozen['Cargo.lock'].decode())['package']}
+    assert registry and all(locked.get(k) == v for k, v in registry.items()), 'Historical registry coverage differs.'
+    # Local clone has its own index/refs""")
+p = p.replace("        frozen[p] = (ROOT / p).read_bytes()", "        if p in frozen:\n            assert frozen[p] == (ROOT / p).read_bytes(), p\n        frozen[p] = (ROOT / p).read_bytes()")
+a = p.index('    provenance.update({')
+b = p.index("    (BASE / 'evidence').mkdir()",a)
+p = p[:a] + '''    provenance.update({'gui-inputs1.json': GATES / 'inputs1.json', 'gui-complete.json': GATES / 'complete.json',
+                       'gui-gate-run.py': GATES / 'run.py'})
+    for name in COMMANDS:
+        for suffix in ('-result.json', '-stdout.log', '-stderr.log'):
+            provenance['gui-' + name + suffix] = GATES / (name + suffix)
+''' + p[b:]
+p = p.replace("'build': 'evidence/gui-build-v3.json', 'preserved': 'evidence/gui-v3-preserved.json', 'inputs': 'evidence/gui-inputs1.json', 'full_gate': 'evidence/gui-full-corrected.json'", "'build': 'evidence/gui-gui-build-result.json', 'inputs': 'evidence/gui-inputs1.json', 'full_gate': 'evidence/gui-desktop-tests-result.json', 'complete': 'evidence/gui-complete.json', 'captured_head': manifest['head'], 'scope': 'Built from captured eeeaa126 plus exact repair input delta; those bytes are committed at base_commit, then reconstructed without changing code.'")
+p = p.replace("'branch': BRANCH, 'source_repository': str(SOURCE)", "'branch': BRANCH, 'record_only_root_paths_after_base': later, 'historical_registry_count': len(registry), 'source_repository': str(SOURCE)")
+p = p.replace("if __name__ == '__main__':\n", "if __name__ == '__main__':\n    sys.stdout.reconfigure(encoding='utf-8')\n    sys.stderr.reconfigure(encoding='utf-8')\n")
+(BASE / 'prepare.py').write_text(p, encoding='utf-8', newline='\n')
+ps = (OLD / 'package2.ps1').read_text(encoding='utf-8').replace('eeeaa1262748800c4c9aaa1eca79a7de96757358', '33c6d83e9ba9a5b1310b1b627d7c40affcbcf15c')
+(BASE / 'package2.ps1').write_text(ps, encoding='utf-8', newline='\n')
+r = (OLD / 'readback.py').read_text(encoding='utf-8').replace('import stat', 'import stat\nimport sys')
+r = r.replace('relative, historical_inputs', 'relative, historical_inputs, HISTORY')
+r = r.replace("    docs = load(stage / 'documentation-check.json')", """    previous = load(HISTORY / 'prior-dependency-notices.json')
+    def registry_key(item):
+        return item['name'], item['version'], item['source'], item['registry_checksum']
+    collected = {registry_key(x): x for x in notices['packages'] if x['source']}
+    covered = 0
+    for old in previous['packages']:
+        if not old['source']:
+            continue
+        current = collected[registry_key(old)]
+        assert old['license'] == current['license']
+        assert set(old['features']).issubset(current['features'])
+        # Exact recorded notice files must remain in the actual ZIP. Current
+        # metadata does not substitute for the historical server's provenance.
+        new_notices = {(n['path'], n['sha256']) for n in current['notices']}
+        for item in old['notices']:
+            assert (item['path'], item['sha256']) in new_notices
+            assert actual[item['path']]['sha256'] == item['sha256']
+        assert old['embedded_fonts'] == current['embedded_fonts']
+        covered += 1
+    assert covered == preparation['historical_registry_count']
+    docs = load(stage / 'documentation-check.json')""")
+r = r.replace("'notice_roots': notices['root_packages']", "'historical_registry_packages_covered': covered, 'notice_roots': notices['root_packages']")
+r = r.replace("if __name__ == '__main__':\n", "if __name__ == '__main__':\n    sys.stdout.reconfigure(encoding='utf-8')\n    sys.stderr.reconfigure(encoding='utf-8')\n")
+(BASE / 'readback.py').write_text(r, encoding='utf-8', newline='\n')
+for name in ('prepare.py', 'readback.py'):
+    ast.parse((BASE / name).read_text(encoding='utf-8'), filename=name)
+assert old_inventory == {p.name: sha(p) for p in OLD.iterdir() if p.is_file()}
+print(json.dumps({'static_ast': 'PASS', 'old_adapter_files_unchanged': len(old_inventory)}))

harness/experiments/navigation-prerelease-20260911/initial-failed/adapter-manifest.json

@@ -0,0 +1,40 @@
+{
+  "scope": "Static adapters only; no clone/metadata/package/application execution",
+  "files": [
+    {
+      "path": "prepare.py",
+      "bytes": 19816,
+      "sha256": "c00c89181f58a9f4afbb29eea7eb7c9c8473deee280531fd2d6be2d88d49a07c"
+    },
+    {
+      "path": "package2.ps1",
+      "bytes": 5189,
+      "sha256": "1bd9c4b47d03f7479dfb627e8ef845a6f5770782a1cfa58e44b0e9b28b45ac64"
+    },
+    {
+      "path": "readback.py",
+      "bytes": 6307,
+      "sha256": "81bad82aed8522d5377fb671b71f4bd7ba329206beb9e96c4cd11f3a8fb343cf"
+    },
+    {
+      "path": "README.md",
+      "bytes": 4909,
+      "sha256": "00fa3176fce5e4e044c8966e4d820e7f3fedb82634e5680b4d957d726e8bdcf2"
+    },
+    {
+      "path": "VALIDATION.pending.md",
+      "bytes": 1219,
+      "sha256": "694a2274ed5c71c3707a90698f7c3254ef4d86233b4bac2d3730b24b970bce1d"
+    },
+    {
+      "path": "adapt.py",
+      "bytes": 8836,
+      "sha256": "ae0f6eb162a27d13c7f3e2dd636bd5b67068e1b9b30a2d29b275a3112f00ab5f"
+    },
+    {
+      "path": "static-source-readback.json",
+      "bytes": 1071,
+      "sha256": "171f6d080e7d95f24c8563bae5e6d6e2d8e00e7802116ce47bdac700c249c520"
+    }
+  ]
+}

harness/experiments/navigation-prerelease-20260911/initial-failed/package2.ps1

@@ -0,0 +1,92 @@
+# Private adapter only. Execute after root authorizes metadata/package work.
+#Requires -Version 7.0
+$ErrorActionPreference = 'Stop'
+$prep = $PSScriptRoot
+$repo = Split-Path -Parent (Split-Path -Parent $prep)
+$source = Join-Path $prep 'source'
+$resultPath = Join-Path $prep 'package2-result.json'
+$logPath = Join-Path $prep 'package2.log'
+$metadataPath = Join-Path $prep 'metadata2-result.json'
+foreach ($path in @($resultPath, $logPath, $metadataPath)) {
+    if (Test-Path -LiteralPath $path) { throw "Refusing existing evidence: $path" }
+}
+$prepared = Get-Content -LiteralPath (Join-Path $prep 'preparation.json') -Raw | ConvertFrom-Json
+$priorResult = Get-Content -LiteralPath (Join-Path $prep 'prepare-result.json') -Raw | ConvertFrom-Json
+if (-not $priorResult.success -or $prepared.base_commit -ne '33c6d83e9ba9a5b1310b1b627d7c40affcbcf15c' -or
+    $prepared.version -ne '0.2.0-preview.navigation.20260911' -or $prepared.target -ne 'x86_64-pc-windows-gnullvm') {
+    throw 'Missing successful designated navigation preparation.'
+}
+$head = (& git -C $source rev-parse HEAD).Trim()
+if ($LASTEXITCODE -ne 0 -or $head -ne $prepared.reconstruction_commit) { throw 'Reconstructed source HEAD changed.' }
+$dirty = & git -C $source status --porcelain
+if ($LASTEXITCODE -ne 0 -or $dirty) { throw 'Reconstructed source is not clean.' }
+foreach ($map in @($prepared.gui_inputs, $prepared.shared_non_cargo_inputs)) {
+    foreach ($property in $map.PSObject.Properties) {
+        if ((Get-FileHash -LiteralPath (Join-Path $source $property.Name)).Hash.ToLowerInvariant() -cne $property.Value) {
+            throw "Frozen source changed: $($property.Name)"
+        }
+    }
+}
+foreach ($item in $prepared.artifacts) {
+    if ((Get-FileHash -LiteralPath (Join-Path $prep $item.destination)).Hash.ToLowerInvariant() -cne $item.sha256) {
+        throw "Frozen binary changed: $($item.destination)"
+    }
+}
+. (Join-Path $repo '.local/toolchain/env.ps1')
+$env:CARGO_BUILD_JOBS = '1'
+$env:CARGO_NET_OFFLINE = 'true'
+# PS7 native stderr is diagnostic output; never reinterpret ordinary Cargo stderr
+# as a PowerShell terminating error. Native exit codes remain explicitly checked.
+$PSNativeCommandUseErrorActionPreference = $false
+$global:arcadiaNavigationMetadata = [pscustomobject]@{
+    Executable = (Get-Command cargo -CommandType Application).Source
+    Calls = 0; Source = $source; ResultPath = $metadataPath
+}
+function cargo {
+    $actual = @($args)
+    $expected = @('metadata', '--locked', '--offline', '--manifest-path',
+        (Join-Path $global:arcadiaNavigationMetadata.Source 'Cargo.toml'),
+        '--filter-platform', 'x86_64-pc-windows-gnullvm', '--format-version', '1')
+    if ($global:arcadiaNavigationMetadata.Calls -ne 0 -or ($actual -join "`n") -cne ($expected -join "`n")) {
+        throw 'Only one exact locked offline metadata call is admitted.'
+    }
+    $global:arcadiaNavigationMetadata.Calls++
+    $receipt = [ordered]@{ executable = $global:arcadiaNavigationMetadata.Executable; arguments = $actual; started = [DateTime]::UtcNow.ToString('o') }
+    try {
+        & $global:arcadiaNavigationMetadata.Executable @actual
+        $receipt.exitCode = $LASTEXITCODE
+    } finally {
+        $receipt.finished = [DateTime]::UtcNow.ToString('o')
+        [IO.File]::WriteAllText($global:arcadiaNavigationMetadata.ResultPath, ($receipt | ConvertTo-Json -Depth 8) + "`n", [Text.UTF8Encoding]::new($false))
+    }
+    $global:LASTEXITCODE = $receipt.exitCode
+    if ($receipt.exitCode -ne 0) { throw "Offline metadata failed: $($receipt.exitCode)" }
+}
+$result = [ordered]@{ started = [DateTime]::UtcNow.ToString('o'); version = $prepared.version; source_commit = $head; native_acceptance = 'Pending' }
+try {
+    & (Join-Path $source 'scripts/package-windows.ps1') `
+        -Target $prepared.target -Version $prepared.version `
+        -BinaryDirectory (Join-Path $prep 'bin') `
+        -LlvmMinGWRoot (Join-Path $repo '.local/toolchain/llvm-mingw-20260826-ucrt-x86_64') `
+        -BuildEvidence (Join-Path $prep 'build-evidence.json') `
+        -Python 'C:/Users/User/.cache/codex-runtimes/codex-primary-runtime/dependencies/python/python.exe' `
+        -OutputRoot (Join-Path $prep 'packages') *>&1 | Tee-Object -FilePath $logPath
+    if ($global:arcadiaNavigationMetadata.Calls -ne 1) { throw 'Expected exactly one metadata call.' }
+    $archive = Join-Path $prep "packages/ArcadiaStudio-$($prepared.version)-$($prepared.target).zip"
+    $result.archive = $archive
+    $result.archive_sha256 = (Get-FileHash -LiteralPath $archive).Hash.ToLowerInvariant()
+    $result.archive_bytes = (Get-Item -LiteralPath $archive).Length
+    $result.success = $true
+} catch {
+    $result.success = $false
+    $result.error = $_.ToString()
+    $_ | Out-String | Add-Content -LiteralPath $logPath
+    Write-Output $_
+} finally {
+    $result.finished = [DateTime]::UtcNow.ToString('o')
+    $result.metadata_calls = $global:arcadiaNavigationMetadata.Calls
+    [IO.File]::WriteAllText($resultPath, ($result | ConvertTo-Json -Depth 8) + "`n", [Text.UTF8Encoding]::new($false))
+    Remove-Item Function:\cargo
+    Remove-Variable arcadiaNavigationMetadata -Scope Global
+}
+if (-not $result.success) { exit 1 }

harness/experiments/navigation-prerelease-20260911/initial-failed/prepare-result.json

@@ -0,0 +1,7 @@
+{
+  "started": "2026-09-11T21:03:07.239702+00:00",
+  "scope": "Preparation only; no application/Cargo/package execution.",
+  "success": false,
+  "error": "CalledProcessError(1, ['git', 'checkout-index', '--all', '--prefix=C:/Users/User/Documents/Git/ARCADIA-Studio/.local/navigation-repair-prerelease-20260911/source-roundtrip/'])",
+  "finished": "2026-09-11T21:03:40.828532+00:00"
+}

harness/experiments/navigation-prerelease-20260911/initial-failed/prepare.py

@@ -0,0 +1,316 @@
+"""Prepare isolated exact sources/binaries only after recorded GUI/full gates.
+
+Do not execute without root's preparation authorization. Never invokes Cargo,
+launches applications, publishes, or writes the main repository's index/refs.
+"""
+from datetime import datetime, timezone
+import hashlib
+import json
+from pathlib import Path, PurePosixPath
+import re
+import shutil
+import subprocess
+import tarfile
+import traceback
+import sys
+import tomllib
+import zipfile
+
+BASE = Path(__file__).resolve().parent
+ROOT = BASE.parents[1]
+SOURCE = BASE / 'source'
+COMMIT = '33c6d83e9ba9a5b1310b1b627d7c40affcbcf15c'
+BRANCH = 'codex/navigation-repair-prerelease-source-20260911'
+VERSION = '0.2.0-preview.navigation.20260911'
+TARGET = 'x86_64-pc-windows-gnullvm'
+GATES = ROOT / '.local/text-repair-save-20260911'
+HISTORY = ROOT / '.local/contextual-prerelease-20260911/evidence'
+INPUT_SHA = '75a282fd3d4cb2dec6763046ea45d0caa015b998281fbdd6f222d8e3a175b13f'
+ZIP_SHA = '213fdb39ea7c3601b4baac674c3ab3ecc863ac44db1b092d922d3e24f26887b7'
+SERVER_SHA = 'efeeb89c0d2e0f93df4472cb3e9f48b2b722a37ae1043c90a5a56f2e845fe665'
+DLL_SHA = 'f45604a12e8bcd839fd86f667c1be1cc7c4f9da2b3c69ff381ac708f0e1ae7d4'
+HISTORICAL = {
+    'server-original-gates.json': 'b7fdfc55ed4c964d276f20f1c57c81c1e924b8da315171089740ab8335ac9f0d',
+    'server-original-binary-hashes.json': '110a03e323133efb48d50ad065d41414599aa85e0ac420e7d622aa04df4d54f8',
+    'server-prior-input-comparisons.json': '3c78dea4e93dae186fd24ab826c6680178a2c7849c270a22deae2ff732f1857b',
+    'prior-dependency-notices.json': '98fab15c1a2bb3aa727c6d52d5c69435b15efa56b6668ed717e7a04cf86f9b52',
+    'server-source-snapshot.tar.gz': 'cbb371a93a562e1e641d7629fe351e016d63e66fc9112499b3fed6d5cd171f78',
+}
+SCRIPT_HASHES = {
+    'scripts/package-windows.ps1': '28997ff78565619ed9c9b185f66dc922808f1f0be17f522b430c6c415448663d',
+    'scripts/package-common.ps1': 'd859453a8230b4f305d822c8742b371a71e35df698109a5d55c948f6dfaf0640',
+    'scripts/windows-notices.ps1': 'a5328c05579e1b9ca09142ee99e87c12994d12764f7c69448e392883d718ef01',
+}
+
+COMMANDS = {
+    'desktop-tests': ['cargo', 'test', '--locked', '--offline', '-p', 'oa-desktop', '--bin', 'arcadia-studio', '--', '--test-threads=1'],
+    'desktop-clippy': ['cargo', 'clippy', '--locked', '--offline', '-p', 'oa-desktop', '--all-targets', '--', '-D', 'warnings'],
+    'scoped-fmt': ['rustfmt', '--check', '--edition', '2024', '--config', 'skip_children=true', 'crates/oa-desktop/src/app.rs', 'crates/oa-desktop/src/document.rs', 'crates/oa-desktop/src/app/repair_save_state_tests.rs'],
+    'diff-check': ['git', 'diff', '--check'],
+    'gui-build': ['cargo', 'build', '--locked', '--offline', '-p', 'oa-desktop', '--bin', 'arcadia-studio', '--message-format=json-render-diagnostics'],
+}
+
+
+def now():
+    return datetime.now(timezone.utc).isoformat()
+
+
+def ordinary(path):
+    path = Path(path).absolute()
+    for part in (path, *path.parents):
+        if part.exists():
+            assert not part.is_symlink() and not (getattr(part.lstat(), 'st_file_attributes', 0) & 0x400), str(part)
+    return path
+
+
+def sha(path):
+    with ordinary(path).open('rb') as stream:
+        return hashlib.file_digest(stream, 'sha256').hexdigest()
+
+
+def load(path):
+    return json.loads(ordinary(path).read_text(encoding='utf-8-sig'))
+
+
+def record(path, value):
+    ordinary(path)
+    with Path(path).open('x', encoding='utf-8', newline='\n') as stream:
+        json.dump(value, stream, ensure_ascii=False, indent=2)
+        stream.write('\n')
+
+
+def git(cwd, *args):
+    return subprocess.run(['git', *args], cwd=cwd, check=True, capture_output=True).stdout
+
+
+def relative(name):
+    p = PurePosixPath(name)
+    assert name == p.as_posix() and not p.is_absolute() and p.parts and all(x not in ('..', '.') for x in p.parts)
+    assert '\\' not in name and ':' not in name and '\n' not in name and '\r' not in name
+    return name
+
+
+def blobs(cwd, revision, paths):
+    paths = list(paths)
+    raw = subprocess.run(['git', 'cat-file', '--batch'], cwd=cwd, check=True, capture_output=True,
+                         input=''.join(f'{revision}:{p}\n' for p in paths).encode()).stdout
+    cursor, out = 0, {}
+    for path in paths:
+        end = raw.index(b'\n', cursor)
+        header = raw[cursor:end].split()
+        assert len(header) == 3 and header[1] == b'blob', path
+        size = int(header[2])
+        out[path] = raw[end + 1:end + 1 + size]
+        cursor = end + size + 2
+    assert cursor == len(raw)
+    return out
+
+
+def root_identity():
+    index = Path(git(ROOT, 'rev-parse', '--git-path', 'index').decode().strip())
+    if not index.is_absolute():
+        index = ROOT / index
+    return {'head': git(ROOT, 'rev-parse', 'HEAD').decode().strip(), 'index_sha256': sha(index),
+            'tracked_status': git(ROOT, 'status', '--porcelain', '-uno').decode()}
+
+
+def historical_inputs():
+    for name, checksum in HISTORICAL.items():
+        assert sha(HISTORY / name) == checksum, name
+    inventory = load(HISTORY / 'server-prior-input-comparisons.json')
+    entries = inventory['server_source_file_comparisons']
+    expected = {relative(e['path']): e['recorded_sha256'] for e in entries}
+    assert len(expected) == len(entries) and expected
+    found = {}
+    with tarfile.open(HISTORY / 'server-source-snapshot.tar.gz', 'r:gz') as archive:
+        for member in archive.getmembers():
+            name = member.name.removeprefix('./')
+            if name in expected:
+                assert member.isfile() and name not in found, name
+                with archive.extractfile(member) as stream:
+                    found[name] = hashlib.file_digest(stream, 'sha256').hexdigest()
+    assert found == expected
+    assert any(e['Hash'].lower() == SERVER_SHA and Path(e['Path']).name == 'arcadia-server.exe'
+               for e in load(HISTORY / 'server-original-binary-hashes.json'))
+    return expected
+
+
+def admission():
+    assert sha(GATES / 'inputs1.json') == INPUT_SHA
+    assert sha(GATES / 'inputs1.zip') == ZIP_SHA
+    manifest = load(GATES / 'inputs1.json')
+    assert manifest['archiveSha256'] == ZIP_SHA
+    expected = {relative(e['path']): e for e in manifest['files']}
+    assert len(expected) == len(manifest['files']) and expected
+    assert len({p.casefold() for p in expected}) == len(expected)
+    with zipfile.ZipFile(GATES / 'inputs1.zip') as archive:
+        assert len(archive.namelist()) == len(expected) and set(archive.namelist()) == set(expected)
+        frozen = {name: archive.read(name) for name in expected}
+    for name, raw in frozen.items():
+        assert len(raw) == expected[name]['bytes'] and hashlib.sha256(raw).hexdigest() == expected[name]['sha256'], name
+    assert len(expected) == 500
+    complete = load(GATES / 'complete.json')
+    assert complete['archiveSha256'] == ZIP_SHA and complete['inputsUnchanged'] is True
+    assert complete['gates'] == list(COMMANDS) and complete['sourceHead'] == manifest['head']
+    # The gates captured eeeaa126 plus the repair delta; COMMIT commits those
+    # exact raw inputs. Never relabel the captured sourceHead as a clean build.
+    assert manifest['head'] == 'eeeaa1262748800c4c9aaa1eca79a7de96757358'
+    for name, command in COMMANDS.items():
+        receipt = load(GATES / (name + '-result.json'))
+        assert receipt['exitCode'] == 0 and receipt['inputsUnchanged'] is True and receipt['command'] == command
+        assert sha(GATES / (name + '-stdout.log')) == receipt['stdoutSha256']
+        assert sha(GATES / (name + '-stderr.log')) == receipt['stderrSha256']
+    build = load(GATES / 'gui-build-result.json')['binary']
+    artifact = build['artifact']
+    assert artifact['target']['name'] == 'arcadia-studio' and artifact['profile']['test'] is False
+    assert artifact['profile']['opt_level'] == '0' and artifact['profile']['debug_assertions'] is True
+    assert Path(artifact['executable']).resolve() == Path(build['path']).resolve()
+    assert Path(build['path']).resolve().is_relative_to(ROOT / '.local/target-gnullvm')
+    gui = GATES / 'gui-repair.exe'
+    assert sha(gui) == build['sha256'] == 'b183ef31f16b3986538b3f2aba8435eab45978635c47f99ca01be6e72b168848'
+    assert gui.stat().st_size == build['bytes'] == 113206272
+    summaries = re.findall(r'test result: ok\. (\d+) passed; (\d+) failed; (\d+) ignored; (\d+) measured; (\d+) filtered out;',
+                           (GATES / 'desktop-tests-stdout.log').read_text(encoding='utf-8'))
+    assert summaries == [('755', '0', '1', '0', '0')]
+    counts = dict(zip(('passed', 'failed', 'ignored', 'measured', 'filtered'), map(int, summaries[0])))
+    server = ROOT / '.local/contextual-prerelease-20260911/bin/arcadia-server.exe'
+    dll = ROOT / '.local/contextual-prerelease-20260911/bin/libunwind.dll'
+    assert sha(server) == SERVER_SHA and sha(dll) == DLL_SHA
+    old = historical_inputs()
+    return manifest, frozen, build, gui, counts, server, dll, old
+
+
+def main():
+    ordinary(BASE)
+    for name in ('source', 'source-roundtrip', 'bin', 'evidence', 'preparation.json', 'committed-roundtrip.json', 'build-evidence.json', 'evidence-manifest.json'):
+        assert not (BASE / name).exists(), f'Refusing existing output: {name}'
+    before = root_identity()
+    assert not before['tracked_status'], 'Root tracked edits must be frozen before preparation.'
+    assert git(ROOT, 'rev-parse', COMMIT).decode().strip() == COMMIT
+    # Later root commits may record evidence only. Do not silently package later
+    # production/docs/dependency or instruction changes under the tested source.
+    git(ROOT, 'merge-base', '--is-ancestor', COMMIT, before['head'])
+    later = git(ROOT, 'diff', '--name-only', '-z', COMMIT, before['head']).decode().split('\0')[:-1]
+    assert all(p.startswith('harness/') and not p.startswith('harness/fixtures/') for p in later), later
+    manifest, frozen, build, gui, counts, server, dll, old = admission()
+    for path, raw in frozen.items():
+        assert ordinary(ROOT / path).read_bytes() == raw, f'Current frozen input changed: {path}'
+    selectors = ['crates', '.cargo', 'Cargo.toml', 'Cargo.lock', 'docs', 'examples', 'harness/fixtures']
+    current_paths = git(ROOT, 'ls-files', '-z', '--cached', '--others', '--exclude-standard', '--', *selectors).decode().split('\0')[:-1]
+    assert sorted(current_paths) == sorted(frozen), 'Current input file set differs from the successful freeze.'
+    committed_paths = git(ROOT, 'ls-tree', '-r', '--name-only', '-z', COMMIT, '--', *selectors).decode().split('\0')[:-1]
+    assert sorted(committed_paths) == sorted(frozen), 'Committed input file set differs from the successful gate freeze.'
+    assert shutil.disk_usage(BASE).free >= 2 * 1024 ** 3
+    original = blobs(ROOT, COMMIT, frozen)
+    for path, raw in frozen.items():
+        assert original[path].replace(b'\r\n', b'\n') == raw.replace(b'\r\n', b'\n'), f'Non-newline source mismatch: {path}'
+    notice = load(HISTORY / 'prior-dependency-notices.json')
+    shared = {p: h for p, h in notice['workspace_build_inputs_sha256'].items() if p not in ('Cargo.toml', 'Cargo.lock')}
+    for p, raw in blobs(ROOT, COMMIT, shared).items():
+        assert hashlib.sha256(raw).hexdigest() == shared[p] or raw.replace(b'\r\n', b'\n') == (ROOT / p).read_bytes().replace(b'\r\n', b'\n')
+        assert sha(ROOT / p) == shared[p], p
+        if p in frozen:
+            assert frozen[p] == (ROOT / p).read_bytes(), p
+        frozen[p] = (ROOT / p).read_bytes()
+    registry = {(x['name'], x['version'], x['source']): x['registry_checksum']
+                for x in notice['packages'] if x['source']}
+    locked = {(x['name'], x['version'], x.get('source')): x.get('checksum')
+              for x in tomllib.loads(frozen['Cargo.lock'].decode())['package']}
+    assert registry and all(locked.get(k) == v for k, v in registry.items()), 'Historical registry coverage differs.'
+    # Local clone has its own index/refs and does not create a worktree in ROOT.
+    git(ROOT, 'clone', '--no-hardlinks', '--no-checkout', str(ROOT), str(SOURCE))
+    git(SOURCE, 'checkout', '-b', BRANCH, COMMIT)
+    checks = {p: hashlib.sha256(raw).hexdigest() for p, raw in frozen.items()}
+    original = blobs(SOURCE, COMMIT, checks)
+    restores = []
+    for p, raw in frozen.items():
+        assert original[p].replace(b'\r\n', b'\n') == raw.replace(b'\r\n', b'\n'), p
+        if hashlib.sha256(original[p]).hexdigest() != checks[p] or sha(SOURCE / p) != checks[p]:
+            assert re.fullmatch(r'[A-Za-z0-9_./-]+', p), 'Attribute path needs explicit quoting review.'
+            ordinary(SOURCE / p).write_bytes(raw)
+            restores.append({'path': p, 'sha256': checks[p], 'base_git_sha256': hashlib.sha256(original[p]).hexdigest(),
+                             'bytes': len(raw), 'crlf': raw.count(b'\r\n'), 'lf': raw.count(b'\n')})
+    if restores:
+        with (SOURCE / '.gitattributes').open('ab') as out:
+            out.write(b'\n# Exact frozen navigation GUI input bytes; historical server source is separate.\n')
+            for item in restores:
+                out.write((item['path'] + ' -text\n').encode())
+        git(SOURCE, 'add', '--renormalize', '--', '.gitattributes', *[x['path'] for x in restores])
+        git(SOURCE, '-c', 'user.name=Codex-9e8r6t', '-c', 'user.email=codex-9e8r6t@local.invalid',
+            'commit', '-m', 'Preserve exact navigation prerelease GUI inputs')
+    reconstruction = git(SOURCE, 'rev-parse', 'HEAD').decode().strip()
+    committed = blobs(SOURCE, 'HEAD', checks)
+    fresh = BASE / 'source-roundtrip'
+    fresh.mkdir()
+    git(SOURCE, 'checkout-index', '--all', '--prefix=' + fresh.as_posix() + '/')
+    for p, checksum in checks.items():
+        assert hashlib.sha256(committed[p]).hexdigest() == sha(SOURCE / p) == sha(fresh / p) == checksum, p
+    for p, checksum in SCRIPT_HASHES.items():
+        assert sha(SOURCE / p) == checksum, p
+    assert not git(SOURCE, 'status', '--porcelain').strip()
+    comparison = {'historical_file_count': len(old), 'changed_current_inputs': [p for p, h in old.items() if sha(SOURCE / p) != h],
+                  'added_current_files': sorted(p.relative_to(SOURCE).as_posix() for crate in ('oa-core', 'oa-server')
+                      for p in (SOURCE / 'crates' / crate).rglob('*') if p.is_file() and p.relative_to(SOURCE).as_posix() not in old),
+                  'scope': 'Historical server inputs verified against their own preserved tar, not required to equal the new GUI source.'}
+    assert comparison['changed_current_inputs'] == ['crates/oa-core/src/language.rs']
+    assert comparison['added_current_files'] == ['crates/oa-core/src/language_outline_tests.rs']
+    (BASE / 'bin').mkdir()
+    artifacts = []
+    for source, name, checksum in ((gui, 'arcadia-studio.exe', build['sha256']), (server, 'arcadia-server.exe', SERVER_SHA), (dll, 'libunwind.dll', DLL_SHA)):
+        assert sha(source) == checksum
+        target = BASE / 'bin' / name
+        with source.open('rb') as src, target.open('xb') as dst:
+            shutil.copyfileobj(src, dst)
+        assert sha(source) == sha(target) == checksum
+        artifacts.append({'source': str(source), 'destination': 'bin/' + name, 'sha256': checksum, 'bytes': target.stat().st_size})
+    provenance = {name: HISTORY / name for name in HISTORICAL}
+    provenance.update({'gui-inputs1.json': GATES / 'inputs1.json', 'gui-complete.json': GATES / 'complete.json',
+                       'gui-gate-run.py': GATES / 'run.py'})
+    for name in COMMANDS:
+        for suffix in ('-result.json', '-stdout.log', '-stderr.log'):
+            provenance['gui-' + name + suffix] = GATES / (name + suffix)
+    (BASE / 'evidence').mkdir()
+    evidence = []
+    for name, source in provenance.items():
+        checksum = sha(source)
+        destination = BASE / 'evidence' / name
+        with source.open('rb') as src, destination.open('xb') as dst:
+            shutil.copyfileobj(src, dst)
+        assert sha(source) == sha(destination) == checksum
+        evidence.append({'source': str(source), 'destination': 'evidence/' + name, 'sha256': checksum, 'bytes': destination.stat().st_size})
+    record(BASE / 'evidence-manifest.json', evidence)
+    record(BASE / 'committed-roundtrip.json', {'base_commit': COMMIT, 'reconstruction_commit': reconstruction, 'checks': checks, 'clean': True})
+    record(BASE / 'build-evidence.json', {
+        'source_identity': f'GUI exact-byte reconstruction {reconstruction} from {COMMIT}; {len(manifest["files"])} frozen GUI gate inputs plus separately verified shared build resources. This is not the original build commit. EFEE server retains its separate September 7 source snapshot; its old language.rs differs from current GUI core. No current-source server claim.',
+        'profile': f'Prebuilt Windows development GUI, actual full desktop result {counts}. Retained EFEE server is the historical development artifact, not rebuilt. Native/package acceptance remains pending.',
+        'compiler': 'Original GUI Cargo artifact/profile and server build records retained separately; package collector records current compiler/sysroot facts. No reproducible build or new server build claimed.',
+        'target': TARGET, 'binary_sha256': {'arcadia-studio.exe': build['sha256'], 'arcadia-server.exe': SERVER_SHA},
+        'provenance_reference_base': 'evidence/ references are external preparation records, not files inside the ZIP.',
+        'per_binary_provenance': {
+            'arcadia-studio.exe': {'build': 'evidence/gui-gui-build-result.json', 'inputs': 'evidence/gui-inputs1.json', 'full_gate': 'evidence/gui-desktop-tests-result.json', 'complete': 'evidence/gui-complete.json', 'captured_head': manifest['head'], 'scope': 'Built from captured eeeaa126 plus exact repair input delta; those bytes are committed at base_commit, then reconstructed without changing code.'},
+            'arcadia-server.exe': {'build': 'evidence/server-original-gates.json', 'hashes': 'evidence/server-original-binary-hashes.json', 'source_tar': 'evidence/server-source-snapshot.tar.gz', 'source_inventory': 'evidence/server-prior-input-comparisons.json', 'notices': 'evidence/prior-dependency-notices.json', 'scope': 'Unchanged historical EFEE; separate source, not rebuilt from navigation source.'}}})
+    after = root_identity()
+    assert after == before, 'Root HEAD/index/tracked state changed during preparation; inspect before proceeding.'
+    record(BASE / 'preparation.json', {'version': VERSION, 'target': TARGET, 'base_commit': COMMIT, 'reconstruction_commit': reconstruction,
+        'branch': BRANCH, 'record_only_root_paths_after_base': later, 'historical_registry_count': len(registry), 'source_repository': str(SOURCE), 'restorations': restores, 'gui_inputs': {e['path']: e['sha256'] for e in manifest['files']},
+        'shared_non_cargo_inputs': shared, 'historical_server_inputs': old, 'historical_server_comparison': comparison,
+        'artifacts': artifacts, 'full_test_counts': counts, 'root_before': before, 'root_after': after, 'prepared': now(),
+        'scope': 'Isolated preparation only; package integrity and native acceptance pending.'})
+    print(json.dumps({'success': True, 'reconstruction': reconstruction, 'gui_inputs': len(manifest['files']), 'restorations': len(restores), 'historical_server_inputs': len(old)}))
+
+
+if __name__ == '__main__':
+    sys.stdout.reconfigure(encoding='utf-8')
+    sys.stderr.reconfigure(encoding='utf-8')
+    assert not (BASE / 'prepare-result.json').exists()
+    status = {'started': now(), 'scope': 'Preparation only; no application/Cargo/package execution.'}
+    try:
+        main()
+        status['success'] = True
+    except BaseException as error:
+        status.update(success=False, error=repr(error))
+        traceback.print_exc()
+        raise
+    finally:
+        status['finished'] = now()
+        record(BASE / 'prepare-result.json', status)

harness/experiments/navigation-prerelease-20260911/initial-failed/readback.py

@@ -0,0 +1,105 @@
+"""Read back the produced ZIP/stage/source without launching either executable."""
+from datetime import datetime, timezone
+import hashlib
+import json
+from pathlib import Path
+import stat
+import sys
+import zipfile
+from prepare import BASE, SOURCE, VERSION, TARGET, COMMIT, SERVER_SHA, DLL_SHA, ordinary, sha, load, record, git, relative, historical_inputs, HISTORY
+
+
+def main():
+    assert not (BASE / 'package-readback.json').exists()
+    preparation = load(BASE / 'preparation.json')
+    terminal = load(BASE / 'package2-result.json')
+    assert terminal['success'] is True and terminal['metadata_calls'] == 1
+    assert preparation['base_commit'] == COMMIT and preparation['version'] == VERSION and preparation['target'] == TARGET
+    name = f'ArcadiaStudio-{VERSION}-{TARGET}'
+    archive_path = BASE / 'packages' / (name + '.zip')
+    stage = BASE / 'packages' / name
+    assert Path(terminal['archive']).resolve() == archive_path.resolve()
+    assert terminal['archive_sha256'] == sha(archive_path) and terminal['archive_bytes'] == archive_path.stat().st_size
+    actual = {}
+    with zipfile.ZipFile(archive_path) as archive:
+        entries = archive.infolist()
+        assert entries and len({e.filename.casefold() for e in entries}) == len(entries)
+        for entry in entries:
+            assert entry.filename.startswith(name + '/') and not entry.is_dir()
+            path = relative(entry.filename[len(name) + 1:])
+            assert not (entry.flag_bits & 1) and not stat.S_ISLNK(entry.external_attr >> 16)
+            assert entry.date_time == (2000, 1, 1, 0, 0, 0)
+            with archive.open(entry) as stream:
+                checksum = hashlib.file_digest(stream, 'sha256').hexdigest()
+            assert sha(stage / path) == checksum and (stage / path).stat().st_size == entry.file_size
+            actual[path] = {'sha256': checksum, 'bytes': entry.file_size}
+    files = {ordinary(p).relative_to(stage).as_posix() for p in stage.rglob('*') if p.is_file()}
+    assert set(actual) == files
+    sums = {}
+    for line in (stage / 'SHA256SUMS.txt').read_text(encoding='utf-8').splitlines():
+        checksum, path = line.split('  ', 1)
+        assert relative(path) not in sums
+        sums[path] = checksum
+    assert set(sums) == set(actual) - {'SHA256SUMS.txt'}
+    assert all(actual[p]['sha256'] == h for p, h in sums.items())
+    companion = (archive_path.with_suffix('.zip.sha256')).read_text(encoding='utf-8').strip().split()
+    assert companion == [terminal['archive_sha256'], archive_path.name]
+    for item in preparation['artifacts']:
+        p = Path(item['destination']).name
+        assert actual[p]['sha256'] == sha(BASE / item['destination']) == item['sha256']
+    assert actual['arcadia-server.exe']['sha256'] == SERVER_SHA and actual['libunwind.dll']['sha256'] == DLL_SHA
+    assert git(SOURCE, 'rev-parse', 'HEAD').decode().strip() == preparation['reconstruction_commit']
+    assert not git(SOURCE, 'status', '--porcelain').strip()
+    for mapping in (preparation['gui_inputs'], preparation['shared_non_cargo_inputs']):
+        for path, checksum in mapping.items():
+            assert sha(SOURCE / path) == checksum
+    # This comparison deliberately uses the old server tar, never GUI source.
+    assert historical_inputs() == preparation['historical_server_inputs']
+    for item in load(BASE / 'evidence-manifest.json'):
+        assert sha(BASE / item['destination']) == item['sha256'] and (BASE / item['destination']).stat().st_size == item['bytes']
+    package = load(stage / 'package.json')
+    assert package['version'] == VERSION and package['target'] == TARGET
+    assert package['build_evidence']['evidence'] == load(BASE / 'build-evidence.json')
+    for path, checksum in package['input_sha256'].items():
+        assert actual[path]['sha256'] == checksum
+    notices = load(stage / 'dependency-notices.json')
+    previous = load(HISTORY / 'prior-dependency-notices.json')
+    def registry_key(item):
+        return item['name'], item['version'], item['source'], item['registry_checksum']
+    collected = {registry_key(x): x for x in notices['packages'] if x['source']}
+    covered = 0
+    for old in previous['packages']:
+        if not old['source']:
+            continue
+        current = collected[registry_key(old)]
+        assert old['license'] == current['license']
+        assert set(old['features']).issubset(current['features'])
+        # Exact recorded notice files must remain in the actual ZIP. Current
+        # metadata does not substitute for the historical server's provenance.
+        new_notices = {(n['path'], n['sha256']) for n in current['notices']}
+        for item in old['notices']:
+            assert (item['path'], item['sha256']) in new_notices
+            assert actual[item['path']]['sha256'] == item['sha256']
+        assert old['embedded_fonts'] == current['embedded_fonts']
+        for font in old['embedded_fonts']:
+            for item in font['notices']:
+                assert actual[item['path']]['sha256'] == item['sha256']
+        covered += 1
+    assert covered == preparation['historical_registry_count']
+    docs = load(stage / 'documentation-check.json')
+    result = {'atUtc': datetime.now(timezone.utc).isoformat(), 'status': 'PASS', 'archive_sha256': sha(archive_path),
+        'archive_bytes': archive_path.stat().st_size, 'file_count': len(actual), 'files': actual,
+        'manifest_entries': len(sums), 'source_commit': preparation['reconstruction_commit'],
+        'gui_inputs_verified': len(preparation['gui_inputs']), 'historical_server_inputs_verified': len(preparation['historical_server_inputs']),
+        'historical_server_comparison': preparation['historical_server_comparison'],
+        'historical_registry_packages_covered': covered, 'notice_roots': notices['root_packages'], 'notice_package_count': len(notices['packages']),
+        'documentation_check': docs, 'binary_imports': package['imports'],
+        'scope': 'Producer packaging readback only; no application launch or independent/native acceptance.'}
+    record(BASE / 'package-readback.json', result)
+    print(json.dumps({k: v for k, v in result.items() if k != 'files'}, ensure_ascii=False, indent=2))
+
+
+if __name__ == '__main__':
+    sys.stdout.reconfigure(encoding='utf-8')
+    sys.stderr.reconfigure(encoding='utf-8')
+    main()

harness/experiments/navigation-prerelease-20260911/initial-failed/static-source-readback.json

@@ -0,0 +1,25 @@
+{
+  "scope": "Read-only source measurement; adapters not executed",
+  "input_files": 500,
+  "input_bytes": 9482855,
+  "newline_only_git_differences": [
+    "crates/oa-desktop/src/behavior/creation.rs",
+    "crates/oa-desktop/src/behavior/scenario/workspace.rs",
+    "crates/oa-desktop/src/behavior/topology/contextual.rs",
+    "crates/oa-desktop/src/guide.rs",
+    "crates/oa-desktop/src/semantic_review/artifacts_view.rs",
+    "crates/oa-desktop/src/semantic_review/attachments_view.rs",
+    "crates/oa-desktop/src/semantic_review/keyed.rs",
+    "crates/oa-desktop/src/semantic_review/keyed_rows.rs",
+    "crates/oa-desktop/src/semantic_review/keyed_tests.rs",
+    "crates/oa-desktop/src/semantic_review/ordered.rs",
+    "docs/api.html",
+    "docs/api.rst",
+    "docs/language.html",
+    "docs/openapi.json",
+    "harness/fixtures/rest-coverage/coverage-probe.json"
+  ],
+  "source_commit": "33c6d83e9ba9a5b1310b1b627d7c40affcbcf15c",
+  "zip_sha256": "213fdb39ea7c3601b4baac674c3ab3ecc863ac44db1b092d922d3e24f26887b7",
+  "outputs_absent": true
+}

harness/experiments/navigation-prerelease-20260911/manifest.json

@@ -0,0 +1,331 @@
+{
+  "scope": "Producer preparation/packaging integrity only; independent package/native/server/publication results remain separate",
+  "payloadFiles": 56,
+  "payloadBytes": 4032493,
+  "files": [
+    {
+      "path": ".gitattributes",
+      "bytes": 58,
+      "sha256": "0a38b8af3fddb7ebb709c8c891e57657b0f5c8fe54a86e63ae4f4c3bfac4808c"
+    },
+    {
+      "path": ".gitignore",
+      "bytes": 10,
+      "sha256": "1b7c01abb4d9e16cc4187667732237bf0ee6cee7bbad14c3b860b7216bc9c4b8"
+    },
+    {
+      "path": "historical-server/git-inputs.json",
+      "bytes": 29305,
+      "sha256": "ec0c36514edef303c07640e48f3c6fdf961a6ce1554bf9f9176d0d5eb8ea51fd",
+      "original": ".local/navigation-prerelease-archive-20260911/historical-server-git-inputs.json"
+    },
+    {
+      "path": "historical-server/original-workspace/build/windows.manifest",
+      "bytes": 354,
+      "sha256": "9c19c5a02f858ece84c44839ad2b145d9c1d90442da0b15c87fd045f975974eb"
+    },
+    {
+      "path": "historical-server/original-workspace/build/windows.rc",
+      "bytes": 24,
+      "sha256": "a27385edcae0bcf96f55361056cb7be5f36d76fcddcaefd20647c91959563e1e"
+    },
+    {
+      "path": "historical-server/original-workspace/build/windows_manifest.rs",
+      "bytes": 1460,
+      "sha256": "168da2c42ecccfebc11ee3e1b455e653a68fe9c6d30a9842a8b9e7441d086c80"
+    },
+    {
+      "path": "historical-server/original-workspace/Cargo.lock",
+      "bytes": 119350,
+      "sha256": "a6e070ed59b0ba19f18d60e8104494b777b470bd0268ae348cbe2b229790449f"
+    },
+    {
+      "path": "historical-server/original-workspace/Cargo.toml",
+      "bytes": 383,
+      "sha256": "9bd014df6e8124c769d551a660f7a511341ff196f80c70008dbb9250efd22081"
+    },
+    {
+      "path": "historical-server/prior-dependency-notices.json",
+      "bytes": 1619590,
+      "sha256": "98fab15c1a2bb3aa727c6d52d5c69435b15efa56b6668ed717e7a04cf86f9b52",
+      "original": ".local/nav-repair-retry-20260911/evidence/prior-dependency-notices.json"
+    },
+    {
+      "path": "historical-server/tar-inventory.json",
+      "bytes": 85902,
+      "sha256": "c4dbe3c08ccafb8a352270d39c5fcdfc532fbc6008d46076b8a1a3a63dc568f3"
+    },
+    {
+      "path": "initial-failed/adapt.py",
+      "bytes": 8836,
+      "sha256": "ae0f6eb162a27d13c7f3e2dd636bd5b67068e1b9b30a2d29b275a3112f00ab5f",
+      "original": ".local/navigation-repair-prerelease-20260911/adapt.py"
+    },
+    {
+      "path": "initial-failed/adapter-manifest.json",
+      "bytes": 1188,
+      "sha256": "24dbf41e533c502ab42fe9f3bd69d4446cb9b1513387b5ebad604cd0e592f061",
+      "original": ".local/navigation-repair-prerelease-20260911/adapter-manifest.json"
+    },
+    {
+      "path": "initial-failed/package2.ps1",
+      "bytes": 5189,
+      "sha256": "1bd9c4b47d03f7479dfb627e8ef845a6f5770782a1cfa58e44b0e9b28b45ac64",
+      "original": ".local/navigation-repair-prerelease-20260911/package2.ps1"
+    },
+    {
+      "path": "initial-failed/prepare-result.json",
+      "bytes": 384,
+      "sha256": "a235d514364f2ec216da25a535579404e00a8bb586802359efbc50c442b994da",
+      "original": ".local/navigation-repair-prerelease-20260911/prepare-result.json"
+    },
+    {
+      "path": "initial-failed/prepare.py",
+      "bytes": 19816,
+      "sha256": "c00c89181f58a9f4afbb29eea7eb7c9c8473deee280531fd2d6be2d88d49a07c",
+      "original": ".local/navigation-repair-prerelease-20260911/prepare.py"
+    },
+    {
+      "path": "initial-failed/readback.py",
+      "bytes": 6307,
+      "sha256": "81bad82aed8522d5377fb671b71f4bd7ba329206beb9e96c4cd11f3a8fb343cf",
+      "original": ".local/navigation-repair-prerelease-20260911/readback.py"
+    },
+    {
+      "path": "initial-failed/README.md",
+      "bytes": 4909,
+      "sha256": "00fa3176fce5e4e044c8966e4d820e7f3fedb82634e5680b4d957d726e8bdcf2",
+      "original": ".local/navigation-repair-prerelease-20260911/README.md"
+    },
+    {
+      "path": "initial-failed/static-source-readback.json",
+      "bytes": 1071,
+      "sha256": "171f6d080e7d95f24c8563bae5e6d6e2d8e00e7802116ce47bdac700c249c520",
+      "original": ".local/navigation-repair-prerelease-20260911/static-source-readback.json"
+    },
+    {
+      "path": "initial-failed/VALIDATION.pending.md",
+      "bytes": 1219,
+      "sha256": "694a2274ed5c71c3707a90698f7c3254ef4d86233b4bac2d3730b24b970bce1d",
+      "original": ".local/navigation-repair-prerelease-20260911/VALIDATION.pending.md"
+    },
+    {
+      "path": "package-metadata/ArcadiaStudio-0.2.0-preview.navigation.20260911-x86_64-pc-windows-gnullvm.zip.sha256",
+      "bytes": 144,
+      "sha256": "435b6fff3fbc1640b4db31c5d848dbcde101aa54cc86fe0eef9c8da6a501ccac",
+      "original": ".local/nav-repair-retry-20260911/packages/ArcadiaStudio-0.2.0-preview.navigation.20260911-x86_64-pc-windows-gnullvm.zip.sha256"
+    },
+    {
+      "path": "package-metadata/dependency-notices.json",
+      "bytes": 1621055,
+      "sha256": "131a8fda64648b31fb706ecb029b01086391e76a2d619304b4252e55903ee62f",
+      "original": ".local/nav-repair-retry-20260911/packages/ArcadiaStudio-0.2.0-preview.navigation.20260911-x86_64-pc-windows-gnullvm/dependency-notices.json"
+    },
+    {
+      "path": "package-metadata/documentation-check.json",
+      "bytes": 43,
+      "sha256": "bcc89585951fd9e5a1641993c51ca79e00a7a06944a8273d2df413331320e93f",
+      "original": ".local/nav-repair-retry-20260911/packages/ArcadiaStudio-0.2.0-preview.navigation.20260911-x86_64-pc-windows-gnullvm/documentation-check.json"
+    },
+    {
+      "path": "package-metadata/LICENSE",
+      "bytes": 1084,
+      "sha256": "51009f2cb07e5d19645858b2fbc037a672a25f8cbf7999522942b86807ecf365",
+      "original": ".local/nav-repair-retry-20260911/packages/ArcadiaStudio-0.2.0-preview.navigation.20260911-x86_64-pc-windows-gnullvm/LICENSE"
+    },
+    {
+      "path": "package-metadata/package.json",
+      "bytes": 76159,
+      "sha256": "73860425cbf24f37ce9a4c0ddb18309fe5bf6d340a74943147e7fced9bb6a30d",
+      "original": ".local/nav-repair-retry-20260911/packages/ArcadiaStudio-0.2.0-preview.navigation.20260911-x86_64-pc-windows-gnullvm/package.json"
+    },
+    {
+      "path": "package-metadata/README.md",
+      "bytes": 1902,
+      "sha256": "597cfb8da873e019d2658420f18ec059f0185fa9106ff9eafe934dfdd6ed266b",
+      "original": ".local/nav-repair-retry-20260911/packages/ArcadiaStudio-0.2.0-preview.navigation.20260911-x86_64-pc-windows-gnullvm/README.md"
+    },
+    {
+      "path": "package-metadata/SHA256SUMS.txt",
+      "bytes": 66376,
+      "sha256": "b2525b0899b403ec63fc76fc389a44356d6256c67012207e4247fa61c80617de",
+      "original": ".local/nav-repair-retry-20260911/packages/ArcadiaStudio-0.2.0-preview.navigation.20260911-x86_64-pc-windows-gnullvm/SHA256SUMS.txt"
+    },
+    {
+      "path": "package-metadata/START-HERE.txt",
+      "bytes": 676,
+      "sha256": "a549295cf57ac73673dc4fa6106463450f982122793cb9c7135ce4fc7087e9ed",
+      "original": ".local/nav-repair-retry-20260911/packages/ArcadiaStudio-0.2.0-preview.navigation.20260911-x86_64-pc-windows-gnullvm/START-HERE.txt"
+    },
+    {
+      "path": "package-metadata/THIRD-PARTY-NOTICES.txt",
+      "bytes": 21265,
+      "sha256": "6756989c8fc73706641cd78449c315458425a2eed9a82febc289b9d28ea7f21f",
+      "original": ".local/nav-repair-retry-20260911/packages/ArcadiaStudio-0.2.0-preview.navigation.20260911-x86_64-pc-windows-gnullvm/THIRD-PARTY-NOTICES.txt"
+    },
+    {
+      "path": "producer/adapter-manifest.json",
+      "bytes": 1018,
+      "sha256": "bbd08342632e463c9bb7b79ff7e467e0cb8faa6b6b085d6c54bd75fbf1750bb9",
+      "original": ".local/nav-repair-retry-20260911/adapter-manifest.json"
+    },
+    {
+      "path": "producer/build-evidence.json",
+      "bytes": 2197,
+      "sha256": "8771c85ec4fef0b70d2b4606c37521221d8e7c0dac04c202dbf4858c0857f179",
+      "original": ".local/nav-repair-retry-20260911/build-evidence.json"
+    },
+    {
+      "path": "producer/committed-roundtrip.json",
+      "bytes": 64061,
+      "sha256": "11eec67992a906dc7703f1c3777974b4e38cb325679ad1e1e7e5de68c3984229",
+      "original": ".local/nav-repair-retry-20260911/committed-roundtrip.json"
+    },
+    {
+      "path": "producer/evidence-manifest.json",
+      "bytes": 6775,
+      "sha256": "92ae5d38cc8beb8ddcf3b618f9d3f8d61d522b50341f1912fd8c752bd3c280b6",
+      "original": ".local/nav-repair-retry-20260911/evidence-manifest.json"
+    },
+    {
+      "path": "producer/failure-audit.json",
+      "bytes": 2038,
+      "sha256": "76115333ee62b5a13bef5f3bf009c34b3cb01d83a193e3802bc326679ee9a07a",
+      "original": ".local/nav-repair-retry-20260911/failure-audit.json"
+    },
+    {
+      "path": "producer/metadata2-result.json",
+      "bytes": 528,
+      "sha256": "44331c089eccfc206f3b44fe5ef56886560a628ad4ad589f9abae9eb4ce3ebcb",
+      "original": ".local/nav-repair-retry-20260911/metadata2-result.json"
+    },
+    {
+      "path": "producer/package-readback.json",
+      "bytes": 99584,
+      "sha256": "db0053ce70648b517942cfc8c915e826a7afd688129fcb4a813e11990820f498",
+      "original": ".local/nav-repair-retry-20260911/package-readback.json"
+    },
+    {
+      "path": "producer/package2-result.json",
+      "bytes": 599,
+      "sha256": "3a54833d5add49d6e05cf2f86383c49eeff5177deffb88f4e07e6341131e00a9",
+      "original": ".local/nav-repair-retry-20260911/package2-result.json"
+    },
+    {
+      "path": "producer/package2.log",
+      "bytes": 503,
+      "sha256": "4c8a81f9fcfcc60331a2fc2e67caaafa77f5c704a7f028215d8cbf02cd6a0e5a",
+      "original": ".local/nav-repair-retry-20260911/package2.log"
+    },
+    {
+      "path": "producer/package2.ps1",
+      "bytes": 5189,
+      "sha256": "1bd9c4b47d03f7479dfb627e8ef845a6f5770782a1cfa58e44b0e9b28b45ac64",
+      "original": ".local/nav-repair-retry-20260911/package2.ps1"
+    },
+    {
+      "path": "producer/preparation.json",
+      "bytes": 84939,
+      "sha256": "addcac3d5ebf17d278fcc2a3b87181afce8f85ec59097f7212a8930b1c1dd282",
+      "original": ".local/nav-repair-retry-20260911/preparation.json"
+    },
+    {
+      "path": "producer/prepare-result.json",
+      "bytes": 193,
+      "sha256": "05855915e53d2a0c6bb1c790f38c4d8bdbc02dd8cceacc3be4125fa4ad43c746",
+      "original": ".local/nav-repair-retry-20260911/prepare-result.json"
+    },
+    {
+      "path": "producer/prepare.py",
+      "bytes": 20450,
+      "sha256": "403844baf739a524c23b8e3f5c3d989979f4292f2e6d8e380fdde119e121698e",
+      "original": ".local/nav-repair-retry-20260911/prepare.py"
+    },
+    {
+      "path": "producer/push-source.py",
+      "bytes": 3826,
+      "sha256": "b99e088e9c1b9c4077b7c88d20de7ad4bf09bb30d327ea1a543834fd8b01af0d",
+      "original": ".local/nav-repair-retry-20260911/push-source.py"
+    },
+    {
+      "path": "producer/readback.py",
+      "bytes": 6307,
+      "sha256": "81bad82aed8522d5377fb671b71f4bd7ba329206beb9e96c4cd11f3a8fb343cf",
+      "original": ".local/nav-repair-retry-20260911/readback.py"
+    },
+    {
+      "path": "producer/README.md",
+      "bytes": 6014,
+      "sha256": "f85504003b2d45c7d0bc2c2a1530166f67446864167d064723a956ebcf0e0beb",
+      "original": ".local/nav-repair-retry-20260911/README.md"
+    },
+    {
+      "path": "producer/source-push-result.json",
+      "bytes": 489,
+      "sha256": "bf2b50193e8bb44868bcf4be92958d1f077136d2a6a2069360582462c0e2d2d3",
+      "original": ".local/nav-repair-retry-20260911/source-push-result.json"
+    },
+    {
+      "path": "producer/VALIDATION.pending.md",
+      "bytes": 1219,
+      "sha256": "694a2274ed5c71c3707a90698f7c3254ef4d86233b4bac2d3730b24b970bce1d",
+      "original": ".local/nav-repair-retry-20260911/VALIDATION.pending.md"
+    },
+    {
+      "path": "README.md",
+      "bytes": 3580,
+      "sha256": "6516506feba6cf452087aac52988d47b0637309a340b7347bf8c8881562f7085",
+      "original": ".local/navigation-prerelease-archive-20260911/README.md"
+    },
+    {
+      "path": "references.json",
+      "bytes": 7351,
+      "sha256": "0557477a55aeee6b90a93aed92b511484416f7f11f6fe53f2b2a866085aeaac9"
+    },
+    {
+      "path": "reviews/nav-repair-retry-review-20260911/adapter-review.md",
+      "bytes": 2225,
+      "sha256": "f958ab2e964bbeda57d96a6ca932efaac397b5672c31cb84bec1ce7ac883f383",
+      "original": ".local/nav-repair-retry-review-20260911/adapter-review.md"
+    },
+    {
+      "path": "reviews/navigation-repair-prerelease-review-20260911/adapter-review.md",
+      "bytes": 4104,
+      "sha256": "a6a9833a19449b6cb05343ec764a8ae37d48cd7ff1a9fb6db09120075248b9ad",
+      "original": ".local/navigation-repair-prerelease-review-20260911/adapter-review.md"
+    },
+    {
+      "path": "reviews/navigation-repair-prerelease-review-20260911/static-readback.json",
+      "bytes": 5382,
+      "sha256": "a6ed03c83c6d341d2044b706f3cd0794ef2f5e535d4d01eec6a75c0e7b75a396",
+      "original": ".local/navigation-repair-prerelease-review-20260911/static-readback.json"
+    },
+    {
+      "path": "source-identity/comparison.json",
+      "bytes": 293,
+      "sha256": "b3e8905b5a6b625e7391e71cdf302f05ab566fa2abbcc47151642bdad0775d77"
+    },
+    {
+      "path": "source-identity/initial-commit.txt",
+      "bytes": 278,
+      "sha256": "851a583a8e2d87b66de91508b0081ad441ddba1b6098c094ce064caaaaab7320"
+    },
+    {
+      "path": "source-identity/reconstructed.gitattributes",
+      "bytes": 5964,
+      "sha256": "106f28d5a1044f6bae3fee17bf45395c30e1da2e6a2354819a426a21ec011f17",
+      "original": ".local/nav-repair-retry-20260911/source/.gitattributes"
+    },
+    {
+      "path": "source-identity/retry-commit.txt",
+      "bytes": 278,
+      "sha256": "ea6580ef3247f665fe44db31d1b2055315fff722934855d698beabf3ea27d0ba"
+    },
+    {
+      "path": "verify_archive.py",
+      "bytes": 3050,
+      "sha256": "3026cbbbf71017a9b9e4de3077e36844b420418cb1a96bc43b124947d07aacbd",
+      "original": ".local/navigation-prerelease-archive-20260911/verify_archive.py"
+    }
+  ]
+}

harness/experiments/navigation-prerelease-20260911/package-metadata/ArcadiaStudio-0.2.0-preview.navigation.20260911-x86_64-pc-windows-gnullvm.zip.sha256

@@ -0,0 +1 @@
+d7228c542f162663933ea002739a78c722bcca41e437df63b7c868ea2af201f1  ArcadiaStudio-0.2.0-preview.navigation.20260911-x86_64-pc-windows-gnullvm.zip

harness/experiments/navigation-prerelease-20260911/package-metadata/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Arcadia Studio contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

harness/experiments/navigation-prerelease-20260911/package-metadata/README.md

@@ -0,0 +1,11 @@
+# Arcadia Studio portable bundle
+
+Run `arcadia-studio.exe` on Windows or `./arcadia-studio` on Linux. Keep this folder together; Home's water-pressure walkthrough uses the complete `examples/release1` folder beside the executable. The application includes searchable offline Help. No Rust installation or server is needed for local modeling.
+
+Start with Home → New or the water-pressure walkthrough. Use the built-in guide for the controls in this binary. The [worked example](examples/release1/README.md), [language and graphical editing contract](docs/language.rst) and [REST contract](docs/api.rst) are included offline. HTML versions are in `docs/language.html` and `docs/api.html`.
+
+The optional `arcadia-server` executable provides programmatic model access. See [server configuration](docs/server.md). Keep its data directory outside this application folder so replacing a bundle does not replace stored models. Cargo and Docker commands in the included reference documentation require a separate source checkout and its build prerequisites; this binary bundle is not that checkout.
+
+Read the included platform packaging guide for runtime prerequisites and clean-environment checks. `SHA256SUMS.txt` inventories package files, and the adjacent archive checksum covers the complete archive. `package.json` records the supplied binary hashes, inspected dependencies, and any explicitly supplied build evidence. `dependency-notices.json`, `THIRD-PARTY-NOTICES.txt` and `licenses/` retain dependency and runtime notices.
+
+Packaging integrity establishes what was delivered. It does not establish current release acceptance, supported graphics on this machine, or that caller-supplied binaries were built from the accompanying source documentation. Consult the binary-specific build and native verification evidence supplied by the distributor; a development preview remains a development preview.

harness/experiments/navigation-prerelease-20260911/package-metadata/SHA256SUMS.txt

@@ -0,0 +1,558 @@
+efeeb89c0d2e0f93df4472cb3e9f48b2b722a37ae1043c90a5a56f2e845fe665  arcadia-server.exe
+b183ef31f16b3986538b3f2aba8435eab45978635c47f99ca01be6e72b168848  arcadia-studio.exe
+131a8fda64648b31fb706ecb029b01086391e76a2d619304b4252e55903ee62f  dependency-notices.json
+1e6c6bb4065e25f8fe1d558a4ed0bbd4844782a4377c2482488db1e6f9cab01d  deployment/arcadia-server.service
+72c04aef4ec879955ed3bdf315987553d018ef46e4b8f350f0f6fe380c453eb7  deployment/Dockerfile
+6bb7d7496110b11a531cb8cd923864c6610850a8f1c4de8a797f54c7156f29e1  deployment/Dockerfile.dockerignore
+6f18cfc2a35eba631dbc61d04cd2721e0e361efff1699bf56d2c450a30a17a0d  docs/api.html
+7eb258088824efa5ac94311b07b73eb46edcac3c300a2aac78d3802111e338c4  docs/api.rst
+739a5bb100c7cb0ed70e18afd1e363029757f3cfd6580bc9c5cf77faccb46940  docs/language.html
+894a1a77f97d1aa94c11762fe4e84b4d95e181a77c630324c16c307637ed27e1  docs/language.rst
+41a1bb1095801df37a1411341c5791d55ea8c365739314d599a60269ac4bc7a0  docs/linux-packaging.md
+c6ae512f791a939eaf6ec5e5e78e9468bdee0e028092d00098bd90ad9498d967  docs/openapi.json
+4828df5bc679e7c71f49b4b85c9e7dacbec52f46d416fed48af70e08886d4e4e  docs/research-v2-service.md
+4eb24937d424ba8b384e1734e02a6f8e963ae11d2715889c92b14b39ff2e4a48  docs/server.md
+2c852ff7041713ffbff3c951ac98df647c51fb70b0feba9000f7bfd5bc2703a8  docs/windows-packaging.md
+bcc89585951fd9e5a1641993c51ca79e00a7a06944a8273d2df413331320e93f  documentation-check.json
+7e183ef9fd8154d3074303f1956cd0d9871c19e3ffc630d333b0bffbd6e30e17  examples/coastal-rescue.arcadia
+242f0b031229a87af5c4ebe5d651defe59c191a6b7a69dc0a77f7e203411f195  examples/coastal-rescue.json
+4dbbbdf8bc7e6cb8e0a81dd678069dae585a9e5187c59bc3665e1fdab3f1a86a  examples/legacy-v1-coastal-rescue.arcadia
+fd0e9dedfb7adb922dc0575cc2b820d40344d639f1d8052bd70363aa59de9c24  examples/legacy-v1-coastal-rescue.oa.json
+f4db17bdca4ecbb1bf0caef01b2da5f1f7f798ab3152b648ce6dd8696a6a68e5  examples/release1/evidence/repair-check.md
+3700393d76b940cfc076bf52861bd7b1f43370f8eabce3594531bd0bf1fc851e  examples/release1/expected-diagnostics.json
+ef0ef4006c3e09d5db6e1b621256b3f7d6642f3a7b09cc34607cfbcca830c727  examples/release1/model.json
+15f30f6bde655808fe754665c26d560e36f2a9bad340f346b09137d0d05045f5  examples/release1/model.rs
+83e73d0a013d5c3e1a4af0d9139ab0cfa362d25a846671fc2dac59181061a9d4  examples/release1/oa/activities/activity_oa_restore_work.arcadia
+172c32c044ef4b5bc58a1f4635cc81f48dabb4014479b47dce7b25fedf2dbd0d  examples/release1/oa/behavior/process_oa_assessment_procedure.arcadia
+d2552dc5383e2e91cb302a790364e197f663c2edc013a2ab1978789825c9c324  examples/release1/oa/behavior/process_oa_field_procedure.arcadia
+cf86f46fa5c5d70592ef43f1bc1cb4d968efd8add384ba88036bef6b88aa4abc  examples/release1/oa/behavior/process_oa_response.arcadia
+b25be524e98a35ebac5e4481b7609c027b32baf9605e8097f807560f94a77ca6  examples/release1/oa/behavior/scenario_oa_conversation.arcadia
+00a1edf2c9707a0eb62ac070c2d02467874f2c9c1f273cc6ddb53d6d65999a1c  examples/release1/oa/behavior/scenario_oa_full_scenario.arcadia
+447c9ad1359f4a31ecf975ad07c0b08d8e7e03191fb0858e2fc56f377b223cd5  examples/release1/oa/behavior/state_machine_oa_monitor.arcadia
+fc8012e5554350b12e1cb80080f8feab80d933c9b33c0f2a7bb500cb7d609936  examples/release1/oa/capabilities.arcadia
+f7cf914766ea73ec53b85e32d117ea9a9dba52d3e038246863541ae7069b1a15  examples/release1/oa/model.arcadia
+951764c14179f27c10e315acf2ea37d1fff54c77b8441e23addd239e8c715ce3  examples/release1/oa/participants.arcadia
+9d0396fb82dd5733edd8d1cf52f968ca84906927c704f9cf0944a7fae215cf49  examples/release1/oa/types.arcadia
+b2674e6bf77cfe0f6f0ba79c81d2e96d92f39c02ca2c6266d80e91723bfb9fda  examples/release1/project.arcadia
+113cfb1cf38a98b51bff60442d86a35d636a3d80ef206bece7d53d0aae67f2d5  examples/release1/README.md
+73928ced61c06cbc08728d7956676a50fd4c05aa5b7f1ff4f29ce27a0b0f2088  examples/release1/sa/behavior/process_sa_assessment_procedure.arcadia
+886d462af83110cbfa55dd232a667ea1446761234471357cbb878794e98e8768  examples/release1/sa/behavior/process_sa_field_procedure.arcadia
+041785fc22842423822431bd5e6e8d16094ebd0716965e7c765fb8c1d7549e8a  examples/release1/sa/behavior/process_sa_response.arcadia
+97276f5757ee9aa12a0dbd9d3ccd58174b3091162bb8bcce357cec20a45f5d85  examples/release1/sa/behavior/scenario_sa_conversation.arcadia
+e12fc406b99d60a2f7768aaa0b25ba560e8605f0b8e37f3a7cdd3b8443562b74  examples/release1/sa/behavior/scenario_sa_full_scenario.arcadia
+05ce29af99424c491c47fe2450dc6f5f8ce995511c01ec7e17bb5855be3c9736  examples/release1/sa/behavior/state_machine_sa_monitor.arcadia
+b6912fb3ece439912345fa71724acd462e716a1e5a88203a1058a5c3b2c20a4f  examples/release1/sa/capabilities.arcadia
+e5a04325d52183956dca814dd90f4e56c96c6b7db0f4f202f203ecb49c3e0f4f  examples/release1/sa/functions/function_sa_audit_thresholds.arcadia
+fddeb67308051325041fee641fe758ddf43345b7c47b66d433616ad07fdccdd6  examples/release1/sa/functions/function_sa_restore_work.arcadia
+d431509251acb859fbb98733b6d18add952495e10a78703fbe8f31e40bc083c4  examples/release1/sa/model.arcadia
+780d2eb08b217b67b55febb3d34846f727b8ee9018df6c5741748647e36b2ff8  examples/release1/sa/participants.arcadia
+101fc0fbd99f1101514aa7b6da4f8e535aae0bb94c9e2b9e7e6c151135b28660  examples/release1/sa/types.arcadia
+48a96f543456c9b5a5798fc795594e4119147fe45f11a6f109f141b7f514560f  examples/release1/traceability.arcadia
+2253e6434f741687e22327c37d520ed15c043bc36025498650bc2366bb6a874d  examples/release1/transition-before.json
+43b9a22e5f95ad3bc0ebd2478ead0e14406854abc989ae94ded9367b013d812a  examples/release1/transition-request.json
+dfc0eb61e0e2aa5bda45524571fbfa3494f44ce19696f3e15e07438074a07bc7  examples/release1/views/diagram_oa_allocation_view.arcadia
+b78b43a26a82efb8fbd5374b09c329fa341f57b29f635d397b9ef8aede71d389  examples/release1/views/diagram_sa_allocation_view.arcadia
+75e8dc9fb30f25d6f8fd3c6b595593ab4f98958a25798f961e336e0fac557649  examples/release1/views/diagram_sa_capability_view.arcadia
+b08c84f3ea633e7c78dfdad3272f75415f6256cf3614b6d99bfd4f0269076c9b  examples/release1/views/diagram_sa_service_view.arcadia
+5f42f4c605e57b817d8400ed21f2b14bfc4e1592aebe941ff113767504c2b869  examples/release1/views/diagram_sa_state_view.arcadia
+dc6b75da72884d399132ed9e300fa5a26b73d802bb526c9af986ae9eeb0a646a  examples/routing-workshop.arcadia
+8592714f75b271133f21ce017d87896b6cf91ea0e4837f1c2ed453e21be26b14  examples/routing-workshop.json
+5f60642f211b2d352a951092faeeb7503d4fb7f6f7fca99e810347231101d31c  examples/source-project/oa.arcadia
+787f6b67b179ffd221f7e5faf1a4edd74cfd116aa1e3b5e9ed9f22fbff612d8d  examples/source-project/project.arcadia
+ab76044836e4dcd42a82d316846ec87da2108939aa2037640c5bca1d2ecdee0f  examples/source-project/sa/assurance.arcadia
+1abad579812e77877b45a3d8e3c3e9da734be2d04a0254cc730a5257ebd2dc88  examples/source-project/sa/participants.arcadia
+f0b7443f728912ca163de39b6055876b533a77feaa3219b2d40a2dd65712e058  examples/source-project/sa/reporting.arcadia
+e29ad3f406a6a50d2f0ae2ca2a53ee3b0c18222cd4098704a46d4f48b64ea17f  examples/source-project/views.arcadia
+f441535c623e0cf20e1875eb2cd33b587ed00e078c37af39cb36d89bb5edc19a  examples/text-first/project.arcadia
+4ec8250d5ed556f1d496e8c85137e973e802ecb11df1a36488411e8cdc5a9f9e  examples/text-first/README.md
+f45604a12e8bcd839fd86f667c1be1cc7c4f9da2b3c69ff381ac708f0e1ae7d4  libunwind.dll
+51009f2cb07e5d19645858b2fbc037a672a25f8cbf7999522942b86807ecf365  LICENSE
+1bc7e6f475b3ec99b7e2643411950ae2368c250dd4c5c325f80f9811362a94a1  licenses/dependencies/arrayref-0.3.9/LICENSE
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/arrayvec-0.7.8/LICENSE-APACHE
+4da95ec4ecb65b738d470b7d762894ad9c97da93e6cbfb18b570fc2c96f4b871  licenses/dependencies/arrayvec-0.7.8/LICENSE-MIT
+0e8a410375e1ee5c75c6198b08b534fec6e5edef766cf971bab4a404542636ab  licenses/dependencies/ash-0.38.0+1.3.281/LICENSE-APACHE
+c733ccf8ab25df175a63d9d844677b98e3a5ab8f8de1c1616087e6868a7f948e  licenses/dependencies/ash-0.38.0+1.3.281/LICENSE-MIT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/atomic-waker-1.1.2/LICENSE-APACHE
+23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3  licenses/dependencies/atomic-waker-1.1.2/LICENSE-MIT
+6226d0632e2e1a80c23597e964da9812ae193c535fe058154afb034e94167aa5  licenses/dependencies/atomic-waker-1.1.2/LICENSE-THIRD-PARTY
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/autocfg-1.5.1/LICENSE-APACHE
+27995d58ad5c1145c1a8cd86244ce844886958a35eb2b78c6b772748669999ac  licenses/dependencies/autocfg-1.5.1/LICENSE-MIT
+6a13bc24a100a6812f053879ec51b126b103af7cda6dbf48c4188722da44da9f  licenses/dependencies/axum-0.8.9/LICENSE
+008c87afcd2e626eaf564093250bed06dd7efb5732113264bba3dda8f1c556a1  licenses/dependencies/axum-core-0.5.6/LICENSE
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/base64-0.22.1/LICENSE-APACHE
+0dd882e53de11566d50f8e8e2d5a651bcf3fabee4987d70f306233cf39094ba7  licenses/dependencies/base64-0.22.1/LICENSE-MIT
+8173d5c29b4f956d532781d2b86e4e30f83e6b7878dce18c919451d6ba707c90  licenses/dependencies/bit-set-0.8.0/LICENSE-APACHE
+f51ac2c59a222f7476ce507ca879960e2b64ea64bb2786eefdbeb7b0b538d1b7  licenses/dependencies/bit-set-0.8.0/LICENSE-MIT
+8173d5c29b4f956d532781d2b86e4e30f83e6b7878dce18c919451d6ba707c90  licenses/dependencies/bit-vec-0.8.0/LICENSE-APACHE
+f51ac2c59a222f7476ce507ca879960e2b64ea64bb2786eefdbeb7b0b538d1b7  licenses/dependencies/bit-vec-0.8.0/LICENSE-MIT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/bitflags-2.13.1/LICENSE-APACHE
+6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb  licenses/dependencies/bitflags-2.13.1/LICENSE-MIT
+e3ba223bb1423f0aad8c3dfce0fe3148db48926d41e6fbc3afbbf5ff9e1c89cb  licenses/dependencies/bytemuck_derive-1.12.0/LICENSE-APACHE
+9df9ba60a11af705f2e451b53762686e615d86f76b169cf075c3237730dbd7e2  licenses/dependencies/bytemuck_derive-1.12.0/LICENSE-MIT
+84b34dd7608f7fb9b17bd588a6bf392bf7de504e2716f024a77d89f1b145a151  licenses/dependencies/bytemuck_derive-1.12.0/LICENSE-ZLIB
+e3ba223bb1423f0aad8c3dfce0fe3148db48926d41e6fbc3afbbf5ff9e1c89cb  licenses/dependencies/bytemuck-1.25.2/LICENSE-APACHE
+9df9ba60a11af705f2e451b53762686e615d86f76b169cf075c3237730dbd7e2  licenses/dependencies/bytemuck-1.25.2/LICENSE-MIT
+84b34dd7608f7fb9b17bd588a6bf392bf7de504e2716f024a77d89f1b145a151  licenses/dependencies/bytemuck-1.25.2/LICENSE-ZLIB
+45f522cacecb1023856e46df79ca625dfc550c94910078bd8aec6e02880b3d42  licenses/dependencies/bytes-1.12.1/LICENSE
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/cc-1.4.5/LICENSE-APACHE
+378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397  licenses/dependencies/cc-1.4.5/LICENSE-MIT
+31b94860253d8ec7b4529f51901044d3b459d6292d996504a36b1bae3a36a812  licenses/dependencies/cfg_aliases-0.2.2/LICENSE
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/cfg-if-1.0.4/LICENSE-APACHE
+378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397  licenses/dependencies/cfg-if-1.0.4/LICENSE-MIT
+a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5  licenses/dependencies/chacha20-0.10.2/LICENSE-APACHE
+b8c6939380a400f53e11923d50fcc4dd2fa1ba8339fd9d04cda38a0251b6c9b0  licenses/dependencies/chacha20-0.10.2/LICENSE-MIT
+c9bff75738922193e67fa726fa225535870d2aa1059f91452c411736284ad566  licenses/dependencies/clipboard-win-5.4.1/supplement/DoumanAsh-clipboard-win-3b27cf2bfd1a-LICENSE
+c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4  licenses/dependencies/codespan-reporting-0.12.0/LICENSE
+9ebf8c4cc0b735ca13a766451f7b8097db3185975ceb2ba94b5abf439156a91f  licenses/dependencies/core_maths-0.1.1/LICENSE
+587dd9548304fd421cd254f7550bd101c1250ffc95417f2f7f92d55b44ecbe53  licenses/dependencies/cosmic-text-0.15.0/fonts/FiraMono-LICENSE
+3c8d13d97ea5eb62868833a377034c6be6a9833e768d32abec2a767a8101e4bc  licenses/dependencies/cosmic-text-0.15.0/fonts/Inter-LICENSE
+5ec4347054089def6904da61d04f0360968f9ef36634b1fe007a5b6ec2f7aa96  licenses/dependencies/cosmic-text-0.15.0/fonts/NotoSans-LICENSE
+000b4962e6b27176a0ff89cce4be555b16472cafb5671eb2804a8fdac6854793  licenses/dependencies/cosmic-text-0.15.0/LICENSE-APACHE
+95557bafe728379e206f3b6d4aceeaa054d271c71d722411a6222e2dec01138c  licenses/dependencies/cosmic-text-0.15.0/LICENSE-MIT
+a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5  licenses/dependencies/cpufeatures-0.3.1/LICENSE-APACHE
+73b9dc2e79c7308998dd30296e073aefaefb944a68fb89aa412c23c0edcabcaa  licenses/dependencies/cpufeatures-0.3.1/LICENSE-MIT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/cryoglyph-0.1.0/LICENSE-APACHE
+23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3  licenses/dependencies/cryoglyph-0.1.0/LICENSE-MIT
+b3ec01ad0869c5c50937bc68780cd0bb44e235ad858dfa54a7a381dced9b115a  licenses/dependencies/cryoglyph-0.1.0/LICENSE-ZLIB
+b59affd015e517ed998dd735757f9a3693643cd389609947ed54074234a10784  licenses/dependencies/cursor-icon-1.2.0/LICENSE-APACHE
+c138726a726ac37bae09d0f8a48e74e8e3aa8a8952fcd10fae0fb224cc1c05f1  licenses/dependencies/cursor-icon-1.2.0/LICENSE-MIT
+01e533bd94e8f1c32b2c2531e2c398de7d35d7804add3d574b4e1fe581d53537  licenses/dependencies/cursor-icon-1.2.0/LICENSE-ZLIB
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/displaydoc-0.2.7/LICENSE-APACHE
+23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3  licenses/dependencies/displaydoc-0.2.7/LICENSE-MIT
+074e6e32c86a4c0ef8b3ed25b721ca23aca83df277cd88106ef7177c354615ff  licenses/dependencies/document-features-0.2.12/LICENSE-APACHE
+aa893340d14b9844625be6a50ac644169a01b52f0211cbf81b09e1874c8cd81d  licenses/dependencies/document-features-0.2.12/LICENSE-MIT
+6dc0e068dcf3a5bc8e054205b85b7720e1d49265bbc64bf515d2cf79197df69a  licenses/dependencies/dpi-0.1.2/LICENSE
+9eff396a99bafd208e7126602420d6864f6066c08b84485a5b032320a9c01997  licenses/dependencies/dpi-0.1.2/LICENSE-LIBM-MIT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/equivalent-1.0.2/LICENSE-APACHE
+7365cc8878a1d7ce155a58c4ca09c3d7a6be413efa5334a80ea842912b669349  licenses/dependencies/equivalent-1.0.2/LICENSE-MIT
+c9bff75738922193e67fa726fa225535870d2aa1059f91452c411736284ad566  licenses/dependencies/error-code-3.4.0/LICENSE
+2d56a37f3d1e461f6b1539ab94e0e6bcc55443e376098aee85ac3b2890860290  licenses/dependencies/etagere-0.2.15/LICENSE-APACHE
+9cfc9c9a4608501b5da3746948d2be2dd709ad51f6bcb0c1c685760ee3dde31f  licenses/dependencies/etagere-0.2.15/LICENSE-MIT
+ec82b96487e9e778ee610c7ab245162464782cfa1f555c2299333f8dbe5c036a  licenses/dependencies/euclid-0.22.14/COPYRIGHT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/euclid-0.22.14/LICENSE-APACHE
+62065228e42caebca7e7d7db1204cbb867033de5982ca4009928915e4095f3a3  licenses/dependencies/euclid-0.22.14/LICENSE-MIT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/fastrand-2.5.0/LICENSE-APACHE
+23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3  licenses/dependencies/fastrand-2.5.0/LICENSE-MIT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/find-msvc-tools-0.1.12/LICENSE-APACHE
+378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397  licenses/dependencies/find-msvc-tools-0.1.12/LICENSE-MIT
+0604d5817110dacc5c7d9b7de6b58b962794603d4823c357157bd5dec4198bc5  licenses/dependencies/float_next_after-1.0.0/LICENSE
+b1181a40b2a7b25cf66fd01481713bc1005df082c53ef73e851e55071b102744  licenses/dependencies/foldhash-0.1.5/LICENSE
+b1181a40b2a7b25cf66fd01481713bc1005df082c53ef73e851e55071b102744  licenses/dependencies/foldhash-0.2.0/LICENSE
+a14f7d685a79c0f4fb64aee305527a6d5fa55f2401f4e6d688d7b1301868e6c0  licenses/dependencies/font-types-0.10.1/LICENSE-APACHE
+8a62fa27ffdccc3df19dce90f8bb3d572e27aecffc1a383d0c2601834dcec434  licenses/dependencies/font-types-0.10.1/LICENSE-MIT
+eba684204073ed715c4abb48129acdfd2bff8ae48339e6a7da3b341d3027b7f0  licenses/dependencies/font-types-0.12.4/LICENSE-APACHE
+7b4c9a3946dfcea7967582760e963e27799e225dcf20565c8ef55324bb017427  licenses/dependencies/font-types-0.12.4/LICENSE-MIT
+59a1fdac3bd550043599bd159fd70f09a1108c2b09e3751d39b11e1ff8e51f00  licenses/dependencies/fontdb-0.23.0/LICENSE
+b84fdd2c3da5db56385cdbb639795e90aa3e035c53bc3591135f18df3331451f  licenses/dependencies/fontdb-0.23.0/tests/fonts/LICENSE.txt
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/form_urlencoded-1.2.2/LICENSE-APACHE
+20c7855c364d57ea4c97889a5e8d98470a9952dade37bd9248b9a54431670e5e  licenses/dependencies/form_urlencoded-1.2.2/LICENSE-MIT
+275c491d6d1160553c32fd6127061d7f9606c3ea25abfad6ca3f6ed088785427  licenses/dependencies/futures-0.3.34/LICENSE-APACHE
+6652c868f35dfe5e8ef636810a4e576b9d663f3a17fb0f5613ad73583e1b88fd  licenses/dependencies/futures-0.3.34/LICENSE-MIT
+275c491d6d1160553c32fd6127061d7f9606c3ea25abfad6ca3f6ed088785427  licenses/dependencies/futures-channel-0.3.34/LICENSE-APACHE
+6652c868f35dfe5e8ef636810a4e576b9d663f3a17fb0f5613ad73583e1b88fd  licenses/dependencies/futures-channel-0.3.34/LICENSE-MIT
+275c491d6d1160553c32fd6127061d7f9606c3ea25abfad6ca3f6ed088785427  licenses/dependencies/futures-core-0.3.34/LICENSE-APACHE
+6652c868f35dfe5e8ef636810a4e576b9d663f3a17fb0f5613ad73583e1b88fd  licenses/dependencies/futures-core-0.3.34/LICENSE-MIT
+275c491d6d1160553c32fd6127061d7f9606c3ea25abfad6ca3f6ed088785427  licenses/dependencies/futures-executor-0.3.34/LICENSE-APACHE
+6652c868f35dfe5e8ef636810a4e576b9d663f3a17fb0f5613ad73583e1b88fd  licenses/dependencies/futures-executor-0.3.34/LICENSE-MIT
+275c491d6d1160553c32fd6127061d7f9606c3ea25abfad6ca3f6ed088785427  licenses/dependencies/futures-io-0.3.34/LICENSE-APACHE
+6652c868f35dfe5e8ef636810a4e576b9d663f3a17fb0f5613ad73583e1b88fd  licenses/dependencies/futures-io-0.3.34/LICENSE-MIT
+275c491d6d1160553c32fd6127061d7f9606c3ea25abfad6ca3f6ed088785427  licenses/dependencies/futures-macro-0.3.34/LICENSE-APACHE
+6652c868f35dfe5e8ef636810a4e576b9d663f3a17fb0f5613ad73583e1b88fd  licenses/dependencies/futures-macro-0.3.34/LICENSE-MIT
+275c491d6d1160553c32fd6127061d7f9606c3ea25abfad6ca3f6ed088785427  licenses/dependencies/futures-sink-0.3.34/LICENSE-APACHE
+6652c868f35dfe5e8ef636810a4e576b9d663f3a17fb0f5613ad73583e1b88fd  licenses/dependencies/futures-sink-0.3.34/LICENSE-MIT
+275c491d6d1160553c32fd6127061d7f9606c3ea25abfad6ca3f6ed088785427  licenses/dependencies/futures-task-0.3.34/LICENSE-APACHE
+6652c868f35dfe5e8ef636810a4e576b9d663f3a17fb0f5613ad73583e1b88fd  licenses/dependencies/futures-task-0.3.34/LICENSE-MIT
+275c491d6d1160553c32fd6127061d7f9606c3ea25abfad6ca3f6ed088785427  licenses/dependencies/futures-util-0.3.34/LICENSE-APACHE
+6652c868f35dfe5e8ef636810a4e576b9d663f3a17fb0f5613ad73583e1b88fd  licenses/dependencies/futures-util-0.3.34/LICENSE-MIT
+aaff376532ea30a0cd5330b9502ad4a4c8bf769c539c87ffe78819d188a18ebf  licenses/dependencies/getrandom-0.2.17/LICENSE-APACHE
+42fa16951ce7f24b5a467a40e5b449a1d41e662f97ca779864f053f39e097737  licenses/dependencies/getrandom-0.2.17/LICENSE-MIT
+aaff376532ea30a0cd5330b9502ad4a4c8bf769c539c87ffe78819d188a18ebf  licenses/dependencies/getrandom-0.4.3/LICENSE-APACHE
+523a42c25d245dde9c015f882cec7f4555aad883382a6cf19b4b7d9b2cd5419b  licenses/dependencies/getrandom-0.4.3/LICENSE-MIT
+cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30  licenses/dependencies/gl_generator-0.14.0/supplement/brendanzab-gl-rs-ea503e8d5fb6-LICENSE
+be33ddb87a30fd321ab100e2d922cba512e50ec7a63d8e62e5bfc0798dd4b585  licenses/dependencies/glam-0.25.0/LICENSE-APACHE
+23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3  licenses/dependencies/glam-0.25.0/LICENSE-MIT
+b8601fc79bdf8d8088f0938bea861ffc63ed0eebbedf25f44ab2cf2e85bd7edc  licenses/dependencies/glow-0.16.0/LICENSE-APACHE
+cdbd06e25b8c9c5d6019949d2de8123f56d29cee4166396423d2ba8c81700845  licenses/dependencies/glow-0.16.0/LICENSE-MIT
+636f644f1e149eb62961657c0e34953681eff64435653912e7bd19992666faa5  licenses/dependencies/glow-0.16.0/LICENSE-ZLIB
+a4445427440043e8ce6fadf7a43fb906cb0d7f6c573a560a9f142cf9f9bf8ff4  licenses/dependencies/glutin_wgl_sys-0.6.1/LICENSE
+12121dfa588677007848ab922a45a1e3248868f6ff063598fceb3141d7897314  licenses/dependencies/gpu-alloc-0.6.2/supplement/zakarumych-gpu-alloc-61020bdcb4eb-COPYING
+12121dfa588677007848ab922a45a1e3248868f6ff063598fceb3141d7897314  licenses/dependencies/gpu-alloc-types-0.3.1/supplement/zakarumych-gpu-alloc-7ddd1fe576fc-COPYING
+0178e21322b0e88aa3aeb3146f6a9611bc1f8df6d98bdfb34be28b9dd56a8107  licenses/dependencies/gpu-allocator-0.27.0/LICENSE-APACHE
+ad41be6cc6538b29b9346648f41432b5e460bad6be073b5eeaa41320ea2921dc  licenses/dependencies/gpu-allocator-0.27.0/LICENSE-MIT
+f72143f7e9d9fb8bd336b139fa22f825a299591c29f2f7338c5566347b137613  licenses/dependencies/gpu-descriptor-0.3.2/supplement/zakarumych-gpu-descriptor-bb28b4e55b74-COPYING
+f72143f7e9d9fb8bd336b139fa22f825a299591c29f2f7338c5566347b137613  licenses/dependencies/gpu-descriptor-types-0.2.0/supplement/zakarumych-gpu-descriptor-9f2fb9546591-COPYING
+7e98bed7f100747aaae7d82ab94fbe6b76fd6b84b09a3aaa413bff8196d0fbb1  licenses/dependencies/guillotiere-0.6.2/LICENSE
+a6cba85bc92e0cff7a450b1d873c0eaa2e9fc96bf472df0247a26bec77bf3ff9  licenses/dependencies/half-2.7.1/LICENSE-APACHE
+508a77d2e7b51d98adeed32648ad124b7b30241a8e70b2e72c99f92d8e5874d1  licenses/dependencies/half-2.7.1/LICENSE-MIT
+7d43d2ef1ce976c7bfb423c696ad9938ccfc31e9ec5be752265e43fe9d29f697  licenses/dependencies/harfrust-0.3.2/LICENSE
+9906940f61b1f0b533fa7d99baf55178b2808fbe113ea51dfbfad8572ccd5f2b  licenses/dependencies/harfrust-0.3.2/scripts/ms-use/COPYING
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/hashbrown-0.15.5/LICENSE-APACHE
+ff8f68cb076caf8cefe7a6430d4ac086ce6af2ca8ce2c4e5a2004d4552ef52a2  licenses/dependencies/hashbrown-0.15.5/LICENSE-MIT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/hashbrown-0.16.1/LICENSE-APACHE
+ff8f68cb076caf8cefe7a6430d4ac086ce6af2ca8ce2c4e5a2004d4552ef52a2  licenses/dependencies/hashbrown-0.16.1/LICENSE-MIT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/hashbrown-0.17.1/LICENSE-APACHE
+ff8f68cb076caf8cefe7a6430d4ac086ce6af2ca8ce2c4e5a2004d4552ef52a2  licenses/dependencies/hashbrown-0.17.1/LICENSE-MIT
+a2010f343487d3f7618affe54f789f5487602331c0a8d03f49e9a7c547cf0499  licenses/dependencies/hexf-parse-0.2.1/supplement/CC0-1.0.txt
+4a56dbdbc12054fd33b7a2634a45cbbe6fe12f5e6f4081002cbfa527f7220c70  licenses/dependencies/hexf-parse-0.2.1/supplement/hexf-parse-0.2.1-Cargo.toml
+8bb1b50b0e5c9399ae33bd35fab2769010fa6c14e8860c729a52295d84896b7a  licenses/dependencies/http-1.5.0/LICENSE-APACHE
+dc91f8200e4b2a1f9261035d4c18c33c246911a6c0f7b543d75347e61b249cff  licenses/dependencies/http-1.5.0/LICENSE-MIT
+248378d0a3383c173fb925f17141b88e71580b3ba17ddc6ac3d2a344683232ab  licenses/dependencies/http-body-1.1.0/LICENSE
+248378d0a3383c173fb925f17141b88e71580b3ba17ddc6ac3d2a344683232ab  licenses/dependencies/http-body-util-0.1.5/LICENSE
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/httparse-1.10.1/LICENSE-APACHE
+391a5396cec6230bfabd4ef4eb2350eb895bc5efce377a2218f5702ed020d3e3  licenses/dependencies/httparse-1.10.1/LICENSE-MIT
+4d10fe5f3aa176b05b229a248866bad70b834c173f1252a814ff4748d8a13837  licenses/dependencies/httpdate-1.0.3/LICENSE-APACHE
+934887691e05d69d7c86ad3f2c360980fa30c15b035e351f3c9865e99da4debc  licenses/dependencies/httpdate-1.0.3/LICENSE-MIT
+2d01890414494742ba4a509fcec8efa40f6d8be22cbd72be7cff08d6fda4ec89  licenses/dependencies/hyper-1.11.1/LICENSE
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/hyper-rustls-0.27.9/LICENSE-APACHE
+7cfafc877eccc46c0e346ccbaa5c51bb6b894d2b818e617d970211e232785ad4  licenses/dependencies/hyper-rustls-0.27.9/LICENSE-ISC
+709e3175b4212f7b13aa93971c9f62ff8c69ec45ad8c6532a7e0c41d7a7d6f8c  licenses/dependencies/hyper-rustls-0.27.9/LICENSE-MIT
+9e0a97848ea543aef745c98e84fde696a9a3e0735538f6daefdd3cb1942effc1  licenses/dependencies/hyper-util-0.1.20/LICENSE
+cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30  licenses/dependencies/iced_core-0.14.0/src/layout/DRUID_LICENSE
+fc9086ba4eba4b77e4c603906362742bc3715ffa2c7810c6074fe7780d3a0398  licenses/dependencies/iced_core-0.14.0/supplement/iced-rs-iced-3997291f318a-LICENSE
+fc9086ba4eba4b77e4c603906362742bc3715ffa2c7810c6074fe7780d3a0398  licenses/dependencies/iced_debug-0.14.0/supplement/iced-rs-iced-3997291f318a-LICENSE
+fc9086ba4eba4b77e4c603906362742bc3715ffa2c7810c6074fe7780d3a0398  licenses/dependencies/iced_futures-0.14.0/supplement/iced-rs-iced-3997291f318a-LICENSE
+99bfb7c1e845b79d1031fcf37e678178eb4a8c7cc74a3f218ddf7223083a6fcd  licenses/dependencies/iced_graphics-0.14.0/assets/FiraSans-Regular.ttf/Fira-OFL.txt
+1e0baaa389b1647d06322ac9ea37822f31995408200ae5a2805a6b9bea0810d1  licenses/dependencies/iced_graphics-0.14.0/assets/FiraSans-Regular.ttf/FiraSans-Regular-NOTICE.txt
+8175634e30f84ef72a24c4965fb0e87f45a3c1274cc0e79e0473af582cffd1c4  licenses/dependencies/iced_graphics-0.14.0/assets/Iced-Icons.ttf/Iced-Icons-NOTICE.txt
+fc9086ba4eba4b77e4c603906362742bc3715ffa2c7810c6074fe7780d3a0398  licenses/dependencies/iced_graphics-0.14.0/assets/Iced-Icons.ttf/iced-rs-iced-3997291f318a-LICENSE
+fc9086ba4eba4b77e4c603906362742bc3715ffa2c7810c6074fe7780d3a0398  licenses/dependencies/iced_graphics-0.14.0/supplement/iced-rs-iced-3997291f318a-LICENSE
+fc9086ba4eba4b77e4c603906362742bc3715ffa2c7810c6074fe7780d3a0398  licenses/dependencies/iced_program-0.14.0/supplement/iced-rs-iced-3997291f318a-LICENSE
+fc9086ba4eba4b77e4c603906362742bc3715ffa2c7810c6074fe7780d3a0398  licenses/dependencies/iced_renderer-0.14.0/supplement/iced-rs-iced-3997291f318a-LICENSE
+fc9086ba4eba4b77e4c603906362742bc3715ffa2c7810c6074fe7780d3a0398  licenses/dependencies/iced_runtime-0.14.0/supplement/iced-rs-iced-3997291f318a-LICENSE
+fc9086ba4eba4b77e4c603906362742bc3715ffa2c7810c6074fe7780d3a0398  licenses/dependencies/iced_tiny_skia-0.14.0/supplement/iced-rs-iced-3997291f318a-LICENSE
+fc9086ba4eba4b77e4c603906362742bc3715ffa2c7810c6074fe7780d3a0398  licenses/dependencies/iced_wgpu-0.14.0/supplement/iced-rs-iced-3997291f318a-LICENSE
+fc9086ba4eba4b77e4c603906362742bc3715ffa2c7810c6074fe7780d3a0398  licenses/dependencies/iced_widget-0.14.2/supplement/iced-rs-iced-54abf81d13fe-LICENSE
+fc9086ba4eba4b77e4c603906362742bc3715ffa2c7810c6074fe7780d3a0398  licenses/dependencies/iced_winit-0.14.0/supplement/iced-rs-iced-3997291f318a-LICENSE
+fc9086ba4eba4b77e4c603906362742bc3715ffa2c7810c6074fe7780d3a0398  licenses/dependencies/iced-0.14.0/LICENSE
+f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2  licenses/dependencies/icu_collections-2.3.0/LICENSE
+f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2  licenses/dependencies/icu_locale_core-2.3.0/LICENSE
+f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2  licenses/dependencies/icu_normalizer_data-2.3.0/LICENSE
+f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2  licenses/dependencies/icu_normalizer-2.3.0/LICENSE
+f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2  licenses/dependencies/icu_properties_data-2.3.0/LICENSE
+f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2  licenses/dependencies/icu_properties-2.3.0/LICENSE
+f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2  licenses/dependencies/icu_provider-2.3.1/LICENSE
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/idna_adapter-1.2.2/LICENSE-APACHE
+8b43ce8accd61e9d370b5ca9e9c4f953279b5c239926c62315b40e24df51b726  licenses/dependencies/idna_adapter-1.2.2/LICENSE-MIT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/idna-1.1.0/LICENSE-APACHE
+b38f11f6096706e6de553dabe2a7ed142d59b6fa8c97e290c67496154745cdd5  licenses/dependencies/idna-1.1.0/LICENSE-MIT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/indexmap-2.14.1/LICENSE-APACHE
+ecc269ef87fd38a1d98e30bfac9ba964a9dbd9315c3770fed98d4d7cb5882055  licenses/dependencies/indexmap-2.14.1/LICENSE-MIT
+87d9feb9238c6bd8e0024fc4733b06cff036f89f36d93b7df1c8a0549bbb7a5b  licenses/dependencies/ipnet-2.12.1/LICENSE-APACHE
+47dc9ff29128ddfb4d6a0435383c9f89120bc374dbcc1dd00b933a0b28aa7865  licenses/dependencies/ipnet-2.12.1/LICENSE-MIT
+62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a  licenses/dependencies/itoa-1.0.18/LICENSE-APACHE
+23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3  licenses/dependencies/itoa-1.0.18/LICENSE-MIT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/jobserver-0.1.35/LICENSE-APACHE
+378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397  licenses/dependencies/jobserver-0.1.35/LICENSE-MIT
+cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30  licenses/dependencies/khronos_api-3.1.0/supplement/brendanzab-gl-rs-f150967b1c44-LICENSE
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/khronos-egl-6.0.0/LICENSE-APACHE
+23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3  licenses/dependencies/khronos-egl-6.0.0/LICENSE-MIT
+cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30  licenses/dependencies/kurbo-0.10.4/LICENSE-APACHE
+23c23145f6eac25c28cdcc03d38506a5712a9a8cffb5bd5301457f6173ea696e  licenses/dependencies/kurbo-0.10.4/LICENSE-MIT
+62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a  licenses/dependencies/libc-0.2.189/LICENSE-APACHE
+123a331b5dbf04c30097fa43b8f858bc85df671fe776de498d01f3d6b7c1f69e  licenses/dependencies/libc-0.2.189/LICENSE-MIT
+b29f8b01452350c20dd1af16ef83b598fea3053578ccc1c7a0ef40e57be2620f  licenses/dependencies/libloading-0.8.9/LICENSE
+3823dda7cf046602f4b4e77ec8e227863dc4736037cc85bb33d9f19febe16bb7  licenses/dependencies/libm-0.2.16/LICENSE.txt
+120b2f21f9b9f98ef4159de09f9a55a3afb6733dd1c0b1d9eeec7f136465b2cd  licenses/dependencies/lilt-0.8.2/LICENSE
+a6cba85bc92e0cff7a450b1d873c0eaa2e9fc96bf472df0247a26bec77bf3ff9  licenses/dependencies/linebender_resource_handle-0.1.1/LICENSE-APACHE
+508a77d2e7b51d98adeed32648ad124b7b30241a8e70b2e72c99f92d8e5874d1  licenses/dependencies/linebender_resource_handle-0.1.1/LICENSE-MIT
+f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2  licenses/dependencies/litemap-0.8.3/LICENSE
+62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a  licenses/dependencies/litrs-1.0.0/LICENSE-APACHE
+7dc1552e88f49132cb358b1b962fc5e79fa42d70bcbb88c526d33e45b8e98036  licenses/dependencies/litrs-1.0.0/LICENSE-MIT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/lock_api-0.4.14/LICENSE-APACHE
+c9a75f18b9ab2927829a208fc6aa2cf4e63b8420887ba29cdb265d6619ae82d5  licenses/dependencies/lock_api-0.4.14/LICENSE-MIT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/log-0.4.34/LICENSE-APACHE
+6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb  licenses/dependencies/log-0.4.34/LICENSE-MIT
+061dc50af2cd9340703daf61978af3200cf681b12ea67a323c33ba109a23a45e  licenses/dependencies/lru-0.16.4/LICENSE
+cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30  licenses/dependencies/lru-slab-0.1.2/LICENSE-APACHE
+1466d9b4f3a59bb8997fc8d5fa977ce3f6a24bb2358793c09bfdf007039f6486  licenses/dependencies/lru-slab-0.1.2/LICENSE-MIT
+09785877275ffada6c371b652a30e95c26b435126fc0fc62f1bc2d72171f80a4  licenses/dependencies/lru-slab-0.1.2/LICENSE-ZLIB
+216486f29671a4262efe32af6d84a75bef398127f8c5f369b5c8305983887a06  licenses/dependencies/lyon_algorithms-1.0.21/supplement/nical-lyon-994526f2766c-LICENSE-APACHE
+80f275e90d799911ed3830a7f242a2ef5a4ade2092fe0aa07bfb2d2cf2f2b95e  licenses/dependencies/lyon_algorithms-1.0.21/supplement/nical-lyon-994526f2766c-LICENSE-MIT
+216486f29671a4262efe32af6d84a75bef398127f8c5f369b5c8305983887a06  licenses/dependencies/lyon_geom-1.0.19/supplement/nical-lyon-56219c95c658-LICENSE-APACHE
+80f275e90d799911ed3830a7f242a2ef5a4ade2092fe0aa07bfb2d2cf2f2b95e  licenses/dependencies/lyon_geom-1.0.19/supplement/nical-lyon-56219c95c658-LICENSE-MIT
+216486f29671a4262efe32af6d84a75bef398127f8c5f369b5c8305983887a06  licenses/dependencies/lyon_path-1.0.19/supplement/nical-lyon-56219c95c658-LICENSE-APACHE
+80f275e90d799911ed3830a7f242a2ef5a4ade2092fe0aa07bfb2d2cf2f2b95e  licenses/dependencies/lyon_path-1.0.19/supplement/nical-lyon-56219c95c658-LICENSE-MIT
+216486f29671a4262efe32af6d84a75bef398127f8c5f369b5c8305983887a06  licenses/dependencies/lyon_tessellation-1.0.21/supplement/nical-lyon-994526f2766c-LICENSE-APACHE
+80f275e90d799911ed3830a7f242a2ef5a4ade2092fe0aa07bfb2d2cf2f2b95e  licenses/dependencies/lyon_tessellation-1.0.21/supplement/nical-lyon-994526f2766c-LICENSE-MIT
+216486f29671a4262efe32af6d84a75bef398127f8c5f369b5c8305983887a06  licenses/dependencies/lyon-1.0.19/supplement/nical-lyon-56219c95c658-LICENSE-APACHE
+80f275e90d799911ed3830a7f242a2ef5a4ade2092fe0aa07bfb2d2cf2f2b95e  licenses/dependencies/lyon-1.0.19/supplement/nical-lyon-56219c95c658-LICENSE-MIT
+de701d0618d694feb1af90f02181a1763d9b0bdeb70a3a592781e529077dba65  licenses/dependencies/matchit-0.8.4/LICENSE
+162ce11ad71338d0a0c6ebaf5c48af72c6ae237b468859d3656fe2d9ed3f3a85  licenses/dependencies/matchit-0.8.4/LICENSE.httprouter
+01c266bced4a434da0051174d6bee16a4c82cf634e2679b6155d40d75012390f  licenses/dependencies/memchr-2.8.3/COPYING
+0f96a83840e146e43c0ec96a22ec1f392e0680e6c1226e6f3ba87e0740af850f  licenses/dependencies/memchr-2.8.3/LICENSE-MIT
+7e12e5df4bae12cb21581ba157ced20e1986a0508dd10d0e8a4ab9a4cf94e85c  licenses/dependencies/memchr-2.8.3/UNLICENSE
+04ea4849dba9dcae07113850c6f1b1a69052c625210639914eee352023f750ad  licenses/dependencies/memmap2-0.9.11/LICENSE-APACHE
+0d25d03b5ab49576178ad0cae7a2648d12c17ad0452fe49c07e55e4b59aa5257  licenses/dependencies/memmap2-0.9.11/LICENSE-MIT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/mime-0.3.17/LICENSE-APACHE
+df9cfd06d8a44d9a671eadd39ffd97f166481da015a30f45dfd27886209c5922  licenses/dependencies/mime-0.3.17/LICENSE-MIT
+07919255c7e04793d8ea760d6c2ce32d19f9ff02bdbdde3ce90b1e1880929a9b  licenses/dependencies/mio-1.2.3/LICENSE
+a6cba85bc92e0cff7a450b1d873c0eaa2e9fc96bf472df0247a26bec77bf3ff9  licenses/dependencies/naga-27.0.3/LICENSE.APACHE
+dc0d97139e8205818c703741c7be7cb3b96888bd5917b8d6fc6133731e403c21  licenses/dependencies/naga-27.0.3/LICENSE.MIT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/num-traits-0.2.19/LICENSE-APACHE
+6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb  licenses/dependencies/num-traits-0.2.19/LICENSE-MIT
+51009f2cb07e5d19645858b2fbc037a672a25f8cbf7999522942b86807ecf365  licenses/dependencies/oa-core-0.2.0/workspace-LICENSE
+51009f2cb07e5d19645858b2fbc037a672a25f8cbf7999522942b86807ecf365  licenses/dependencies/oa-desktop-0.2.0/workspace-LICENSE
+51009f2cb07e5d19645858b2fbc037a672a25f8cbf7999522942b86807ecf365  licenses/dependencies/oa-server-0.2.0/workspace-LICENSE
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/once_cell-1.21.4/LICENSE-APACHE
+23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3  licenses/dependencies/once_cell-1.21.4/LICENSE-MIT
+f7715d38a3fa1b4ac97c5729740752505a39cb92ee83ab5b102aeb5eaa7cdea4  licenses/dependencies/ordered-float-5.5.0/LICENSE-MIT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/parking_lot_core-0.9.12/LICENSE-APACHE
+c9a75f18b9ab2927829a208fc6aa2cf4e63b8420887ba29cdb265d6619ae82d5  licenses/dependencies/parking_lot_core-0.9.12/LICENSE-MIT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/parking_lot-0.12.5/LICENSE-APACHE
+c9a75f18b9ab2927829a208fc6aa2cf4e63b8420887ba29cdb265d6619ae82d5  licenses/dependencies/parking_lot-0.12.5/LICENSE-MIT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/percent-encoding-2.3.2/LICENSE-APACHE
+b38f11f6096706e6de553dabe2a7ed142d59b6fa8c97e290c67496154745cdd5  licenses/dependencies/percent-encoding-2.3.2/LICENSE-MIT
+0d542e0c8804e39aa7f37eb00da5a762149dc682d7829451287e11b938e94594  licenses/dependencies/pin-project-lite-0.2.17/LICENSE-APACHE
+23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3  licenses/dependencies/pin-project-lite-0.2.17/LICENSE-MIT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/pkg-config-0.3.34/LICENSE-APACHE
+378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397  licenses/dependencies/pkg-config-0.3.34/LICENSE-MIT
+f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2  licenses/dependencies/potential_utf-0.1.6/LICENSE
+8173d5c29b4f956d532781d2b86e4e30f83e6b7878dce18c919451d6ba707c90  licenses/dependencies/presser-0.3.1/LICENSE-APACHE
+090a294a492ab2f41388252312a65cf2f0e423330b721a68c6665ac64766753b  licenses/dependencies/presser-0.3.1/LICENSE-MIT
+62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a  licenses/dependencies/proc-macro2-1.0.107/LICENSE-APACHE
+23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3  licenses/dependencies/proc-macro2-1.0.107/LICENSE-MIT
+10d30a673cd5e9349bdc02aeb48f14b3386d27d0da32df8f0a555d4aa16aa551  licenses/dependencies/profiling-1.0.18/supplement/aclysma-profiling-8271551172eb-LICENSE-APACHE
+c8167fdeeed46d3f244d3f85c5bf998ce889343691c32be2c61a8bc4b5c08333  licenses/dependencies/profiling-1.0.18/supplement/aclysma-profiling-8271551172eb-LICENSE-MIT
+c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4  licenses/dependencies/quinn-0.11.11/LICENSE-APACHE
+4b2d0aca6789fa39e03d6738e869ea0988cceba210ca34ebb59c15c463e93a04  licenses/dependencies/quinn-0.11.11/LICENSE-MIT
+c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4  licenses/dependencies/quinn-proto-0.11.17/LICENSE-APACHE
+4b2d0aca6789fa39e03d6738e869ea0988cceba210ca34ebb59c15c463e93a04  licenses/dependencies/quinn-proto-0.11.17/LICENSE-MIT
+c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4  licenses/dependencies/quinn-udp-0.5.15/LICENSE-APACHE
+4b2d0aca6789fa39e03d6738e869ea0988cceba210ca34ebb59c15c463e93a04  licenses/dependencies/quinn-udp-0.5.15/LICENSE-MIT
+62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a  licenses/dependencies/quote-1.0.47/LICENSE-APACHE
+23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3  licenses/dependencies/quote-1.0.47/LICENSE-MIT
+92b81db30f7ab6d693e0af5661a40d273ca1947e891123ed823924192c10cbc7  licenses/dependencies/rand_core-0.10.1/COPYRIGHT
+6df43f6f4b5d4587f3d8d71e45532c688fd168afa5fe89d571cb32fa09c4ef51  licenses/dependencies/rand_core-0.10.1/LICENSE-APACHE
+8b6e9feec03e7c9a5facb26855cecd31662bf989b636bcfe79521bdf8ac863f0  licenses/dependencies/rand_core-0.10.1/LICENSE-MIT
+90eb64f0279b0d9432accfa6023ff803bc4965212383697eee27a0f426d5f8d5  licenses/dependencies/rand_pcg-0.10.2/COPYRIGHT
+6df43f6f4b5d4587f3d8d71e45532c688fd168afa5fe89d571cb32fa09c4ef51  licenses/dependencies/rand_pcg-0.10.2/LICENSE-APACHE
+2234e3cefee876aeb686ad89e978bdb07bf118a1186ab1cf161bcdf69d4b4f57  licenses/dependencies/rand_pcg-0.10.2/LICENSE-MIT
+90eb64f0279b0d9432accfa6023ff803bc4965212383697eee27a0f426d5f8d5  licenses/dependencies/rand-0.10.2/COPYRIGHT
+35242e7a83f69875e6edeff02291e688c97caafe2f8902e4e19b49d3e78b4cab  licenses/dependencies/rand-0.10.2/LICENSE-APACHE
+209fbbe0ad52d9235e37badf9cadfe4dbdc87203179c0899e738b39ade42177b  licenses/dependencies/rand-0.10.2/LICENSE-MIT
+a6cba85bc92e0cff7a450b1d873c0eaa2e9fc96bf472df0247a26bec77bf3ff9  licenses/dependencies/range-alloc-0.1.5/LICENSE.APACHE
+ba00052102ed87948bb8822d6e1c496260c83042887b22bb5caad922ec025a60  licenses/dependencies/range-alloc-0.1.5/LICENSE.MIT
+1c7745cc26c7294bc9dbc883bcd50700b99a8c0f4859bfce84ec555098ce1ab5  licenses/dependencies/rangemap-1.8.0/LICENSE-APACHE
+29a4c3823ee29ee5a97c145574a1bac20629fd5e6708be1df0d25bab563e093c  licenses/dependencies/rangemap-1.8.0/LICENSE-MIT
+0d542e0c8804e39aa7f37eb00da5a762149dc682d7829451287e11b938e94594  licenses/dependencies/raw-window-handle-0.6.2/LICENSE-APACHE.md
+9c5a80639a57c1c945570e7ebbca0706305849ce3c098021325cca9db2f7acc4  licenses/dependencies/raw-window-handle-0.6.2/LICENSE-MIT.md
+ae895c8576e682f310fb70d93d9f99b1dd82872094c54a8f6cdfe2ca5c2d6ecb  licenses/dependencies/raw-window-handle-0.6.2/LICENSE-ZLIB.md
+a14f7d685a79c0f4fb64aee305527a6d5fa55f2401f4e6d688d7b1301868e6c0  licenses/dependencies/read-fonts-0.35.0/LICENSE-APACHE
+8a62fa27ffdccc3df19dce90f8bb3d572e27aecffc1a383d0c2601834dcec434  licenses/dependencies/read-fonts-0.35.0/LICENSE-MIT
+eba684204073ed715c4abb48129acdfd2bff8ae48339e6a7da3b341d3027b7f0  licenses/dependencies/read-fonts-0.41.0/LICENSE-APACHE
+7b4c9a3946dfcea7967582760e963e27799e225dcf20565c8ef55324bb017427  licenses/dependencies/read-fonts-0.41.0/LICENSE-MIT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/renderdoc-sys-1.1.0/LICENSE-APACHE
+24b2f2eff5a7622e87162823e260f00c6dfbce0e26d585d3d28c785f1edc80ed  licenses/dependencies/renderdoc-sys-1.1.0/LICENSE-MIT
+751963a8b88c0e3a9f27e98933079fbcf09b9998b2c13ac49c2e4d58444520d6  licenses/dependencies/reqwest-0.12.28/LICENSE-APACHE
+47d4e1803702728e03d30f8a848ae2249ba274bbd9f8443e803f7924d83cd371  licenses/dependencies/reqwest-0.12.28/LICENSE-MIT
+65fc947f4bac882a2cd104ef73c246b1b037059df9f2b3a58b7f77f0b9e56071  licenses/dependencies/rfd-0.15.4/LICENSE
+b3d734001a94efff3579978d953391aa7115f877657d25eb54037a43875d078a  licenses/dependencies/ring-0.17.14/LICENSE
+005fc765ddc5115da796cca915baa9557abae13ff35e0a47c47affc56f6c414d  licenses/dependencies/ring-0.17.14/LICENSE-BoringSSL
+f025ccfb7dfb6bdfedc75ca0f67acc69e6fb4998143d834f7c2f38a29989680f  licenses/dependencies/ring-0.17.14/LICENSE-other-bits
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/ring-0.17.14/src/polyfill/once_cell/LICENSE-APACHE
+6ee2ed6c77710de911761acd5fc1ad1da00f476beb1a7ef27e78c2d1858deafc  licenses/dependencies/ring-0.17.14/src/polyfill/once_cell/LICENSE-MIT
+9eacbcb81be660840c714a560a9d65ba07913db98dd4baf969f78dd499fdd60f  licenses/dependencies/ring-0.17.14/third_party/fiat/LICENSE
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/rustc-hash-1.1.0/LICENSE-APACHE
+23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3  licenses/dependencies/rustc-hash-1.1.0/LICENSE-MIT
+95bd3988beee069fa2848f648dab43cc6e0b2add2ad6bcb17360caf749802bcc  licenses/dependencies/rustc-hash-2.1.3/LICENSE-APACHE
+30fefc3a7d6a0041541858293bcbea2dde4caa4c0a5802f996a7f7e8c0085652  licenses/dependencies/rustc-hash-2.1.3/LICENSE-MIT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/rustls-0.23.43/LICENSE-APACHE
+7cfafc877eccc46c0e346ccbaa5c51bb6b894d2b818e617d970211e232785ad4  licenses/dependencies/rustls-0.23.43/LICENSE-ISC
+709e3175b4212f7b13aa93971c9f62ff8c69ec45ad8c6532a7e0c41d7a7d6f8c  licenses/dependencies/rustls-0.23.43/LICENSE-MIT
+45fd05c4865e7c350b98ad7ac50e1b15462d49af4a91e9b0c9dd933dc9a69742  licenses/dependencies/rustls-pki-types-1.15.1/LICENSE-APACHE
+9117d922e667125508dde62b02c1f57ed22f5ad21eb536aa2e2d99e1c796e639  licenses/dependencies/rustls-pki-types-1.15.1/LICENSE-MIT
+5b698ca13897be3afdb7174256fa1574f8c6892b8bea1a66dd6469d3fe27885a  licenses/dependencies/rustls-webpki-0.103.15/LICENSE
+62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a  licenses/dependencies/ryu-1.0.23/LICENSE-APACHE
+c9bff75738922193e67fa726fa225535870d2aa1059f91452c411736284ad566  licenses/dependencies/ryu-1.0.23/LICENSE-BOOST
+01c266bced4a434da0051174d6bee16a4c82cf634e2679b6155d40d75012390f  licenses/dependencies/same-file-1.0.6/COPYING
+cb3c929a05e6cbc9de9ab06a4c57eeb60ca8c724bef6c138c87d3a577e27aa14  licenses/dependencies/same-file-1.0.6/LICENSE-MIT
+7e12e5df4bae12cb21581ba157ced20e1986a0508dd10d0e8a4ab9a4cf94e85c  licenses/dependencies/same-file-1.0.6/UNLICENSE
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/scopeguard-1.2.0/LICENSE-APACHE
+fb77f0a9c53e473abe5103c8632ef9f0f2874d4fb3f17cb2d8c661aab9cee9d7  licenses/dependencies/scopeguard-1.2.0/LICENSE-MIT
+c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4  licenses/dependencies/self_cell-1.3.0/LICENSE-APACHE
+f9c375a1be4a41f7b70301dd83c91cb89e41567478859b77eef375a52d782505  licenses/dependencies/self_cell-1.3.0/LICENSE-GPLv2
+62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a  licenses/dependencies/serde_core-1.0.229/LICENSE-APACHE
+23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3  licenses/dependencies/serde_core-1.0.229/LICENSE-MIT
+62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a  licenses/dependencies/serde_derive-1.0.229/LICENSE-APACHE
+23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3  licenses/dependencies/serde_derive-1.0.229/LICENSE-MIT
+62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a  licenses/dependencies/serde_json-1.0.151/LICENSE-APACHE
+23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3  licenses/dependencies/serde_json-1.0.151/LICENSE-MIT
+62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a  licenses/dependencies/serde_path_to_error-0.1.20/LICENSE-APACHE
+23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3  licenses/dependencies/serde_path_to_error-0.1.20/LICENSE-MIT
+62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a  licenses/dependencies/serde_urlencoded-0.7.1/LICENSE-APACHE
+b9eb266294324f672cbe945fe8f2e32f85024f0d61a1a7d14382cdde0ac44769  licenses/dependencies/serde_urlencoded-0.7.1/LICENSE-MIT
+62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a  licenses/dependencies/serde-1.0.229/LICENSE-APACHE
+23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3  licenses/dependencies/serde-1.0.229/LICENSE-MIT
+282a21b0710441c364025461a447362daf18f5798a7b72ae2f801a2aa536da51  licenses/dependencies/sha1_smol-1.0.1/LICENSE
+553fffcd9b1cb158bc3e9edc35da85ca5c3b3d7d2e61c883ebcfa8a65814b583  licenses/dependencies/shlex-2.0.1/LICENSE-APACHE
+4455bf75a91154108304cb283e0fea9948c14f13e20d60887cf2552449dea3b1  licenses/dependencies/shlex-2.0.1/LICENSE-MIT
+a14f7d685a79c0f4fb64aee305527a6d5fa55f2401f4e6d688d7b1301868e6c0  licenses/dependencies/skrifa-0.37.0/LICENSE-APACHE
+8a62fa27ffdccc3df19dce90f8bb3d572e27aecffc1a383d0c2601834dcec434  licenses/dependencies/skrifa-0.37.0/LICENSE-MIT
+eba684204073ed715c4abb48129acdfd2bff8ae48339e6a7da3b341d3027b7f0  licenses/dependencies/skrifa-0.44.0/LICENSE-APACHE
+7b4c9a3946dfcea7967582760e963e27799e225dcf20565c8ef55324bb017427  licenses/dependencies/skrifa-0.44.0/LICENSE-MIT
+8ce0830173fdac609dfb4ea603fdc002c2f4af0dc9b1a005653f5da9cf534b18  licenses/dependencies/slab-0.4.12/LICENSE
+6cec81441b2ab2b5090954c1fb5d0bcca81b86487b5849061fa8952d20ef67d4  licenses/dependencies/slotmap-1.1.1/LICENSE
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/smallvec-1.16.0/LICENSE-APACHE
+0b28172679e0009b655da42797c03fd163a3379d5cfa67ba1f1655e974a2a1a9  licenses/dependencies/smallvec-1.16.0/LICENSE-MIT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/smol_str-0.2.2/LICENSE-APACHE
+23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3  licenses/dependencies/smol_str-0.2.2/LICENSE-MIT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/socket2-0.6.5/LICENSE-APACHE
+378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397  licenses/dependencies/socket2-0.6.5/LICENSE-MIT
+a4445427440043e8ce6fadf7a43fb906cb0d7f6c573a560a9f142cf9f9bf8ff4  licenses/dependencies/softbuffer-0.4.8/LICENSE-APACHE
+0463bfa47d6d763d8c824333efb0e6d6df3946c13c3b077c78ed9f23ca50d0f2  licenses/dependencies/softbuffer-0.4.8/LICENSE-MIT
+cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30  licenses/dependencies/spirv-0.3.0+sdk-1.3.268.0/supplement/gfx-rs-rspirv-e91a5debc10c-LICENSE
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/stable_deref_trait-1.2.1/LICENSE-APACHE
+5e05b024f653a5ce199e77cbbbd42fb5553562ec714b819421ed0c3e552a75d7  licenses/dependencies/stable_deref_trait-1.2.1/LICENSE-MIT
+cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30  licenses/dependencies/static_assertions-1.1.0/LICENSE-APACHE
+ea084a2373ebc1f0902c09266e7bf25a05ab3814c1805bb017ffa7308f90c061  licenses/dependencies/static_assertions-1.1.0/LICENSE-MIT
+3085885678bb161f6c472bbd331f66a2550b555eb76128f7f8247779128199c0  licenses/dependencies/strict-num-0.1.1/LICENSE
+d1fc1bc0d155df60b2e7705b6b2ae02a05c96f948e1cec6e2fb86360b09f346b  licenses/dependencies/subtle-2.6.1/LICENSE
+7e98bed7f100747aaae7d82ab94fbe6b76fd6b84b09a3aaa413bff8196d0fbb1  licenses/dependencies/svg_fmt-0.4.5/supplement/nical-rust_debug-93f414cd572b-LICENSE
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/swash-0.2.10/LICENSE-APACHE
+122dadfc2eb4de0f4bafcd9eb4e7502cfe338a7965ebd1d18708cc5050f43f76  licenses/dependencies/swash-0.2.10/LICENSE-MIT
+62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a  licenses/dependencies/syn-2.0.119/LICENSE-APACHE
+23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3  licenses/dependencies/syn-2.0.119/LICENSE-MIT
+62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a  licenses/dependencies/syn-3.0.5/LICENSE-APACHE
+23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3  licenses/dependencies/syn-3.0.5/LICENSE-MIT
+0d542e0c8804e39aa7f37eb00da5a762149dc682d7829451287e11b938e94594  licenses/dependencies/sync_wrapper-1.0.2/LICENSE
+219920e865eee70b7dcfc948a86b099e7f4fe2de01bcca2ca9a20c0a033f2b59  licenses/dependencies/synstructure-0.13.2/LICENSE
+c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4  licenses/dependencies/sys-locale-0.3.2/LICENSE-APACHE
+5cc390ab5e5e6507f467368cbab1297552d64bfd863f4b496c7928508bcfefd8  licenses/dependencies/sys-locale-0.3.2/LICENSE-MIT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/tempfile-3.27.0/LICENSE-APACHE
+8b427f5bc501764575e52ba4f9d95673cf8f6d80a86d0d06599852e1a9a20a36  licenses/dependencies/tempfile-3.27.0/LICENSE-MIT
+01c266bced4a434da0051174d6bee16a4c82cf634e2679b6155d40d75012390f  licenses/dependencies/termcolor-1.4.1/COPYING
+0f96a83840e146e43c0ec96a22ec1f392e0680e6c1226e6f3ba87e0740af850f  licenses/dependencies/termcolor-1.4.1/LICENSE-MIT
+7e12e5df4bae12cb21581ba157ced20e1986a0508dd10d0e8a4ab9a4cf94e85c  licenses/dependencies/termcolor-1.4.1/UNLICENSE
+62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a  licenses/dependencies/thiserror-1.0.69/LICENSE-APACHE
+23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3  licenses/dependencies/thiserror-1.0.69/LICENSE-MIT
+62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a  licenses/dependencies/thiserror-2.0.20/LICENSE-APACHE
+23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3  licenses/dependencies/thiserror-2.0.20/LICENSE-MIT
+62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a  licenses/dependencies/thiserror-impl-1.0.69/LICENSE-APACHE
+23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3  licenses/dependencies/thiserror-impl-1.0.69/LICENSE-MIT
+62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a  licenses/dependencies/thiserror-impl-2.0.20/LICENSE-APACHE
+23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3  licenses/dependencies/thiserror-impl-2.0.20/LICENSE-MIT
+6d41e05f1d54fe726997cb0334ec539f1dff50600b1d5d90462ec2b392770ced  licenses/dependencies/tiny-skia-0.11.4/LICENSE
+6d41e05f1d54fe726997cb0334ec539f1dff50600b1d5d90462ec2b392770ced  licenses/dependencies/tiny-skia-path-0.11.4/LICENSE
+f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2  licenses/dependencies/tinystr-0.8.4/LICENSE
+4f44572785f35152c1fd2eadf565b7e079c0f300b4324f0af653419f9d76b735  licenses/dependencies/tinyvec_macros-0.1.1/LICENSE-APACHE.md
+1dd8eca0f83669e75fa119e34fb9e1be9d16e3e9b6368962b8019db6e8ae5f7b  licenses/dependencies/tinyvec_macros-0.1.1/LICENSE-MIT.md
+41ace205715d9f19a3214218cc1c01d57c533e02cd0fef7c8e51a49a7fce5ac5  licenses/dependencies/tinyvec_macros-0.1.1/LICENSE-ZLIB.md
+cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30  licenses/dependencies/tinyvec-1.13.2/LICENSE-APACHE.md
+fd80a26fbb3f644af1fa994134446702932968519797227e07a1368dea80f0bc  licenses/dependencies/tinyvec-1.13.2/LICENSE-MIT.md
+84b34dd7608f7fb9b17bd588a6bf392bf7de504e2716f024a77d89f1b145a151  licenses/dependencies/tinyvec-1.13.2/LICENSE-ZLIB.md
+253cd04c6714889df2d32f3f64d669179a1c95c76ac43c40882c52eb06bc3552  licenses/dependencies/tokio-1.53.1/LICENSE
+0b83dc40cba89b9922bb84b0a9c7d2768ce37c1d7e138b7424fd4549915778c9  licenses/dependencies/tokio-macros-2.7.2/LICENSE
+cc117d90b498b32b11a886f279b359da16a73c3b01efbb2f5cc004b20262334e  licenses/dependencies/tokio-rustls-0.26.5/LICENSE-APACHE
+e20fa2b8e0a2565f24a792b94b4bf4b6c2b9d36f781d8a9516e218a036e6677a  licenses/dependencies/tokio-rustls-0.26.5/LICENSE-MIT
+4249c8e6c5ebb85f97c77e6457c6fafc1066406eb8f1ef61e796fbdc5ff18482  licenses/dependencies/tower-0.5.3/LICENSE
+5049cf464977eff4b4fcfa7988d84e74116956a3eb9d5f1d451b3f828f945233  licenses/dependencies/tower-http-0.6.11/LICENSE
+4249c8e6c5ebb85f97c77e6457c6fafc1066406eb8f1ef61e796fbdc5ff18482  licenses/dependencies/tower-layer-0.3.3/LICENSE
+4249c8e6c5ebb85f97c77e6457c6fafc1066406eb8f1ef61e796fbdc5ff18482  licenses/dependencies/tower-service-0.3.3/LICENSE
+898b1ae9821e98daf8964c8d6c7f61641f5f5aa78ad500020771c0939ee0dea1  licenses/dependencies/tracing-0.1.44/LICENSE
+898b1ae9821e98daf8964c8d6c7f61641f5f5aa78ad500020771c0939ee0dea1  licenses/dependencies/tracing-attributes-0.1.31/LICENSE
+898b1ae9821e98daf8964c8d6c7f61641f5f5aa78ad500020771c0939ee0dea1  licenses/dependencies/tracing-core-0.1.36/LICENSE
+58545fed1565e42d687aecec6897d35c6d37ccb71479a137c0deb2203e125c79  licenses/dependencies/tracing-core-0.1.36/src/spin/LICENSE
+c816a0749cdc6bf062a5111c159723de51b2bfac66a1dac2655abd9e6b1583eb  licenses/dependencies/try-lock-0.2.5/LICENSE
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/ttf-parser-0.25.1/LICENSE-APACHE
+f3c9fe731c701ed77fd5fbaac573872af04dc5869385eb9bd5e3c73c42713814  licenses/dependencies/ttf-parser-0.25.1/LICENSE-MIT
+58d1e17ffe5109a7ae296caafcadfdbe6a7d176f0bc4ab01e12a689b0499d8bd  licenses/dependencies/ttf-parser-0.25.1/tests/fonts/colr_1_LICENSE
+edb20b474f6cbd4f4db066b54a9e0f687d0009d309412a63431189b59b8e2a07  licenses/dependencies/unicode-bidi-0.3.18/COPYRIGHT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/unicode-bidi-0.3.18/LICENSE-APACHE
+7b63ecd5f1902af1b63729947373683c32745c16a10e8e6292e2e2dcd7e90ae0  licenses/dependencies/unicode-bidi-0.3.18/LICENSE-MIT
+62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a  licenses/dependencies/unicode-ident-1.0.24/LICENSE-APACHE
+23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3  licenses/dependencies/unicode-ident-1.0.24/LICENSE-MIT
+f7db81051789b729fea528a63ec4c938fdcb93d9d61d97dc8cc2e9df6d47f2a1  licenses/dependencies/unicode-ident-1.0.24/LICENSE-UNICODE
+c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4  licenses/dependencies/unicode-linebreak-0.1.5/LICENSE
+7cbb56d1b5d83d735056b363ab20958524120afafc4ad8206e6be98cdec5d737  licenses/dependencies/unicode-script-0.5.8/LICENSE-APACHE
+7ad3ea8ca3caf894db98c3f31d5d4949173ffa93c883ef19a9e529ad48960f8c  licenses/dependencies/unicode-script-0.5.8/LICENSE-MIT
+23860c2a7b5d96b21569afedf033469bab9fe14a1b24a35068b8641c578ce24d  licenses/dependencies/unicode-segmentation-1.13.3/COPYRIGHT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/unicode-segmentation-1.13.3/LICENSE-APACHE
+7b63ecd5f1902af1b63729947373683c32745c16a10e8e6292e2e2dcd7e90ae0  licenses/dependencies/unicode-segmentation-1.13.3/LICENSE-MIT
+23860c2a7b5d96b21569afedf033469bab9fe14a1b24a35068b8641c578ce24d  licenses/dependencies/unicode-width-0.2.2/COPYRIGHT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/unicode-width-0.2.2/LICENSE-APACHE
+7b63ecd5f1902af1b63729947373683c32745c16a10e8e6292e2e2dcd7e90ae0  licenses/dependencies/unicode-width-0.2.2/LICENSE-MIT
+7abd9b6960dcf7d4d0a48606a5b71bfe37d472db68d70637f3a58a56785f1621  licenses/dependencies/untrusted-0.9.0/LICENSE.txt
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/url-2.5.8/LICENSE-APACHE
+b38f11f6096706e6de553dabe2a7ed142d59b6fa8c97e290c67496154745cdd5  licenses/dependencies/url-2.5.8/LICENSE-MIT
+c30152c94a6d75e021adbc52b3a52470366a46edb917e17deae3259251af244c  licenses/dependencies/utf8_iter-1.0.4/COPYRIGHT
+cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30  licenses/dependencies/utf8_iter-1.0.4/LICENSE-APACHE
+3fa4ca83dcc9237839b1bdeb2e6d16bdfb5ec0c5ce42b24694d8bbf0dcbef72c  licenses/dependencies/utf8_iter-1.0.4/LICENSE-MIT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/uuid-1.26.0/LICENSE-APACHE
+436bc5a105d8e57dcd8778730f3754f7bf39c14d2f530e4cde4bd2d17a83ec3d  licenses/dependencies/uuid-1.26.0/LICENSE-MIT
+a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2  licenses/dependencies/version_check-0.9.5/LICENSE-APACHE
+b7e650f3fce5c53249d1cdc608b54df156a97edd636cf9d23498d0cfe7aec63e  licenses/dependencies/version_check-0.9.5/LICENSE-MIT
+a65f5d0a945d267751344c95665945b90c030ea107faf5c85d518929886187da  licenses/dependencies/want-0.3.1/LICENSE
+54a744942eb3fa63a74d8d359989ed6962c04f3f10ff20cfa08ff8aa7efbe4e6  licenses/dependencies/web-time-1.1.0/LICENSE-APACHE
+f428305bbf2e70fbd807af0f3c7ac1b7acfb95311640f451e9d2e48db6d7e96b  licenses/dependencies/web-time-1.1.0/LICENSE-MIT
+e271993808fec50ab29350b39539cdec611a9103f827e0aa26d61da70e2d33f8  licenses/dependencies/webpki-roots-1.0.9/LICENSE
+a6cba85bc92e0cff7a450b1d873c0eaa2e9fc96bf472df0247a26bec77bf3ff9  licenses/dependencies/wgpu-27.0.1/LICENSE.APACHE
+dc0d97139e8205818c703741c7be7cb3b96888bd5917b8d6fc6133731e403c21  licenses/dependencies/wgpu-27.0.1/LICENSE.MIT
+a6cba85bc92e0cff7a450b1d873c0eaa2e9fc96bf472df0247a26bec77bf3ff9  licenses/dependencies/wgpu-core-27.0.3/LICENSE.APACHE
+dc0d97139e8205818c703741c7be7cb3b96888bd5917b8d6fc6133731e403c21  licenses/dependencies/wgpu-core-27.0.3/LICENSE.MIT
+a6cba85bc92e0cff7a450b1d873c0eaa2e9fc96bf472df0247a26bec77bf3ff9  licenses/dependencies/wgpu-core-deps-windows-linux-android-27.0.0/LICENSE.APACHE
+dc0d97139e8205818c703741c7be7cb3b96888bd5917b8d6fc6133731e403c21  licenses/dependencies/wgpu-core-deps-windows-linux-android-27.0.0/LICENSE.MIT
+a6cba85bc92e0cff7a450b1d873c0eaa2e9fc96bf472df0247a26bec77bf3ff9  licenses/dependencies/wgpu-hal-27.0.4/LICENSE.APACHE
+dc0d97139e8205818c703741c7be7cb3b96888bd5917b8d6fc6133731e403c21  licenses/dependencies/wgpu-hal-27.0.4/LICENSE.MIT
+a6cba85bc92e0cff7a450b1d873c0eaa2e9fc96bf472df0247a26bec77bf3ff9  licenses/dependencies/wgpu-types-27.0.1/LICENSE.APACHE
+dc0d97139e8205818c703741c7be7cb3b96888bd5917b8d6fc6133731e403c21  licenses/dependencies/wgpu-types-27.0.1/LICENSE.MIT
+01c266bced4a434da0051174d6bee16a4c82cf634e2679b6155d40d75012390f  licenses/dependencies/winapi-util-0.1.11/COPYING
+cb3c929a05e6cbc9de9ab06a4c57eeb60ca8c724bef6c138c87d3a577e27aa14  licenses/dependencies/winapi-util-0.1.11/LICENSE-MIT
+7e12e5df4bae12cb21581ba157ced20e1986a0508dd10d0e8a4ab9a4cf94e85c  licenses/dependencies/winapi-util-0.1.11/UNLICENSE
+7faec985f3e9b1c4a1df646bfedc304ba67e409447f7ab7f4f591f68708d85dc  licenses/dependencies/window_clipboard-0.5.1/LICENSE
+c16f8dcf1a368b83be78d826ea23de4079fe1b4469a0ab9ee20563f37ff3d44b  licenses/dependencies/windows_x86_64_gnullvm-0.52.6/license-apache-2.0
+c2cfccb812fe482101a8f04597dfc5a9991a6b2748266c47ac91b6a5aae15383  licenses/dependencies/windows_x86_64_gnullvm-0.52.6/license-mit
+c16f8dcf1a368b83be78d826ea23de4079fe1b4469a0ab9ee20563f37ff3d44b  licenses/dependencies/windows-0.58.0/license-apache-2.0
+c2cfccb812fe482101a8f04597dfc5a9991a6b2748266c47ac91b6a5aae15383  licenses/dependencies/windows-0.58.0/license-mit
+c16f8dcf1a368b83be78d826ea23de4079fe1b4469a0ab9ee20563f37ff3d44b  licenses/dependencies/windows-core-0.58.0/license-apache-2.0
+c2cfccb812fe482101a8f04597dfc5a9991a6b2748266c47ac91b6a5aae15383  licenses/dependencies/windows-core-0.58.0/license-mit
+c16f8dcf1a368b83be78d826ea23de4079fe1b4469a0ab9ee20563f37ff3d44b  licenses/dependencies/windows-implement-0.58.0/license-apache-2.0
+c2cfccb812fe482101a8f04597dfc5a9991a6b2748266c47ac91b6a5aae15383  licenses/dependencies/windows-implement-0.58.0/license-mit
+c16f8dcf1a368b83be78d826ea23de4079fe1b4469a0ab9ee20563f37ff3d44b  licenses/dependencies/windows-interface-0.58.0/license-apache-2.0
+c2cfccb812fe482101a8f04597dfc5a9991a6b2748266c47ac91b6a5aae15383  licenses/dependencies/windows-interface-0.58.0/license-mit
+c16f8dcf1a368b83be78d826ea23de4079fe1b4469a0ab9ee20563f37ff3d44b  licenses/dependencies/windows-link-0.2.1/license-apache-2.0
+c2cfccb812fe482101a8f04597dfc5a9991a6b2748266c47ac91b6a5aae15383  licenses/dependencies/windows-link-0.2.1/license-mit
+c16f8dcf1a368b83be78d826ea23de4079fe1b4469a0ab9ee20563f37ff3d44b  licenses/dependencies/windows-result-0.2.0/license-apache-2.0
+c2cfccb812fe482101a8f04597dfc5a9991a6b2748266c47ac91b6a5aae15383  licenses/dependencies/windows-result-0.2.0/license-mit
+c16f8dcf1a368b83be78d826ea23de4079fe1b4469a0ab9ee20563f37ff3d44b  licenses/dependencies/windows-strings-0.1.0/license-apache-2.0
+c2cfccb812fe482101a8f04597dfc5a9991a6b2748266c47ac91b6a5aae15383  licenses/dependencies/windows-strings-0.1.0/license-mit
+c16f8dcf1a368b83be78d826ea23de4079fe1b4469a0ab9ee20563f37ff3d44b  licenses/dependencies/windows-sys-0.52.0/license-apache-2.0
+c2cfccb812fe482101a8f04597dfc5a9991a6b2748266c47ac91b6a5aae15383  licenses/dependencies/windows-sys-0.52.0/license-mit
+c16f8dcf1a368b83be78d826ea23de4079fe1b4469a0ab9ee20563f37ff3d44b  licenses/dependencies/windows-sys-0.59.0/license-apache-2.0
+c2cfccb812fe482101a8f04597dfc5a9991a6b2748266c47ac91b6a5aae15383  licenses/dependencies/windows-sys-0.59.0/license-mit
+c16f8dcf1a368b83be78d826ea23de4079fe1b4469a0ab9ee20563f37ff3d44b  licenses/dependencies/windows-sys-0.61.2/license-apache-2.0
+c2cfccb812fe482101a8f04597dfc5a9991a6b2748266c47ac91b6a5aae15383  licenses/dependencies/windows-sys-0.61.2/license-mit
+c16f8dcf1a368b83be78d826ea23de4079fe1b4469a0ab9ee20563f37ff3d44b  licenses/dependencies/windows-targets-0.52.6/license-apache-2.0
+c2cfccb812fe482101a8f04597dfc5a9991a6b2748266c47ac91b6a5aae15383  licenses/dependencies/windows-targets-0.52.6/license-mit
+6dc0e068dcf3a5bc8e054205b85b7720e1d49265bbc64bf515d2cf79197df69a  licenses/dependencies/winit-0.30.13/LICENSE
+f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2  licenses/dependencies/writeable-0.6.4/LICENSE
+0dc18d924dc0a5f41172a393012843a5eaaef338e795b3645da9cc3b6068220b  licenses/dependencies/xml-rs-0.8.29/LICENSE
+7cfd738c53d61c79f07e348f622bf7707c9084237054d37fbe07788a75f5881c  licenses/dependencies/yazi-0.2.1/LICENSE-APACHE
+df62e3ef3f207c91073fedd78b4156a278681d0dd3f942379242c62c6a71a3ec  licenses/dependencies/yazi-0.2.1/LICENSE-MIT
+f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2  licenses/dependencies/yoke-0.8.3/LICENSE
+f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2  licenses/dependencies/yoke-derive-0.8.2/LICENSE
+7cfd738c53d61c79f07e348f622bf7707c9084237054d37fbe07788a75f5881c  licenses/dependencies/zeno-0.3.3/LICENSE-APACHE
+34dff8202d63e6df022f4f0ce88dab24f254c35ee0d5958b74dcf74d9eae21cc  licenses/dependencies/zeno-0.3.3/LICENSE-MIT
+9d185ac6703c4b0453974c0d85e9eee43e6941009296bb1f5eb0b54e2329e9f3  licenses/dependencies/zerocopy-0.8.56/LICENSE-APACHE
+83c1763356e822adde0a2cae748d938a73fdc263849ccff6b27776dff213bd32  licenses/dependencies/zerocopy-0.8.56/LICENSE-BSD
+1a2f5c12ddc934d58956aa5dbdd3255fe55fd957633ab7d0d39e4f0daa73f7df  licenses/dependencies/zerocopy-0.8.56/LICENSE-MIT
+9d185ac6703c4b0453974c0d85e9eee43e6941009296bb1f5eb0b54e2329e9f3  licenses/dependencies/zerocopy-derive-0.8.56/LICENSE-APACHE
+83c1763356e822adde0a2cae748d938a73fdc263849ccff6b27776dff213bd32  licenses/dependencies/zerocopy-derive-0.8.56/LICENSE-BSD
+1a2f5c12ddc934d58956aa5dbdd3255fe55fd957633ab7d0d39e4f0daa73f7df  licenses/dependencies/zerocopy-derive-0.8.56/LICENSE-MIT
+f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2  licenses/dependencies/zerofrom-0.1.8/LICENSE
+f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2  licenses/dependencies/zerofrom-derive-0.1.7/LICENSE
+cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30  licenses/dependencies/zeroize-1.9.0/LICENSE-APACHE
+8c7516d4b27b1e495be5e38b612298b63de48d05f49cdac94f70f3cd70f8864b  licenses/dependencies/zeroize-1.9.0/LICENSE-MIT
+f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2  licenses/dependencies/zerotrie-0.2.5/LICENSE
+f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2  licenses/dependencies/zerovec-0.11.8/LICENSE
+f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2  licenses/dependencies/zerovec-derive-0.11.6/LICENSE
+23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3  licenses/dependencies/zmij-1.0.23/LICENSE-MIT
+b5efebcaca80879234098e52d1725e6d9eb8fb96a19fce625d39184b705f7b6d  licenses/llvm-libunwind/llvm-ea7d852a70e8-libunwind-LICENSE.TXT
+8d85c1057d742e597985c7d4e6320b015a9139385cff4cbae06ffc0ebe89afee  licenses/llvm-mingw-LICENSE.TXT
+28e85c5aa4af9b4f1dfe6b4817aa3eefb3eaaee7fd735045016f29ccf50276a1  licenses/rust/COPYING.RUNTIME
+8ceb4b9ee5adedde47b31e975c1d90c73ad27b6b165a1dcd80c7c545eb65b903  licenses/rust/COPYING3
+68129500b616d5838629e68f55ff3aed5e096dacf60ce9eb41bbe599a563afa6  licenses/rust/COPYRIGHT-library.html
+5b0c93fc4e6d4b072eaa521b1762d1e746f4c368f65e81a0e5308e2772dac85e  licenses/rust/COPYRIGHT.html
+73860425cbf24f37ce9a4c0ddb18309fe5bf6d340a74943147e7fced9bb6a30d  package.json
+597cfb8da873e019d2658420f18ec059f0185fa9106ff9eafe934dfdd6ed266b  README.md
+a549295cf57ac73673dc4fa6106463450f982122793cb9c7135ce4fc7087e9ed  START-HERE.txt
+6756989c8fc73706641cd78449c315458425a2eed9a82febc289b9d28ea7f21f  THIRD-PARTY-NOTICES.txt

harness/experiments/navigation-prerelease-20260911/package-metadata/START-HERE.txt

@@ -0,0 +1,11 @@
+Arcadia Studio portable Windows bundle
+
+Open arcadia-studio.exe. See docs/windows-packaging.md for runtime prerequisites
+and verification, README.md for model workflows, and docs/server.md to run the
+optional arcadia-server.exe. Examples are under examples/; Help is built in.
+
+Keep the bundled runtime DLL beside both executables when present. No compiler
+installation or machine PATH change is required by the staged runtime closure.
+This binary bundle does not include repository sources needed for Cargo/Docker
+build commands. Packaging integrity is not native release acceptance; read
+package.json and the distributor's binary-specific acceptance record for limitations.

harness/experiments/navigation-prerelease-20260911/package-metadata/THIRD-PARTY-NOTICES.txt

@@ -0,0 +1,273 @@
+Third-party notice inventory
+
+Exact versions, license expressions, source hashes and notice paths: dependency-notices.json
+License texts and embedded-asset notices: licenses/
+Rust distribution notices: licenses/rust/
+Collection does not establish binary/source equivalence or a universal license audit.
+
+oa-core 0.2.0 -- MIT -- licenses/dependencies/oa-core-0.2.0/
+oa-desktop 0.2.0 -- MIT -- licenses/dependencies/oa-desktop-0.2.0/
+oa-server 0.2.0 -- MIT -- licenses/dependencies/oa-server-0.2.0/
+arrayref 0.3.9 -- BSD-2-Clause -- licenses/dependencies/arrayref-0.3.9/
+arrayvec 0.7.8 -- MIT OR Apache-2.0 -- licenses/dependencies/arrayvec-0.7.8/
+ash 0.38.0+1.3.281 -- MIT OR Apache-2.0 -- licenses/dependencies/ash-0.38.0+1.3.281/
+atomic-waker 1.1.2 -- Apache-2.0 OR MIT -- licenses/dependencies/atomic-waker-1.1.2/
+autocfg 1.5.1 -- Apache-2.0 OR MIT -- licenses/dependencies/autocfg-1.5.1/
+axum-core 0.5.6 -- MIT -- licenses/dependencies/axum-core-0.5.6/
+axum 0.8.9 -- MIT -- licenses/dependencies/axum-0.8.9/
+base64 0.22.1 -- MIT OR Apache-2.0 -- licenses/dependencies/base64-0.22.1/
+bit-set 0.8.0 -- Apache-2.0 OR MIT -- licenses/dependencies/bit-set-0.8.0/
+bit-vec 0.8.0 -- Apache-2.0 OR MIT -- licenses/dependencies/bit-vec-0.8.0/
+bitflags 2.13.1 -- MIT OR Apache-2.0 -- licenses/dependencies/bitflags-2.13.1/
+bytemuck_derive 1.12.0 -- Zlib OR Apache-2.0 OR MIT -- licenses/dependencies/bytemuck_derive-1.12.0/
+bytemuck 1.25.2 -- Zlib OR Apache-2.0 OR MIT -- licenses/dependencies/bytemuck-1.25.2/
+bytes 1.12.1 -- MIT -- licenses/dependencies/bytes-1.12.1/
+cc 1.4.5 -- MIT OR Apache-2.0 -- licenses/dependencies/cc-1.4.5/
+cfg_aliases 0.2.2 -- MIT -- licenses/dependencies/cfg_aliases-0.2.2/
+cfg-if 1.0.4 -- MIT OR Apache-2.0 -- licenses/dependencies/cfg-if-1.0.4/
+chacha20 0.10.2 -- MIT OR Apache-2.0 -- licenses/dependencies/chacha20-0.10.2/
+clipboard-win 5.4.1 -- BSL-1.0 -- licenses/dependencies/clipboard-win-5.4.1/
+codespan-reporting 0.12.0 -- Apache-2.0 -- licenses/dependencies/codespan-reporting-0.12.0/
+core_maths 0.1.1 -- MIT -- licenses/dependencies/core_maths-0.1.1/
+cosmic-text 0.15.0 -- MIT OR Apache-2.0 -- licenses/dependencies/cosmic-text-0.15.0/
+cpufeatures 0.3.1 -- MIT OR Apache-2.0 -- licenses/dependencies/cpufeatures-0.3.1/
+cryoglyph 0.1.0 -- MIT OR Apache-2.0 OR Zlib -- licenses/dependencies/cryoglyph-0.1.0/
+cursor-icon 1.2.0 -- MIT OR Apache-2.0 OR Zlib -- licenses/dependencies/cursor-icon-1.2.0/
+displaydoc 0.2.7 -- MIT OR Apache-2.0 -- licenses/dependencies/displaydoc-0.2.7/
+document-features 0.2.12 -- MIT OR Apache-2.0 -- licenses/dependencies/document-features-0.2.12/
+dpi 0.1.2 -- Apache-2.0 AND MIT -- licenses/dependencies/dpi-0.1.2/
+equivalent 1.0.2 -- Apache-2.0 OR MIT -- licenses/dependencies/equivalent-1.0.2/
+error-code 3.4.0 -- BSL-1.0 -- licenses/dependencies/error-code-3.4.0/
+etagere 0.2.15 -- MIT/Apache-2.0 -- licenses/dependencies/etagere-0.2.15/
+euclid 0.22.14 -- MIT OR Apache-2.0 -- licenses/dependencies/euclid-0.22.14/
+fastrand 2.5.0 -- Apache-2.0 OR MIT -- licenses/dependencies/fastrand-2.5.0/
+find-msvc-tools 0.1.12 -- MIT OR Apache-2.0 -- licenses/dependencies/find-msvc-tools-0.1.12/
+float_next_after 1.0.0 -- MIT -- licenses/dependencies/float_next_after-1.0.0/
+foldhash 0.1.5 -- Zlib -- licenses/dependencies/foldhash-0.1.5/
+foldhash 0.2.0 -- Zlib -- licenses/dependencies/foldhash-0.2.0/
+font-types 0.10.1 -- MIT OR Apache-2.0 -- licenses/dependencies/font-types-0.10.1/
+font-types 0.12.4 -- MIT OR Apache-2.0 -- licenses/dependencies/font-types-0.12.4/
+fontdb 0.23.0 -- MIT -- licenses/dependencies/fontdb-0.23.0/
+form_urlencoded 1.2.2 -- MIT OR Apache-2.0 -- licenses/dependencies/form_urlencoded-1.2.2/
+futures-channel 0.3.34 -- MIT OR Apache-2.0 -- licenses/dependencies/futures-channel-0.3.34/
+futures-core 0.3.34 -- MIT OR Apache-2.0 -- licenses/dependencies/futures-core-0.3.34/
+futures-executor 0.3.34 -- MIT OR Apache-2.0 -- licenses/dependencies/futures-executor-0.3.34/
+futures-io 0.3.34 -- MIT OR Apache-2.0 -- licenses/dependencies/futures-io-0.3.34/
+futures-macro 0.3.34 -- MIT OR Apache-2.0 -- licenses/dependencies/futures-macro-0.3.34/
+futures-sink 0.3.34 -- MIT OR Apache-2.0 -- licenses/dependencies/futures-sink-0.3.34/
+futures-task 0.3.34 -- MIT OR Apache-2.0 -- licenses/dependencies/futures-task-0.3.34/
+futures-util 0.3.34 -- MIT OR Apache-2.0 -- licenses/dependencies/futures-util-0.3.34/
+futures 0.3.34 -- MIT OR Apache-2.0 -- licenses/dependencies/futures-0.3.34/
+getrandom 0.2.17 -- MIT OR Apache-2.0 -- licenses/dependencies/getrandom-0.2.17/
+getrandom 0.4.3 -- MIT OR Apache-2.0 -- licenses/dependencies/getrandom-0.4.3/
+gl_generator 0.14.0 -- Apache-2.0 -- licenses/dependencies/gl_generator-0.14.0/
+glam 0.25.0 -- MIT OR Apache-2.0 -- licenses/dependencies/glam-0.25.0/
+glow 0.16.0 -- MIT OR Apache-2.0 OR Zlib -- licenses/dependencies/glow-0.16.0/
+glutin_wgl_sys 0.6.1 -- Apache-2.0 -- licenses/dependencies/glutin_wgl_sys-0.6.1/
+gpu-alloc-types 0.3.1 -- MIT OR Apache-2.0 -- licenses/dependencies/gpu-alloc-types-0.3.1/
+gpu-alloc 0.6.2 -- MIT OR Apache-2.0 -- licenses/dependencies/gpu-alloc-0.6.2/
+gpu-allocator 0.27.0 -- MIT OR Apache-2.0 -- licenses/dependencies/gpu-allocator-0.27.0/
+gpu-descriptor-types 0.2.0 -- MIT OR Apache-2.0 -- licenses/dependencies/gpu-descriptor-types-0.2.0/
+gpu-descriptor 0.3.2 -- MIT OR Apache-2.0 -- licenses/dependencies/gpu-descriptor-0.3.2/
+guillotiere 0.6.2 -- MIT/Apache-2.0 -- licenses/dependencies/guillotiere-0.6.2/
+half 2.7.1 -- MIT OR Apache-2.0 -- licenses/dependencies/half-2.7.1/
+harfrust 0.3.2 -- MIT -- licenses/dependencies/harfrust-0.3.2/
+hashbrown 0.15.5 -- MIT OR Apache-2.0 -- licenses/dependencies/hashbrown-0.15.5/
+hashbrown 0.16.1 -- MIT OR Apache-2.0 -- licenses/dependencies/hashbrown-0.16.1/
+hashbrown 0.17.1 -- MIT OR Apache-2.0 -- licenses/dependencies/hashbrown-0.17.1/
+hexf-parse 0.2.1 -- CC0-1.0 -- licenses/dependencies/hexf-parse-0.2.1/
+http-body-util 0.1.5 -- MIT -- licenses/dependencies/http-body-util-0.1.5/
+http-body 1.1.0 -- MIT -- licenses/dependencies/http-body-1.1.0/
+http 1.5.0 -- MIT OR Apache-2.0 -- licenses/dependencies/http-1.5.0/
+httparse 1.10.1 -- MIT OR Apache-2.0 -- licenses/dependencies/httparse-1.10.1/
+httpdate 1.0.3 -- MIT OR Apache-2.0 -- licenses/dependencies/httpdate-1.0.3/
+hyper-rustls 0.27.9 -- Apache-2.0 OR ISC OR MIT -- licenses/dependencies/hyper-rustls-0.27.9/
+hyper-util 0.1.20 -- MIT -- licenses/dependencies/hyper-util-0.1.20/
+hyper 1.11.1 -- MIT -- licenses/dependencies/hyper-1.11.1/
+iced_core 0.14.0 -- MIT -- licenses/dependencies/iced_core-0.14.0/
+iced_debug 0.14.0 -- MIT -- licenses/dependencies/iced_debug-0.14.0/
+iced_futures 0.14.0 -- MIT -- licenses/dependencies/iced_futures-0.14.0/
+iced_graphics 0.14.0 -- MIT -- licenses/dependencies/iced_graphics-0.14.0/
+iced_program 0.14.0 -- MIT -- licenses/dependencies/iced_program-0.14.0/
+iced_renderer 0.14.0 -- MIT -- licenses/dependencies/iced_renderer-0.14.0/
+iced_runtime 0.14.0 -- MIT -- licenses/dependencies/iced_runtime-0.14.0/
+iced_tiny_skia 0.14.0 -- MIT -- licenses/dependencies/iced_tiny_skia-0.14.0/
+iced_wgpu 0.14.0 -- MIT -- licenses/dependencies/iced_wgpu-0.14.0/
+iced_widget 0.14.2 -- MIT -- licenses/dependencies/iced_widget-0.14.2/
+iced_winit 0.14.0 -- MIT -- licenses/dependencies/iced_winit-0.14.0/
+iced 0.14.0 -- MIT -- licenses/dependencies/iced-0.14.0/
+icu_collections 2.3.0 -- Unicode-3.0 -- licenses/dependencies/icu_collections-2.3.0/
+icu_locale_core 2.3.0 -- Unicode-3.0 -- licenses/dependencies/icu_locale_core-2.3.0/
+icu_normalizer_data 2.3.0 -- Unicode-3.0 -- licenses/dependencies/icu_normalizer_data-2.3.0/
+icu_normalizer 2.3.0 -- Unicode-3.0 -- licenses/dependencies/icu_normalizer-2.3.0/
+icu_properties_data 2.3.0 -- Unicode-3.0 -- licenses/dependencies/icu_properties_data-2.3.0/
+icu_properties 2.3.0 -- Unicode-3.0 -- licenses/dependencies/icu_properties-2.3.0/
+icu_provider 2.3.1 -- Unicode-3.0 -- licenses/dependencies/icu_provider-2.3.1/
+idna_adapter 1.2.2 -- Apache-2.0 OR MIT -- licenses/dependencies/idna_adapter-1.2.2/
+idna 1.1.0 -- MIT OR Apache-2.0 -- licenses/dependencies/idna-1.1.0/
+indexmap 2.14.1 -- Apache-2.0 OR MIT -- licenses/dependencies/indexmap-2.14.1/
+ipnet 2.12.1 -- MIT OR Apache-2.0 -- licenses/dependencies/ipnet-2.12.1/
+itoa 1.0.18 -- MIT OR Apache-2.0 -- licenses/dependencies/itoa-1.0.18/
+jobserver 0.1.35 -- MIT OR Apache-2.0 -- licenses/dependencies/jobserver-0.1.35/
+khronos_api 3.1.0 -- Apache-2.0 -- licenses/dependencies/khronos_api-3.1.0/
+khronos-egl 6.0.0 -- MIT/Apache-2.0 -- licenses/dependencies/khronos-egl-6.0.0/
+kurbo 0.10.4 -- MIT OR Apache-2.0 -- licenses/dependencies/kurbo-0.10.4/
+libc 0.2.189 -- MIT OR Apache-2.0 -- licenses/dependencies/libc-0.2.189/
+libloading 0.8.9 -- ISC -- licenses/dependencies/libloading-0.8.9/
+libm 0.2.16 -- MIT -- licenses/dependencies/libm-0.2.16/
+lilt 0.8.2 -- MIT -- licenses/dependencies/lilt-0.8.2/
+linebender_resource_handle 0.1.1 -- Apache-2.0 OR MIT -- licenses/dependencies/linebender_resource_handle-0.1.1/
+litemap 0.8.3 -- Unicode-3.0 -- licenses/dependencies/litemap-0.8.3/
+litrs 1.0.0 -- MIT OR Apache-2.0 -- licenses/dependencies/litrs-1.0.0/
+lock_api 0.4.14 -- MIT OR Apache-2.0 -- licenses/dependencies/lock_api-0.4.14/
+log 0.4.34 -- MIT OR Apache-2.0 -- licenses/dependencies/log-0.4.34/
+lru-slab 0.1.2 -- MIT OR Apache-2.0 OR Zlib -- licenses/dependencies/lru-slab-0.1.2/
+lru 0.16.4 -- MIT -- licenses/dependencies/lru-0.16.4/
+lyon_algorithms 1.0.21 -- MIT OR Apache-2.0 -- licenses/dependencies/lyon_algorithms-1.0.21/
+lyon_geom 1.0.19 -- MIT OR Apache-2.0 -- licenses/dependencies/lyon_geom-1.0.19/
+lyon_path 1.0.19 -- MIT OR Apache-2.0 -- licenses/dependencies/lyon_path-1.0.19/
+lyon_tessellation 1.0.21 -- MIT OR Apache-2.0 -- licenses/dependencies/lyon_tessellation-1.0.21/
+lyon 1.0.19 -- MIT OR Apache-2.0 -- licenses/dependencies/lyon-1.0.19/
+matchit 0.8.4 -- MIT AND BSD-3-Clause -- licenses/dependencies/matchit-0.8.4/
+memchr 2.8.3 -- Unlicense OR MIT -- licenses/dependencies/memchr-2.8.3/
+memmap2 0.9.11 -- MIT OR Apache-2.0 -- licenses/dependencies/memmap2-0.9.11/
+mime 0.3.17 -- MIT OR Apache-2.0 -- licenses/dependencies/mime-0.3.17/
+mio 1.2.3 -- MIT -- licenses/dependencies/mio-1.2.3/
+naga 27.0.3 -- MIT OR Apache-2.0 -- licenses/dependencies/naga-27.0.3/
+num-traits 0.2.19 -- MIT OR Apache-2.0 -- licenses/dependencies/num-traits-0.2.19/
+once_cell 1.21.4 -- MIT OR Apache-2.0 -- licenses/dependencies/once_cell-1.21.4/
+ordered-float 5.5.0 -- MIT -- licenses/dependencies/ordered-float-5.5.0/
+parking_lot_core 0.9.12 -- MIT OR Apache-2.0 -- licenses/dependencies/parking_lot_core-0.9.12/
+parking_lot 0.12.5 -- MIT OR Apache-2.0 -- licenses/dependencies/parking_lot-0.12.5/
+percent-encoding 2.3.2 -- MIT OR Apache-2.0 -- licenses/dependencies/percent-encoding-2.3.2/
+pin-project-lite 0.2.17 -- Apache-2.0 OR MIT -- licenses/dependencies/pin-project-lite-0.2.17/
+pkg-config 0.3.34 -- MIT OR Apache-2.0 -- licenses/dependencies/pkg-config-0.3.34/
+potential_utf 0.1.6 -- Unicode-3.0 -- licenses/dependencies/potential_utf-0.1.6/
+presser 0.3.1 -- MIT OR Apache-2.0 -- licenses/dependencies/presser-0.3.1/
+proc-macro2 1.0.107 -- MIT OR Apache-2.0 -- licenses/dependencies/proc-macro2-1.0.107/
+profiling 1.0.18 -- MIT OR Apache-2.0 -- licenses/dependencies/profiling-1.0.18/
+quinn-proto 0.11.17 -- MIT OR Apache-2.0 -- licenses/dependencies/quinn-proto-0.11.17/
+quinn-udp 0.5.15 -- MIT OR Apache-2.0 -- licenses/dependencies/quinn-udp-0.5.15/
+quinn 0.11.11 -- MIT OR Apache-2.0 -- licenses/dependencies/quinn-0.11.11/
+quote 1.0.47 -- MIT OR Apache-2.0 -- licenses/dependencies/quote-1.0.47/
+rand_core 0.10.1 -- MIT OR Apache-2.0 -- licenses/dependencies/rand_core-0.10.1/
+rand_pcg 0.10.2 -- MIT OR Apache-2.0 -- licenses/dependencies/rand_pcg-0.10.2/
+rand 0.10.2 -- MIT OR Apache-2.0 -- licenses/dependencies/rand-0.10.2/
+range-alloc 0.1.5 -- MIT OR Apache-2.0 -- licenses/dependencies/range-alloc-0.1.5/
+rangemap 1.8.0 -- MIT/Apache-2.0 -- licenses/dependencies/rangemap-1.8.0/
+raw-window-handle 0.6.2 -- MIT OR Apache-2.0 OR Zlib -- licenses/dependencies/raw-window-handle-0.6.2/
+read-fonts 0.35.0 -- MIT OR Apache-2.0 -- licenses/dependencies/read-fonts-0.35.0/
+read-fonts 0.41.0 -- MIT OR Apache-2.0 -- licenses/dependencies/read-fonts-0.41.0/
+renderdoc-sys 1.1.0 -- MIT OR Apache-2.0 -- licenses/dependencies/renderdoc-sys-1.1.0/
+reqwest 0.12.28 -- MIT OR Apache-2.0 -- licenses/dependencies/reqwest-0.12.28/
+rfd 0.15.4 -- MIT -- licenses/dependencies/rfd-0.15.4/
+ring 0.17.14 -- Apache-2.0 AND ISC -- licenses/dependencies/ring-0.17.14/
+rustc-hash 1.1.0 -- Apache-2.0/MIT -- licenses/dependencies/rustc-hash-1.1.0/
+rustc-hash 2.1.3 -- Apache-2.0 OR MIT -- licenses/dependencies/rustc-hash-2.1.3/
+rustls-pki-types 1.15.1 -- MIT OR Apache-2.0 -- licenses/dependencies/rustls-pki-types-1.15.1/
+rustls-webpki 0.103.15 -- ISC -- licenses/dependencies/rustls-webpki-0.103.15/
+rustls 0.23.43 -- Apache-2.0 OR ISC OR MIT -- licenses/dependencies/rustls-0.23.43/
+ryu 1.0.23 -- Apache-2.0 OR BSL-1.0 -- licenses/dependencies/ryu-1.0.23/
+same-file 1.0.6 -- Unlicense/MIT -- licenses/dependencies/same-file-1.0.6/
+scopeguard 1.2.0 -- MIT OR Apache-2.0 -- licenses/dependencies/scopeguard-1.2.0/
+self_cell 1.3.0 -- Apache-2.0 OR GPL-2.0-only -- licenses/dependencies/self_cell-1.3.0/
+serde_core 1.0.229 -- MIT OR Apache-2.0 -- licenses/dependencies/serde_core-1.0.229/
+serde_derive 1.0.229 -- MIT OR Apache-2.0 -- licenses/dependencies/serde_derive-1.0.229/
+serde_json 1.0.151 -- MIT OR Apache-2.0 -- licenses/dependencies/serde_json-1.0.151/
+serde_path_to_error 0.1.20 -- MIT OR Apache-2.0 -- licenses/dependencies/serde_path_to_error-0.1.20/
+serde_urlencoded 0.7.1 -- MIT/Apache-2.0 -- licenses/dependencies/serde_urlencoded-0.7.1/
+serde 1.0.229 -- MIT OR Apache-2.0 -- licenses/dependencies/serde-1.0.229/
+sha1_smol 1.0.1 -- BSD-3-Clause -- licenses/dependencies/sha1_smol-1.0.1/
+shlex 2.0.1 -- MIT OR Apache-2.0 -- licenses/dependencies/shlex-2.0.1/
+skrifa 0.37.0 -- MIT OR Apache-2.0 -- licenses/dependencies/skrifa-0.37.0/
+skrifa 0.44.0 -- MIT OR Apache-2.0 -- licenses/dependencies/skrifa-0.44.0/
+slab 0.4.12 -- MIT -- licenses/dependencies/slab-0.4.12/
+slotmap 1.1.1 -- Zlib -- licenses/dependencies/slotmap-1.1.1/
+smallvec 1.16.0 -- MIT OR Apache-2.0 -- licenses/dependencies/smallvec-1.16.0/
+smol_str 0.2.2 -- MIT OR Apache-2.0 -- licenses/dependencies/smol_str-0.2.2/
+socket2 0.6.5 -- MIT OR Apache-2.0 -- licenses/dependencies/socket2-0.6.5/
+softbuffer 0.4.8 -- MIT OR Apache-2.0 -- licenses/dependencies/softbuffer-0.4.8/
+spirv 0.3.0+sdk-1.3.268.0 -- Apache-2.0 -- licenses/dependencies/spirv-0.3.0+sdk-1.3.268.0/
+stable_deref_trait 1.2.1 -- MIT OR Apache-2.0 -- licenses/dependencies/stable_deref_trait-1.2.1/
+static_assertions 1.1.0 -- MIT OR Apache-2.0 -- licenses/dependencies/static_assertions-1.1.0/
+strict-num 0.1.1 -- MIT -- licenses/dependencies/strict-num-0.1.1/
+subtle 2.6.1 -- BSD-3-Clause -- licenses/dependencies/subtle-2.6.1/
+svg_fmt 0.4.5 -- MIT/Apache-2.0 -- licenses/dependencies/svg_fmt-0.4.5/
+swash 0.2.10 -- Apache-2.0 OR MIT -- licenses/dependencies/swash-0.2.10/
+syn 2.0.119 -- MIT OR Apache-2.0 -- licenses/dependencies/syn-2.0.119/
+syn 3.0.5 -- MIT OR Apache-2.0 -- licenses/dependencies/syn-3.0.5/
+sync_wrapper 1.0.2 -- Apache-2.0 -- licenses/dependencies/sync_wrapper-1.0.2/
+synstructure 0.13.2 -- MIT -- licenses/dependencies/synstructure-0.13.2/
+sys-locale 0.3.2 -- MIT OR Apache-2.0 -- licenses/dependencies/sys-locale-0.3.2/
+tempfile 3.27.0 -- MIT OR Apache-2.0 -- licenses/dependencies/tempfile-3.27.0/
+termcolor 1.4.1 -- Unlicense OR MIT -- licenses/dependencies/termcolor-1.4.1/
+thiserror-impl 1.0.69 -- MIT OR Apache-2.0 -- licenses/dependencies/thiserror-impl-1.0.69/
+thiserror-impl 2.0.20 -- MIT OR Apache-2.0 -- licenses/dependencies/thiserror-impl-2.0.20/
+thiserror 1.0.69 -- MIT OR Apache-2.0 -- licenses/dependencies/thiserror-1.0.69/
+thiserror 2.0.20 -- MIT OR Apache-2.0 -- licenses/dependencies/thiserror-2.0.20/
+tiny-skia-path 0.11.4 -- BSD-3-Clause -- licenses/dependencies/tiny-skia-path-0.11.4/
+tiny-skia 0.11.4 -- BSD-3-Clause -- licenses/dependencies/tiny-skia-0.11.4/
+tinystr 0.8.4 -- Unicode-3.0 -- licenses/dependencies/tinystr-0.8.4/
+tinyvec_macros 0.1.1 -- MIT OR Apache-2.0 OR Zlib -- licenses/dependencies/tinyvec_macros-0.1.1/
+tinyvec 1.13.2 -- Zlib OR Apache-2.0 OR MIT -- licenses/dependencies/tinyvec-1.13.2/
+tokio-macros 2.7.2 -- MIT -- licenses/dependencies/tokio-macros-2.7.2/
+tokio-rustls 0.26.5 -- MIT OR Apache-2.0 -- licenses/dependencies/tokio-rustls-0.26.5/
+tokio 1.53.1 -- MIT -- licenses/dependencies/tokio-1.53.1/
+tower-http 0.6.11 -- MIT -- licenses/dependencies/tower-http-0.6.11/
+tower-layer 0.3.3 -- MIT -- licenses/dependencies/tower-layer-0.3.3/
+tower-service 0.3.3 -- MIT -- licenses/dependencies/tower-service-0.3.3/
+tower 0.5.3 -- MIT -- licenses/dependencies/tower-0.5.3/
+tracing-attributes 0.1.31 -- MIT -- licenses/dependencies/tracing-attributes-0.1.31/
+tracing-core 0.1.36 -- MIT -- licenses/dependencies/tracing-core-0.1.36/
+tracing 0.1.44 -- MIT -- licenses/dependencies/tracing-0.1.44/
+try-lock 0.2.5 -- MIT -- licenses/dependencies/try-lock-0.2.5/
+ttf-parser 0.25.1 -- MIT OR Apache-2.0 -- licenses/dependencies/ttf-parser-0.25.1/
+unicode-bidi 0.3.18 -- MIT OR Apache-2.0 -- licenses/dependencies/unicode-bidi-0.3.18/
+unicode-ident 1.0.24 -- (MIT OR Apache-2.0) AND Unicode-3.0 -- licenses/dependencies/unicode-ident-1.0.24/
+unicode-linebreak 0.1.5 -- Apache-2.0 -- licenses/dependencies/unicode-linebreak-0.1.5/
+unicode-script 0.5.8 -- MIT OR Apache-2.0 -- licenses/dependencies/unicode-script-0.5.8/
+unicode-segmentation 1.13.3 -- MIT OR Apache-2.0 -- licenses/dependencies/unicode-segmentation-1.13.3/
+unicode-width 0.2.2 -- MIT OR Apache-2.0 -- licenses/dependencies/unicode-width-0.2.2/
+untrusted 0.9.0 -- ISC -- licenses/dependencies/untrusted-0.9.0/
+url 2.5.8 -- MIT OR Apache-2.0 -- licenses/dependencies/url-2.5.8/
+utf8_iter 1.0.4 -- Apache-2.0 OR MIT -- licenses/dependencies/utf8_iter-1.0.4/
+uuid 1.26.0 -- Apache-2.0 OR MIT -- licenses/dependencies/uuid-1.26.0/
+version_check 0.9.5 -- MIT/Apache-2.0 -- licenses/dependencies/version_check-0.9.5/
+want 0.3.1 -- MIT -- licenses/dependencies/want-0.3.1/
+web-time 1.1.0 -- MIT OR Apache-2.0 -- licenses/dependencies/web-time-1.1.0/
+webpki-roots 1.0.9 -- CDLA-Permissive-2.0 -- licenses/dependencies/webpki-roots-1.0.9/
+wgpu-core-deps-windows-linux-android 27.0.0 -- MIT OR Apache-2.0 -- licenses/dependencies/wgpu-core-deps-windows-linux-android-27.0.0/
+wgpu-core 27.0.3 -- MIT OR Apache-2.0 -- licenses/dependencies/wgpu-core-27.0.3/
+wgpu-hal 27.0.4 -- MIT OR Apache-2.0 -- licenses/dependencies/wgpu-hal-27.0.4/
+wgpu-types 27.0.1 -- MIT OR Apache-2.0 -- licenses/dependencies/wgpu-types-27.0.1/
+wgpu 27.0.1 -- MIT OR Apache-2.0 -- licenses/dependencies/wgpu-27.0.1/
+winapi-util 0.1.11 -- Unlicense OR MIT -- licenses/dependencies/winapi-util-0.1.11/
+window_clipboard 0.5.1 -- MIT -- licenses/dependencies/window_clipboard-0.5.1/
+windows_x86_64_gnullvm 0.52.6 -- MIT OR Apache-2.0 -- licenses/dependencies/windows_x86_64_gnullvm-0.52.6/
+windows-core 0.58.0 -- MIT OR Apache-2.0 -- licenses/dependencies/windows-core-0.58.0/
+windows-implement 0.58.0 -- MIT OR Apache-2.0 -- licenses/dependencies/windows-implement-0.58.0/
+windows-interface 0.58.0 -- MIT OR Apache-2.0 -- licenses/dependencies/windows-interface-0.58.0/
+windows-link 0.2.1 -- MIT OR Apache-2.0 -- licenses/dependencies/windows-link-0.2.1/
+windows-result 0.2.0 -- MIT OR Apache-2.0 -- licenses/dependencies/windows-result-0.2.0/
+windows-strings 0.1.0 -- MIT OR Apache-2.0 -- licenses/dependencies/windows-strings-0.1.0/
+windows-sys 0.52.0 -- MIT OR Apache-2.0 -- licenses/dependencies/windows-sys-0.52.0/
+windows-sys 0.59.0 -- MIT OR Apache-2.0 -- licenses/dependencies/windows-sys-0.59.0/
+windows-sys 0.61.2 -- MIT OR Apache-2.0 -- licenses/dependencies/windows-sys-0.61.2/
+windows-targets 0.52.6 -- MIT OR Apache-2.0 -- licenses/dependencies/windows-targets-0.52.6/
+windows 0.58.0 -- MIT OR Apache-2.0 -- licenses/dependencies/windows-0.58.0/
+winit 0.30.13 -- Apache-2.0 -- licenses/dependencies/winit-0.30.13/
+writeable 0.6.4 -- Unicode-3.0 -- licenses/dependencies/writeable-0.6.4/
+xml-rs 0.8.29 -- MIT -- licenses/dependencies/xml-rs-0.8.29/
+yazi 0.2.1 -- Apache-2.0 OR MIT -- licenses/dependencies/yazi-0.2.1/
+yoke-derive 0.8.2 -- Unicode-3.0 -- licenses/dependencies/yoke-derive-0.8.2/
+yoke 0.8.3 -- Unicode-3.0 -- licenses/dependencies/yoke-0.8.3/
+zeno 0.3.3 -- Apache-2.0 OR MIT -- licenses/dependencies/zeno-0.3.3/
+zerocopy-derive 0.8.56 -- BSD-2-Clause OR Apache-2.0 OR MIT -- licenses/dependencies/zerocopy-derive-0.8.56/
+zerocopy 0.8.56 -- BSD-2-Clause OR Apache-2.0 OR MIT -- licenses/dependencies/zerocopy-0.8.56/
+zerofrom-derive 0.1.7 -- Unicode-3.0 -- licenses/dependencies/zerofrom-derive-0.1.7/
+zerofrom 0.1.8 -- Unicode-3.0 -- licenses/dependencies/zerofrom-0.1.8/
+zeroize 1.9.0 -- Apache-2.0 OR MIT -- licenses/dependencies/zeroize-1.9.0/
+zerotrie 0.2.5 -- Unicode-3.0 -- licenses/dependencies/zerotrie-0.2.5/
+zerovec-derive 0.11.6 -- Unicode-3.0 -- licenses/dependencies/zerovec-derive-0.11.6/
+zerovec 0.11.8 -- Unicode-3.0 -- licenses/dependencies/zerovec-0.11.8/
+zmij 1.0.23 -- MIT -- licenses/dependencies/zmij-1.0.23/

harness/experiments/navigation-prerelease-20260911/package-metadata/documentation-check.json

@@ -0,0 +1,3 @@
+{
+  "checked_local_document_links": 17
+}

harness/experiments/navigation-prerelease-20260911/package-metadata/package.json

@@ -0,0 +1,650 @@
+{
+  "version": "0.2.0-preview.navigation.20260911",
+  "target": "x86_64-pc-windows-gnullvm",
+  "acceptance": "Packaging integrity only; native clean-environment verification required.",
+  "build": "Prebuilt inputs supplied by caller; this script does not establish build profile or source revision.",
+  "build_evidence": {
+    "assertion": "Caller-supplied build evidence; target and binary hashes checked, source/compiler/profile statements not inferred or independently proven by packaging.",
+    "evidence": {
+      "source_identity": "GUI exact-byte reconstruction 802855f7e6f2f00a107a12196b458b267f586b8d from 33c6d83e9ba9a5b1310b1b627d7c40affcbcf15c; 500 frozen GUI gate inputs plus separately verified shared build resources. This is not the original build commit. EFEE server retains its separate September 7 source snapshot; its old language.rs differs from current GUI core. No current-source server claim.",
+      "profile": "Prebuilt Windows development GUI, actual full desktop result {'passed': 755, 'failed': 0, 'ignored': 1, 'measured': 0, 'filtered': 0}. Retained EFEE server is the historical development artifact, not rebuilt. Native/package acceptance remains pending.",
+      "compiler": "Original GUI Cargo artifact/profile and server build records retained separately; package collector records current compiler/sysroot facts. No reproducible build or new server build claimed.",
+      "target": "x86_64-pc-windows-gnullvm",
+      "binary_sha256": {
+        "arcadia-studio.exe": "b183ef31f16b3986538b3f2aba8435eab45978635c47f99ca01be6e72b168848",
+        "arcadia-server.exe": "efeeb89c0d2e0f93df4472cb3e9f48b2b722a37ae1043c90a5a56f2e845fe665"
+      },
+      "provenance_reference_base": "evidence/ references are external preparation records, not files inside the ZIP.",
+      "per_binary_provenance": {
+        "arcadia-studio.exe": {
+          "build": "evidence/gui-gui-build-result.json",
+          "inputs": "evidence/gui-inputs1.json",
+          "full_gate": "evidence/gui-desktop-tests-result.json",
+          "complete": "evidence/gui-complete.json",
+          "captured_head": "eeeaa1262748800c4c9aaa1eca79a7de96757358",
+          "scope": "Built from captured eeeaa126 plus exact repair input delta; those bytes are committed at base_commit, then reconstructed without changing code."
+        },
+        "arcadia-server.exe": {
+          "build": "evidence/server-original-gates.json",
+          "hashes": "evidence/server-original-binary-hashes.json",
+          "source_tar": "evidence/server-source-snapshot.tar.gz",
+          "source_inventory": "evidence/server-prior-input-comparisons.json",
+          "notices": "evidence/prior-dependency-notices.json",
+          "scope": "Unchanged historical EFEE; separate source, not rebuilt from navigation source."
+        }
+      }
+    }
+  },
+  "imports": {
+    "arcadia-studio.exe": [
+      "advapi32.dll",
+      "api-ms-win-core-synch-l1-2-0.dll",
+      "api-ms-win-crt-environment-l1-1-0.dll",
+      "api-ms-win-crt-heap-l1-1-0.dll",
+      "api-ms-win-crt-locale-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-runtime-l1-1-0.dll",
+      "api-ms-win-crt-stdio-l1-1-0.dll",
+      "api-ms-win-crt-string-l1-1-0.dll",
+      "bcrypt.dll",
+      "bcryptprimitives.dll",
+      "dwmapi.dll",
+      "gdi32.dll",
+      "imm32.dll",
+      "kernel32.dll",
+      "libunwind.dll",
+      "ntdll.dll",
+      "ole32.dll",
+      "oleaut32.dll",
+      "opengl32.dll",
+      "shell32.dll",
+      "user32.dll",
+      "uxtheme.dll",
+      "ws2_32.dll"
+    ],
+    "arcadia-server.exe": [
+      "api-ms-win-core-synch-l1-2-0.dll",
+      "api-ms-win-crt-environment-l1-1-0.dll",
+      "api-ms-win-crt-heap-l1-1-0.dll",
+      "api-ms-win-crt-locale-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-runtime-l1-1-0.dll",
+      "api-ms-win-crt-stdio-l1-1-0.dll",
+      "api-ms-win-crt-string-l1-1-0.dll",
+      "bcryptprimitives.dll",
+      "kernel32.dll",
+      "libunwind.dll",
+      "ntdll.dll",
+      "ws2_32.dll"
+    ],
+    "libunwind.dll": [
+      "api-ms-win-crt-convert-l1-1-0.dll",
+      "api-ms-win-crt-environment-l1-1-0.dll",
+      "api-ms-win-crt-filesystem-l1-1-0.dll",
+      "api-ms-win-crt-heap-l1-1-0.dll",
+      "api-ms-win-crt-locale-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"
+    ]
+  },
+  "input_sha256": {
+    "arcadia-studio.exe": "b183ef31f16b3986538b3f2aba8435eab45978635c47f99ca01be6e72b168848",
+    "arcadia-server.exe": "efeeb89c0d2e0f93df4472cb3e9f48b2b722a37ae1043c90a5a56f2e845fe665",
+    "libunwind.dll": "f45604a12e8bcd839fd86f667c1be1cc7c4f9da2b3c69ff381ac708f0e1ae7d4",
+    "licenses/llvm-mingw-LICENSE.TXT": "8d85c1057d742e597985c7d4e6320b015a9139385cff4cbae06ffc0ebe89afee",
+    "LICENSE": "51009f2cb07e5d19645858b2fbc037a672a25f8cbf7999522942b86807ecf365",
+    "README.md": "597cfb8da873e019d2658420f18ec059f0185fa9106ff9eafe934dfdd6ed266b",
+    "deployment/Dockerfile": "72c04aef4ec879955ed3bdf315987553d018ef46e4b8f350f0f6fe380c453eb7",
+    "deployment/Dockerfile.dockerignore": "6bb7d7496110b11a531cb8cd923864c6610850a8f1c4de8a797f54c7156f29e1",
+    "deployment/arcadia-server.service": "1e6c6bb4065e25f8fe1d558a4ed0bbd4844782a4377c2482488db1e6f9cab01d",
+    "docs/api.html": "6f18cfc2a35eba631dbc61d04cd2721e0e361efff1699bf56d2c450a30a17a0d",
+    "docs/api.rst": "7eb258088824efa5ac94311b07b73eb46edcac3c300a2aac78d3802111e338c4",
+    "docs/language.html": "739a5bb100c7cb0ed70e18afd1e363029757f3cfd6580bc9c5cf77faccb46940",
+    "docs/language.rst": "894a1a77f97d1aa94c11762fe4e84b4d95e181a77c630324c16c307637ed27e1",
+    "docs/linux-packaging.md": "41a1bb1095801df37a1411341c5791d55ea8c365739314d599a60269ac4bc7a0",
+    "docs/openapi.json": "c6ae512f791a939eaf6ec5e5e78e9468bdee0e028092d00098bd90ad9498d967",
+    "docs/research-v2-service.md": "4828df5bc679e7c71f49b4b85c9e7dacbec52f46d416fed48af70e08886d4e4e",
+    "docs/server.md": "4eb24937d424ba8b384e1734e02a6f8e963ae11d2715889c92b14b39ff2e4a48",
+    "docs/windows-packaging.md": "2c852ff7041713ffbff3c951ac98df647c51fb70b0feba9000f7bfd5bc2703a8",
+    "examples/coastal-rescue.arcadia": "7e183ef9fd8154d3074303f1956cd0d9871c19e3ffc630d333b0bffbd6e30e17",
+    "examples/coastal-rescue.json": "242f0b031229a87af5c4ebe5d651defe59c191a6b7a69dc0a77f7e203411f195",
+    "examples/legacy-v1-coastal-rescue.arcadia": "4dbbbdf8bc7e6cb8e0a81dd678069dae585a9e5187c59bc3665e1fdab3f1a86a",
+    "examples/legacy-v1-coastal-rescue.oa.json": "fd0e9dedfb7adb922dc0575cc2b820d40344d639f1d8052bd70363aa59de9c24",
+    "examples/release1/README.md": "113cfb1cf38a98b51bff60442d86a35d636a3d80ef206bece7d53d0aae67f2d5",
+    "examples/release1/evidence/repair-check.md": "f4db17bdca4ecbb1bf0caef01b2da5f1f7f798ab3152b648ce6dd8696a6a68e5",
+    "examples/release1/expected-diagnostics.json": "3700393d76b940cfc076bf52861bd7b1f43370f8eabce3594531bd0bf1fc851e",
+    "examples/release1/model.json": "ef0ef4006c3e09d5db6e1b621256b3f7d6642f3a7b09cc34607cfbcca830c727",
+    "examples/release1/model.rs": "15f30f6bde655808fe754665c26d560e36f2a9bad340f346b09137d0d05045f5",
+    "examples/release1/oa/activities/activity_oa_restore_work.arcadia": "83e73d0a013d5c3e1a4af0d9139ab0cfa362d25a846671fc2dac59181061a9d4",
+    "examples/release1/oa/behavior/process_oa_assessment_procedure.arcadia": "172c32c044ef4b5bc58a1f4635cc81f48dabb4014479b47dce7b25fedf2dbd0d",
+    "examples/release1/oa/behavior/process_oa_field_procedure.arcadia": "d2552dc5383e2e91cb302a790364e197f663c2edc013a2ab1978789825c9c324",
+    "examples/release1/oa/behavior/process_oa_response.arcadia": "cf86f46fa5c5d70592ef43f1bc1cb4d968efd8add384ba88036bef6b88aa4abc",
+    "examples/release1/oa/behavior/scenario_oa_conversation.arcadia": "b25be524e98a35ebac5e4481b7609c027b32baf9605e8097f807560f94a77ca6",
+    "examples/release1/oa/behavior/scenario_oa_full_scenario.arcadia": "00a1edf2c9707a0eb62ac070c2d02467874f2c9c1f273cc6ddb53d6d65999a1c",
+    "examples/release1/oa/behavior/state_machine_oa_monitor.arcadia": "447c9ad1359f4a31ecf975ad07c0b08d8e7e03191fb0858e2fc56f377b223cd5",
+    "examples/release1/oa/capabilities.arcadia": "fc8012e5554350b12e1cb80080f8feab80d933c9b33c0f2a7bb500cb7d609936",
+    "examples/release1/oa/model.arcadia": "f7cf914766ea73ec53b85e32d117ea9a9dba52d3e038246863541ae7069b1a15",
+    "examples/release1/oa/participants.arcadia": "951764c14179f27c10e315acf2ea37d1fff54c77b8441e23addd239e8c715ce3",
+    "examples/release1/oa/types.arcadia": "9d0396fb82dd5733edd8d1cf52f968ca84906927c704f9cf0944a7fae215cf49",
+    "examples/release1/project.arcadia": "b2674e6bf77cfe0f6f0ba79c81d2e96d92f39c02ca2c6266d80e91723bfb9fda",
+    "examples/release1/sa/behavior/process_sa_assessment_procedure.arcadia": "73928ced61c06cbc08728d7956676a50fd4c05aa5b7f1ff4f29ce27a0b0f2088",
+    "examples/release1/sa/behavior/process_sa_field_procedure.arcadia": "886d462af83110cbfa55dd232a667ea1446761234471357cbb878794e98e8768",
+    "examples/release1/sa/behavior/process_sa_response.arcadia": "041785fc22842423822431bd5e6e8d16094ebd0716965e7c765fb8c1d7549e8a",
+    "examples/release1/sa/behavior/scenario_sa_conversation.arcadia": "97276f5757ee9aa12a0dbd9d3ccd58174b3091162bb8bcce357cec20a45f5d85",
+    "examples/release1/sa/behavior/scenario_sa_full_scenario.arcadia": "e12fc406b99d60a2f7768aaa0b25ba560e8605f0b8e37f3a7cdd3b8443562b74",
+    "examples/release1/sa/behavior/state_machine_sa_monitor.arcadia": "05ce29af99424c491c47fe2450dc6f5f8ce995511c01ec7e17bb5855be3c9736",
+    "examples/release1/sa/capabilities.arcadia": "b6912fb3ece439912345fa71724acd462e716a1e5a88203a1058a5c3b2c20a4f",
+    "examples/release1/sa/functions/function_sa_audit_thresholds.arcadia": "e5a04325d52183956dca814dd90f4e56c96c6b7db0f4f202f203ecb49c3e0f4f",
+    "examples/release1/sa/functions/function_sa_restore_work.arcadia": "fddeb67308051325041fee641fe758ddf43345b7c47b66d433616ad07fdccdd6",
+    "examples/release1/sa/model.arcadia": "d431509251acb859fbb98733b6d18add952495e10a78703fbe8f31e40bc083c4",
+    "examples/release1/sa/participants.arcadia": "780d2eb08b217b67b55febb3d34846f727b8ee9018df6c5741748647e36b2ff8",
+    "examples/release1/sa/types.arcadia": "101fc0fbd99f1101514aa7b6da4f8e535aae0bb94c9e2b9e7e6c151135b28660",
+    "examples/release1/traceability.arcadia": "48a96f543456c9b5a5798fc795594e4119147fe45f11a6f109f141b7f514560f",
+    "examples/release1/transition-before.json": "2253e6434f741687e22327c37d520ed15c043bc36025498650bc2366bb6a874d",
+    "examples/release1/transition-request.json": "43b9a22e5f95ad3bc0ebd2478ead0e14406854abc989ae94ded9367b013d812a",
+    "examples/release1/views/diagram_oa_allocation_view.arcadia": "dfc0eb61e0e2aa5bda45524571fbfa3494f44ce19696f3e15e07438074a07bc7",
+    "examples/release1/views/diagram_sa_allocation_view.arcadia": "b78b43a26a82efb8fbd5374b09c329fa341f57b29f635d397b9ef8aede71d389",
+    "examples/release1/views/diagram_sa_capability_view.arcadia": "75e8dc9fb30f25d6f8fd3c6b595593ab4f98958a25798f961e336e0fac557649",
+    "examples/release1/views/diagram_sa_service_view.arcadia": "b08c84f3ea633e7c78dfdad3272f75415f6256cf3614b6d99bfd4f0269076c9b",
+    "examples/release1/views/diagram_sa_state_view.arcadia": "5f42f4c605e57b817d8400ed21f2b14bfc4e1592aebe941ff113767504c2b869",
+    "examples/routing-workshop.arcadia": "dc6b75da72884d399132ed9e300fa5a26b73d802bb526c9af986ae9eeb0a646a",
+    "examples/routing-workshop.json": "8592714f75b271133f21ce017d87896b6cf91ea0e4837f1c2ed453e21be26b14",
+    "examples/source-project/oa.arcadia": "5f60642f211b2d352a951092faeeb7503d4fb7f6f7fca99e810347231101d31c",
+    "examples/source-project/project.arcadia": "787f6b67b179ffd221f7e5faf1a4edd74cfd116aa1e3b5e9ed9f22fbff612d8d",
+    "examples/source-project/sa/assurance.arcadia": "ab76044836e4dcd42a82d316846ec87da2108939aa2037640c5bca1d2ecdee0f",
+    "examples/source-project/sa/participants.arcadia": "1abad579812e77877b45a3d8e3c3e9da734be2d04a0254cc730a5257ebd2dc88",
+    "examples/source-project/sa/reporting.arcadia": "f0b7443f728912ca163de39b6055876b533a77feaa3219b2d40a2dd65712e058",
+    "examples/source-project/views.arcadia": "e29ad3f406a6a50d2f0ae2ca2a53ee3b0c18222cd4098704a46d4f48b64ea17f",
+    "examples/text-first/README.md": "4ec8250d5ed556f1d496e8c85137e973e802ecb11df1a36488411e8cdc5a9f9e",
+    "examples/text-first/project.arcadia": "f441535c623e0cf20e1875eb2cd33b587ed00e078c37af39cb36d89bb5edc19a",
+    "licenses/dependencies/oa-core-0.2.0/workspace-LICENSE": "51009f2cb07e5d19645858b2fbc037a672a25f8cbf7999522942b86807ecf365",
+    "licenses/dependencies/oa-desktop-0.2.0/workspace-LICENSE": "51009f2cb07e5d19645858b2fbc037a672a25f8cbf7999522942b86807ecf365",
+    "licenses/dependencies/oa-server-0.2.0/workspace-LICENSE": "51009f2cb07e5d19645858b2fbc037a672a25f8cbf7999522942b86807ecf365",
+    "licenses/dependencies/arrayref-0.3.9/LICENSE": "1bc7e6f475b3ec99b7e2643411950ae2368c250dd4c5c325f80f9811362a94a1",
+    "licenses/dependencies/arrayvec-0.7.8/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/arrayvec-0.7.8/LICENSE-MIT": "4da95ec4ecb65b738d470b7d762894ad9c97da93e6cbfb18b570fc2c96f4b871",
+    "licenses/dependencies/ash-0.38.0+1.3.281/LICENSE-APACHE": "0e8a410375e1ee5c75c6198b08b534fec6e5edef766cf971bab4a404542636ab",
+    "licenses/dependencies/ash-0.38.0+1.3.281/LICENSE-MIT": "c733ccf8ab25df175a63d9d844677b98e3a5ab8f8de1c1616087e6868a7f948e",
+    "licenses/dependencies/atomic-waker-1.1.2/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/atomic-waker-1.1.2/LICENSE-MIT": "23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3",
+    "licenses/dependencies/atomic-waker-1.1.2/LICENSE-THIRD-PARTY": "6226d0632e2e1a80c23597e964da9812ae193c535fe058154afb034e94167aa5",
+    "licenses/dependencies/autocfg-1.5.1/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/autocfg-1.5.1/LICENSE-MIT": "27995d58ad5c1145c1a8cd86244ce844886958a35eb2b78c6b772748669999ac",
+    "licenses/dependencies/axum-core-0.5.6/LICENSE": "008c87afcd2e626eaf564093250bed06dd7efb5732113264bba3dda8f1c556a1",
+    "licenses/dependencies/axum-0.8.9/LICENSE": "6a13bc24a100a6812f053879ec51b126b103af7cda6dbf48c4188722da44da9f",
+    "licenses/dependencies/base64-0.22.1/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/base64-0.22.1/LICENSE-MIT": "0dd882e53de11566d50f8e8e2d5a651bcf3fabee4987d70f306233cf39094ba7",
+    "licenses/dependencies/bit-set-0.8.0/LICENSE-APACHE": "8173d5c29b4f956d532781d2b86e4e30f83e6b7878dce18c919451d6ba707c90",
+    "licenses/dependencies/bit-set-0.8.0/LICENSE-MIT": "f51ac2c59a222f7476ce507ca879960e2b64ea64bb2786eefdbeb7b0b538d1b7",
+    "licenses/dependencies/bit-vec-0.8.0/LICENSE-APACHE": "8173d5c29b4f956d532781d2b86e4e30f83e6b7878dce18c919451d6ba707c90",
+    "licenses/dependencies/bit-vec-0.8.0/LICENSE-MIT": "f51ac2c59a222f7476ce507ca879960e2b64ea64bb2786eefdbeb7b0b538d1b7",
+    "licenses/dependencies/bitflags-2.13.1/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/bitflags-2.13.1/LICENSE-MIT": "6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb",
+    "licenses/dependencies/bytemuck_derive-1.12.0/LICENSE-APACHE": "e3ba223bb1423f0aad8c3dfce0fe3148db48926d41e6fbc3afbbf5ff9e1c89cb",
+    "licenses/dependencies/bytemuck_derive-1.12.0/LICENSE-MIT": "9df9ba60a11af705f2e451b53762686e615d86f76b169cf075c3237730dbd7e2",
+    "licenses/dependencies/bytemuck_derive-1.12.0/LICENSE-ZLIB": "84b34dd7608f7fb9b17bd588a6bf392bf7de504e2716f024a77d89f1b145a151",
+    "licenses/dependencies/bytemuck-1.25.2/LICENSE-APACHE": "e3ba223bb1423f0aad8c3dfce0fe3148db48926d41e6fbc3afbbf5ff9e1c89cb",
+    "licenses/dependencies/bytemuck-1.25.2/LICENSE-MIT": "9df9ba60a11af705f2e451b53762686e615d86f76b169cf075c3237730dbd7e2",
+    "licenses/dependencies/bytemuck-1.25.2/LICENSE-ZLIB": "84b34dd7608f7fb9b17bd588a6bf392bf7de504e2716f024a77d89f1b145a151",
+    "licenses/dependencies/bytes-1.12.1/LICENSE": "45f522cacecb1023856e46df79ca625dfc550c94910078bd8aec6e02880b3d42",
+    "licenses/dependencies/cc-1.4.5/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/cc-1.4.5/LICENSE-MIT": "378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397",
+    "licenses/dependencies/cfg_aliases-0.2.2/LICENSE": "31b94860253d8ec7b4529f51901044d3b459d6292d996504a36b1bae3a36a812",
+    "licenses/dependencies/cfg-if-1.0.4/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/cfg-if-1.0.4/LICENSE-MIT": "378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397",
+    "licenses/dependencies/chacha20-0.10.2/LICENSE-APACHE": "a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5",
+    "licenses/dependencies/chacha20-0.10.2/LICENSE-MIT": "b8c6939380a400f53e11923d50fcc4dd2fa1ba8339fd9d04cda38a0251b6c9b0",
+    "licenses/dependencies/clipboard-win-5.4.1/supplement/DoumanAsh-clipboard-win-3b27cf2bfd1a-LICENSE": "c9bff75738922193e67fa726fa225535870d2aa1059f91452c411736284ad566",
+    "licenses/dependencies/codespan-reporting-0.12.0/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4",
+    "licenses/dependencies/core_maths-0.1.1/LICENSE": "9ebf8c4cc0b735ca13a766451f7b8097db3185975ceb2ba94b5abf439156a91f",
+    "licenses/dependencies/cosmic-text-0.15.0/fonts/FiraMono-LICENSE": "587dd9548304fd421cd254f7550bd101c1250ffc95417f2f7f92d55b44ecbe53",
+    "licenses/dependencies/cosmic-text-0.15.0/fonts/Inter-LICENSE": "3c8d13d97ea5eb62868833a377034c6be6a9833e768d32abec2a767a8101e4bc",
+    "licenses/dependencies/cosmic-text-0.15.0/fonts/NotoSans-LICENSE": "5ec4347054089def6904da61d04f0360968f9ef36634b1fe007a5b6ec2f7aa96",
+    "licenses/dependencies/cosmic-text-0.15.0/LICENSE-APACHE": "000b4962e6b27176a0ff89cce4be555b16472cafb5671eb2804a8fdac6854793",
+    "licenses/dependencies/cosmic-text-0.15.0/LICENSE-MIT": "95557bafe728379e206f3b6d4aceeaa054d271c71d722411a6222e2dec01138c",
+    "licenses/dependencies/cpufeatures-0.3.1/LICENSE-APACHE": "a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5",
+    "licenses/dependencies/cpufeatures-0.3.1/LICENSE-MIT": "73b9dc2e79c7308998dd30296e073aefaefb944a68fb89aa412c23c0edcabcaa",
+    "licenses/dependencies/cryoglyph-0.1.0/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/cryoglyph-0.1.0/LICENSE-MIT": "23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3",
+    "licenses/dependencies/cryoglyph-0.1.0/LICENSE-ZLIB": "b3ec01ad0869c5c50937bc68780cd0bb44e235ad858dfa54a7a381dced9b115a",
+    "licenses/dependencies/cursor-icon-1.2.0/LICENSE-APACHE": "b59affd015e517ed998dd735757f9a3693643cd389609947ed54074234a10784",
+    "licenses/dependencies/cursor-icon-1.2.0/LICENSE-MIT": "c138726a726ac37bae09d0f8a48e74e8e3aa8a8952fcd10fae0fb224cc1c05f1",
+    "licenses/dependencies/cursor-icon-1.2.0/LICENSE-ZLIB": "01e533bd94e8f1c32b2c2531e2c398de7d35d7804add3d574b4e1fe581d53537",
+    "licenses/dependencies/displaydoc-0.2.7/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/displaydoc-0.2.7/LICENSE-MIT": "23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3",
+    "licenses/dependencies/document-features-0.2.12/LICENSE-APACHE": "074e6e32c86a4c0ef8b3ed25b721ca23aca83df277cd88106ef7177c354615ff",
+    "licenses/dependencies/document-features-0.2.12/LICENSE-MIT": "aa893340d14b9844625be6a50ac644169a01b52f0211cbf81b09e1874c8cd81d",
+    "licenses/dependencies/dpi-0.1.2/LICENSE": "6dc0e068dcf3a5bc8e054205b85b7720e1d49265bbc64bf515d2cf79197df69a",
+    "licenses/dependencies/dpi-0.1.2/LICENSE-LIBM-MIT": "9eff396a99bafd208e7126602420d6864f6066c08b84485a5b032320a9c01997",
+    "licenses/dependencies/equivalent-1.0.2/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/equivalent-1.0.2/LICENSE-MIT": "7365cc8878a1d7ce155a58c4ca09c3d7a6be413efa5334a80ea842912b669349",
+    "licenses/dependencies/error-code-3.4.0/LICENSE": "c9bff75738922193e67fa726fa225535870d2aa1059f91452c411736284ad566",
+    "licenses/dependencies/etagere-0.2.15/LICENSE-APACHE": "2d56a37f3d1e461f6b1539ab94e0e6bcc55443e376098aee85ac3b2890860290",
+    "licenses/dependencies/etagere-0.2.15/LICENSE-MIT": "9cfc9c9a4608501b5da3746948d2be2dd709ad51f6bcb0c1c685760ee3dde31f",
+    "licenses/dependencies/euclid-0.22.14/COPYRIGHT": "ec82b96487e9e778ee610c7ab245162464782cfa1f555c2299333f8dbe5c036a",
+    "licenses/dependencies/euclid-0.22.14/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/euclid-0.22.14/LICENSE-MIT": "62065228e42caebca7e7d7db1204cbb867033de5982ca4009928915e4095f3a3",
+    "licenses/dependencies/fastrand-2.5.0/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/fastrand-2.5.0/LICENSE-MIT": "23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3",
+    "licenses/dependencies/find-msvc-tools-0.1.12/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/find-msvc-tools-0.1.12/LICENSE-MIT": "378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397",
+    "licenses/dependencies/float_next_after-1.0.0/LICENSE": "0604d5817110dacc5c7d9b7de6b58b962794603d4823c357157bd5dec4198bc5",
+    "licenses/dependencies/foldhash-0.1.5/LICENSE": "b1181a40b2a7b25cf66fd01481713bc1005df082c53ef73e851e55071b102744",
+    "licenses/dependencies/foldhash-0.2.0/LICENSE": "b1181a40b2a7b25cf66fd01481713bc1005df082c53ef73e851e55071b102744",
+    "licenses/dependencies/font-types-0.10.1/LICENSE-APACHE": "a14f7d685a79c0f4fb64aee305527a6d5fa55f2401f4e6d688d7b1301868e6c0",
+    "licenses/dependencies/font-types-0.10.1/LICENSE-MIT": "8a62fa27ffdccc3df19dce90f8bb3d572e27aecffc1a383d0c2601834dcec434",
+    "licenses/dependencies/font-types-0.12.4/LICENSE-APACHE": "eba684204073ed715c4abb48129acdfd2bff8ae48339e6a7da3b341d3027b7f0",
+    "licenses/dependencies/font-types-0.12.4/LICENSE-MIT": "7b4c9a3946dfcea7967582760e963e27799e225dcf20565c8ef55324bb017427",
+    "licenses/dependencies/fontdb-0.23.0/LICENSE": "59a1fdac3bd550043599bd159fd70f09a1108c2b09e3751d39b11e1ff8e51f00",
+    "licenses/dependencies/fontdb-0.23.0/tests/fonts/LICENSE.txt": "b84fdd2c3da5db56385cdbb639795e90aa3e035c53bc3591135f18df3331451f",
+    "licenses/dependencies/form_urlencoded-1.2.2/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/form_urlencoded-1.2.2/LICENSE-MIT": "20c7855c364d57ea4c97889a5e8d98470a9952dade37bd9248b9a54431670e5e",
+    "licenses/dependencies/futures-channel-0.3.34/LICENSE-APACHE": "275c491d6d1160553c32fd6127061d7f9606c3ea25abfad6ca3f6ed088785427",
+    "licenses/dependencies/futures-channel-0.3.34/LICENSE-MIT": "6652c868f35dfe5e8ef636810a4e576b9d663f3a17fb0f5613ad73583e1b88fd",
+    "licenses/dependencies/futures-core-0.3.34/LICENSE-APACHE": "275c491d6d1160553c32fd6127061d7f9606c3ea25abfad6ca3f6ed088785427",
+    "licenses/dependencies/futures-core-0.3.34/LICENSE-MIT": "6652c868f35dfe5e8ef636810a4e576b9d663f3a17fb0f5613ad73583e1b88fd",
+    "licenses/dependencies/futures-executor-0.3.34/LICENSE-APACHE": "275c491d6d1160553c32fd6127061d7f9606c3ea25abfad6ca3f6ed088785427",
+    "licenses/dependencies/futures-executor-0.3.34/LICENSE-MIT": "6652c868f35dfe5e8ef636810a4e576b9d663f3a17fb0f5613ad73583e1b88fd",
+    "licenses/dependencies/futures-io-0.3.34/LICENSE-APACHE": "275c491d6d1160553c32fd6127061d7f9606c3ea25abfad6ca3f6ed088785427",
+    "licenses/dependencies/futures-io-0.3.34/LICENSE-MIT": "6652c868f35dfe5e8ef636810a4e576b9d663f3a17fb0f5613ad73583e1b88fd",
+    "licenses/dependencies/futures-macro-0.3.34/LICENSE-APACHE": "275c491d6d1160553c32fd6127061d7f9606c3ea25abfad6ca3f6ed088785427",
+    "licenses/dependencies/futures-macro-0.3.34/LICENSE-MIT": "6652c868f35dfe5e8ef636810a4e576b9d663f3a17fb0f5613ad73583e1b88fd",
+    "licenses/dependencies/futures-sink-0.3.34/LICENSE-APACHE": "275c491d6d1160553c32fd6127061d7f9606c3ea25abfad6ca3f6ed088785427",
+    "licenses/dependencies/futures-sink-0.3.34/LICENSE-MIT": "6652c868f35dfe5e8ef636810a4e576b9d663f3a17fb0f5613ad73583e1b88fd",
+    "licenses/dependencies/futures-task-0.3.34/LICENSE-APACHE": "275c491d6d1160553c32fd6127061d7f9606c3ea25abfad6ca3f6ed088785427",
+    "licenses/dependencies/futures-task-0.3.34/LICENSE-MIT": "6652c868f35dfe5e8ef636810a4e576b9d663f3a17fb0f5613ad73583e1b88fd",
+    "licenses/dependencies/futures-util-0.3.34/LICENSE-APACHE": "275c491d6d1160553c32fd6127061d7f9606c3ea25abfad6ca3f6ed088785427",
+    "licenses/dependencies/futures-util-0.3.34/LICENSE-MIT": "6652c868f35dfe5e8ef636810a4e576b9d663f3a17fb0f5613ad73583e1b88fd",
+    "licenses/dependencies/futures-0.3.34/LICENSE-APACHE": "275c491d6d1160553c32fd6127061d7f9606c3ea25abfad6ca3f6ed088785427",
+    "licenses/dependencies/futures-0.3.34/LICENSE-MIT": "6652c868f35dfe5e8ef636810a4e576b9d663f3a17fb0f5613ad73583e1b88fd",
+    "licenses/dependencies/getrandom-0.2.17/LICENSE-APACHE": "aaff376532ea30a0cd5330b9502ad4a4c8bf769c539c87ffe78819d188a18ebf",
+    "licenses/dependencies/getrandom-0.2.17/LICENSE-MIT": "42fa16951ce7f24b5a467a40e5b449a1d41e662f97ca779864f053f39e097737",
+    "licenses/dependencies/getrandom-0.4.3/LICENSE-APACHE": "aaff376532ea30a0cd5330b9502ad4a4c8bf769c539c87ffe78819d188a18ebf",
+    "licenses/dependencies/getrandom-0.4.3/LICENSE-MIT": "523a42c25d245dde9c015f882cec7f4555aad883382a6cf19b4b7d9b2cd5419b",
+    "licenses/dependencies/gl_generator-0.14.0/supplement/brendanzab-gl-rs-ea503e8d5fb6-LICENSE": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30",
+    "licenses/dependencies/glam-0.25.0/LICENSE-APACHE": "be33ddb87a30fd321ab100e2d922cba512e50ec7a63d8e62e5bfc0798dd4b585",
+    "licenses/dependencies/glam-0.25.0/LICENSE-MIT": "23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3",
+    "licenses/dependencies/glow-0.16.0/LICENSE-APACHE": "b8601fc79bdf8d8088f0938bea861ffc63ed0eebbedf25f44ab2cf2e85bd7edc",
+    "licenses/dependencies/glow-0.16.0/LICENSE-MIT": "cdbd06e25b8c9c5d6019949d2de8123f56d29cee4166396423d2ba8c81700845",
+    "licenses/dependencies/glow-0.16.0/LICENSE-ZLIB": "636f644f1e149eb62961657c0e34953681eff64435653912e7bd19992666faa5",
+    "licenses/dependencies/glutin_wgl_sys-0.6.1/LICENSE": "a4445427440043e8ce6fadf7a43fb906cb0d7f6c573a560a9f142cf9f9bf8ff4",
+    "licenses/dependencies/gpu-alloc-types-0.3.1/supplement/zakarumych-gpu-alloc-7ddd1fe576fc-COPYING": "12121dfa588677007848ab922a45a1e3248868f6ff063598fceb3141d7897314",
+    "licenses/dependencies/gpu-alloc-0.6.2/supplement/zakarumych-gpu-alloc-61020bdcb4eb-COPYING": "12121dfa588677007848ab922a45a1e3248868f6ff063598fceb3141d7897314",
+    "licenses/dependencies/gpu-allocator-0.27.0/LICENSE-APACHE": "0178e21322b0e88aa3aeb3146f6a9611bc1f8df6d98bdfb34be28b9dd56a8107",
+    "licenses/dependencies/gpu-allocator-0.27.0/LICENSE-MIT": "ad41be6cc6538b29b9346648f41432b5e460bad6be073b5eeaa41320ea2921dc",
+    "licenses/dependencies/gpu-descriptor-types-0.2.0/supplement/zakarumych-gpu-descriptor-9f2fb9546591-COPYING": "f72143f7e9d9fb8bd336b139fa22f825a299591c29f2f7338c5566347b137613",
+    "licenses/dependencies/gpu-descriptor-0.3.2/supplement/zakarumych-gpu-descriptor-bb28b4e55b74-COPYING": "f72143f7e9d9fb8bd336b139fa22f825a299591c29f2f7338c5566347b137613",
+    "licenses/dependencies/guillotiere-0.6.2/LICENSE": "7e98bed7f100747aaae7d82ab94fbe6b76fd6b84b09a3aaa413bff8196d0fbb1",
+    "licenses/dependencies/half-2.7.1/LICENSE-APACHE": "a6cba85bc92e0cff7a450b1d873c0eaa2e9fc96bf472df0247a26bec77bf3ff9",
+    "licenses/dependencies/half-2.7.1/LICENSE-MIT": "508a77d2e7b51d98adeed32648ad124b7b30241a8e70b2e72c99f92d8e5874d1",
+    "licenses/dependencies/harfrust-0.3.2/LICENSE": "7d43d2ef1ce976c7bfb423c696ad9938ccfc31e9ec5be752265e43fe9d29f697",
+    "licenses/dependencies/harfrust-0.3.2/scripts/ms-use/COPYING": "9906940f61b1f0b533fa7d99baf55178b2808fbe113ea51dfbfad8572ccd5f2b",
+    "licenses/dependencies/hashbrown-0.15.5/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/hashbrown-0.15.5/LICENSE-MIT": "ff8f68cb076caf8cefe7a6430d4ac086ce6af2ca8ce2c4e5a2004d4552ef52a2",
+    "licenses/dependencies/hashbrown-0.16.1/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/hashbrown-0.16.1/LICENSE-MIT": "ff8f68cb076caf8cefe7a6430d4ac086ce6af2ca8ce2c4e5a2004d4552ef52a2",
+    "licenses/dependencies/hashbrown-0.17.1/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/hashbrown-0.17.1/LICENSE-MIT": "ff8f68cb076caf8cefe7a6430d4ac086ce6af2ca8ce2c4e5a2004d4552ef52a2",
+    "licenses/dependencies/hexf-parse-0.2.1/supplement/CC0-1.0.txt": "a2010f343487d3f7618affe54f789f5487602331c0a8d03f49e9a7c547cf0499",
+    "licenses/dependencies/hexf-parse-0.2.1/supplement/hexf-parse-0.2.1-Cargo.toml": "4a56dbdbc12054fd33b7a2634a45cbbe6fe12f5e6f4081002cbfa527f7220c70",
+    "licenses/dependencies/http-body-util-0.1.5/LICENSE": "248378d0a3383c173fb925f17141b88e71580b3ba17ddc6ac3d2a344683232ab",
+    "licenses/dependencies/http-body-1.1.0/LICENSE": "248378d0a3383c173fb925f17141b88e71580b3ba17ddc6ac3d2a344683232ab",
+    "licenses/dependencies/http-1.5.0/LICENSE-APACHE": "8bb1b50b0e5c9399ae33bd35fab2769010fa6c14e8860c729a52295d84896b7a",
+    "licenses/dependencies/http-1.5.0/LICENSE-MIT": "dc91f8200e4b2a1f9261035d4c18c33c246911a6c0f7b543d75347e61b249cff",
+    "licenses/dependencies/httparse-1.10.1/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/httparse-1.10.1/LICENSE-MIT": "391a5396cec6230bfabd4ef4eb2350eb895bc5efce377a2218f5702ed020d3e3",
+    "licenses/dependencies/httpdate-1.0.3/LICENSE-APACHE": "4d10fe5f3aa176b05b229a248866bad70b834c173f1252a814ff4748d8a13837",
+    "licenses/dependencies/httpdate-1.0.3/LICENSE-MIT": "934887691e05d69d7c86ad3f2c360980fa30c15b035e351f3c9865e99da4debc",
+    "licenses/dependencies/hyper-rustls-0.27.9/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/hyper-rustls-0.27.9/LICENSE-ISC": "7cfafc877eccc46c0e346ccbaa5c51bb6b894d2b818e617d970211e232785ad4",
+    "licenses/dependencies/hyper-rustls-0.27.9/LICENSE-MIT": "709e3175b4212f7b13aa93971c9f62ff8c69ec45ad8c6532a7e0c41d7a7d6f8c",
+    "licenses/dependencies/hyper-util-0.1.20/LICENSE": "9e0a97848ea543aef745c98e84fde696a9a3e0735538f6daefdd3cb1942effc1",
+    "licenses/dependencies/hyper-1.11.1/LICENSE": "2d01890414494742ba4a509fcec8efa40f6d8be22cbd72be7cff08d6fda4ec89",
+    "licenses/dependencies/iced_core-0.14.0/src/layout/DRUID_LICENSE": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30",
+    "licenses/dependencies/iced_core-0.14.0/supplement/iced-rs-iced-3997291f318a-LICENSE": "fc9086ba4eba4b77e4c603906362742bc3715ffa2c7810c6074fe7780d3a0398",
+    "licenses/dependencies/iced_debug-0.14.0/supplement/iced-rs-iced-3997291f318a-LICENSE": "fc9086ba4eba4b77e4c603906362742bc3715ffa2c7810c6074fe7780d3a0398",
+    "licenses/dependencies/iced_futures-0.14.0/supplement/iced-rs-iced-3997291f318a-LICENSE": "fc9086ba4eba4b77e4c603906362742bc3715ffa2c7810c6074fe7780d3a0398",
+    "licenses/dependencies/iced_graphics-0.14.0/supplement/iced-rs-iced-3997291f318a-LICENSE": "fc9086ba4eba4b77e4c603906362742bc3715ffa2c7810c6074fe7780d3a0398",
+    "licenses/dependencies/iced_graphics-0.14.0/assets/FiraSans-Regular.ttf/Fira-OFL.txt": "99bfb7c1e845b79d1031fcf37e678178eb4a8c7cc74a3f218ddf7223083a6fcd",
+    "licenses/dependencies/iced_graphics-0.14.0/assets/FiraSans-Regular.ttf/FiraSans-Regular-NOTICE.txt": "1e0baaa389b1647d06322ac9ea37822f31995408200ae5a2805a6b9bea0810d1",
+    "licenses/dependencies/iced_graphics-0.14.0/assets/Iced-Icons.ttf/iced-rs-iced-3997291f318a-LICENSE": "fc9086ba4eba4b77e4c603906362742bc3715ffa2c7810c6074fe7780d3a0398",
+    "licenses/dependencies/iced_graphics-0.14.0/assets/Iced-Icons.ttf/Iced-Icons-NOTICE.txt": "8175634e30f84ef72a24c4965fb0e87f45a3c1274cc0e79e0473af582cffd1c4",
+    "licenses/dependencies/iced_program-0.14.0/supplement/iced-rs-iced-3997291f318a-LICENSE": "fc9086ba4eba4b77e4c603906362742bc3715ffa2c7810c6074fe7780d3a0398",
+    "licenses/dependencies/iced_renderer-0.14.0/supplement/iced-rs-iced-3997291f318a-LICENSE": "fc9086ba4eba4b77e4c603906362742bc3715ffa2c7810c6074fe7780d3a0398",
+    "licenses/dependencies/iced_runtime-0.14.0/supplement/iced-rs-iced-3997291f318a-LICENSE": "fc9086ba4eba4b77e4c603906362742bc3715ffa2c7810c6074fe7780d3a0398",
+    "licenses/dependencies/iced_tiny_skia-0.14.0/supplement/iced-rs-iced-3997291f318a-LICENSE": "fc9086ba4eba4b77e4c603906362742bc3715ffa2c7810c6074fe7780d3a0398",
+    "licenses/dependencies/iced_wgpu-0.14.0/supplement/iced-rs-iced-3997291f318a-LICENSE": "fc9086ba4eba4b77e4c603906362742bc3715ffa2c7810c6074fe7780d3a0398",
+    "licenses/dependencies/iced_widget-0.14.2/supplement/iced-rs-iced-54abf81d13fe-LICENSE": "fc9086ba4eba4b77e4c603906362742bc3715ffa2c7810c6074fe7780d3a0398",
+    "licenses/dependencies/iced_winit-0.14.0/supplement/iced-rs-iced-3997291f318a-LICENSE": "fc9086ba4eba4b77e4c603906362742bc3715ffa2c7810c6074fe7780d3a0398",
+    "licenses/dependencies/iced-0.14.0/LICENSE": "fc9086ba4eba4b77e4c603906362742bc3715ffa2c7810c6074fe7780d3a0398",
+    "licenses/dependencies/icu_collections-2.3.0/LICENSE": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2",
+    "licenses/dependencies/icu_locale_core-2.3.0/LICENSE": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2",
+    "licenses/dependencies/icu_normalizer_data-2.3.0/LICENSE": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2",
+    "licenses/dependencies/icu_normalizer-2.3.0/LICENSE": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2",
+    "licenses/dependencies/icu_properties_data-2.3.0/LICENSE": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2",
+    "licenses/dependencies/icu_properties-2.3.0/LICENSE": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2",
+    "licenses/dependencies/icu_provider-2.3.1/LICENSE": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2",
+    "licenses/dependencies/idna_adapter-1.2.2/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/idna_adapter-1.2.2/LICENSE-MIT": "8b43ce8accd61e9d370b5ca9e9c4f953279b5c239926c62315b40e24df51b726",
+    "licenses/dependencies/idna-1.1.0/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/idna-1.1.0/LICENSE-MIT": "b38f11f6096706e6de553dabe2a7ed142d59b6fa8c97e290c67496154745cdd5",
+    "licenses/dependencies/indexmap-2.14.1/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/indexmap-2.14.1/LICENSE-MIT": "ecc269ef87fd38a1d98e30bfac9ba964a9dbd9315c3770fed98d4d7cb5882055",
+    "licenses/dependencies/ipnet-2.12.1/LICENSE-APACHE": "87d9feb9238c6bd8e0024fc4733b06cff036f89f36d93b7df1c8a0549bbb7a5b",
+    "licenses/dependencies/ipnet-2.12.1/LICENSE-MIT": "47dc9ff29128ddfb4d6a0435383c9f89120bc374dbcc1dd00b933a0b28aa7865",
+    "licenses/dependencies/itoa-1.0.18/LICENSE-APACHE": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a",
+    "licenses/dependencies/itoa-1.0.18/LICENSE-MIT": "23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3",
+    "licenses/dependencies/jobserver-0.1.35/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/jobserver-0.1.35/LICENSE-MIT": "378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397",
+    "licenses/dependencies/khronos_api-3.1.0/supplement/brendanzab-gl-rs-f150967b1c44-LICENSE": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30",
+    "licenses/dependencies/khronos-egl-6.0.0/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/khronos-egl-6.0.0/LICENSE-MIT": "23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3",
+    "licenses/dependencies/kurbo-0.10.4/LICENSE-APACHE": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30",
+    "licenses/dependencies/kurbo-0.10.4/LICENSE-MIT": "23c23145f6eac25c28cdcc03d38506a5712a9a8cffb5bd5301457f6173ea696e",
+    "licenses/dependencies/libc-0.2.189/LICENSE-APACHE": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a",
+    "licenses/dependencies/libc-0.2.189/LICENSE-MIT": "123a331b5dbf04c30097fa43b8f858bc85df671fe776de498d01f3d6b7c1f69e",
+    "licenses/dependencies/libloading-0.8.9/LICENSE": "b29f8b01452350c20dd1af16ef83b598fea3053578ccc1c7a0ef40e57be2620f",
+    "licenses/dependencies/libm-0.2.16/LICENSE.txt": "3823dda7cf046602f4b4e77ec8e227863dc4736037cc85bb33d9f19febe16bb7",
+    "licenses/dependencies/lilt-0.8.2/LICENSE": "120b2f21f9b9f98ef4159de09f9a55a3afb6733dd1c0b1d9eeec7f136465b2cd",
+    "licenses/dependencies/linebender_resource_handle-0.1.1/LICENSE-APACHE": "a6cba85bc92e0cff7a450b1d873c0eaa2e9fc96bf472df0247a26bec77bf3ff9",
+    "licenses/dependencies/linebender_resource_handle-0.1.1/LICENSE-MIT": "508a77d2e7b51d98adeed32648ad124b7b30241a8e70b2e72c99f92d8e5874d1",
+    "licenses/dependencies/litemap-0.8.3/LICENSE": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2",
+    "licenses/dependencies/litrs-1.0.0/LICENSE-APACHE": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a",
+    "licenses/dependencies/litrs-1.0.0/LICENSE-MIT": "7dc1552e88f49132cb358b1b962fc5e79fa42d70bcbb88c526d33e45b8e98036",
+    "licenses/dependencies/lock_api-0.4.14/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/lock_api-0.4.14/LICENSE-MIT": "c9a75f18b9ab2927829a208fc6aa2cf4e63b8420887ba29cdb265d6619ae82d5",
+    "licenses/dependencies/log-0.4.34/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/log-0.4.34/LICENSE-MIT": "6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb",
+    "licenses/dependencies/lru-slab-0.1.2/LICENSE-APACHE": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30",
+    "licenses/dependencies/lru-slab-0.1.2/LICENSE-MIT": "1466d9b4f3a59bb8997fc8d5fa977ce3f6a24bb2358793c09bfdf007039f6486",
+    "licenses/dependencies/lru-slab-0.1.2/LICENSE-ZLIB": "09785877275ffada6c371b652a30e95c26b435126fc0fc62f1bc2d72171f80a4",
+    "licenses/dependencies/lru-0.16.4/LICENSE": "061dc50af2cd9340703daf61978af3200cf681b12ea67a323c33ba109a23a45e",
+    "licenses/dependencies/lyon_algorithms-1.0.21/supplement/nical-lyon-994526f2766c-LICENSE-APACHE": "216486f29671a4262efe32af6d84a75bef398127f8c5f369b5c8305983887a06",
+    "licenses/dependencies/lyon_algorithms-1.0.21/supplement/nical-lyon-994526f2766c-LICENSE-MIT": "80f275e90d799911ed3830a7f242a2ef5a4ade2092fe0aa07bfb2d2cf2f2b95e",
+    "licenses/dependencies/lyon_geom-1.0.19/supplement/nical-lyon-56219c95c658-LICENSE-APACHE": "216486f29671a4262efe32af6d84a75bef398127f8c5f369b5c8305983887a06",
+    "licenses/dependencies/lyon_geom-1.0.19/supplement/nical-lyon-56219c95c658-LICENSE-MIT": "80f275e90d799911ed3830a7f242a2ef5a4ade2092fe0aa07bfb2d2cf2f2b95e",
+    "licenses/dependencies/lyon_path-1.0.19/supplement/nical-lyon-56219c95c658-LICENSE-APACHE": "216486f29671a4262efe32af6d84a75bef398127f8c5f369b5c8305983887a06",
+    "licenses/dependencies/lyon_path-1.0.19/supplement/nical-lyon-56219c95c658-LICENSE-MIT": "80f275e90d799911ed3830a7f242a2ef5a4ade2092fe0aa07bfb2d2cf2f2b95e",
+    "licenses/dependencies/lyon_tessellation-1.0.21/supplement/nical-lyon-994526f2766c-LICENSE-APACHE": "216486f29671a4262efe32af6d84a75bef398127f8c5f369b5c8305983887a06",
+    "licenses/dependencies/lyon_tessellation-1.0.21/supplement/nical-lyon-994526f2766c-LICENSE-MIT": "80f275e90d799911ed3830a7f242a2ef5a4ade2092fe0aa07bfb2d2cf2f2b95e",
+    "licenses/dependencies/lyon-1.0.19/supplement/nical-lyon-56219c95c658-LICENSE-APACHE": "216486f29671a4262efe32af6d84a75bef398127f8c5f369b5c8305983887a06",
+    "licenses/dependencies/lyon-1.0.19/supplement/nical-lyon-56219c95c658-LICENSE-MIT": "80f275e90d799911ed3830a7f242a2ef5a4ade2092fe0aa07bfb2d2cf2f2b95e",
+    "licenses/dependencies/matchit-0.8.4/LICENSE": "de701d0618d694feb1af90f02181a1763d9b0bdeb70a3a592781e529077dba65",
+    "licenses/dependencies/matchit-0.8.4/LICENSE.httprouter": "162ce11ad71338d0a0c6ebaf5c48af72c6ae237b468859d3656fe2d9ed3f3a85",
+    "licenses/dependencies/memchr-2.8.3/COPYING": "01c266bced4a434da0051174d6bee16a4c82cf634e2679b6155d40d75012390f",
+    "licenses/dependencies/memchr-2.8.3/LICENSE-MIT": "0f96a83840e146e43c0ec96a22ec1f392e0680e6c1226e6f3ba87e0740af850f",
+    "licenses/dependencies/memchr-2.8.3/UNLICENSE": "7e12e5df4bae12cb21581ba157ced20e1986a0508dd10d0e8a4ab9a4cf94e85c",
+    "licenses/dependencies/memmap2-0.9.11/LICENSE-APACHE": "04ea4849dba9dcae07113850c6f1b1a69052c625210639914eee352023f750ad",
+    "licenses/dependencies/memmap2-0.9.11/LICENSE-MIT": "0d25d03b5ab49576178ad0cae7a2648d12c17ad0452fe49c07e55e4b59aa5257",
+    "licenses/dependencies/mime-0.3.17/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/mime-0.3.17/LICENSE-MIT": "df9cfd06d8a44d9a671eadd39ffd97f166481da015a30f45dfd27886209c5922",
+    "licenses/dependencies/mio-1.2.3/LICENSE": "07919255c7e04793d8ea760d6c2ce32d19f9ff02bdbdde3ce90b1e1880929a9b",
+    "licenses/dependencies/naga-27.0.3/LICENSE.APACHE": "a6cba85bc92e0cff7a450b1d873c0eaa2e9fc96bf472df0247a26bec77bf3ff9",
+    "licenses/dependencies/naga-27.0.3/LICENSE.MIT": "dc0d97139e8205818c703741c7be7cb3b96888bd5917b8d6fc6133731e403c21",
+    "licenses/dependencies/num-traits-0.2.19/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/num-traits-0.2.19/LICENSE-MIT": "6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb",
+    "licenses/dependencies/once_cell-1.21.4/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/once_cell-1.21.4/LICENSE-MIT": "23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3",
+    "licenses/dependencies/ordered-float-5.5.0/LICENSE-MIT": "f7715d38a3fa1b4ac97c5729740752505a39cb92ee83ab5b102aeb5eaa7cdea4",
+    "licenses/dependencies/parking_lot_core-0.9.12/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/parking_lot_core-0.9.12/LICENSE-MIT": "c9a75f18b9ab2927829a208fc6aa2cf4e63b8420887ba29cdb265d6619ae82d5",
+    "licenses/dependencies/parking_lot-0.12.5/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/parking_lot-0.12.5/LICENSE-MIT": "c9a75f18b9ab2927829a208fc6aa2cf4e63b8420887ba29cdb265d6619ae82d5",
+    "licenses/dependencies/percent-encoding-2.3.2/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/percent-encoding-2.3.2/LICENSE-MIT": "b38f11f6096706e6de553dabe2a7ed142d59b6fa8c97e290c67496154745cdd5",
+    "licenses/dependencies/pin-project-lite-0.2.17/LICENSE-APACHE": "0d542e0c8804e39aa7f37eb00da5a762149dc682d7829451287e11b938e94594",
+    "licenses/dependencies/pin-project-lite-0.2.17/LICENSE-MIT": "23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3",
+    "licenses/dependencies/pkg-config-0.3.34/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/pkg-config-0.3.34/LICENSE-MIT": "378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397",
+    "licenses/dependencies/potential_utf-0.1.6/LICENSE": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2",
+    "licenses/dependencies/presser-0.3.1/LICENSE-APACHE": "8173d5c29b4f956d532781d2b86e4e30f83e6b7878dce18c919451d6ba707c90",
+    "licenses/dependencies/presser-0.3.1/LICENSE-MIT": "090a294a492ab2f41388252312a65cf2f0e423330b721a68c6665ac64766753b",
+    "licenses/dependencies/proc-macro2-1.0.107/LICENSE-APACHE": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a",
+    "licenses/dependencies/proc-macro2-1.0.107/LICENSE-MIT": "23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3",
+    "licenses/dependencies/profiling-1.0.18/supplement/aclysma-profiling-8271551172eb-LICENSE-APACHE": "10d30a673cd5e9349bdc02aeb48f14b3386d27d0da32df8f0a555d4aa16aa551",
+    "licenses/dependencies/profiling-1.0.18/supplement/aclysma-profiling-8271551172eb-LICENSE-MIT": "c8167fdeeed46d3f244d3f85c5bf998ce889343691c32be2c61a8bc4b5c08333",
+    "licenses/dependencies/quinn-proto-0.11.17/LICENSE-APACHE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4",
+    "licenses/dependencies/quinn-proto-0.11.17/LICENSE-MIT": "4b2d0aca6789fa39e03d6738e869ea0988cceba210ca34ebb59c15c463e93a04",
+    "licenses/dependencies/quinn-udp-0.5.15/LICENSE-APACHE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4",
+    "licenses/dependencies/quinn-udp-0.5.15/LICENSE-MIT": "4b2d0aca6789fa39e03d6738e869ea0988cceba210ca34ebb59c15c463e93a04",
+    "licenses/dependencies/quinn-0.11.11/LICENSE-APACHE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4",
+    "licenses/dependencies/quinn-0.11.11/LICENSE-MIT": "4b2d0aca6789fa39e03d6738e869ea0988cceba210ca34ebb59c15c463e93a04",
+    "licenses/dependencies/quote-1.0.47/LICENSE-APACHE": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a",
+    "licenses/dependencies/quote-1.0.47/LICENSE-MIT": "23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3",
+    "licenses/dependencies/rand_core-0.10.1/COPYRIGHT": "92b81db30f7ab6d693e0af5661a40d273ca1947e891123ed823924192c10cbc7",
+    "licenses/dependencies/rand_core-0.10.1/LICENSE-APACHE": "6df43f6f4b5d4587f3d8d71e45532c688fd168afa5fe89d571cb32fa09c4ef51",
+    "licenses/dependencies/rand_core-0.10.1/LICENSE-MIT": "8b6e9feec03e7c9a5facb26855cecd31662bf989b636bcfe79521bdf8ac863f0",
+    "licenses/dependencies/rand_pcg-0.10.2/COPYRIGHT": "90eb64f0279b0d9432accfa6023ff803bc4965212383697eee27a0f426d5f8d5",
+    "licenses/dependencies/rand_pcg-0.10.2/LICENSE-APACHE": "6df43f6f4b5d4587f3d8d71e45532c688fd168afa5fe89d571cb32fa09c4ef51",
+    "licenses/dependencies/rand_pcg-0.10.2/LICENSE-MIT": "2234e3cefee876aeb686ad89e978bdb07bf118a1186ab1cf161bcdf69d4b4f57",
+    "licenses/dependencies/rand-0.10.2/COPYRIGHT": "90eb64f0279b0d9432accfa6023ff803bc4965212383697eee27a0f426d5f8d5",
+    "licenses/dependencies/rand-0.10.2/LICENSE-APACHE": "35242e7a83f69875e6edeff02291e688c97caafe2f8902e4e19b49d3e78b4cab",
+    "licenses/dependencies/rand-0.10.2/LICENSE-MIT": "209fbbe0ad52d9235e37badf9cadfe4dbdc87203179c0899e738b39ade42177b",
+    "licenses/dependencies/range-alloc-0.1.5/LICENSE.APACHE": "a6cba85bc92e0cff7a450b1d873c0eaa2e9fc96bf472df0247a26bec77bf3ff9",
+    "licenses/dependencies/range-alloc-0.1.5/LICENSE.MIT": "ba00052102ed87948bb8822d6e1c496260c83042887b22bb5caad922ec025a60",
+    "licenses/dependencies/rangemap-1.8.0/LICENSE-APACHE": "1c7745cc26c7294bc9dbc883bcd50700b99a8c0f4859bfce84ec555098ce1ab5",
+    "licenses/dependencies/rangemap-1.8.0/LICENSE-MIT": "29a4c3823ee29ee5a97c145574a1bac20629fd5e6708be1df0d25bab563e093c",
+    "licenses/dependencies/raw-window-handle-0.6.2/LICENSE-APACHE.md": "0d542e0c8804e39aa7f37eb00da5a762149dc682d7829451287e11b938e94594",
+    "licenses/dependencies/raw-window-handle-0.6.2/LICENSE-MIT.md": "9c5a80639a57c1c945570e7ebbca0706305849ce3c098021325cca9db2f7acc4",
+    "licenses/dependencies/raw-window-handle-0.6.2/LICENSE-ZLIB.md": "ae895c8576e682f310fb70d93d9f99b1dd82872094c54a8f6cdfe2ca5c2d6ecb",
+    "licenses/dependencies/read-fonts-0.35.0/LICENSE-APACHE": "a14f7d685a79c0f4fb64aee305527a6d5fa55f2401f4e6d688d7b1301868e6c0",
+    "licenses/dependencies/read-fonts-0.35.0/LICENSE-MIT": "8a62fa27ffdccc3df19dce90f8bb3d572e27aecffc1a383d0c2601834dcec434",
+    "licenses/dependencies/read-fonts-0.41.0/LICENSE-APACHE": "eba684204073ed715c4abb48129acdfd2bff8ae48339e6a7da3b341d3027b7f0",
+    "licenses/dependencies/read-fonts-0.41.0/LICENSE-MIT": "7b4c9a3946dfcea7967582760e963e27799e225dcf20565c8ef55324bb017427",
+    "licenses/dependencies/renderdoc-sys-1.1.0/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/renderdoc-sys-1.1.0/LICENSE-MIT": "24b2f2eff5a7622e87162823e260f00c6dfbce0e26d585d3d28c785f1edc80ed",
+    "licenses/dependencies/reqwest-0.12.28/LICENSE-APACHE": "751963a8b88c0e3a9f27e98933079fbcf09b9998b2c13ac49c2e4d58444520d6",
+    "licenses/dependencies/reqwest-0.12.28/LICENSE-MIT": "47d4e1803702728e03d30f8a848ae2249ba274bbd9f8443e803f7924d83cd371",
+    "licenses/dependencies/rfd-0.15.4/LICENSE": "65fc947f4bac882a2cd104ef73c246b1b037059df9f2b3a58b7f77f0b9e56071",
+    "licenses/dependencies/ring-0.17.14/LICENSE": "b3d734001a94efff3579978d953391aa7115f877657d25eb54037a43875d078a",
+    "licenses/dependencies/ring-0.17.14/LICENSE-BoringSSL": "005fc765ddc5115da796cca915baa9557abae13ff35e0a47c47affc56f6c414d",
+    "licenses/dependencies/ring-0.17.14/LICENSE-other-bits": "f025ccfb7dfb6bdfedc75ca0f67acc69e6fb4998143d834f7c2f38a29989680f",
+    "licenses/dependencies/ring-0.17.14/src/polyfill/once_cell/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/ring-0.17.14/src/polyfill/once_cell/LICENSE-MIT": "6ee2ed6c77710de911761acd5fc1ad1da00f476beb1a7ef27e78c2d1858deafc",
+    "licenses/dependencies/ring-0.17.14/third_party/fiat/LICENSE": "9eacbcb81be660840c714a560a9d65ba07913db98dd4baf969f78dd499fdd60f",
+    "licenses/dependencies/rustc-hash-1.1.0/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/rustc-hash-1.1.0/LICENSE-MIT": "23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3",
+    "licenses/dependencies/rustc-hash-2.1.3/LICENSE-APACHE": "95bd3988beee069fa2848f648dab43cc6e0b2add2ad6bcb17360caf749802bcc",
+    "licenses/dependencies/rustc-hash-2.1.3/LICENSE-MIT": "30fefc3a7d6a0041541858293bcbea2dde4caa4c0a5802f996a7f7e8c0085652",
+    "licenses/dependencies/rustls-pki-types-1.15.1/LICENSE-APACHE": "45fd05c4865e7c350b98ad7ac50e1b15462d49af4a91e9b0c9dd933dc9a69742",
+    "licenses/dependencies/rustls-pki-types-1.15.1/LICENSE-MIT": "9117d922e667125508dde62b02c1f57ed22f5ad21eb536aa2e2d99e1c796e639",
+    "licenses/dependencies/rustls-webpki-0.103.15/LICENSE": "5b698ca13897be3afdb7174256fa1574f8c6892b8bea1a66dd6469d3fe27885a",
+    "licenses/dependencies/rustls-0.23.43/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/rustls-0.23.43/LICENSE-ISC": "7cfafc877eccc46c0e346ccbaa5c51bb6b894d2b818e617d970211e232785ad4",
+    "licenses/dependencies/rustls-0.23.43/LICENSE-MIT": "709e3175b4212f7b13aa93971c9f62ff8c69ec45ad8c6532a7e0c41d7a7d6f8c",
+    "licenses/dependencies/ryu-1.0.23/LICENSE-APACHE": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a",
+    "licenses/dependencies/ryu-1.0.23/LICENSE-BOOST": "c9bff75738922193e67fa726fa225535870d2aa1059f91452c411736284ad566",
+    "licenses/dependencies/same-file-1.0.6/COPYING": "01c266bced4a434da0051174d6bee16a4c82cf634e2679b6155d40d75012390f",
+    "licenses/dependencies/same-file-1.0.6/LICENSE-MIT": "cb3c929a05e6cbc9de9ab06a4c57eeb60ca8c724bef6c138c87d3a577e27aa14",
+    "licenses/dependencies/same-file-1.0.6/UNLICENSE": "7e12e5df4bae12cb21581ba157ced20e1986a0508dd10d0e8a4ab9a4cf94e85c",
+    "licenses/dependencies/scopeguard-1.2.0/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/scopeguard-1.2.0/LICENSE-MIT": "fb77f0a9c53e473abe5103c8632ef9f0f2874d4fb3f17cb2d8c661aab9cee9d7",
+    "licenses/dependencies/self_cell-1.3.0/LICENSE-APACHE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4",
+    "licenses/dependencies/self_cell-1.3.0/LICENSE-GPLv2": "f9c375a1be4a41f7b70301dd83c91cb89e41567478859b77eef375a52d782505",
+    "licenses/dependencies/serde_core-1.0.229/LICENSE-APACHE": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a",
+    "licenses/dependencies/serde_core-1.0.229/LICENSE-MIT": "23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3",
+    "licenses/dependencies/serde_derive-1.0.229/LICENSE-APACHE": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a",
+    "licenses/dependencies/serde_derive-1.0.229/LICENSE-MIT": "23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3",
+    "licenses/dependencies/serde_json-1.0.151/LICENSE-APACHE": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a",
+    "licenses/dependencies/serde_json-1.0.151/LICENSE-MIT": "23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3",
+    "licenses/dependencies/serde_path_to_error-0.1.20/LICENSE-APACHE": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a",
+    "licenses/dependencies/serde_path_to_error-0.1.20/LICENSE-MIT": "23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3",
+    "licenses/dependencies/serde_urlencoded-0.7.1/LICENSE-APACHE": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a",
+    "licenses/dependencies/serde_urlencoded-0.7.1/LICENSE-MIT": "b9eb266294324f672cbe945fe8f2e32f85024f0d61a1a7d14382cdde0ac44769",
+    "licenses/dependencies/serde-1.0.229/LICENSE-APACHE": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a",
+    "licenses/dependencies/serde-1.0.229/LICENSE-MIT": "23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3",
+    "licenses/dependencies/sha1_smol-1.0.1/LICENSE": "282a21b0710441c364025461a447362daf18f5798a7b72ae2f801a2aa536da51",
+    "licenses/dependencies/shlex-2.0.1/LICENSE-APACHE": "553fffcd9b1cb158bc3e9edc35da85ca5c3b3d7d2e61c883ebcfa8a65814b583",
+    "licenses/dependencies/shlex-2.0.1/LICENSE-MIT": "4455bf75a91154108304cb283e0fea9948c14f13e20d60887cf2552449dea3b1",
+    "licenses/dependencies/skrifa-0.37.0/LICENSE-APACHE": "a14f7d685a79c0f4fb64aee305527a6d5fa55f2401f4e6d688d7b1301868e6c0",
+    "licenses/dependencies/skrifa-0.37.0/LICENSE-MIT": "8a62fa27ffdccc3df19dce90f8bb3d572e27aecffc1a383d0c2601834dcec434",
+    "licenses/dependencies/skrifa-0.44.0/LICENSE-APACHE": "eba684204073ed715c4abb48129acdfd2bff8ae48339e6a7da3b341d3027b7f0",
+    "licenses/dependencies/skrifa-0.44.0/LICENSE-MIT": "7b4c9a3946dfcea7967582760e963e27799e225dcf20565c8ef55324bb017427",
+    "licenses/dependencies/slab-0.4.12/LICENSE": "8ce0830173fdac609dfb4ea603fdc002c2f4af0dc9b1a005653f5da9cf534b18",
+    "licenses/dependencies/slotmap-1.1.1/LICENSE": "6cec81441b2ab2b5090954c1fb5d0bcca81b86487b5849061fa8952d20ef67d4",
+    "licenses/dependencies/smallvec-1.16.0/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/smallvec-1.16.0/LICENSE-MIT": "0b28172679e0009b655da42797c03fd163a3379d5cfa67ba1f1655e974a2a1a9",
+    "licenses/dependencies/smol_str-0.2.2/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/smol_str-0.2.2/LICENSE-MIT": "23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3",
+    "licenses/dependencies/socket2-0.6.5/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/socket2-0.6.5/LICENSE-MIT": "378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397",
+    "licenses/dependencies/softbuffer-0.4.8/LICENSE-APACHE": "a4445427440043e8ce6fadf7a43fb906cb0d7f6c573a560a9f142cf9f9bf8ff4",
+    "licenses/dependencies/softbuffer-0.4.8/LICENSE-MIT": "0463bfa47d6d763d8c824333efb0e6d6df3946c13c3b077c78ed9f23ca50d0f2",
+    "licenses/dependencies/spirv-0.3.0+sdk-1.3.268.0/supplement/gfx-rs-rspirv-e91a5debc10c-LICENSE": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30",
+    "licenses/dependencies/stable_deref_trait-1.2.1/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/stable_deref_trait-1.2.1/LICENSE-MIT": "5e05b024f653a5ce199e77cbbbd42fb5553562ec714b819421ed0c3e552a75d7",
+    "licenses/dependencies/static_assertions-1.1.0/LICENSE-APACHE": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30",
+    "licenses/dependencies/static_assertions-1.1.0/LICENSE-MIT": "ea084a2373ebc1f0902c09266e7bf25a05ab3814c1805bb017ffa7308f90c061",
+    "licenses/dependencies/strict-num-0.1.1/LICENSE": "3085885678bb161f6c472bbd331f66a2550b555eb76128f7f8247779128199c0",
+    "licenses/dependencies/subtle-2.6.1/LICENSE": "d1fc1bc0d155df60b2e7705b6b2ae02a05c96f948e1cec6e2fb86360b09f346b",
+    "licenses/dependencies/svg_fmt-0.4.5/supplement/nical-rust_debug-93f414cd572b-LICENSE": "7e98bed7f100747aaae7d82ab94fbe6b76fd6b84b09a3aaa413bff8196d0fbb1",
+    "licenses/dependencies/swash-0.2.10/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/swash-0.2.10/LICENSE-MIT": "122dadfc2eb4de0f4bafcd9eb4e7502cfe338a7965ebd1d18708cc5050f43f76",
+    "licenses/dependencies/syn-2.0.119/LICENSE-APACHE": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a",
+    "licenses/dependencies/syn-2.0.119/LICENSE-MIT": "23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3",
+    "licenses/dependencies/syn-3.0.5/LICENSE-APACHE": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a",
+    "licenses/dependencies/syn-3.0.5/LICENSE-MIT": "23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3",
+    "licenses/dependencies/sync_wrapper-1.0.2/LICENSE": "0d542e0c8804e39aa7f37eb00da5a762149dc682d7829451287e11b938e94594",
+    "licenses/dependencies/synstructure-0.13.2/LICENSE": "219920e865eee70b7dcfc948a86b099e7f4fe2de01bcca2ca9a20c0a033f2b59",
+    "licenses/dependencies/sys-locale-0.3.2/LICENSE-APACHE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4",
+    "licenses/dependencies/sys-locale-0.3.2/LICENSE-MIT": "5cc390ab5e5e6507f467368cbab1297552d64bfd863f4b496c7928508bcfefd8",
+    "licenses/dependencies/tempfile-3.27.0/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/tempfile-3.27.0/LICENSE-MIT": "8b427f5bc501764575e52ba4f9d95673cf8f6d80a86d0d06599852e1a9a20a36",
+    "licenses/dependencies/termcolor-1.4.1/COPYING": "01c266bced4a434da0051174d6bee16a4c82cf634e2679b6155d40d75012390f",
+    "licenses/dependencies/termcolor-1.4.1/LICENSE-MIT": "0f96a83840e146e43c0ec96a22ec1f392e0680e6c1226e6f3ba87e0740af850f",
+    "licenses/dependencies/termcolor-1.4.1/UNLICENSE": "7e12e5df4bae12cb21581ba157ced20e1986a0508dd10d0e8a4ab9a4cf94e85c",
+    "licenses/dependencies/thiserror-impl-1.0.69/LICENSE-APACHE": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a",
+    "licenses/dependencies/thiserror-impl-1.0.69/LICENSE-MIT": "23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3",
+    "licenses/dependencies/thiserror-impl-2.0.20/LICENSE-APACHE": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a",
+    "licenses/dependencies/thiserror-impl-2.0.20/LICENSE-MIT": "23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3",
+    "licenses/dependencies/thiserror-1.0.69/LICENSE-APACHE": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a",
+    "licenses/dependencies/thiserror-1.0.69/LICENSE-MIT": "23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3",
+    "licenses/dependencies/thiserror-2.0.20/LICENSE-APACHE": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a",
+    "licenses/dependencies/thiserror-2.0.20/LICENSE-MIT": "23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3",
+    "licenses/dependencies/tiny-skia-path-0.11.4/LICENSE": "6d41e05f1d54fe726997cb0334ec539f1dff50600b1d5d90462ec2b392770ced",
+    "licenses/dependencies/tiny-skia-0.11.4/LICENSE": "6d41e05f1d54fe726997cb0334ec539f1dff50600b1d5d90462ec2b392770ced",
+    "licenses/dependencies/tinystr-0.8.4/LICENSE": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2",
+    "licenses/dependencies/tinyvec_macros-0.1.1/LICENSE-APACHE.md": "4f44572785f35152c1fd2eadf565b7e079c0f300b4324f0af653419f9d76b735",
+    "licenses/dependencies/tinyvec_macros-0.1.1/LICENSE-MIT.md": "1dd8eca0f83669e75fa119e34fb9e1be9d16e3e9b6368962b8019db6e8ae5f7b",
+    "licenses/dependencies/tinyvec_macros-0.1.1/LICENSE-ZLIB.md": "41ace205715d9f19a3214218cc1c01d57c533e02cd0fef7c8e51a49a7fce5ac5",
+    "licenses/dependencies/tinyvec-1.13.2/LICENSE-APACHE.md": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30",
+    "licenses/dependencies/tinyvec-1.13.2/LICENSE-MIT.md": "fd80a26fbb3f644af1fa994134446702932968519797227e07a1368dea80f0bc",
+    "licenses/dependencies/tinyvec-1.13.2/LICENSE-ZLIB.md": "84b34dd7608f7fb9b17bd588a6bf392bf7de504e2716f024a77d89f1b145a151",
+    "licenses/dependencies/tokio-macros-2.7.2/LICENSE": "0b83dc40cba89b9922bb84b0a9c7d2768ce37c1d7e138b7424fd4549915778c9",
+    "licenses/dependencies/tokio-rustls-0.26.5/LICENSE-APACHE": "cc117d90b498b32b11a886f279b359da16a73c3b01efbb2f5cc004b20262334e",
+    "licenses/dependencies/tokio-rustls-0.26.5/LICENSE-MIT": "e20fa2b8e0a2565f24a792b94b4bf4b6c2b9d36f781d8a9516e218a036e6677a",
+    "licenses/dependencies/tokio-1.53.1/LICENSE": "253cd04c6714889df2d32f3f64d669179a1c95c76ac43c40882c52eb06bc3552",
+    "licenses/dependencies/tower-http-0.6.11/LICENSE": "5049cf464977eff4b4fcfa7988d84e74116956a3eb9d5f1d451b3f828f945233",
+    "licenses/dependencies/tower-layer-0.3.3/LICENSE": "4249c8e6c5ebb85f97c77e6457c6fafc1066406eb8f1ef61e796fbdc5ff18482",
+    "licenses/dependencies/tower-service-0.3.3/LICENSE": "4249c8e6c5ebb85f97c77e6457c6fafc1066406eb8f1ef61e796fbdc5ff18482",
+    "licenses/dependencies/tower-0.5.3/LICENSE": "4249c8e6c5ebb85f97c77e6457c6fafc1066406eb8f1ef61e796fbdc5ff18482",
+    "licenses/dependencies/tracing-attributes-0.1.31/LICENSE": "898b1ae9821e98daf8964c8d6c7f61641f5f5aa78ad500020771c0939ee0dea1",
+    "licenses/dependencies/tracing-core-0.1.36/LICENSE": "898b1ae9821e98daf8964c8d6c7f61641f5f5aa78ad500020771c0939ee0dea1",
+    "licenses/dependencies/tracing-core-0.1.36/src/spin/LICENSE": "58545fed1565e42d687aecec6897d35c6d37ccb71479a137c0deb2203e125c79",
+    "licenses/dependencies/tracing-0.1.44/LICENSE": "898b1ae9821e98daf8964c8d6c7f61641f5f5aa78ad500020771c0939ee0dea1",
+    "licenses/dependencies/try-lock-0.2.5/LICENSE": "c816a0749cdc6bf062a5111c159723de51b2bfac66a1dac2655abd9e6b1583eb",
+    "licenses/dependencies/ttf-parser-0.25.1/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/ttf-parser-0.25.1/LICENSE-MIT": "f3c9fe731c701ed77fd5fbaac573872af04dc5869385eb9bd5e3c73c42713814",
+    "licenses/dependencies/ttf-parser-0.25.1/tests/fonts/colr_1_LICENSE": "58d1e17ffe5109a7ae296caafcadfdbe6a7d176f0bc4ab01e12a689b0499d8bd",
+    "licenses/dependencies/unicode-bidi-0.3.18/COPYRIGHT": "edb20b474f6cbd4f4db066b54a9e0f687d0009d309412a63431189b59b8e2a07",
+    "licenses/dependencies/unicode-bidi-0.3.18/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/unicode-bidi-0.3.18/LICENSE-MIT": "7b63ecd5f1902af1b63729947373683c32745c16a10e8e6292e2e2dcd7e90ae0",
+    "licenses/dependencies/unicode-ident-1.0.24/LICENSE-APACHE": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a",
+    "licenses/dependencies/unicode-ident-1.0.24/LICENSE-MIT": "23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3",
+    "licenses/dependencies/unicode-ident-1.0.24/LICENSE-UNICODE": "f7db81051789b729fea528a63ec4c938fdcb93d9d61d97dc8cc2e9df6d47f2a1",
+    "licenses/dependencies/unicode-linebreak-0.1.5/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4",
+    "licenses/dependencies/unicode-script-0.5.8/LICENSE-APACHE": "7cbb56d1b5d83d735056b363ab20958524120afafc4ad8206e6be98cdec5d737",
+    "licenses/dependencies/unicode-script-0.5.8/LICENSE-MIT": "7ad3ea8ca3caf894db98c3f31d5d4949173ffa93c883ef19a9e529ad48960f8c",
+    "licenses/dependencies/unicode-segmentation-1.13.3/COPYRIGHT": "23860c2a7b5d96b21569afedf033469bab9fe14a1b24a35068b8641c578ce24d",
+    "licenses/dependencies/unicode-segmentation-1.13.3/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/unicode-segmentation-1.13.3/LICENSE-MIT": "7b63ecd5f1902af1b63729947373683c32745c16a10e8e6292e2e2dcd7e90ae0",
+    "licenses/dependencies/unicode-width-0.2.2/COPYRIGHT": "23860c2a7b5d96b21569afedf033469bab9fe14a1b24a35068b8641c578ce24d",
+    "licenses/dependencies/unicode-width-0.2.2/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/unicode-width-0.2.2/LICENSE-MIT": "7b63ecd5f1902af1b63729947373683c32745c16a10e8e6292e2e2dcd7e90ae0",
+    "licenses/dependencies/untrusted-0.9.0/LICENSE.txt": "7abd9b6960dcf7d4d0a48606a5b71bfe37d472db68d70637f3a58a56785f1621",
+    "licenses/dependencies/url-2.5.8/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/url-2.5.8/LICENSE-MIT": "b38f11f6096706e6de553dabe2a7ed142d59b6fa8c97e290c67496154745cdd5",
+    "licenses/dependencies/utf8_iter-1.0.4/COPYRIGHT": "c30152c94a6d75e021adbc52b3a52470366a46edb917e17deae3259251af244c",
+    "licenses/dependencies/utf8_iter-1.0.4/LICENSE-APACHE": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30",
+    "licenses/dependencies/utf8_iter-1.0.4/LICENSE-MIT": "3fa4ca83dcc9237839b1bdeb2e6d16bdfb5ec0c5ce42b24694d8bbf0dcbef72c",
+    "licenses/dependencies/uuid-1.26.0/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/uuid-1.26.0/LICENSE-MIT": "436bc5a105d8e57dcd8778730f3754f7bf39c14d2f530e4cde4bd2d17a83ec3d",
+    "licenses/dependencies/version_check-0.9.5/LICENSE-APACHE": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2",
+    "licenses/dependencies/version_check-0.9.5/LICENSE-MIT": "b7e650f3fce5c53249d1cdc608b54df156a97edd636cf9d23498d0cfe7aec63e",
+    "licenses/dependencies/want-0.3.1/LICENSE": "a65f5d0a945d267751344c95665945b90c030ea107faf5c85d518929886187da",
+    "licenses/dependencies/web-time-1.1.0/LICENSE-APACHE": "54a744942eb3fa63a74d8d359989ed6962c04f3f10ff20cfa08ff8aa7efbe4e6",
+    "licenses/dependencies/web-time-1.1.0/LICENSE-MIT": "f428305bbf2e70fbd807af0f3c7ac1b7acfb95311640f451e9d2e48db6d7e96b",
+    "licenses/dependencies/webpki-roots-1.0.9/LICENSE": "e271993808fec50ab29350b39539cdec611a9103f827e0aa26d61da70e2d33f8",
+    "licenses/dependencies/wgpu-core-deps-windows-linux-android-27.0.0/LICENSE.APACHE": "a6cba85bc92e0cff7a450b1d873c0eaa2e9fc96bf472df0247a26bec77bf3ff9",
+    "licenses/dependencies/wgpu-core-deps-windows-linux-android-27.0.0/LICENSE.MIT": "dc0d97139e8205818c703741c7be7cb3b96888bd5917b8d6fc6133731e403c21",
+    "licenses/dependencies/wgpu-core-27.0.3/LICENSE.APACHE": "a6cba85bc92e0cff7a450b1d873c0eaa2e9fc96bf472df0247a26bec77bf3ff9",
+    "licenses/dependencies/wgpu-core-27.0.3/LICENSE.MIT": "dc0d97139e8205818c703741c7be7cb3b96888bd5917b8d6fc6133731e403c21",
+    "licenses/dependencies/wgpu-hal-27.0.4/LICENSE.APACHE": "a6cba85bc92e0cff7a450b1d873c0eaa2e9fc96bf472df0247a26bec77bf3ff9",
+    "licenses/dependencies/wgpu-hal-27.0.4/LICENSE.MIT": "dc0d97139e8205818c703741c7be7cb3b96888bd5917b8d6fc6133731e403c21",
+    "licenses/dependencies/wgpu-types-27.0.1/LICENSE.APACHE": "a6cba85bc92e0cff7a450b1d873c0eaa2e9fc96bf472df0247a26bec77bf3ff9",
+    "licenses/dependencies/wgpu-types-27.0.1/LICENSE.MIT": "dc0d97139e8205818c703741c7be7cb3b96888bd5917b8d6fc6133731e403c21",
+    "licenses/dependencies/wgpu-27.0.1/LICENSE.APACHE": "a6cba85bc92e0cff7a450b1d873c0eaa2e9fc96bf472df0247a26bec77bf3ff9",
+    "licenses/dependencies/wgpu-27.0.1/LICENSE.MIT": "dc0d97139e8205818c703741c7be7cb3b96888bd5917b8d6fc6133731e403c21",
+    "licenses/dependencies/winapi-util-0.1.11/COPYING": "01c266bced4a434da0051174d6bee16a4c82cf634e2679b6155d40d75012390f",
+    "licenses/dependencies/winapi-util-0.1.11/LICENSE-MIT": "cb3c929a05e6cbc9de9ab06a4c57eeb60ca8c724bef6c138c87d3a577e27aa14",
+    "licenses/dependencies/winapi-util-0.1.11/UNLICENSE": "7e12e5df4bae12cb21581ba157ced20e1986a0508dd10d0e8a4ab9a4cf94e85c",
+    "licenses/dependencies/window_clipboard-0.5.1/LICENSE": "7faec985f3e9b1c4a1df646bfedc304ba67e409447f7ab7f4f591f68708d85dc",
+    "licenses/dependencies/windows_x86_64_gnullvm-0.52.6/license-apache-2.0": "c16f8dcf1a368b83be78d826ea23de4079fe1b4469a0ab9ee20563f37ff3d44b",
+    "licenses/dependencies/windows_x86_64_gnullvm-0.52.6/license-mit": "c2cfccb812fe482101a8f04597dfc5a9991a6b2748266c47ac91b6a5aae15383",
+    "licenses/dependencies/windows-core-0.58.0/license-apache-2.0": "c16f8dcf1a368b83be78d826ea23de4079fe1b4469a0ab9ee20563f37ff3d44b",
+    "licenses/dependencies/windows-core-0.58.0/license-mit": "c2cfccb812fe482101a8f04597dfc5a9991a6b2748266c47ac91b6a5aae15383",
+    "licenses/dependencies/windows-implement-0.58.0/license-apache-2.0": "c16f8dcf1a368b83be78d826ea23de4079fe1b4469a0ab9ee20563f37ff3d44b",
+    "licenses/dependencies/windows-implement-0.58.0/license-mit": "c2cfccb812fe482101a8f04597dfc5a9991a6b2748266c47ac91b6a5aae15383",
+    "licenses/dependencies/windows-interface-0.58.0/license-apache-2.0": "c16f8dcf1a368b83be78d826ea23de4079fe1b4469a0ab9ee20563f37ff3d44b",
+    "licenses/dependencies/windows-interface-0.58.0/license-mit": "c2cfccb812fe482101a8f04597dfc5a9991a6b2748266c47ac91b6a5aae15383",
+    "licenses/dependencies/windows-link-0.2.1/license-apache-2.0": "c16f8dcf1a368b83be78d826ea23de4079fe1b4469a0ab9ee20563f37ff3d44b",
+    "licenses/dependencies/windows-link-0.2.1/license-mit": "c2cfccb812fe482101a8f04597dfc5a9991a6b2748266c47ac91b6a5aae15383",
+    "licenses/dependencies/windows-result-0.2.0/license-apache-2.0": "c16f8dcf1a368b83be78d826ea23de4079fe1b4469a0ab9ee20563f37ff3d44b",
+    "licenses/dependencies/windows-result-0.2.0/license-mit": "c2cfccb812fe482101a8f04597dfc5a9991a6b2748266c47ac91b6a5aae15383",
+    "licenses/dependencies/windows-strings-0.1.0/license-apache-2.0": "c16f8dcf1a368b83be78d826ea23de4079fe1b4469a0ab9ee20563f37ff3d44b",
+    "licenses/dependencies/windows-strings-0.1.0/license-mit": "c2cfccb812fe482101a8f04597dfc5a9991a6b2748266c47ac91b6a5aae15383",
+    "licenses/dependencies/windows-sys-0.52.0/license-apache-2.0": "c16f8dcf1a368b83be78d826ea23de4079fe1b4469a0ab9ee20563f37ff3d44b",
+    "licenses/dependencies/windows-sys-0.52.0/license-mit": "c2cfccb812fe482101a8f04597dfc5a9991a6b2748266c47ac91b6a5aae15383",
+    "licenses/dependencies/windows-sys-0.59.0/license-apache-2.0": "c16f8dcf1a368b83be78d826ea23de4079fe1b4469a0ab9ee20563f37ff3d44b",
+    "licenses/dependencies/windows-sys-0.59.0/license-mit": "c2cfccb812fe482101a8f04597dfc5a9991a6b2748266c47ac91b6a5aae15383",
+    "licenses/dependencies/windows-sys-0.61.2/license-apache-2.0": "c16f8dcf1a368b83be78d826ea23de4079fe1b4469a0ab9ee20563f37ff3d44b",
+    "licenses/dependencies/windows-sys-0.61.2/license-mit": "c2cfccb812fe482101a8f04597dfc5a9991a6b2748266c47ac91b6a5aae15383",
+    "licenses/dependencies/windows-targets-0.52.6/license-apache-2.0": "c16f8dcf1a368b83be78d826ea23de4079fe1b4469a0ab9ee20563f37ff3d44b",
+    "licenses/dependencies/windows-targets-0.52.6/license-mit": "c2cfccb812fe482101a8f04597dfc5a9991a6b2748266c47ac91b6a5aae15383",
+    "licenses/dependencies/windows-0.58.0/license-apache-2.0": "c16f8dcf1a368b83be78d826ea23de4079fe1b4469a0ab9ee20563f37ff3d44b",
+    "licenses/dependencies/windows-0.58.0/license-mit": "c2cfccb812fe482101a8f04597dfc5a9991a6b2748266c47ac91b6a5aae15383",
+    "licenses/dependencies/winit-0.30.13/LICENSE": "6dc0e068dcf3a5bc8e054205b85b7720e1d49265bbc64bf515d2cf79197df69a",
+    "licenses/dependencies/writeable-0.6.4/LICENSE": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2",
+    "licenses/dependencies/xml-rs-0.8.29/LICENSE": "0dc18d924dc0a5f41172a393012843a5eaaef338e795b3645da9cc3b6068220b",
+    "licenses/dependencies/yazi-0.2.1/LICENSE-APACHE": "7cfd738c53d61c79f07e348f622bf7707c9084237054d37fbe07788a75f5881c",
+    "licenses/dependencies/yazi-0.2.1/LICENSE-MIT": "df62e3ef3f207c91073fedd78b4156a278681d0dd3f942379242c62c6a71a3ec",
+    "licenses/dependencies/yoke-derive-0.8.2/LICENSE": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2",
+    "licenses/dependencies/yoke-0.8.3/LICENSE": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2",
+    "licenses/dependencies/zeno-0.3.3/LICENSE-APACHE": "7cfd738c53d61c79f07e348f622bf7707c9084237054d37fbe07788a75f5881c",
+    "licenses/dependencies/zeno-0.3.3/LICENSE-MIT": "34dff8202d63e6df022f4f0ce88dab24f254c35ee0d5958b74dcf74d9eae21cc",
+    "licenses/dependencies/zerocopy-derive-0.8.56/LICENSE-APACHE": "9d185ac6703c4b0453974c0d85e9eee43e6941009296bb1f5eb0b54e2329e9f3",
+    "licenses/dependencies/zerocopy-derive-0.8.56/LICENSE-BSD": "83c1763356e822adde0a2cae748d938a73fdc263849ccff6b27776dff213bd32",
+    "licenses/dependencies/zerocopy-derive-0.8.56/LICENSE-MIT": "1a2f5c12ddc934d58956aa5dbdd3255fe55fd957633ab7d0d39e4f0daa73f7df",
+    "licenses/dependencies/zerocopy-0.8.56/LICENSE-APACHE": "9d185ac6703c4b0453974c0d85e9eee43e6941009296bb1f5eb0b54e2329e9f3",
+    "licenses/dependencies/zerocopy-0.8.56/LICENSE-BSD": "83c1763356e822adde0a2cae748d938a73fdc263849ccff6b27776dff213bd32",
+    "licenses/dependencies/zerocopy-0.8.56/LICENSE-MIT": "1a2f5c12ddc934d58956aa5dbdd3255fe55fd957633ab7d0d39e4f0daa73f7df",
+    "licenses/dependencies/zerofrom-derive-0.1.7/LICENSE": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2",
+    "licenses/dependencies/zerofrom-0.1.8/LICENSE": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2",
+    "licenses/dependencies/zeroize-1.9.0/LICENSE-APACHE": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30",
+    "licenses/dependencies/zeroize-1.9.0/LICENSE-MIT": "8c7516d4b27b1e495be5e38b612298b63de48d05f49cdac94f70f3cd70f8864b",
+    "licenses/dependencies/zerotrie-0.2.5/LICENSE": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2",
+    "licenses/dependencies/zerovec-derive-0.11.6/LICENSE": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2",
+    "licenses/dependencies/zerovec-0.11.8/LICENSE": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2",
+    "licenses/dependencies/zmij-1.0.23/LICENSE-MIT": "23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3",
+    "licenses/rust/COPYRIGHT.html": "5b0c93fc4e6d4b072eaa521b1762d1e746f4c368f65e81a0e5308e2772dac85e",
+    "licenses/rust/COPYRIGHT-library.html": "68129500b616d5838629e68f55ff3aed5e096dacf60ce9eb41bbe599a563afa6",
+    "licenses/rust/COPYING3": "8ceb4b9ee5adedde47b31e975c1d90c73ad27b6b165a1dcd80c7c545eb65b903",
+    "licenses/rust/COPYING.RUNTIME": "28e85c5aa4af9b4f1dfe6b4817aa3eefb3eaaee7fd735045016f29ccf50276a1",
+    "licenses/llvm-libunwind/llvm-ea7d852a70e8-libunwind-LICENSE.TXT": "b5efebcaca80879234098e52d1725e6d9eb8fb96a19fce625d39184b705f7b6d"
+  }
+}

harness/experiments/navigation-prerelease-20260911/producer/README.md

@@ -0,0 +1,33 @@
+# Repaired navigation prerelease retry — not executed
+
+Codex-9e8r6t /root/release_audit. Root owns execution, independent acceptance and publication of reserved `v0.2.0-preview.navigation.20260911` (#6/comment493). This is a separate adapter set; the earlier `.local/navigation-prerelease-20260911` and its review remain unchanged historical evidence. No clone, metadata, package, application or compiler was run to prepare this set. Only static AST/PowerShell parsing, source/receipt reads and private adapter writes were performed. The historical `.local/navigation-repair-prerelease-20260911/adapt.py` records the initial text adaptation; subsequent narrow review corrections are in the final scripts. This retry contains no generator. Do not rerun the historical generator over either frozen set.
+
+## Exact scope and provenance
+
+The immutable code commit is `33c6d83e9ba9a5b1310b1b627d7c40affcbcf15c`. The 500 raw build inputs are `.local/text-repair-save-20260911/inputs1.json` (SHA256 `75a282fd3d4cb2dec6763046ea45d0caa015b998281fbdd6f222d8e3a175b13f`) and its ZIP `213fdb39ea7c3601b4baac674c3ab3ecc863ac44db1b092d922d3e24f26887b7`. Gates were actually captured on eeeaa126 with the repair delta; 33c6d83 commits those exact code bytes. The adapter proves normalized Git equivalence and raw-file identity; it never relabels the original gate HEAD as 33c6d83.
+
+The actual five successful command receipts and their hash-bound logs plus complete.json are required. Full suite must report 755 passed, 0 failed, 1 ignored, no filtering. Preserved gui-repair.exe must match actual gui-build-result.json: SHA256 `b183ef31f16b3986538b3f2aba8435eab45978635c47f99ca01be6e72b168848`, 113,206,272 bytes. Old GUI5478 is not accepted. Native-v4 is separately root-owned and pending here; no native pass is inferred from these gates or an application launch.
+
+EFEE server remains the historical September 7 artifact (`efeeb89c0d2e0f93df4472cb3e9f48b2b722a37ae1043c90a5a56f2e845fe665`); runtime remains F456 (`f45604a12e8bcd839fd86f667c1be1cc7c4f9da2b3c69ff381ac708f0e1ae7d4`). The server's original tar, build/hash records and source/notice inventory are copied separately. Current core language.rs differs and language_outline_tests.rs is added. The server is not rebuilt and must never be described as a current-source server. Historical registry checksums must still be locked; readback additionally requires historical package features, license/font notice identities and actual notice bytes in the ZIP. An unexpected difference refuses and requires review rather than a blanket licensing fallback.
+
+## Future explicitly authorized sequence
+
+From repository cwd, use bundled Python `C:/Users/User/.cache/codex-runtimes/codex-primary-runtime/dependencies/python/python.exe`:
+
+1. `python .local/nav-repair-retry-20260911/prepare.py`
+2. With root's metadata lease: `pwsh -NoProfile -File .local/nav-repair-retry-20260911/package2.ps1`
+3. `python .local/nav-repair-retry-20260911/readback.py`
+
+Replace `python` with the absolute bundled executable. These are instructions, not executed results. Preparation exclusively creates source/, source-roundtrip/, bin/, evidence/ and receipts. It uses a separate local clone and branch `codex/navigation-repair-prerelease-source-20260911`; no root index/refs mutation. All 500 paths and bytes must match current working inputs and the designated Git tree. Newline-only restorations are measured afresh, scoped -text rules applied only in the clone, committed locally and checked byte-for-byte in a fresh checkout. No former 11/15-path count is assumed. Original evidence is copied byte-exact; no executable is compiled.
+
+Root may have later **record-only** commits: the designated source must be an ancestor and every changed path must be under harness/ excluding harness/fixtures/. Those paths and the actual root HEAD are recorded separately, never substituted into binary provenance. Any later source, docs, dependency, script or instruction change refuses. Tracked WIP also refuses. Root HEAD/index/status must remain unchanged throughout preparation. Later record files are not silently included in the clone based at 33c6d83.
+
+Packaging retains existing strict scripts, explicit x86_64-pc-windows-gnullvm and one exact locked/offline Cargo metadata invocation. It never builds or downloads. PS7 avoids the prior PS5 native stderr failure. Refusal-to-overwrite remains; a failed attempt preserves partial outputs and needs a fresh reviewed retry directory. Readback derives actual ZIP hash/counts and verifies every stage/checksum/source/evidence/binary entry. It is producer integrity evidence only, not independent package/server/native acceptance.
+
+Do not execute old adapters, publish a source branch/tag/release, or treat VALIDATION.pending.md as final acceptance. No WSL operations are included. All output actions await root's explicit execution after native acceptance; final package GUI/server checks remain root/reviewer-owned.
+
+## Preserved initial failure and narrow retry
+
+The previous preparation at .local/navigation-repair-prerelease-20260911 failed checkout-index at 21:03:40 UTC. Its result, reconstructed source 613c480a and partial fresh checkout remain untouched. Seven of 2,174 tracked paths are missing: every missing absolute path is 260–266 characters; every present path is at most 259. This strongly supports a Windows MAX_PATH boundary, but original stderr was not retained, so the diagnostic cause is not proven. See failure-audit.json.
+
+This fresh, shorter directory retries the complete isolated preparation. Only operational changes: checkout-index uses command-local git -c core.longpaths=true (no global/local settings mutation), and all failed Git calls retain raw stdout/stderr plus command/cwd/exit/hash receipts. Source 33c/B183/500 inputs, measured restorations, full frozen-input Git/working/fresh-checkout hash equality and root index/ref guards are unchanged. It does not reuse partial source outputs. No retry has been executed.

harness/experiments/navigation-prerelease-20260911/producer/VALIDATION.pending.md

@@ -0,0 +1,9 @@
+# Pending repaired navigation Windows milestone
+
+Draft only. Planned version: 0.2.0-preview.navigation.20260911. No ZIP or packaged acceptance exists from these adapters.
+
+GUI: 33c6d83 committed equivalent of the 500 raw repair inputs, ZIP213fdb39; actual B183 preserved GUI. Recorded headless gates: 755 passed, 0 failed, 1 ignored; strict all-target Clippy, scoped format, diff check and GUI build succeeded. Original build captured eeeaa126 plus the repair delta; exact receipts retain that distinction.
+
+Server: retained historical EFEE September 7 binary with its own source snapshot/build/notices. It is not built from 33c6d83. Runtime F456 unchanged. Current metadata collection is not retroactive server build provenance.
+
+Pending: root's repaired native recovery/save acceptance; actual package creation/readback; independent historical/current notice coverage and packaged server restart/model oracle; packaged GUI launch/save/package-integrity acceptance; final source/tag/asset publication and byte readback. Earlier native5478 passed navigation checks but exposed false-clean Apply status; those passes do not close the repaired candidate's native gate. Root owns replacing this draft with actual results.

harness/experiments/navigation-prerelease-20260911/producer/adapter-manifest.json

@@ -0,0 +1,35 @@
+{
+  "scope": "Static adapter retry preparation only; no retry executed",
+  "files": [
+    {
+      "path": "prepare.py",
+      "bytes": 20450,
+      "sha256": "403844baf739a524c23b8e3f5c3d989979f4292f2e6d8e380fdde119e121698e"
+    },
+    {
+      "path": "package2.ps1",
+      "bytes": 5189,
+      "sha256": "1bd9c4b47d03f7479dfb627e8ef845a6f5770782a1cfa58e44b0e9b28b45ac64"
+    },
+    {
+      "path": "readback.py",
+      "bytes": 6307,
+      "sha256": "81bad82aed8522d5377fb671b71f4bd7ba329206beb9e96c4cd11f3a8fb343cf"
+    },
+    {
+      "path": "README.md",
+      "bytes": 6014,
+      "sha256": "f85504003b2d45c7d0bc2c2a1530166f67446864167d064723a956ebcf0e0beb"
+    },
+    {
+      "path": "VALIDATION.pending.md",
+      "bytes": 1219,
+      "sha256": "694a2274ed5c71c3707a90698f7c3254ef4d86233b4bac2d3730b24b970bce1d"
+    },
+    {
+      "path": "failure-audit.json",
+      "bytes": 2038,
+      "sha256": "76115333ee62b5a13bef5f3bf009c34b3cb01d83a193e3802bc326679ee9a07a"
+    }
+  ]
+}

harness/experiments/navigation-prerelease-20260911/producer/build-evidence.json

@@ -0,0 +1,29 @@
+{
+  "source_identity": "GUI exact-byte reconstruction 802855f7e6f2f00a107a12196b458b267f586b8d from 33c6d83e9ba9a5b1310b1b627d7c40affcbcf15c; 500 frozen GUI gate inputs plus separately verified shared build resources. This is not the original build commit. EFEE server retains its separate September 7 source snapshot; its old language.rs differs from current GUI core. No current-source server claim.",
+  "profile": "Prebuilt Windows development GUI, actual full desktop result {'passed': 755, 'failed': 0, 'ignored': 1, 'measured': 0, 'filtered': 0}. Retained EFEE server is the historical development artifact, not rebuilt. Native/package acceptance remains pending.",
+  "compiler": "Original GUI Cargo artifact/profile and server build records retained separately; package collector records current compiler/sysroot facts. No reproducible build or new server build claimed.",
+  "target": "x86_64-pc-windows-gnullvm",
+  "binary_sha256": {
+    "arcadia-studio.exe": "b183ef31f16b3986538b3f2aba8435eab45978635c47f99ca01be6e72b168848",
+    "arcadia-server.exe": "efeeb89c0d2e0f93df4472cb3e9f48b2b722a37ae1043c90a5a56f2e845fe665"
+  },
+  "provenance_reference_base": "evidence/ references are external preparation records, not files inside the ZIP.",
+  "per_binary_provenance": {
+    "arcadia-studio.exe": {
+      "build": "evidence/gui-gui-build-result.json",
+      "inputs": "evidence/gui-inputs1.json",
+      "full_gate": "evidence/gui-desktop-tests-result.json",
+      "complete": "evidence/gui-complete.json",
+      "captured_head": "eeeaa1262748800c4c9aaa1eca79a7de96757358",
+      "scope": "Built from captured eeeaa126 plus exact repair input delta; those bytes are committed at base_commit, then reconstructed without changing code."
+    },
+    "arcadia-server.exe": {
+      "build": "evidence/server-original-gates.json",
+      "hashes": "evidence/server-original-binary-hashes.json",
+      "source_tar": "evidence/server-source-snapshot.tar.gz",
+      "source_inventory": "evidence/server-prior-input-comparisons.json",
+      "notices": "evidence/prior-dependency-notices.json",
+      "scope": "Unchanged historical EFEE; separate source, not rebuilt from navigation source."
+    }
+  }
+}

harness/experiments/navigation-prerelease-20260911/producer/committed-roundtrip.json

@@ -0,0 +1,511 @@
+{
+  "base_commit": "33c6d83e9ba9a5b1310b1b627d7c40affcbcf15c",
+  "reconstruction_commit": "802855f7e6f2f00a107a12196b458b267f586b8d",
+  "checks": {
+    "Cargo.lock": "2b960242c33eb839ff008d01731f6d5cdb4e047ca8cd6e13151cbf9c09913510",
+    "Cargo.toml": "369f5b4b2b60705a94623c8c0b68f8e0b048f263280ce07ae0629ad353797d62",
+    "crates/oa-cli/Cargo.toml": "49c567f1af74a826683b4d96845feb3806fd9bcb7dc2767e16b5509d4e5e1cde",
+    "crates/oa-cli/src/lib.rs": "97bebab63b4a611a1d36ad0c20fe452cbe1985fe3a6fbd39c954603da11410fc",
+    "crates/oa-cli/src/main.rs": "de964f9b6c59c0f31c080afbd3b31d442b07b1b44f6a187a248d3409c45d35fb",
+    "crates/oa-cli/tests/source_cli.rs": "a3a1b856c7a9fd3d80bc8074150a24fbb0ef0e9ddf736c7cea036725fc3dc2b8",
+    "crates/oa-core/Cargo.toml": "64824ec447be777841a972bf06c894ef2624a37e4725583bcfe0389deb9f00a3",
+    "crates/oa-core/build.rs": "ab1be6ae1fd8bf3ebaeef6348347a9d5e666bde693126f199e041659e0b094a9",
+    "crates/oa-core/examples/generate_demo.rs": "e26f432c95331aeca50985dbb3ad2c558affd43023b585811f0f7bfaa59f6661",
+    "crates/oa-core/examples/generate_release1.rs": "1d5f11165d74893e4bc18dbf3a2f2111f4026bd89fd06ee7f0bae69e45c4d4b5",
+    "crates/oa-core/examples/release_dense_views.rs": "a83158488ef9b7394f136c52b1496719be935c4e5bdfe457cab5c9894f5f9412",
+    "crates/oa-core/examples/routing_workshop.rs": "571307b18b6d4fa04700c5a4d4b0c2154c419e93a21292b2028e7b6f46a2faa7",
+    "crates/oa-core/src/data.rs": "7f9c7c7dd8353cb5a38597b92cde6d3e890203d392473187eb387d41ff37414a",
+    "crates/oa-core/src/demo.rs": "ad62123f96c20ff023cafc1a9849b0fa06bc62edd1fb9701799e4599b458600c",
+    "crates/oa-core/src/language.rs": "34cbb144a111e6f0ddadfca7d40636a8e3323fe65ea8920fd2402f0352b41f57",
+    "crates/oa-core/src/language/semantic_source.rs": "584b5bb59d87a7b8d44d5dd2d124c3a1323b21492b138a17bc9526c0087c9e29",
+    "crates/oa-core/src/language_nesting_tests.rs": "bd061611e8cb6f28ab203c73e544ac98bf275eb464cd314ad5fbd25f773df33b",
+    "crates/oa-core/src/language_outline_tests.rs": "4c79a01e8aea243dd9ef66ce71b9fae263d0e79c319a46c51223679897e8b9df",
+    "crates/oa-core/src/lib.rs": "52cb6ee7a4ffc00711ecf121c1a1b14ca154863f7ca27b0d2a8e239edce8aca7",
+    "crates/oa-core/src/migration_v2/README.md": "fb61d3faa33d7bdfba73415415a0882c0fbd3e0b45df42f972a19aec6da927b9",
+    "crates/oa-core/src/migration_v2/adapter.rs": "66741b4c8354a23b8a932ecc5bf1bc3bb6e74279558757b8c35bc2157a7e51b5",
+    "crates/oa-core/src/migration_v2/mod.rs": "857d8bb13b6814daba6780ca770c16352943c01cb130245d055f11b3b957b3e9",
+    "crates/oa-core/src/migration_v2/model.rs": "8ac63eb59b2e57bdecff2477ee0634096090924d3dd1851e1c454880a889dacb",
+    "crates/oa-core/src/migration_v2/references.rs": "33a6819abc83139fdaebeebd1b553238a328637106cce7dd5a535f1791d43e20",
+    "crates/oa-core/src/migration_v2/source.rs": "74fee9b24e7c912182c998ab9d9aeec125e2009c3214959229e844c67afe2bf6",
+    "crates/oa-core/src/migration_v2/state_validation.rs": "e29ef071bab0a68460ddf55c46131c6f66c022d52c3c602c37c013c3649da1b0",
+    "crates/oa-core/src/migration_v2/transitions.rs": "f74174c532ba56b57c80b719a11fb4adea0a78ccc2828fff72fe2b9eda5a10b1",
+    "crates/oa-core/src/migration_v2/validation.rs": "6d5e4a4e2805ae5045bf789a0485e14a61c63346587bace2b4a91173a688f780",
+    "crates/oa-core/src/migration_v3/README.md": "3755a63f840d7f0eadf68afa7a9d587877a9468ff982d3610539e8a0bb067a82",
+    "crates/oa-core/src/migration_v3/mod.rs": "f4edb6a0b50ecfe8670973776d703047b064420cb1f05913129c00fc656b3722",
+    "crates/oa-core/src/migration_v4.rs": "50c652964f0f309e7f3f54b6ef12c40d42fcecc0490f005995c713df1179af70",
+    "crates/oa-core/src/model.rs": "4585c895c64c4a183941c92cf047a9e52ff0cbe41971e16e78d229ea9dc101fb",
+    "crates/oa-core/src/operations.rs": "a5ffbbf54cd440316a106d1188bfb699b57dae59f466edcb33618c333cd19f41",
+    "crates/oa-core/src/persistence.rs": "1c01474f906a63e552c0d590b272c95821c00a100b3e79e58e67dbbeac341a14",
+    "crates/oa-core/src/ports.rs": "5cac12eea70a54ebebbd6be77b63ce92e3195325c4bc7d27705c518686cbac80",
+    "crates/oa-core/src/projection.rs": "69ed12bace2cc5024e151752a174ab14034ac2d05eb741fcf13e9a27521c059b",
+    "crates/oa-core/src/projection/port_layout.rs": "a08d17d10a58bb8b206dd001b19b91d5aa3a9f743b298a4da57d503223c20079",
+    "crates/oa-core/src/projection/state.rs": "73a607bac713ec7ff49a509fefb1a53c7686dca93ee241ffc835564d743afb28",
+    "crates/oa-core/src/references.rs": "93553c234f32da35f1f41a7b83ad81c471c9803efa78ca222cf7de3c2f86c0bb",
+    "crates/oa-core/src/routing.rs": "c5ebb350ba76f731f5c48d968bfbba4b6ef68ec046eb5893d116c4637ef15080",
+    "crates/oa-core/src/semantic.rs": "f9895dd5b8fb27d10d4cfbb41c3542ef2018365a589b8d5778e5674ae5a1f239",
+    "crates/oa-core/src/semantic/catalog.rs": "1ff74fcca18084d178681d7ff38ee1ccac632c27c4de0595ba1ceab8067ab3a4",
+    "crates/oa-core/src/semantic/historical.rs": "eaf3284bf234312698514cdb636bc8348e1b5d746cb16b18df777e77d312abfb",
+    "crates/oa-core/src/semantic/linked.rs": "6f335b14e809aecfc35defcaf77cb821b080d1506dbc46297912b25af98c07a2",
+    "crates/oa-core/src/semantic/mutate.rs": "dc2b4c4a6eb156fe468eaa8c85fd37a505c0cd8ea1f226cb69cd01689afd3d9d",
+    "crates/oa-core/src/semantic/review.rs": "0c157d2c327e72e89cca3b423e71ee73798105c5bb7271439c1a101642c91e3e",
+    "crates/oa-core/src/semantic/types.rs": "6922fe35089f12fad43ab0ce1c6886d01a3855f90b8e2543e99802ac5e6f1bbb",
+    "crates/oa-core/src/session.rs": "1eb77b329b2986fc6f5dc0171e77fd860375cdfd8c769a1367b445d6c49ebe00",
+    "crates/oa-core/src/source_files.rs": "669491dbddb8e8e6556161426dffa1a49ac1c826d31020bff0956d81a4d84683",
+    "crates/oa-core/src/source_project.rs": "1394370bcc5908873b830c2c11312e6e1611af41f46c4f43ca0a6bcb713bb466",
+    "crates/oa-core/src/source_project/source_migration.rs": "add463ae85c420f853d324b00a221f0f874164cc3f3ed6bbb07557a9ed7a8c95",
+    "crates/oa-core/src/source_project/source_structure.rs": "9f1f83315856a7025fe662c0fbb13452f31613224a03663150d6225d1ddc162f",
+    "crates/oa-core/src/state_validation.rs": "e28d7f74385e2a78763716b34491bd73a00bfeccc085970ceb130627e3faee18",
+    "crates/oa-core/src/topology_context.rs": "16de69b297de95d93c73808621607833b713af811dd082f0169186ae1e5c3e2d",
+    "crates/oa-core/src/topology_context/analysis.rs": "dead6194f0aa60cc46045c0e5ee10dbdbb689158c38634dfbbbc45d2ba88ac65",
+    "crates/oa-core/src/topology_context/analysis_tests.rs": "17839263410815e96fe027d4eba3aae0a9ab3b82b16947e2b29ebe0d09782b56",
+    "crates/oa-core/src/transitions.rs": "fadd1b07b89cae4117b91abb4f1ac9ea81ff818ef20f2175e76ee8cf21fb708d",
+    "crates/oa-core/src/transitions/communication.rs": "2b476630a88edd9021b9156ca12a5402e01604095f0d4002afb452671903a028",
+    "crates/oa-core/src/validation.rs": "7c1b4ae5e4ebba13e99af9158ccde138dfc5e9a7afb580e76fba72d0b64ba74e",
+    "crates/oa-core/src/validation/coverage.rs": "b08e4b344ecad055714168c83beff7fe29ba4edc53edbffa2eae04e5580a4d5f",
+    "crates/oa-core/src/view_options.rs": "421ede0a04c593ca1df0e6e0d06fabcfcc8113cdbcfb0adc7f5c8ef4d1724208",
+    "crates/oa-core/src/view_options_tests.rs": "64aac44de2df42a1012239a3dd75c473daf0c8990b3170b7bf7e78a556080208",
+    "crates/oa-core/tests/communication_boundary_scenarios.rs": "e1100b8f363910a487d90c73acc7df543dc6d532158c3c63ad11cd3d40d8e12b",
+    "crates/oa-core/tests/communication_means.rs": "a25f2749180bc6f4beb1445bfad3351eedf0669131a7439b633ab804439e95a4",
+    "crates/oa-core/tests/coverage_diagnostics.rs": "e2e9c3996daab47f2bd23f5d8c48b4e372af33331152f5fc85b76f06d04fcdf4",
+    "crates/oa-core/tests/fixtures/v2-coastal-rescue.arcadia": "f0df129c1914bfc01d0b047b0cd4b520d8cf0c249ea9ced085de400c0be87ff3",
+    "crates/oa-core/tests/fixtures/v2-coastal-rescue.json": "3ed53508eb544bbd788832f7bebea2ec31b3d66191f24f45098cc9750ec4c005",
+    "crates/oa-core/tests/fixtures/v3-data-contract.arcadia": "305f19d1b79f99f8d4cf627ba2e9ca6836bb7959cc0070227815937a699eafea",
+    "crates/oa-core/tests/fixtures/v3-data-contract.json": "1b41299c53204e6232397d25a58d5bccdbbc16e770c75e8edb55ce36ccfe58a2",
+    "crates/oa-core/tests/fixtures/v4-reviewed-prose.arcadia": "5fa53a26a5ad010c8e59eb56d9b2b52003569e66c0377ffb58840590168ad0c1",
+    "crates/oa-core/tests/fixtures/v4-reviewed-prose.json": "2808088afcc165f4bd6da5129151143411c997041c3de61d600ab76e05d24a47",
+    "crates/oa-core/tests/language.rs": "77f6cb2a69976bfb5f60b243b71c07fb0edc7505002c1e9e73fcd6ddf6d9496e",
+    "crates/oa-core/tests/port_anchors.rs": "efbc0fa18733b1aaac501f9785a4c392fc49c05c45a5778d26e9b5dd951ca6fa",
+    "crates/oa-core/tests/port_migration.rs": "1801c376a5435ac7efb2a8342348b2c7ffef930bba65deca4acb66b06e0483d7",
+    "crates/oa-core/tests/port_source.rs": "8d2ddaca4045d330f6eda2591561497b858aad53769a823249d0bea4f5916e12",
+    "crates/oa-core/tests/prepared_commands.rs": "52cab1c668064777412df0a6a3c20d74d579b33794b4b00525b9f151c06eac9b",
+    "crates/oa-core/tests/process_diagnostics.rs": "1dbbc590239ef7542be4a2bdc9543aaa64d108417b03dd312a0894e364745906",
+    "crates/oa-core/tests/r3_constructor_ack.rs": "e5c44676ea0aab97f2e091ddac2f4bc4a4a90f5877f7bbf08b61229600944dd0",
+    "crates/oa-core/tests/r3_migration.rs": "ebd04120f5215b3956fdc79ee78f6e38734c7d13392f1fc28aaba957912265bd",
+    "crates/oa-core/tests/r3_semantic.rs": "49c3763eaf2131070a7c46cc23a84f917d292d41610b6404510e5607f8890c32",
+    "crates/oa-core/tests/r3_source.rs": "f31f60659df3c7ef601650d1cff140589d8729f01a3f65a4a6a6c2272f15c408",
+    "crates/oa-core/tests/r6_data.rs": "5f7ffb3bc73c3c85423623fe56f8680646dc97040327bdbead9d47a37e80f155",
+    "crates/oa-core/tests/r6_migration.rs": "81519bc1512f5e069432e9a1cdad04c10216d492df01b4b75b02102480ebd6a1",
+    "crates/oa-core/tests/r6_source.rs": "88a0aa087a7678e2898ff6057538072ca92072190712f05fff08372cc56ebed6",
+    "crates/oa-core/tests/release1_teaching.rs": "be179290d871125dc97cfd2a3067c7ac89c8a538fdb0afafc5b825bcdfb2bef2",
+    "crates/oa-core/tests/release_capabilities.rs": "b92cba2a562e78287ddd7dc3e94557848d17faa0c8a102601b50286b9af48a30",
+    "crates/oa-core/tests/release_diagrams.rs": "cefcc0582d91266d5de6ee5daefcfe41b606ab971ab235b59034a8e1dbc24b7d",
+    "crates/oa-core/tests/release_language_limits.rs": "8578da4f76bbd2d0e1bfe295ab1259e2162a3fe3d0d2ba8901915d7a40942806",
+    "crates/oa-core/tests/release_ports.rs": "506e62beab0c7ec0cece83e9e0c1a810fa1f99285c9e1cab0c77f06de55a40e1",
+    "crates/oa-core/tests/release_routing.rs": "ae168faaba23769b7ca1fd65f217b9db671726e67276eb5a04e5e72b1447a462",
+    "crates/oa-core/tests/release_scenarios.rs": "0f5d876badeec653fc7b12610a77d867e9a53582e605253deff8d379da21572f",
+    "crates/oa-core/tests/release_states.rs": "b1a26acee95eaba7f9920f9da738a1e33606552eb078e6d298895daff7e3d811",
+    "crates/oa-core/tests/release_topology.rs": "c51dbe5aa5a038f9ed830daa02aa67714472179eb7fd6da5ce36dc6931c8b3a9",
+    "crates/oa-core/tests/review_regressions.rs": "f154e5c88d35e31512e2b07733a1327ea3e2fcfd1ef8eb23066a4e9573f387c1",
+    "crates/oa-core/tests/route_source.rs": "1a73fdbac0d0ae0e84d8d67b6ad398e11223958f5dca007f73757c91827decfb",
+    "crates/oa-core/tests/routing_geometry.rs": "2d8eea4a2bba535ed0ea6daabccdaf87b375828c404baa10518c7bd7fd6253d3",
+    "crates/oa-core/tests/routing_labels.rs": "dff884d799c3c5c9257210248c55767e294e3cb317c605cbd0ddc9600c216eb6",
+    "crates/oa-core/tests/semantic_artifact_absence_oracle.rs": "d93eaf9667f4221232168bef0fe9f069e5be1b1f23410bda5dd67010b96e5c8a",
+    "crates/oa-core/tests/semantic_attachments_gui_oracle.rs": "7f526d363ba05e7ac89faf0fead0796e419c34ee204edf44a1b46c78308b0970",
+    "crates/oa-core/tests/source6_view_contract.rs": "fa566de53946d40bbbd9033edfeed177180c4dc44afa2f2f4667ffdc622eb3bb",
+    "crates/oa-core/tests/source7_contract.rs": "cad4f1a135ddbd947bdf3c71d1b44f1e438725095ea8c4d893464bc721c2363f",
+    "crates/oa-core/tests/source_files.rs": "f0429a0b89a443458ea9af7083c1e4e7411417a7e6b47e618bfbb9266dc164f9",
+    "crates/oa-core/tests/source_identity_updates.rs": "f52aa38b4d317e532c641ad7463472e4b40e802e60052cf0017556ffc63da06c",
+    "crates/oa-core/tests/source_nested_updates.rs": "9ac3390936c0d250651ea94a1b8faf0adfb680f061ececc56f2a52909b5ba855",
+    "crates/oa-core/tests/source_project.rs": "cef58adb16aa4d2527ddc0628aec3e26f0b42b4be70014a7e360fafdac13a942",
+    "crates/oa-core/tests/state_diagrams.rs": "6b02b387a3ae559cb3ad72de24292a5abcb76aaac0adbab5d2aa5211b22cd2e5",
+    "crates/oa-core/tests/workflows.rs": "bd843dfddbd5724ec08f657571f887496203056fe2fa5864ef50a168a613b89b",
+    "crates/oa-desktop/Cargo.toml": "f3547b2b924d5db6706c0a8e069014b440ff65315d82fc8aced0360af4b3cdc9",
+    "crates/oa-desktop/build.rs": "ab1be6ae1fd8bf3ebaeef6348347a9d5e666bde693126f199e041659e0b094a9",
+    "crates/oa-desktop/src/app.rs": "4a41b062da233a72f1b04866898eeddb3f79882918a67f5f09469fe4eadd9929",
+    "crates/oa-desktop/src/app/architecture_authoring.rs": "37c7db33e99dd4adcc5a51f09ee4878af94fd32413359890a541690080885f65",
+    "crates/oa-desktop/src/app/architecture_authoring/palette.rs": "8f9937cb30b48b83759fd084a8a5990a2daa3920280f1210abe048560241985a",
+    "crates/oa-desktop/src/app/architecture_authoring/tests.rs": "ed864839940a1910c97537b6ee151b57ab115ece6f60bae602552b84f9af4a5d",
+    "crates/oa-desktop/src/app/architecture_authoring_tests.rs": "77eb1a0038d038b989f7ac568760e16fe23c4b8d73cd9fbe32b70817ea23cfec",
+    "crates/oa-desktop/src/app/behavior_lifecycle_tests.rs": "1af2e290aa259a6af6b0585950cda93fe3a562c7b8be1e938fe1d80747b11808",
+    "crates/oa-desktop/src/app/checkpoints.rs": "55e5babdcabef767af3bc8be9cc3153b3f5cc0695701b890820ec0225643852e",
+    "crates/oa-desktop/src/app/diagram_selection_tests.rs": "4fa507adbc23db3a6eb202d809c695ec0ebd6181356930c4fa7528a9a0c7be57",
+    "crates/oa-desktop/src/app/hosted.rs": "14e2fcd79558ff56d000571f1f576e5601818d702783634aa4017000d382c62a",
+    "crates/oa-desktop/src/app/hosted/tests.rs": "fa118f64d04b400ccc01e4e67adaf3541975288882afa265a9e7f092cdbda232",
+    "crates/oa-desktop/src/app/process_canvas.rs": "11e991afbce187ae633e01214b2509a13623c940f1f5e6416aaee204158bc5a4",
+    "crates/oa-desktop/src/app/repair_save_state_tests.rs": "5543dcba853bb1513acf824b860249729a6004747e7e320b46efe60ea19e2d83",
+    "crates/oa-desktop/src/app/review_navigation_tests.rs": "5ebba36092cc89fcba394578e69c9507ad5a369e9a26526761716b5d4ee3ad75",
+    "crates/oa-desktop/src/app/save_as_tests.rs": "f8b915793f1a36fd152569c4781a4bdc17f4af404a8ceb373330053413087a1c",
+    "crates/oa-desktop/src/app/source_symbols.rs": "99370865b548b28f32f4c6ce7e9f8eeaa0c80268a644f2ebcc4bd1e11695e59c",
+    "crates/oa-desktop/src/app/source_symbols/tests.rs": "33292a7ce9b61dbc134f74372caa93af9704e2f968cd698da13ea6a1b8cf3ea6",
+    "crates/oa-desktop/src/app/state_diagram.rs": "f7fd50cc9a86adb794713958348af63afc7c698f74965e13188b7b8a9e735c55",
+    "crates/oa-desktop/src/app/state_diagram_tests.rs": "612e414b1a2cab12cbfd8fce23745559ff27577700694d53af67ad1f2883ee2c",
+    "crates/oa-desktop/src/app/transition_context_tests.rs": "47002fb025f3a2f8c53871f9509bfe8611a61db6fb0e1b3125eb6e875425cb1d",
+    "crates/oa-desktop/src/app/view_copy_tests.rs": "296821c51dcde568e7d717039aa26bfc1b56a9074aa16051007bb351b33a4d44",
+    "crates/oa-desktop/src/behavior.rs": "c9e0aea6a24cc982d0d82ee2b9b66f250cdfac037b36bf6b1b9d7dd38246cd3c",
+    "crates/oa-desktop/src/behavior/contextual_source_tests.rs": "5f05318a6533503b9d6febf1ec4dd7256f192394bc1b952a7904c8175bd8ddae",
+    "crates/oa-desktop/src/behavior/creation.rs": "0fb19be3a5688c4bd3ca3643c47a97da7e7f85add8a860cd046a0d9cb3ce9dfc",
+    "crates/oa-desktop/src/behavior/creation/app_tests.rs": "e9c5bf2b07357b7a2f679ae0d8f6904c1c1461aaeb94fa0db478b54d4641ae3e",
+    "crates/oa-desktop/src/behavior/creation/tests.rs": "a0d1daf9fb3920f7e6181a9802d84fbe056cbf0043b9e41dba5fdda687d9818a",
+    "crates/oa-desktop/src/behavior/scenario.rs": "d12a4b1caa61c08f69c4d2a64bd15568c4b7158dea91aac5a52a58a35adb863c",
+    "crates/oa-desktop/src/behavior/scenario/workspace.rs": "69c7ad32e4bdc39f42d2e6c7764cfe1fa7867cd7dbcf9b904dec805e6c912666",
+    "crates/oa-desktop/src/behavior/scenario/workspace/tests.rs": "abfc7caefb0de5bd479eb4af1b159ca77b68e6a157f477939628c3d5c90b44b6",
+    "crates/oa-desktop/src/behavior/scenario_operation_tests.rs": "89fb71c690e07eac314f7a5e05862d5c1e2f9c21039673bf22c4ac894d21c977",
+    "crates/oa-desktop/src/behavior/source_draft.rs": "85d543cc288e48b4c13001e4e386b5b54d9b1e349a5ac31e4e307572f2d8fb3c",
+    "crates/oa-desktop/src/behavior/state_canvas.rs": "2e2ad57b86f4cc1cc0c4c4c230571ef19bcc2f052001a8bdcc44925e5103077a",
+    "crates/oa-desktop/src/behavior/state_edit.rs": "cb2289e727163626152fc2f11195c6ee824851cb9442c57496da97fe7aebfb7c",
+    "crates/oa-desktop/src/behavior/state_menu.rs": "cc87c5caa177e114e4d9a7f7367e37ec2b0d1e1c16b0b99709b05ea0e59cf894",
+    "crates/oa-desktop/src/behavior/state_view.rs": "1eb892a9139ecb0671784c879ee5114f27e598e5b3589f5cdad0abffd5909f24",
+    "crates/oa-desktop/src/behavior/states.rs": "8986ed9492960e20f1254e9dfe3ff91d79ce9fef66f3bda738f9933278043954",
+    "crates/oa-desktop/src/behavior/topology.rs": "d06b2f0fc39b4814e94200297e148f1d4d97e04cb167766030ac9df18689e3b0",
+    "crates/oa-desktop/src/behavior/topology/contextual.rs": "edc84fc69d8d4a8f4ce81a4452c4e2e35cfaf98addeed10235f392506c74e8b0",
+    "crates/oa-desktop/src/behavior/topology/contextual_routing.rs": "d914b0e82aa8d253fe64be2ef74443d1fd2e6cec26d1cf30620a57646e1d426c",
+    "crates/oa-desktop/src/behavior/topology/direct.rs": "413aa2009ee4cba0941836b43e41f16a04c8fc8568b6e92db5bb08516e95c287",
+    "crates/oa-desktop/src/behavior/topology/direct_tests.rs": "ac8c8023117e31723084adb06e3ca7fd4ea3f95ad229622ccc759fa19b50c27e",
+    "crates/oa-desktop/src/behavior/topology/layout_tests.rs": "4529ac8b05de769a2ada112473146fbfa27b0467d97d3541b86c4446b6050b83",
+    "crates/oa-desktop/src/behavior/topology/view.rs": "a7d806cd621bdf857c4e4861685cd3eb556b320de3985b9cc3d9d131dad370dc",
+    "crates/oa-desktop/src/connection_edit.rs": "020581e077f82b43c936b623cc51733b02b88428df4e5f25df74b9705819fa37",
+    "crates/oa-desktop/src/connection_tool.rs": "649da93677d52dae495b0e19bc32f3122ab05a6d84de8402578ff5ce3f6ee1d3",
+    "crates/oa-desktop/src/context_menu.rs": "629354b34dc232763700251f2695b4d4e53d6251c0b1432ecc0dfe424f7dfeac",
+    "crates/oa-desktop/src/data_values.rs": "e1deb1cad551f0a9fdef9653aad257cfb36e6d9c0f93b6245061ec3fab8fd365",
+    "crates/oa-desktop/src/data_view.rs": "158b852be5d3db450aa5cda8b68a35bd96bddce1d8d053a7a23582095c06362d",
+    "crates/oa-desktop/src/diagram.rs": "4580b170e264d14e5cfa874709f6d2e076a05155bfbe1809336a9d05f75e98ef",
+    "crates/oa-desktop/src/diagram/lifecycle_tests.rs": "d0e72cc0574657d5a31c3ce307b58401d0ed77eedccd1aa02377f55ab0bc03f0",
+    "crates/oa-desktop/src/diagram/pointer_tests.rs": "10ca5049034159205ac8f22805354f308b0ba0596f331568c26cd1393bc8cedc",
+    "crates/oa-desktop/src/diagram/port_hit_tests.rs": "d2d0647629bf725b4dddfc211f5a27d495ed093a79af87cdae6c196f09a97b93",
+    "crates/oa-desktop/src/diagram/port_labels.rs": "28782983b82e4fca5dd4410ac8bd562359943b7010c7b24ecc42f0c7ad7fb63e",
+    "crates/oa-desktop/src/diagram/view_options_tests.rs": "cf0c98a7715558baf17b59f67a80556f98ad30262b4434635e617c6601775433",
+    "crates/oa-desktop/src/document.rs": "7c87280b5b8d112c34865253f8ba0f80d43bc9897771943b15dc7b5608eb17a4",
+    "crates/oa-desktop/src/document_save_as_tests.rs": "83dc243a25f4e97674ff0d86c794a490cc923e98f1f9fb05bb038f622f11e20b",
+    "crates/oa-desktop/src/explorer.rs": "fa01c59219564ba9ae5553abc2b6f94e9849f9148d5812ef99b40318fe5dcf9a",
+    "crates/oa-desktop/src/explorer_view.rs": "a720d7484bcc3a24729332a00e005d1cc6f5f945a9cc3965134e0024dffb581f",
+    "crates/oa-desktop/src/forms.rs": "e5c0805b93daf0e8244d4be32e5a0dd3a1856c281a9d9fb5f98497dcc43c4da2",
+    "crates/oa-desktop/src/forms/context_fields.rs": "eaacd474f6500dd344d5a8b63ccb1d1dd86fe2aea78ab708afa8a80d62ce69bf",
+    "crates/oa-desktop/src/forms/data_fields.rs": "f56397886d74086d69783f18fab961e13b0af05a8bb0d10d0dfa187cdad05f5c",
+    "crates/oa-desktop/src/forms/history_fields.rs": "e7100474cde18bdfe95562bcb3c055f29b4b15aa64788a578194464aebcd046e",
+    "crates/oa-desktop/src/forms/history_fields/tests.rs": "16d3c308138c063f45986d53c621ad83c7dc2ce853edd31b7204e2939a382df9",
+    "crates/oa-desktop/src/forms/port_fields.rs": "3fe684d651d5be6203fd9db3979c772913e1af5ac1514e67be386ffd88dc8127",
+    "crates/oa-desktop/src/forms/view_fields.rs": "5184d438f0dfd4e29f284ff048e19da73e71be1f24a6e9f123c7e922aecb85fa",
+    "crates/oa-desktop/src/guide.rs": "64c782afebecad5489d3bf06b41f3273904222c18e3244990f2749c991c92b55",
+    "crates/oa-desktop/src/highlight.rs": "da7c254fff7052e5fd9ec7469f473b91a819406028d7c304f6e22c4169561600",
+    "crates/oa-desktop/src/home.rs": "f03c1071334894f586a5a7c86026602a694db3c2faf902822e1dbe5156a859c2",
+    "crates/oa-desktop/src/home/tests.rs": "3b03ccfc97dfb75954e1e0ed568bb87a632295c07b96cedc05ed381f87b378f3",
+    "crates/oa-desktop/src/hosted/client.rs": "54b24b4b50f8d87d7c92946ea5a2cff4c98760e70555b3ce3d90be27115e95d4",
+    "crates/oa-desktop/src/hosted/client_tests.rs": "3ef70907ca75e098d631c41b90badd4cff1e1eb1b3c78e15a9f811c13ba8ffbe",
+    "crates/oa-desktop/src/hosted/mod.rs": "1b75e11c80fcb38fd20bb3487e3f88729fdac73e471c5ae64da28c249f77c63b",
+    "crates/oa-desktop/src/hosted/view.rs": "fc0c7b7ce3a5f05c49713df6661067751f81e810af11c614ca265ea9490e6463",
+    "crates/oa-desktop/src/main.rs": "cb0a919fd0df0924591283da5b55d64d525d8461640441509350be840235e51a",
+    "crates/oa-desktop/src/model_menu.rs": "12994a5433a91f8295a59d4bf40f35f1edb8d8dbb497a11eae8760299627f1d4",
+    "crates/oa-desktop/src/navigation.rs": "71355a12e1b4791106426d83fe5ebf0b29bce8e1dc594f0655ab85695469669e",
+    "crates/oa-desktop/src/port_edit.rs": "70b99f577c4fdeda8780c8dc1ee7b1639fd77aaca06658f06d725139fb3efb6d",
+    "crates/oa-desktop/src/port_preview.rs": "069487c4ece737d52e8ae4a84dcfb132236aca6799e841c91c8e7244320cf871",
+    "crates/oa-desktop/src/port_workflow.rs": "ccc15f97c3272145a67bb5857b4faeaf7437561bd61912fa27ab26e8824146a0",
+    "crates/oa-desktop/src/recovery.rs": "57e22e5fbb0e994e64ae03e69450271fe9f04a951db1670c2a018abe99db4489",
+    "crates/oa-desktop/src/recovery/fixtures/README.md": "a90002df1e087d2dac7be26926864243568a0de7c4103e4927435b34178e8016",
+    "crates/oa-desktop/src/recovery/fixtures/profiles.json": "2c12ae96b50e6da5d60ce2b7fa00204be71dfbe2fd51311fc337a0de6a4332ff",
+    "crates/oa-desktop/src/recovery/fixtures/source5-bundle.json": "12715995e6f7f35414aea53b3ad720b9b31873ffdeaf4444231db1a5ac3c463e",
+    "crates/oa-desktop/src/recovery/fixtures/source5-model.json": "5535a706df9ec21715e8b6a5aa6dbd79636ae461450aee61305559016167612b",
+    "crates/oa-desktop/src/recovery/fixtures/source6-bundle.json": "ea88890a33f47d67dfb06d6dbbcc179058cf28dad76ae7d615c00aaf30dbbbfe",
+    "crates/oa-desktop/src/recovery/fixtures/source6-model.json": "5bb8db0b6394276666323483f977ac3586f88554c81a148c6d508fca0ef4576f",
+    "crates/oa-desktop/src/recovery/source5.rs": "0f0a763f0c98c2c908d4c2b95d8a4c042b6a255ee1cc16260e5404669691f642",
+    "crates/oa-desktop/src/recovery/source5_tests.rs": "cfd17a742f1f27b523fce7cd9309f0a07a30413395f6c58659fb91d02834a7a3",
+    "crates/oa-desktop/src/recovery/source7_tests.rs": "7ee61de66c75bf949489ba51ddc9677e2b4efc68801cf27909c9b894bfdc9288",
+    "crates/oa-desktop/src/route_edit.rs": "457ae59c2761a43a8620b4d336a7cf0f54b965997110ecaf968756a88b6b0374",
+    "crates/oa-desktop/src/semantic_review.rs": "916192003637b60c12f6b3b3663a5b9c770ae4d10d51a415f6b3e4035e30fe13",
+    "crates/oa-desktop/src/semantic_review/artifacts.rs": "a79236a8150597ff808597e59cf4f1e9e61c74c4901d9c8cf42d3427bb52a9a8",
+    "crates/oa-desktop/src/semantic_review/artifacts_recovery_falsifier_tests.rs": "3f255d04e4bffa5a467b75e3cbf6f7149aa3269a02f2a89fbaa1db0e5df9ae62",
+    "crates/oa-desktop/src/semantic_review/artifacts_tests.rs": "04d0dd2ac453705185663f705282aa4a3a31433466a5be305764248da1a03c32",
+    "crates/oa-desktop/src/semantic_review/artifacts_view.rs": "e8ce3d844d6230c20fe2fda4d0fb256af8043f9b586160a8d110665c45a79561",
+    "crates/oa-desktop/src/semantic_review/attachments.rs": "de0ec0c740895b160ff5b847332c087c3f1a48931583464069470cc61315ed59",
+    "crates/oa-desktop/src/semantic_review/attachments_tests.rs": "8b26be0324e0f33b1e7cf7af340350df8ed98963002d6da8589ee0e6f6900bea",
+    "crates/oa-desktop/src/semantic_review/attachments_view.rs": "cd8c4418b43d207fcc55a82a2364cd84053643e5c09c96de008c94b8372653fa",
+    "crates/oa-desktop/src/semantic_review/batch.rs": "44830e1a9fa572493d423545336f76e79fa24ef29900e4f7927cbc83f9071d17",
+    "crates/oa-desktop/src/semantic_review/batch_tests.rs": "2a8131b81322e6a49b1348c6efec4526a3df53c8eefc0a2b25c746e2b7c6ead8",
+    "crates/oa-desktop/src/semantic_review/compose.rs": "c6adcc9882dde65e9f04f6eda7f0c855c5cbb285cf421123029169112793ce9b",
+    "crates/oa-desktop/src/semantic_review/compose_diagnostic_tests.rs": "440daf8d43278ef981c620d1818d0daaed8fb83193b8e8ff67b2e42fbf882938",
+    "crates/oa-desktop/src/semantic_review/constructor_tests.rs": "85149521ad7df62918f6f2fab6da2b3346c342ab4bce7100de3f6206c1e81096",
+    "crates/oa-desktop/src/semantic_review/constructors.rs": "0982163439b06a42d9af1643530364109282e63f05b323a35a76d8241f3caa32",
+    "crates/oa-desktop/src/semantic_review/history.rs": "df038c2464eab8093a983f3104f0d04ca8f602010a50e1d3eeb8e53f2309e201",
+    "crates/oa-desktop/src/semantic_review/keyed.rs": "f8db8578ecff84526bda96c233b50e56f1cf1c5b8ab04cbbaa04f9b5e78300f0",
+    "crates/oa-desktop/src/semantic_review/keyed_rows.rs": "af9b137fe56ff3a71378e9998bfbb7b68f035bd542aa6fa90b83e04796cf4b38",
+    "crates/oa-desktop/src/semantic_review/keyed_rows_tests.rs": "1a3b09e7ed100411cdf8043f9a78defc664a873ee0201117709185c201a5c57f",
+    "crates/oa-desktop/src/semantic_review/keyed_tests.rs": "112a2d50130407a4a1069827e4e5d5a8681e672dd3e54b559c6d3dde4302a298",
+    "crates/oa-desktop/src/semantic_review/message_kind.rs": "4ed19952ea511d1b3226564a138e3322f994371d6b49794c14bc3689d1393e7f",
+    "crates/oa-desktop/src/semantic_review/message_kind_tests.rs": "5fcf9930e949aebeb12eab0327264f32a2388d62dbf098bd2365711e22623c52",
+    "crates/oa-desktop/src/semantic_review/ordered.rs": "8b809e8b0958e553896829b655684084bf2f0ca7df9d40c6acbdad8749cd6342",
+    "crates/oa-desktop/src/semantic_review/ordered_tests.rs": "5c8ea3a69e3da3b94d13f50f12aa7dc53246ccba25ffcace9552a0eb76b0bf36",
+    "crates/oa-desktop/src/semantic_review/recovery.rs": "88e69044d90c481593bab7cc125f0401c05202fccdde07698cec9483947fe8be",
+    "crates/oa-desktop/src/semantic_review/row.rs": "ecde54540071fde82d8d580d0da2fccd16d6b8e0144bd5e129afe91455f73bb1",
+    "crates/oa-desktop/src/semantic_review/scalar.rs": "9ad202174934dd9a63fbf9cba43135aead571db60846c8b7b1d3019a11df26c2",
+    "crates/oa-desktop/src/semantic_review/source7_tests.rs": "5e8221d77b068fa30c1571988448cb8829711735881d810f3d333cbc95d34a9f",
+    "crates/oa-desktop/src/semantic_review/tests.rs": "8839e241cf81d1e66abe072728eee1870b42341fbbefae9f39bda1b1a020f4ba",
+    "crates/oa-desktop/src/semantic_review/view.rs": "c391814442cd5e95040c6dab9d511a254181de56c68d5c266d879870001561ad",
+    "crates/oa-desktop/src/semantic_review/view_reserved_artifact_tests.rs": "6c766b29c8664d15cb113d2cc71bba9b60ae4ccf7e44c9c5d3c41e1dc4b7ed90",
+    "crates/oa-desktop/src/source_navigation.rs": "3f7007bc3b3ef6266e92ea4121cfbdb32df2e97713797b403ce6649070a90517",
+    "crates/oa-desktop/src/source_navigation/controller.rs": "4ec54ce769f047d6e5c1de6bdbe81648ad63c75cfd04aea5356bd5663126d77c",
+    "crates/oa-desktop/src/source_navigation/interaction.rs": "c6efa6105b8ba46655e27a89b9fa59e6fc01a4c6f331f886e035af1e70cbf8a9",
+    "crates/oa-desktop/src/source_navigation/interaction/tests.rs": "6cf5c5944b9c46c275c9039f7166b627fa9176187b39348152f67040c92c95e1",
+    "crates/oa-desktop/src/source_navigation/query.rs": "aa8e8e9d446b57c30520c4b3ca1ae9fe524cecb2f4f4f4b229d930ea0377ecca",
+    "crates/oa-desktop/src/source_navigation/query_tests.rs": "a4ecc95a49d0a9325cbf1548cf95a8d367f758f8eb1f44346a2b71ef046f6668",
+    "crates/oa-desktop/src/source_navigation/symbols.rs": "d6c9325223fb3f18e887a63187b67aa59735d4e51f501c9e27ebb870944912ec",
+    "crates/oa-desktop/src/source_tree.rs": "4d55e0110a1eb128a5d26c28f3aae5853d79b7245812b7c82bd275f38440a5aa",
+    "crates/oa-desktop/src/source_workspace.rs": "388c71f63829c0c76526a1700ebf5f240c86c467a65aae4fca4cd6c6a88c468b",
+    "crates/oa-desktop/src/style.rs": "05d61bec16141612ccafa0988e8c4827f41754509efdb3b961eab69127ded896",
+    "crates/oa-desktop/src/tests.rs": "94e340b8ef7f9a3bb71fd2a2098dbb9c3d2bb3adba25b5949430b714e36fdfe1",
+    "crates/oa-desktop/src/view_copy.rs": "5630f31c942e1226aafd67eabdace6a5c5494875bdc6f7f077019e8110ba41a9",
+    "crates/oa-desktop/src/views.rs": "e5ed7640fbd2653983c418b88fd2e3612b91f8f02fa2f50f1b5dfd31aab773b2",
+    "crates/oa-desktop/src/views/source_symbols.rs": "9cd536072e110803b6a592bcbcd595b6f9eb32fc1d0b4c9de741247c459abbe5",
+    "crates/oa-desktop/src/views/traceability.rs": "4c89dcf35c25e737d8cce4d543a5989ca104a5678e6cf40df47e457773d2ef94",
+    "crates/oa-desktop/src/workflow.rs": "a00ba19d6d23435d18c9e1f6a0ad2065f889bcfa97aa3840bcdfaa03cb2666aa",
+    "crates/oa-desktop/src/workflow/communication.rs": "34d121ad97706012722e4bb6210072ecc3a5b4718b0ceab0c3d0f14d4cd780a1",
+    "crates/oa-desktop/src/workflow/recovery.rs": "0849b0f34dba5e8761be5fa05784d134ac74e4e9db395d6b9b7d6cff71e3f3dc",
+    "crates/oa-desktop/src/workflow/transition_tests.rs": "589b1b2dbadca74a52c2cfcfd4fe620bd4790abd113ac02182e91616c52d793c",
+    "crates/oa-server/Cargo.toml": "527ff5e15010a8b560a6659aa1ae4bf0c8df0d9e019f03c47529ec6a750c0982",
+    "crates/oa-server/build.rs": "ab1be6ae1fd8bf3ebaeef6348347a9d5e666bde693126f199e041659e0b094a9",
+    "crates/oa-server/src/error.rs": "93817f1502386e4662c96ee1c7d1c4afc4e33bda6fd64e46c86c8e1afd5a9368",
+    "crates/oa-server/src/lib.rs": "20bef350350ed6339588b23af684abf745f97916c7edf3853ee042abe687e664",
+    "crates/oa-server/src/main.rs": "d59a6a2b5c7034bd2e00a516d2d49abb16391bf0316c1c357ddafb9c82d2d1e3",
+    "crates/oa-server/src/preparation_http_tests.rs": "454b90d0055d35644c8d990cd7576ddf675a9b271ca07fe9b0efce25d8ddbc07",
+    "crates/oa-server/src/routes.rs": "3f9a0c22043dbf28f7a8e587d2fc3abf869f76f4d23a46fe0aeb9c4392454a4b",
+    "crates/oa-server/src/store.rs": "37dcfb845b7993d5bced2bcf25fedfcd2a9c20a748f9315afe6cca1f41f89ae5",
+    "crates/oa-server/src/store_preparation_gate.rs": "427c390da3c0281ba1fe115a93ea90800e3b45fce6bcb9185e71982ddd885fec",
+    "crates/oa-server/tests/http.rs": "50daa6a90e96ad6fe3c6a27df2eaebe486270599c203892d09769c547a194975",
+    "crates/oa-server/tests/http/communication_limits.rs": "ba5474dd8e494a0176fffb4548c8e3deb2081b15de33bfce82394c764e0a2c16",
+    "crates/oa-server/tests/http/data_contracts.rs": "8cd456db83f301baca380acf025a5a99db4edf7d8839537dfbd02c4307e10e6b",
+    "crates/oa-server/tests/http/port_anchors.rs": "7199d0a208ddad9e1518b6e3fb390d64da111716d7505ba5c995deae19ad1258",
+    "crates/oa-server/tests/http/semantic_transitions.rs": "856d1c9b633ffb581e3e631f4e5a607789a02181dbf060667f208a569bfa4920",
+    "crates/oa-server/tests/http/source6_views.rs": "867bccda0e030eeeb9976b4ceeb47b21ab5044d700278022d5fb495bbb64ca07",
+    "crates/oa-server/tests/http/source7_contracts.rs": "0e0a467186da7263c0754890aff69ebd0d92d36b5224e4865bb6854b18dab7e8",
+    "crates/oa-server/tests/http/source_projects.rs": "8ff580f317ec267d1cd72ae14d8638f74a77cdf99ca4c78f66f4290c2d77460a",
+    "crates/oa-server/tests/semantic_http_contract.py": "4737ff94f10761f94151a694414c5c62737e0391ec820bca132830652bc4cca2",
+    "crates/oa-server/tests/semantic_schema.py": "70c9d267268bd390680f290a585bd4ae0c6d8ef999ee2f32ece6e172293574f7",
+    "crates/oa-server/tests/state_representation.rs": "6686c826f28248ae4b63ec3f2112e193d4a347724b87974483217fcfee49cd61",
+    "docs/acceptance.md": "32ed3e4fed63f5c464e0937221f401d71623b276dd70f083531ac6ccebbf9050",
+    "docs/api.html": "6f18cfc2a35eba631dbc61d04cd2721e0e361efff1699bf56d2c450a30a17a0d",
+    "docs/api.rst": "7eb258088824efa5ac94311b07b73eb46edcac3c300a2aac78d3802111e338c4",
+    "docs/architecture.md": "a50bd1645222ef3e574fa07a6ab9aa213431ee8833c6c0158ad91ce0f799543c",
+    "docs/language.html": "739a5bb100c7cb0ed70e18afd1e363029757f3cfd6580bc9c5cf77faccb46940",
+    "docs/language.rst": "894a1a77f97d1aa94c11762fe4e84b4d95e181a77c630324c16c307637ed27e1",
+    "docs/linux-packaging.md": "41a1bb1095801df37a1411341c5791d55ea8c365739314d599a60269ac4bc7a0",
+    "docs/openapi.json": "c6ae512f791a939eaf6ec5e5e78e9468bdee0e028092d00098bd90ad9498d967",
+    "docs/research-v2-architecture.md": "1b3809f2dabe6b1805dbf3d3f2625c471cd21356c7bd603916466a8c4ced8090",
+    "docs/research-v2-semantics.md": "b7ec3677300248926a88b84da3e7ffe52f5b73524c7712c927a0e951569db04f",
+    "docs/research-v2-service.md": "4828df5bc679e7c71f49b4b85c9e7dacbec52f46d416fed48af70e08886d4e4e",
+    "docs/research-v2-ui.md": "894e721b59a8ca85f0d95b6706ed5f130a0372def460cf33aeefc9e5e38cde0a",
+    "docs/scope.md": "58b88a7f0b1c8a79edf23c375a141d7b1b821bca4f3212a80e29db5ea3fba796",
+    "docs/server.md": "4eb24937d424ba8b384e1734e02a6f8e963ae11d2715889c92b14b39ff2e4a48",
+    "docs/source-cli.md": "34f12b72cc6d6ead4f47c7818c1897db592f8ad493c70776db2ab48c24d8f051",
+    "docs/v2-interface.md": "c7fbaf0ebd3fc9f6c11f818db2b0b9d68a33f580cfced22bde83ce08ae790bc7",
+    "docs/validation.md": "f46ea950ed1a54409aa07c4f9e90f39f8e2d00c1dd1b6cb805caa3993845967f",
+    "docs/windows-packaging.md": "2c852ff7041713ffbff3c951ac98df647c51fb70b0feba9000f7bfd5bc2703a8",
+    "examples/coastal-rescue.arcadia": "7e183ef9fd8154d3074303f1956cd0d9871c19e3ffc630d333b0bffbd6e30e17",
+    "examples/coastal-rescue.json": "242f0b031229a87af5c4ebe5d651defe59c191a6b7a69dc0a77f7e203411f195",
+    "examples/legacy-v1-coastal-rescue.arcadia": "4dbbbdf8bc7e6cb8e0a81dd678069dae585a9e5187c59bc3665e1fdab3f1a86a",
+    "examples/legacy-v1-coastal-rescue.oa.json": "fd0e9dedfb7adb922dc0575cc2b820d40344d639f1d8052bd70363aa59de9c24",
+    "examples/release1/README.md": "113cfb1cf38a98b51bff60442d86a35d636a3d80ef206bece7d53d0aae67f2d5",
+    "examples/release1/evidence/repair-check.md": "f4db17bdca4ecbb1bf0caef01b2da5f1f7f798ab3152b648ce6dd8696a6a68e5",
+    "examples/release1/expected-diagnostics.json": "3700393d76b940cfc076bf52861bd7b1f43370f8eabce3594531bd0bf1fc851e",
+    "examples/release1/model.json": "ef0ef4006c3e09d5db6e1b621256b3f7d6642f3a7b09cc34607cfbcca830c727",
+    "examples/release1/model.rs": "15f30f6bde655808fe754665c26d560e36f2a9bad340f346b09137d0d05045f5",
+    "examples/release1/oa/activities/activity_oa_restore_work.arcadia": "83e73d0a013d5c3e1a4af0d9139ab0cfa362d25a846671fc2dac59181061a9d4",
+    "examples/release1/oa/behavior/process_oa_assessment_procedure.arcadia": "172c32c044ef4b5bc58a1f4635cc81f48dabb4014479b47dce7b25fedf2dbd0d",
+    "examples/release1/oa/behavior/process_oa_field_procedure.arcadia": "d2552dc5383e2e91cb302a790364e197f663c2edc013a2ab1978789825c9c324",
+    "examples/release1/oa/behavior/process_oa_response.arcadia": "cf86f46fa5c5d70592ef43f1bc1cb4d968efd8add384ba88036bef6b88aa4abc",
+    "examples/release1/oa/behavior/scenario_oa_conversation.arcadia": "b25be524e98a35ebac5e4481b7609c027b32baf9605e8097f807560f94a77ca6",
+    "examples/release1/oa/behavior/scenario_oa_full_scenario.arcadia": "00a1edf2c9707a0eb62ac070c2d02467874f2c9c1f273cc6ddb53d6d65999a1c",
+    "examples/release1/oa/behavior/state_machine_oa_monitor.arcadia": "447c9ad1359f4a31ecf975ad07c0b08d8e7e03191fb0858e2fc56f377b223cd5",
+    "examples/release1/oa/capabilities.arcadia": "fc8012e5554350b12e1cb80080f8feab80d933c9b33c0f2a7bb500cb7d609936",
+    "examples/release1/oa/model.arcadia": "f7cf914766ea73ec53b85e32d117ea9a9dba52d3e038246863541ae7069b1a15",
+    "examples/release1/oa/participants.arcadia": "951764c14179f27c10e315acf2ea37d1fff54c77b8441e23addd239e8c715ce3",
+    "examples/release1/oa/types.arcadia": "9d0396fb82dd5733edd8d1cf52f968ca84906927c704f9cf0944a7fae215cf49",
+    "examples/release1/project.arcadia": "b2674e6bf77cfe0f6f0ba79c81d2e96d92f39c02ca2c6266d80e91723bfb9fda",
+    "examples/release1/sa/behavior/process_sa_assessment_procedure.arcadia": "73928ced61c06cbc08728d7956676a50fd4c05aa5b7f1ff4f29ce27a0b0f2088",
+    "examples/release1/sa/behavior/process_sa_field_procedure.arcadia": "886d462af83110cbfa55dd232a667ea1446761234471357cbb878794e98e8768",
+    "examples/release1/sa/behavior/process_sa_response.arcadia": "041785fc22842423822431bd5e6e8d16094ebd0716965e7c765fb8c1d7549e8a",
+    "examples/release1/sa/behavior/scenario_sa_conversation.arcadia": "97276f5757ee9aa12a0dbd9d3ccd58174b3091162bb8bcce357cec20a45f5d85",
+    "examples/release1/sa/behavior/scenario_sa_full_scenario.arcadia": "e12fc406b99d60a2f7768aaa0b25ba560e8605f0b8e37f3a7cdd3b8443562b74",
+    "examples/release1/sa/behavior/state_machine_sa_monitor.arcadia": "05ce29af99424c491c47fe2450dc6f5f8ce995511c01ec7e17bb5855be3c9736",
+    "examples/release1/sa/capabilities.arcadia": "b6912fb3ece439912345fa71724acd462e716a1e5a88203a1058a5c3b2c20a4f",
+    "examples/release1/sa/functions/function_sa_audit_thresholds.arcadia": "e5a04325d52183956dca814dd90f4e56c96c6b7db0f4f202f203ecb49c3e0f4f",
+    "examples/release1/sa/functions/function_sa_restore_work.arcadia": "fddeb67308051325041fee641fe758ddf43345b7c47b66d433616ad07fdccdd6",
+    "examples/release1/sa/model.arcadia": "d431509251acb859fbb98733b6d18add952495e10a78703fbe8f31e40bc083c4",
+    "examples/release1/sa/participants.arcadia": "780d2eb08b217b67b55febb3d34846f727b8ee9018df6c5741748647e36b2ff8",
+    "examples/release1/sa/types.arcadia": "101fc0fbd99f1101514aa7b6da4f8e535aae0bb94c9e2b9e7e6c151135b28660",
+    "examples/release1/traceability.arcadia": "48a96f543456c9b5a5798fc795594e4119147fe45f11a6f109f141b7f514560f",
+    "examples/release1/transition-before.json": "2253e6434f741687e22327c37d520ed15c043bc36025498650bc2366bb6a874d",
+    "examples/release1/transition-request.json": "43b9a22e5f95ad3bc0ebd2478ead0e14406854abc989ae94ded9367b013d812a",
+    "examples/release1/views/diagram_oa_allocation_view.arcadia": "dfc0eb61e0e2aa5bda45524571fbfa3494f44ce19696f3e15e07438074a07bc7",
+    "examples/release1/views/diagram_sa_allocation_view.arcadia": "b78b43a26a82efb8fbd5374b09c329fa341f57b29f635d397b9ef8aede71d389",
+    "examples/release1/views/diagram_sa_capability_view.arcadia": "75e8dc9fb30f25d6f8fd3c6b595593ab4f98958a25798f961e336e0fac557649",
+    "examples/release1/views/diagram_sa_service_view.arcadia": "b08c84f3ea633e7c78dfdad3272f75415f6256cf3614b6d99bfd4f0269076c9b",
+    "examples/release1/views/diagram_sa_state_view.arcadia": "5f42f4c605e57b817d8400ed21f2b14bfc4e1592aebe941ff113767504c2b869",
+    "examples/routing-workshop.arcadia": "dc6b75da72884d399132ed9e300fa5a26b73d802bb526c9af986ae9eeb0a646a",
+    "examples/routing-workshop.json": "8592714f75b271133f21ce017d87896b6cf91ea0e4837f1c2ed453e21be26b14",
+    "examples/source-project/oa.arcadia": "5f60642f211b2d352a951092faeeb7503d4fb7f6f7fca99e810347231101d31c",
+    "examples/source-project/project.arcadia": "787f6b67b179ffd221f7e5faf1a4edd74cfd116aa1e3b5e9ed9f22fbff612d8d",
+    "examples/source-project/sa/assurance.arcadia": "ab76044836e4dcd42a82d316846ec87da2108939aa2037640c5bca1d2ecdee0f",
+    "examples/source-project/sa/participants.arcadia": "1abad579812e77877b45a3d8e3c3e9da734be2d04a0254cc730a5257ebd2dc88",
+    "examples/source-project/sa/reporting.arcadia": "f0b7443f728912ca163de39b6055876b533a77feaa3219b2d40a2dd65712e058",
+    "examples/source-project/views.arcadia": "e29ad3f406a6a50d2f0ae2ca2a53ee3b0c18222cd4098704a46d4f48b64ea17f",
+    "examples/text-first/README.md": "4ec8250d5ed556f1d496e8c85137e973e802ecb11df1a36488411e8cdc5a9f9e",
+    "examples/text-first/project.arcadia": "f441535c623e0cf20e1875eb2cd33b587ed00e078c37af39cb36d89bb5edc19a",
+    "harness/fixtures/basic-editing/README.md": "3545d9695e7c62e0caa818efd7f4dc426f04876a3626e0f3b1bad606b258cb26",
+    "harness/fixtures/basic-editing/base/expected-baseline.json": "f239e728d650b0af32bb8f3dcaf6b27c99b9c5041132ac14e51756ea6563d978",
+    "harness/fixtures/basic-editing/base/project.arcadia": "045cb047d7bfbca72c3fb30db4c81a30ad463d3af7fc51604906ad7fa75a1ff8",
+    "harness/fixtures/basic-editing/base/rationale.arcadia": "c01867c9dc0d40726853119fac3c6ad24a40d8d362a93a8b9d20df04ec2e273f",
+    "harness/fixtures/basic-editing/manifest.json": "d23c21b02064ddb85e051e10e16ff089daba8d9910bb1a695dfabe2db3757734",
+    "harness/fixtures/behavior-creation/README.md": "9e5fc751424d12cfe76a84abb1da45b2d38947409179451bb90ffe7e7ddc8723",
+    "harness/fixtures/interface-operation-probe/README.md": "088f0bdb3375deb8f2c7e3b749ca8d210ea828ca4dece69b3871b674e3110175",
+    "harness/fixtures/interface-operation-probe/hashes.json": "f6d3e8aa42f40f64ce2ecba7b9cf112eb9091f3cccde3a592b0434e834cf2a6a",
+    "harness/fixtures/interface-operation-probe/output/after-reset-deletion.arcadia": "c0fe9570684c0061efc4cad65e339fede6961b04ca90c6f324c787bd65e61226",
+    "harness/fixtures/interface-operation-probe/output/after-reset-deletion.json": "93187f7a1b476a44185725c6b15f2e1767482b6911ab1280144348d033eb51f0",
+    "harness/fixtures/interface-operation-probe/output/boundary-only.arcadia": "02f85e39957ebe6d56336fa729a5c8b10f51865face9d3b2c9679200571fcfc7",
+    "harness/fixtures/interface-operation-probe/output/boundary-only.json": "756f9710336e6734ce3592ca774c6f104bba5a37c9e165540eb39326682393d1",
+    "harness/fixtures/interface-operation-probe/output/explicit-functional-refinement.arcadia": "ac5b629ba5596464f9f8a975b8bc2764e3007ceb7342de3f828d4b18e4f069b7",
+    "harness/fixtures/interface-operation-probe/output/explicit-functional-refinement.json": "78a47c978dc667aa1c45af711f06aa2a0d3c581003013e30c3e02fb0faae2e64",
+    "harness/fixtures/interface-operation-probe/probe.rs": "72b1b443e25eb20420dec4477b0fb5ef5d1c705e3882c81df88dd578ab96a426",
+    "harness/fixtures/release1-native/README.md": "5f5ba040fd2df9261a29bcab3f9a7ae27c3683265411ad3dda0b467d5df8590e",
+    "harness/fixtures/release1-native/artifacts/README.md": "24200c84ccc2ef3e17c029744074e5cea785188f5549ac54e44cf89682643f81",
+    "harness/fixtures/release1-native/artifacts/generate-semantic-artifacts.rs": "444f360b78df52c5e42046f77b148781e0c9bddc2a09c0b7bd65c7a4f376cfe6",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-create.after.arcadia": "84b22e95c213018612e6e8a84cad68b35a8b495ff3515b0f978c5e7a3d196d79",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-create.after.json": "13a6f99ec2df1dd35ee8b2613f183918cd9537eda4a5da085ad52e65c033db59",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-create.arcadia": "1e0d662ba33071b122ad9206d2d559a8e748c9431eb3ac1b759bde3760ca877c",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-create.json": "fa6a2e3643c0f909b92407abec3edc897033162eeaa501f8d4616f79d41fa044",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-create.manifest.json": "65cb70b0d697a055363ba01bf30bed7e412d43c9978a033549c378d117719ae7",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-create.request.json": "ed905267263e7f8a0cd2dbe833196b30118b6a246815216932fae661ad650699",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-delete.after.arcadia": "e50fc462ec22dbf98011929931dd2489430001c3e6433608685b9d88bceb9acb",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-delete.after.json": "f27a7b38d59c7cefe58cb36783d3d4dd8d8ae1168d9aed1eb61d343c18758908",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-delete.arcadia": "eba2aec39e6efb405eace4bc8ab0c5563907c26d449e71a4aa750df9f73233b4",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-delete.json": "2ef777f19b94f08b5e5ca2ef727777897e1018f1426eee291408b3c69101f596",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-delete.manifest.json": "3af7232ed3056ca84dcaf0f266ead3faaa512a0dc0051c7ba68791c20dbae0cf",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-delete.request.json": "8af21b00b62e620256fbf50e47c6c5836cdb6922d9549cc4b3d86bc03b008073",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-move.after.arcadia": "20bb30473830e44228958e78fb7480269cdcc0580c6c90c718da75f34ca5a43f",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-move.after.json": "44f4b05db49758dcf344788f57cecc0250fd029099b1c54e4e1e3e972f6cf039",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-move.arcadia": "b0fd031671c9f755756922ec5c40a0ce3f40164d22c3c389aec9fd0705344da7",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-move.json": "1acf81e08c51c85aceb14a3efbc39ec680552a19c7824aab4611ac3cf71b9c6d",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-move.manifest.json": "a07978f4b0a3ca83e5ae5f35e7b66b26473b24431fc90e5889d755f1816d52dd",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-move.request.json": "5ff844a038b0030adb5a83d13d81e60f30627543388f6199b6a0e026fc42ea58",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-native.md": "a51ffbc45b6c172cbfed3b16c249296e6a28d457fea57393dd958cdcfbafbca1",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts.hashes.json": "3ad8b7428b3ed7585a91e7f5d9d5f4880caccfd0b08dca25d05af523e62e0a10",
+    "harness/fixtures/release1-native/communication-means/README.md": "015c16010c212af283f9def118c6d263ba65a3bc6e81a750f180624ca69bb311",
+    "harness/fixtures/release1-native/communication-means/cm-create.after-template/entry.arcadia": "a6976e7c21031e7cc3cb731e20c3075cf89cf85144dc8d3f52930f8521ea196f",
+    "harness/fixtures/release1-native/communication-means/cm-create.after-template/expected.json": "60c4419415c546f06c9972ac7bb0e530ada7b30a200b59e75ddda231a24f9a3d",
+    "harness/fixtures/release1-native/communication-means/cm-create.after-template/traceability.arcadia": "3c41459f2b0706a767988738bf8126f76540415bb5940d9c5db19cbe8c18182d",
+    "harness/fixtures/release1-native/communication-means/cm-create.request.json": "b16e673b29c96b5aed681389ff7669110abe552939e86dd0ec6011c9a45ed860",
+    "harness/fixtures/release1-native/communication-means/cm-draw.arcadia": "a511a4d817d9c5c80233bce83e84a7056b7dce7afd9fcc25696e333f8f4df055",
+    "harness/fixtures/release1-native/communication-means/cm-draw.json": "7140114926228b1c378c450535f7a70992c71a879a8d2270c49e8d5f04a2f484",
+    "harness/fixtures/release1-native/communication-means/cm-reuse.after-template/entry.arcadia": "910e6dfe609467047ce629ec9c626f4e927cada74bfbfa164414a8fe6783ea87",
+    "harness/fixtures/release1-native/communication-means/cm-reuse.after-template/expected.json": "567259e20c9f6278776e8fa99b8b2fdbbc9a883ad875c5d39dae1b53de3a2924",
+    "harness/fixtures/release1-native/communication-means/cm-reuse.after-template/traceability.arcadia": "997f72fe9258012df66e88344cf39c1a2cebf2327f604056b67f7f2a8ebcfbfa",
+    "harness/fixtures/release1-native/communication-means/cm-reuse.request.json": "cb3fe05859cfffec6f8846c19983dc462413bc0ea4f6e19204f09c259919c4b1",
+    "harness/fixtures/release1-native/communication-means/cm-reverse-behavior.after-template/cm-reverse-scenario.arcadia": "ec826b9b84616507490ac30e4d57100dd6338dba2f7071e879a8fb58820a85c5",
+    "harness/fixtures/release1-native/communication-means/cm-reverse-behavior.after-template/expected.json": "ef07e4d2d3fc36004ff01739838281581d9a703c747611eacc01bb9cc672489f",
+    "harness/fixtures/release1-native/communication-means/cm-reverse-behavior.after-template/oa/behavior/scenario_oa_cm_200.arcadia": "0ec8d7e38f5a5cd56ccf3979757b3a9f412ad0ae36ee6c2690b7872129046d70",
+    "harness/fixtures/release1-native/communication-means/cm-reverse-behavior.after-template/request.json": "c0ac99ee186d126fe3ec57f2c0a4072984d39d36ad21ead357ab66a08ac0065c",
+    "harness/fixtures/release1-native/communication-means/cm-reverse-behavior.after-template/traceability.arcadia": "dd5d356390089e4ec474374956f6219502733987e60ef8ff32920d8b33dce858",
+    "harness/fixtures/release1-native/communication-means/cm-reverse-scenario.after-template/entry.arcadia": "86dd8a355f6c9dadfea56d06e5247c9b0f820819d7df17ef5690671c7c81324b",
+    "harness/fixtures/release1-native/communication-means/cm-reverse-scenario.after-template/expected.json": "980489ec2c483d4f9efada61358c1f29bafb2572fd5b804c656b91b8e9bb4f9a",
+    "harness/fixtures/release1-native/communication-means/cm-reverse-scenario.after-template/oa/behavior/scenario_oa_cm_200.arcadia": "0ec8d7e38f5a5cd56ccf3979757b3a9f412ad0ae36ee6c2690b7872129046d70",
+    "harness/fixtures/release1-native/communication-means/cm-reverse-scenario.after-template/traceability.arcadia": "dd5d356390089e4ec474374956f6219502733987e60ef8ff32920d8b33dce858",
+    "harness/fixtures/release1-native/communication-means/cm-reverse-scenario.arcadia": "1abc4c4cac37cfb06ed3b12a115f9e7e6a2d3affd34b25c355309e5ee465fa40",
+    "harness/fixtures/release1-native/communication-means/cm-reverse-scenario.json": "a5cf4cb2ef390113dd752f4054d43fb789da2ca77799efb5782805ae8aa2dfd5",
+    "harness/fixtures/release1-native/communication-means/cm-reverse-scenario.request.json": "c0ac99ee186d126fe3ec57f2c0a4072984d39d36ad21ead357ab66a08ac0065c",
+    "harness/fixtures/release1-native/communication-means/cm-transition-ready.arcadia": "b761c4c2af5f7064aaf1f887ffd6094eb6ae834b2c8057ecdbc4aa97c042066b",
+    "harness/fixtures/release1-native/communication-means/cm-transition-ready.json": "2536b000de361fb131787e32b466b9123d4e98abf00c099ad32f6cb8e7fb530b",
+    "harness/fixtures/release1-native/communication-means/generate-communication-means.rs": "003521404b702332082e01f2be7676fda1dd7b5bcf220bb81d25120c8984c75d",
+    "harness/fixtures/release1-native/communication-means/hashes.json": "39b4dc02fc8b074015c59354fd1c1061c25832fde25065c7151f36eb0455e6f6",
+    "harness/fixtures/release1-native/communication-means/manifest.json": "fb921f42f2c4a4f8a67d1266f17f8c7750b6a2619554b713aa92b17918f0c43e",
+    "harness/fixtures/release1-native/dense-40/dense-40-oracle.json": "74edca148583f42c269e51f135662f65ef1c9ea1c94516d63e2a5091967dc99b",
+    "harness/fixtures/release1-native/dense-40/dense-40.arcadia": "00b87736b82c5afd33b311df7aebe9a6c8c51b6de66221181b5ea8bc8ca221a3",
+    "harness/fixtures/release1-native/dense-40/dense-40.json": "5dd4f22453330cab3abc059881660190e689a22619853f77cf6d0b52735d97ad",
+    "harness/fixtures/release1-native/semantic-attachments-native.md": "28906924b05f75bbf432389517aef65f1df474d2f2bff79a3586564f7f7328ef",
+    "harness/fixtures/release1-native/semantic-attachments.after.arcadia": "9d084dd75a0251d349cc31f9ee98df58d0bc76859dc3cb1503f242e2f759888a",
+    "harness/fixtures/release1-native/semantic-attachments.after.json": "f09be41afd85c18fd52fdf997e9b81c4b7cb2c41e78d167abcd14caea8110333",
+    "harness/fixtures/release1-native/semantic-attachments.arcadia": "8740f27be99624013d9be876639c0411e1b8c14f0f9a843f43dc71d769efd79a",
+    "harness/fixtures/release1-native/semantic-attachments.hashes.json": "00fc9e2c709bdcd9ee98012176cb0edb635c112153d963cd169bf4bf69a9e010",
+    "harness/fixtures/release1-native/semantic-attachments.json": "9c188f2890630c7feec2be719a7104af9690da7ea836df18fa78da3ff2acfc1b",
+    "harness/fixtures/release1-native/semantic-attachments.manifest.json": "46b40f221ffad614733b615208814ace63947e96b80bbfdec63853ccd4f4e8c8",
+    "harness/fixtures/release1-native/semantic-attachments.request.json": "b57f656f0b9cf2c595e83150c683301909e20f15684d35d108d3c57ee0dc5909",
+    "harness/fixtures/release1-native/semantic-batch-native.md": "dddca2b85f892b05881c75ef3cd62437396cc086a09909b621e02bad0cbe56ff",
+    "harness/fixtures/release1-native/semantic-batch.after.arcadia": "d3315bba762395205ae761e6e64029e8b4070c15a1299c6114075581db7b0974",
+    "harness/fixtures/release1-native/semantic-batch.after.json": "8f36119c7e893a4af374b13b85b1c2cb3df0196df8d06a551386628fc8b8646d",
+    "harness/fixtures/release1-native/semantic-batch.arcadia": "5e1f433e04621424edac43e53411624059e873f88dd531bfdb39093953485ed7",
+    "harness/fixtures/release1-native/semantic-batch.hashes.json": "1bd87700b04e4f169ab5f8aceaa3b0c3ec3a1cc43e1bce135a1cee506fc75d38",
+    "harness/fixtures/release1-native/semantic-batch.json": "1972242d2a8677d004dc3af1081feb292de65fe26128d877dded8661f9906619",
+    "harness/fixtures/release1-native/semantic-batch.manifest.json": "1e440efa02e2ccc27585d9a49c7864d53e3e3e7645ccb219f040e00d95331b8e",
+    "harness/fixtures/release1-native/semantic-batch.request.json": "71f23474614aab90398ce24f00f2cf61d6cb9a3a34faa3e12e0c8104e0a71073",
+    "harness/fixtures/release1-native/semantic-keyed.after-repair.arcadia": "e3ce0347746584f503b825a8b6bd23a7eebf0827940112ef8f36d500c1d0a043",
+    "harness/fixtures/release1-native/semantic-keyed.after-repair.json": "29736f2a619f7f2d0e795229f6e8c3645a1b4eca6292043cd604aa01b1ec9170",
+    "harness/fixtures/release1-native/semantic-keyed.after-take.arcadia": "9ab573c92be66e3bae659dd826923ba6066979b1651edda7bd469056632cd77e",
+    "harness/fixtures/release1-native/semantic-keyed.after-take.json": "828c990c6129692cd31c7f6ed0dd6c952f9cfffdd90bc80171df82d4d929afba",
+    "harness/fixtures/release1-native/semantic-keyed.arcadia": "49214be2ca9c8bb6195c3b39737c053847021839f70f0bb2921d35a1fbd2ac83",
+    "harness/fixtures/release1-native/semantic-keyed.invalid-request.json": "8b02d4739b1be2c8a64da76423b4a6cae7d89c60f4d30723b94f1da3779cbcca",
+    "harness/fixtures/release1-native/semantic-keyed.invalid.txt": "aa536e18bc65325163e9b645a4ad031ab599fcb05948dcf741b725d0f0c8b602",
+    "harness/fixtures/release1-native/semantic-keyed.json": "995dd72f5c1f07f998233ae9847e337cb82de0c2a9053d3905be021d5f8124b9",
+    "harness/fixtures/release1-native/semantic-keyed.manifest.json": "ad315359bfd68ce0d265976dc9e4ea6a502ebbb87d7339dd1af5ef27dd01e433",
+    "harness/fixtures/release1-native/semantic-keyed.repair-plan.json": "27bf316ad66ffa91f6323e75b0c280baf5caec298645793dea72c5d42aa3b782",
+    "harness/fixtures/release1-native/semantic-keyed.repair-request.json": "f4f6b5480ec8927033ea469ea82c1e8411cb6dba95d2da680f15bc193914c9b4",
+    "harness/fixtures/release1-native/semantic-keyed.steps.md": "7d7e38d93641a5f22a2738baa4dbacc392eebb477a855cdce0641961980a19ad",
+    "harness/fixtures/release1-native/semantic-keyed.take-plan.json": "74dd68ba686b8928054480f0bfed55aad91f6f1208803399dc9878e894f57ecb",
+    "harness/fixtures/release1-native/semantic-keyed.take-request.json": "d19a53002a6bf95af3123a3ef9f78baaf7ce1085d4f06f0f4a9d5e5d5accbc0e",
+    "harness/fixtures/release1-native/semantic-ordered-branch-steps.after-order.arcadia": "90277f1780d43a6f0b2184bf00b87e7a4f3518d67c6f10d4793daafe1aabf493",
+    "harness/fixtures/release1-native/semantic-ordered-branch-steps.after-order.json": "5a3c8494f6976c23b990c14b40760fb2f32ca9973caf6f31dab5632310663591",
+    "harness/fixtures/release1-native/semantic-ordered-branch-steps.ambiguous-request.json": "6a86fde194faa55f2d1bdb982571e0e711e5401b53a960e6acb8cf3e17f506c8",
+    "harness/fixtures/release1-native/semantic-ordered-branch-steps.ambiguous.txt": "0f938b23fcfce776a61a57de5a2c82b4a0720b5e5af6780fdb96f5f92b3edd21",
+    "harness/fixtures/release1-native/semantic-ordered-branch-steps.arcadia": "e7c30c5a5c3ba7209c8e223f02da55821d7af10a2f09844a7065ae6cd8f22aa5",
+    "harness/fixtures/release1-native/semantic-ordered-branch-steps.final-plan.json": "d1e5c2ed08e0aa6274a0421a39876d1ba99f4e441c7a0a68660a83b9e017da14",
+    "harness/fixtures/release1-native/semantic-ordered-branch-steps.final-request.json": "433f723252598994dac7184da61f95344b528156cc5a0fba1a7864b2ec9f002b",
+    "harness/fixtures/release1-native/semantic-ordered-branch-steps.json": "9e4e2ce1c7879935ad0860a3ae720506c929a8422b51491b719d88af3fd3ff2d",
+    "harness/fixtures/release1-native/semantic-ordered-branch-steps.manifest.json": "87e8899c7d4e54faedeef32afb7592fb65278d1bd7390850ab198dcf62068329",
+    "harness/fixtures/release1-native/semantic-ordered-fragment.after-order.arcadia": "6c77ed42bbf9f4ebe08bfa233197a4020e5587ce33747f7914430aa0c662d9a3",
+    "harness/fixtures/release1-native/semantic-ordered-fragment.after-order.json": "1dd7ca2bcfc84ac23369c506302b39569d2ebc41e5a4edc99378a1fe01923b7e",
+    "harness/fixtures/release1-native/semantic-ordered-fragment.ambiguous-request.json": "e0ea7aeb25687ae63c65128f1aab78273f14030d179d3fbea63fe91ab5430136",
+    "harness/fixtures/release1-native/semantic-ordered-fragment.ambiguous.txt": "0f938b23fcfce776a61a57de5a2c82b4a0720b5e5af6780fdb96f5f92b3edd21",
+    "harness/fixtures/release1-native/semantic-ordered-fragment.arcadia": "563c36162050c8564ffa25a85c726462ecdaebdb87659b3f3610506bfd5581e6",
+    "harness/fixtures/release1-native/semantic-ordered-fragment.final-plan.json": "f96c43fc58dbe48a044b628b31bb3f0b59171dad5b6982ec6c34a5597e474130",
+    "harness/fixtures/release1-native/semantic-ordered-fragment.final-request.json": "d38fdb13612b07254edad80848f79c1e097d5f868c020feae9ba072aa697a50d",
+    "harness/fixtures/release1-native/semantic-ordered-fragment.json": "2ed0daed118f2df13dcad738dab174ad34d44a15921cf8097415e707978b0968",
+    "harness/fixtures/release1-native/semantic-ordered-fragment.manifest.json": "c79bd12a85d8d4f25cc3ee43581b3e5e74ae9ad7e4de0c72764975ba2b89c279",
+    "harness/fixtures/release1-native/semantic-ordered-reverse.after-order.arcadia": "98020e048ac01f285c6ad8c10ce22bef05e193b5ba0f5558be1fb26a7bf82620",
+    "harness/fixtures/release1-native/semantic-ordered-reverse.after-order.json": "ea3783992488bc6ee944eb91a26ccf3dbc05a3909528fc32ec8023a76765cee6",
+    "harness/fixtures/release1-native/semantic-ordered-reverse.ambiguous-request.json": "ea3cfd25f7a50481805956fb88ab851516dcd602dd6564502a0cc55f7de6a54f",
+    "harness/fixtures/release1-native/semantic-ordered-reverse.ambiguous.txt": "0f938b23fcfce776a61a57de5a2c82b4a0720b5e5af6780fdb96f5f92b3edd21",
+    "harness/fixtures/release1-native/semantic-ordered-reverse.arcadia": "2b7c3694623bbea3e36dcc6f674d4adcd91e23c8e1005ded21e5a69648a048e5",
+    "harness/fixtures/release1-native/semantic-ordered-reverse.final-plan.json": "95a23bd334cffcaef0c3b1012b7555efd2a077ef6f9140d58020910ef8a76723",
+    "harness/fixtures/release1-native/semantic-ordered-reverse.final-request.json": "1e2433ed5821bf65443f56cb27381ee935db81b1955d3a539b7952898312a410",
+    "harness/fixtures/release1-native/semantic-ordered-reverse.json": "0033f8780c2ba69779b811bca792340c25a092f887e5811c6839f0a691d744f2",
+    "harness/fixtures/release1-native/semantic-ordered-reverse.manifest.json": "e3b4a60a56abee779ca8356605c968aa2d99256a3bd3c5601b14b5c5502a1a05",
+    "harness/fixtures/release1-native/semantic-ordered-scenario.after-order.arcadia": "e265cab35097acc46f5123107c13bc35b9f71931ff650557fc1c85779141b327",
+    "harness/fixtures/release1-native/semantic-ordered-scenario.after-order.json": "9b777828d3681138de6bbd08de8bf922bed92c27be60b103d8ff73ce7ddd0a48",
+    "harness/fixtures/release1-native/semantic-ordered-scenario.ambiguous-request.json": "7d124256730bf2feee772c7d0118b87eb288e8aaa9179d69ceb9259dbceb2c71",
+    "harness/fixtures/release1-native/semantic-ordered-scenario.ambiguous.txt": "0f938b23fcfce776a61a57de5a2c82b4a0720b5e5af6780fdb96f5f92b3edd21",
+    "harness/fixtures/release1-native/semantic-ordered-scenario.arcadia": "87a5a3665dab2dd6e595867dcebb1586e93dd067c85d6e24b1a4d3ff0ad6d4ba",
+    "harness/fixtures/release1-native/semantic-ordered-scenario.final-plan.json": "1888ca51e0923866a9afea99cad069fe5d3f19f0a1b24328e20ac1b9f52d8bad",
+    "harness/fixtures/release1-native/semantic-ordered-scenario.final-request.json": "5070a5b85feb1bc7b1fc648cd5d35ef26663492c8666dcd471950c06ec3a6052",
+    "harness/fixtures/release1-native/semantic-ordered-scenario.json": "725b35e36640c81c70c7efea5c3304bf61b49ef9664194ca0d491782cc62191a",
+    "harness/fixtures/release1-native/semantic-ordered-scenario.manifest.json": "1b43abf8fed3061c65a7b7cb103d31ea7ece333a2da83c645f8d228448c4dbb2",
+    "harness/fixtures/release1-native/semantic-ordered.after-order.arcadia": "65a6217f474b5085f37b511151185c2c08ff7a1998e924f1fe01f29c410f6ced",
+    "harness/fixtures/release1-native/semantic-ordered.after-order.json": "8a53bb9b43eab5b6dca5e08deef20c14c96e134b9ee816a99b7960bb5255e008",
+    "harness/fixtures/release1-native/semantic-ordered.ambiguous-request.json": "c704f99245f00d5c3be0562d91931b4e7f1fb3fb36f41991eb76656ffbd6129f",
+    "harness/fixtures/release1-native/semantic-ordered.ambiguous.txt": "0f938b23fcfce776a61a57de5a2c82b4a0720b5e5af6780fdb96f5f92b3edd21",
+    "harness/fixtures/release1-native/semantic-ordered.arcadia": "c59ec1233d5a9fbb8e386f6d9b13f398be21baf813ba215efb51bfc1bb98db36",
+    "harness/fixtures/release1-native/semantic-ordered.final-plan.json": "30c5c3f614a74708763df612016483623792f4c65e2ed2fa662ac417cfb852eb",
+    "harness/fixtures/release1-native/semantic-ordered.final-request.json": "3b6c35ef78133f0980cb6fb53fbc29c5d3c4deb5dc4be01c2c3384e221987b9b",
+    "harness/fixtures/release1-native/semantic-ordered.json": "c159c60403abcf8fefab7f19cbad9989488e8ccc20b82c57597b22a0ae254802",
+    "harness/fixtures/release1-native/semantic-ordered.manifest.json": "af8a314a9b1d85a8f98affa5a6649f43d252851158798e1ad687bb1b6966b14f",
+    "harness/fixtures/release1-native/semantic-ordered.steps.md": "6004894e9d9f478b7fe1c3c3e0706dcc546d5df8557cff91b4cf26f8a4badf24",
+    "harness/fixtures/release1-native/source5-recovery/15000000-0000-4000-8000-000000000010.json": "71cca2a59f36b2a07d11dedbe9101226aa1a4a00d8ac244b5565202e56709f51",
+    "harness/fixtures/release1-native/source5-recovery/generate.py": "e44986c1d563499f25917441220b23883fc9cb0f89faf409873191f0212fbd2f",
+    "harness/fixtures/release1-native/state-actions.arcadia": "9cde82608110e56aa9e14c9e33eb38976f53aed74ab013145d411d5743a0ec26",
+    "harness/fixtures/rest-coverage/README.md": "df4a391312e0c8b20ccdcc850199443b08547be1b10b1f2447a067bf4bf544e6",
+    "harness/fixtures/rest-coverage/coverage-probe.json": "699b868dd6c955f7ef02f2f061935471f3d21a406005fcdecba8cc719cc69a1f",
+    "harness/fixtures/rest-coverage/run-coverage-probe.ps1": "f24f19fca418b76a7249894a08c116e16b465a02f8f899d12b808ccfdd90a3bd",
+    "harness/fixtures/run-timed-bundle-oracle.ps1": "fab696486a574f9867c6e69a8a8b960e7e9722206441b9cc5f36d41f285f1a25",
+    "harness/fixtures/scenario-authoring/README.md": "6b651b180b76d10b00bc49d77a8f5e0b3ba0317446978f41b541f5bb23fedad8",
+    "harness/fixtures/scenario-authoring/base/expected-baseline.json": "abd8246c939ebb8a2162ef82e23d0fb322ee1a8b4d0d7c28a34037e42e86e841",
+    "harness/fixtures/scenario-authoring/base/project.arcadia": "9b1afbe96b0bf8fa613451b00929492f05a59b9eb2ca74c2c374a8b7bb7cba9e",
+    "harness/fixtures/scenario-authoring/base/rationale.arcadia": "82df210f22f6aa336a3e7e00240977d671c7c3923db7bc58fb29e6d98b67ef49",
+    "harness/fixtures/source7-native/README.md": "7abccbc3da0980d1d099761d1a66d12c403a0f543954134537ecd4930d182b4b",
+    "harness/fixtures/source7-native/base/expected-baseline.json": "e2882a58f841f460f45d9d67db1606440e0d7997b9b29a784569ae48e4b23bfb",
+    "harness/fixtures/source7-native/base/project.arcadia": "5474d8ca05fd1375220dc0ad40d913631fde51159e9632bb9f290d1ecdab8dd7",
+    "harness/fixtures/source7-native/base/rationale.arcadia": "e6a600e13036d4ad594a65380ed1b3d82d1772d583041bb0a624c9588a73047a",
+    "harness/fixtures/source7-native/manifest.json": "6c57164a796234d83818d462d0a25f10e77062d405769e602ae2a7bec251e3b6",
+    "harness/fixtures/staged-source-authoring/README.md": "711910a12d5f3960f32da9aa7bc2e647f31d770c84b7fc26e232dcb3a76f8821",
+    "harness/fixtures/staged-source-authoring/base/notes.arcadia": "ad9de02963c20d1f43856455a797deb05ca674659e45f2c4b96b52783024f8bd",
+    "harness/fixtures/staged-source-authoring/base/project.arcadia": "aa844950ec4fb86f262a257e1fc370a26557ea7978d8a4cab78265037660234c",
+    "LICENSE": "51009f2cb07e5d19645858b2fbc037a672a25f8cbf7999522942b86807ecf365",
+    "build/windows_manifest.rs": "168da2c42ecccfebc11ee3e1b455e653a68fe9c6d30a9842a8b9e7441d086c80",
+    "build/windows.manifest": "9c19c5a02f858ece84c44839ad2b145d9c1d90442da0b15c87fd045f975974eb",
+    "build/windows.rc": "a27385edcae0bcf96f55361056cb7be5f36d76fcddcaefd20647c91959563e1e"
+  },
+  "clean": true
+}

harness/experiments/navigation-prerelease-20260911/producer/evidence-manifest.json

@@ -0,0 +1,140 @@
+[
+  {
+    "source": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\contextual-prerelease-20260911\\evidence\\server-original-gates.json",
+    "destination": "evidence/server-original-gates.json",
+    "sha256": "b7fdfc55ed4c964d276f20f1c57c81c1e924b8da315171089740ab8335ac9f0d",
+    "bytes": 2572
+  },
+  {
+    "source": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\contextual-prerelease-20260911\\evidence\\server-original-binary-hashes.json",
+    "destination": "evidence/server-original-binary-hashes.json",
+    "sha256": "110a03e323133efb48d50ad065d41414599aa85e0ac420e7d622aa04df4d54f8",
+    "bytes": 744
+  },
+  {
+    "source": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\contextual-prerelease-20260911\\evidence\\server-prior-input-comparisons.json",
+    "destination": "evidence/server-prior-input-comparisons.json",
+    "sha256": "3c78dea4e93dae186fd24ab826c6680178a2c7849c270a22deae2ff732f1857b",
+    "bytes": 66465
+  },
+  {
+    "source": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\contextual-prerelease-20260911\\evidence\\prior-dependency-notices.json",
+    "destination": "evidence/prior-dependency-notices.json",
+    "sha256": "98fab15c1a2bb3aa727c6d52d5c69435b15efa56b6668ed717e7a04cf86f9b52",
+    "bytes": 1619590
+  },
+  {
+    "source": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\contextual-prerelease-20260911\\evidence\\server-source-snapshot.tar.gz",
+    "destination": "evidence/server-source-snapshot.tar.gz",
+    "sha256": "cbb371a93a562e1e641d7629fe351e016d63e66fc9112499b3fed6d5cd171f78",
+    "bytes": 2089801
+  },
+  {
+    "source": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\text-repair-save-20260911\\inputs1.json",
+    "destination": "evidence/gui-inputs1.json",
+    "sha256": "75a282fd3d4cb2dec6763046ea45d0caa015b998281fbdd6f222d8e3a175b13f",
+    "bytes": 93531
+  },
+  {
+    "source": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\text-repair-save-20260911\\complete.json",
+    "destination": "evidence/gui-complete.json",
+    "sha256": "20034a0ccfd935fbcac0218ff0f1e370899e5f8a32b6dde35aebb62a7d0b98c8",
+    "bytes": 359
+  },
+  {
+    "source": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\text-repair-save-20260911\\run.py",
+    "destination": "evidence/gui-gate-run.py",
+    "sha256": "ddac72721ff6ce8df37d9b1fff0136f82c5f744d349725fa4eef7aa8c466afcc",
+    "bytes": 4917
+  },
+  {
+    "source": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\text-repair-save-20260911\\desktop-tests-result.json",
+    "destination": "evidence/gui-desktop-tests-result.json",
+    "sha256": "e6873ad9ac0bd3451785608618c7dbc11aceb05858fb4eee21aff472c14ef9c5",
+    "bytes": 531
+  },
+  {
+    "source": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\text-repair-save-20260911\\desktop-tests-stdout.log",
+    "destination": "evidence/gui-desktop-tests-stdout.log",
+    "sha256": "a7e1a1dd98adc5de453ffc6b888c42d90f7f64d33fa7b76f4271faa93344ccd9",
+    "bytes": 85051
+  },
+  {
+    "source": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\text-repair-save-20260911\\desktop-tests-stderr.log",
+    "destination": "evidence/gui-desktop-tests-stderr.log",
+    "sha256": "a0bb3154f9204d12e7ccc7934953af5cca8f4a4b9496a2d3ca3d93ed96d99db5",
+    "bytes": 262
+  },
+  {
+    "source": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\text-repair-save-20260911\\desktop-clippy-result.json",
+    "destination": "evidence/gui-desktop-clippy-result.json",
+    "sha256": "b3ea09aa7097400077f13e809c44e908469c37e844c47b73ef25813c484279b9",
+    "bytes": 521
+  },
+  {
+    "source": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\text-repair-save-20260911\\desktop-clippy-stdout.log",
+    "destination": "evidence/gui-desktop-clippy-stdout.log",
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "bytes": 0
+  },
+  {
+    "source": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\text-repair-save-20260911\\desktop-clippy-stderr.log",
+    "destination": "evidence/gui-desktop-clippy-stderr.log",
+    "sha256": "21b277b6aa7d27f9ecb0692579527a8d798083c24a3cbfeef29bdafd9fe71889",
+    "bytes": 155
+  },
+  {
+    "source": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\text-repair-save-20260911\\scoped-fmt-result.json",
+    "destination": "evidence/gui-scoped-fmt-result.json",
+    "sha256": "9906fb9bde7e0f6a9037ea0b2ccb61f4b9c61c7741c69a52ce995850259ac020",
+    "bytes": 615
+  },
+  {
+    "source": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\text-repair-save-20260911\\scoped-fmt-stdout.log",
+    "destination": "evidence/gui-scoped-fmt-stdout.log",
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "bytes": 0
+  },
+  {
+    "source": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\text-repair-save-20260911\\scoped-fmt-stderr.log",
+    "destination": "evidence/gui-scoped-fmt-stderr.log",
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "bytes": 0
+  },
+  {
+    "source": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\text-repair-save-20260911\\diff-check-result.json",
+    "destination": "evidence/gui-diff-check-result.json",
+    "sha256": "cec5b925f98e43f9c8d29e0ef99b3b0d817f7433f4d5464acda974b8bd516a81",
+    "bytes": 416
+  },
+  {
+    "source": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\text-repair-save-20260911\\diff-check-stdout.log",
+    "destination": "evidence/gui-diff-check-stdout.log",
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "bytes": 0
+  },
+  {
+    "source": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\text-repair-save-20260911\\diff-check-stderr.log",
+    "destination": "evidence/gui-diff-check-stderr.log",
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "bytes": 0
+  },
+  {
+    "source": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\text-repair-save-20260911\\gui-build-result.json",
+    "destination": "evidence/gui-gui-build-result.json",
+    "sha256": "044588599aad6a8b879288050fb2eda204854cf3048c3deef164367eac22bbdf",
+    "bytes": 1883
+  },
+  {
+    "source": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\text-repair-save-20260911\\gui-build-stdout.log",
+    "destination": "evidence/gui-gui-build-stdout.log",
+    "sha256": "4340de1b0c0207d6c898ea105e34451671ad6a92b4414c6f8f6da4e8978268cd",
+    "bytes": 282605
+  },
+  {
+    "source": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\text-repair-save-20260911\\gui-build-stderr.log",
+    "destination": "evidence/gui-gui-build-stderr.log",
+    "sha256": "472f3b59616dd2e571d5fe4751da2e99da0431cdc2de0312507fd4fc303a2b60",
+    "bytes": 155
+  }
+]

harness/experiments/navigation-prerelease-20260911/producer/failure-audit.json

@@ -0,0 +1,38 @@
+{
+  "scope": "Read-only failed-checkout audit; original stderr unavailable; no retry executed",
+  "tracked_paths": 2174,
+  "missing": [
+    {
+      "path": "harness/experiments/contextual-prerelease-20260911/producer/package-metadata/ArcadiaStudio-0.2.0-preview.contextual.20260911-x86_64-pc-windows-gnullvm.zip.sha256",
+      "absolute_chars": 266
+    },
+    {
+      "path": "harness/experiments/text-navigation-native-20260911/corrected-native-v3/engineering-navigation-saved-sources/oa/activities/activity_oa_restore_work.arcadia",
+      "absolute_chars": 260
+    },
+    {
+      "path": "harness/experiments/text-navigation-native-20260911/corrected-native-v3/engineering-navigation-saved-sources/oa/behavior/process_oa_assessment_procedure.arcadia",
+      "absolute_chars": 265
+    },
+    {
+      "path": "harness/experiments/text-navigation-native-20260911/corrected-native-v3/engineering-navigation-saved-sources/oa/behavior/process_oa_field_procedure.arcadia",
+      "absolute_chars": 260
+    },
+    {
+      "path": "harness/experiments/text-navigation-native-20260911/corrected-native-v3/engineering-navigation-saved-sources/sa/behavior/process_sa_assessment_procedure.arcadia",
+      "absolute_chars": 265
+    },
+    {
+      "path": "harness/experiments/text-navigation-native-20260911/corrected-native-v3/engineering-navigation-saved-sources/sa/behavior/process_sa_field_procedure.arcadia",
+      "absolute_chars": 260
+    },
+    {
+      "path": "harness/experiments/text-navigation-native-20260911/corrected-native-v3/engineering-navigation-saved-sources/sa/functions/function_sa_audit_thresholds.arcadia",
+      "absolute_chars": 263
+    }
+  ],
+  "maximum_present_absolute_chars": 259,
+  "failed_result_sha256": "a235d514364f2ec216da25a535579404e00a8bb586802359efbc50c442b994da",
+  "source_reconstruction": "613c480a27426dd25f17b339803f789ac3dbf0ea",
+  "hypothesis": "MAX_PATH strongly supported by exact missing260..266 versus present<=259 split; original Git stderr was not retained"
+}

harness/experiments/navigation-prerelease-20260911/producer/metadata2-result.json

@@ -0,0 +1,17 @@
+{
+  "executable": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\toolchain\\cargo\\bin\\cargo.exe",
+  "arguments": [
+    "metadata",
+    "--locked",
+    "--offline",
+    "--manifest-path",
+    "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\nav-repair-retry-20260911\\source\\Cargo.toml",
+    "--filter-platform",
+    "x86_64-pc-windows-gnullvm",
+    "--format-version",
+    1
+  ],
+  "started": "2026-09-11T21:10:19.0914063Z",
+  "exitCode": 0,
+  "finished": "2026-09-11T21:10:26.0065154Z"
+}

harness/experiments/navigation-prerelease-20260911/producer/package2-result.json

@@ -0,0 +1,12 @@
+{
+  "started": "2026-09-11T21:10:14.7356878Z",
+  "version": "0.2.0-preview.navigation.20260911",
+  "source_commit": "802855f7e6f2f00a107a12196b458b267f586b8d",
+  "native_acceptance": "Pending",
+  "archive": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\nav-repair-retry-20260911\\packages\\ArcadiaStudio-0.2.0-preview.navigation.20260911-x86_64-pc-windows-gnullvm.zip",
+  "archive_sha256": "d7228c542f162663933ea002739a78c722bcca41e437df63b7c868ea2af201f1",
+  "archive_bytes": 32971712,
+  "success": true,
+  "finished": "2026-09-11T21:12:50.8008972Z",
+  "metadata_calls": 1
+}

harness/experiments/navigation-prerelease-20260911/producer/package2.log

@@ -0,0 +1,7 @@
+
+Directory        : C:\Users\User\Documents\Git\ARCADIA-Studio\.local\nav-repair-retry-20260911\packages\ArcadiaStudio-0.2.0-preview.navigation.20260911-x86_64-pc-windows-gnullvm
+Archive          : C:\Users\User\Documents\Git\ARCADIA-Studio\.local\nav-repair-retry-20260911\packages\ArcadiaStudio-0.2.0-preview.navigation.20260911-x86_64-pc-windows-gnullvm.zip
+SHA256           : d7228c542f162663933ea002739a78c722bcca41e437df63b7c868ea2af201f1
+Files            : 559
+NativeAcceptance : Pending
+

harness/experiments/navigation-prerelease-20260911/producer/package2.ps1

@@ -0,0 +1,92 @@
+# Private adapter only. Execute after root authorizes metadata/package work.
+#Requires -Version 7.0
+$ErrorActionPreference = 'Stop'
+$prep = $PSScriptRoot
+$repo = Split-Path -Parent (Split-Path -Parent $prep)
+$source = Join-Path $prep 'source'
+$resultPath = Join-Path $prep 'package2-result.json'
+$logPath = Join-Path $prep 'package2.log'
+$metadataPath = Join-Path $prep 'metadata2-result.json'
+foreach ($path in @($resultPath, $logPath, $metadataPath)) {
+    if (Test-Path -LiteralPath $path) { throw "Refusing existing evidence: $path" }
+}
+$prepared = Get-Content -LiteralPath (Join-Path $prep 'preparation.json') -Raw | ConvertFrom-Json
+$priorResult = Get-Content -LiteralPath (Join-Path $prep 'prepare-result.json') -Raw | ConvertFrom-Json
+if (-not $priorResult.success -or $prepared.base_commit -ne '33c6d83e9ba9a5b1310b1b627d7c40affcbcf15c' -or
+    $prepared.version -ne '0.2.0-preview.navigation.20260911' -or $prepared.target -ne 'x86_64-pc-windows-gnullvm') {
+    throw 'Missing successful designated navigation preparation.'
+}
+$head = (& git -C $source rev-parse HEAD).Trim()
+if ($LASTEXITCODE -ne 0 -or $head -ne $prepared.reconstruction_commit) { throw 'Reconstructed source HEAD changed.' }
+$dirty = & git -C $source status --porcelain
+if ($LASTEXITCODE -ne 0 -or $dirty) { throw 'Reconstructed source is not clean.' }
+foreach ($map in @($prepared.gui_inputs, $prepared.shared_non_cargo_inputs)) {
+    foreach ($property in $map.PSObject.Properties) {
+        if ((Get-FileHash -LiteralPath (Join-Path $source $property.Name)).Hash.ToLowerInvariant() -cne $property.Value) {
+            throw "Frozen source changed: $($property.Name)"
+        }
+    }
+}
+foreach ($item in $prepared.artifacts) {
+    if ((Get-FileHash -LiteralPath (Join-Path $prep $item.destination)).Hash.ToLowerInvariant() -cne $item.sha256) {
+        throw "Frozen binary changed: $($item.destination)"
+    }
+}
+. (Join-Path $repo '.local/toolchain/env.ps1')
+$env:CARGO_BUILD_JOBS = '1'
+$env:CARGO_NET_OFFLINE = 'true'
+# PS7 native stderr is diagnostic output; never reinterpret ordinary Cargo stderr
+# as a PowerShell terminating error. Native exit codes remain explicitly checked.
+$PSNativeCommandUseErrorActionPreference = $false
+$global:arcadiaNavigationMetadata = [pscustomobject]@{
+    Executable = (Get-Command cargo -CommandType Application).Source
+    Calls = 0; Source = $source; ResultPath = $metadataPath
+}
+function cargo {
+    $actual = @($args)
+    $expected = @('metadata', '--locked', '--offline', '--manifest-path',
+        (Join-Path $global:arcadiaNavigationMetadata.Source 'Cargo.toml'),
+        '--filter-platform', 'x86_64-pc-windows-gnullvm', '--format-version', '1')
+    if ($global:arcadiaNavigationMetadata.Calls -ne 0 -or ($actual -join "`n") -cne ($expected -join "`n")) {
+        throw 'Only one exact locked offline metadata call is admitted.'
+    }
+    $global:arcadiaNavigationMetadata.Calls++
+    $receipt = [ordered]@{ executable = $global:arcadiaNavigationMetadata.Executable; arguments = $actual; started = [DateTime]::UtcNow.ToString('o') }
+    try {
+        & $global:arcadiaNavigationMetadata.Executable @actual
+        $receipt.exitCode = $LASTEXITCODE
+    } finally {
+        $receipt.finished = [DateTime]::UtcNow.ToString('o')
+        [IO.File]::WriteAllText($global:arcadiaNavigationMetadata.ResultPath, ($receipt | ConvertTo-Json -Depth 8) + "`n", [Text.UTF8Encoding]::new($false))
+    }
+    $global:LASTEXITCODE = $receipt.exitCode
+    if ($receipt.exitCode -ne 0) { throw "Offline metadata failed: $($receipt.exitCode)" }
+}
+$result = [ordered]@{ started = [DateTime]::UtcNow.ToString('o'); version = $prepared.version; source_commit = $head; native_acceptance = 'Pending' }
+try {
+    & (Join-Path $source 'scripts/package-windows.ps1') `
+        -Target $prepared.target -Version $prepared.version `
+        -BinaryDirectory (Join-Path $prep 'bin') `
+        -LlvmMinGWRoot (Join-Path $repo '.local/toolchain/llvm-mingw-20260826-ucrt-x86_64') `
+        -BuildEvidence (Join-Path $prep 'build-evidence.json') `
+        -Python 'C:/Users/User/.cache/codex-runtimes/codex-primary-runtime/dependencies/python/python.exe' `
+        -OutputRoot (Join-Path $prep 'packages') *>&1 | Tee-Object -FilePath $logPath
+    if ($global:arcadiaNavigationMetadata.Calls -ne 1) { throw 'Expected exactly one metadata call.' }
+    $archive = Join-Path $prep "packages/ArcadiaStudio-$($prepared.version)-$($prepared.target).zip"
+    $result.archive = $archive
+    $result.archive_sha256 = (Get-FileHash -LiteralPath $archive).Hash.ToLowerInvariant()
+    $result.archive_bytes = (Get-Item -LiteralPath $archive).Length
+    $result.success = $true
+} catch {
+    $result.success = $false
+    $result.error = $_.ToString()
+    $_ | Out-String | Add-Content -LiteralPath $logPath
+    Write-Output $_
+} finally {
+    $result.finished = [DateTime]::UtcNow.ToString('o')
+    $result.metadata_calls = $global:arcadiaNavigationMetadata.Calls
+    [IO.File]::WriteAllText($resultPath, ($result | ConvertTo-Json -Depth 8) + "`n", [Text.UTF8Encoding]::new($false))
+    Remove-Item Function:\cargo
+    Remove-Variable arcadiaNavigationMetadata -Scope Global
+}
+if (-not $result.success) { exit 1 }

harness/experiments/navigation-prerelease-20260911/producer/preparation.json

@@ -0,0 +1,812 @@
+{
+  "version": "0.2.0-preview.navigation.20260911",
+  "target": "x86_64-pc-windows-gnullvm",
+  "base_commit": "33c6d83e9ba9a5b1310b1b627d7c40affcbcf15c",
+  "reconstruction_commit": "802855f7e6f2f00a107a12196b458b267f586b8d",
+  "branch": "codex/navigation-repair-prerelease-source-20260911",
+  "record_only_root_paths_after_base": [],
+  "historical_registry_count": 263,
+  "source_repository": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\nav-repair-retry-20260911\\source",
+  "restorations": [
+    {
+      "path": "crates/oa-desktop/src/behavior/creation.rs",
+      "sha256": "0fb19be3a5688c4bd3ca3643c47a97da7e7f85add8a860cd046a0d9cb3ce9dfc",
+      "base_git_sha256": "438a245ead397060767c790c51a8f21cd5021342627999deb4695cf3bd22091a",
+      "bytes": 30053,
+      "crlf": 752,
+      "lf": 766
+    },
+    {
+      "path": "crates/oa-desktop/src/behavior/scenario/workspace.rs",
+      "sha256": "69c7ad32e4bdc39f42d2e6c7764cfe1fa7867cd7dbcf9b904dec805e6c912666",
+      "base_git_sha256": "790a2917d7e7102beeae68ff43ef1693d11132573651265db490b560e14b7062",
+      "bytes": 32785,
+      "crlf": 810,
+      "lf": 810
+    },
+    {
+      "path": "crates/oa-desktop/src/behavior/topology/contextual.rs",
+      "sha256": "edc84fc69d8d4a8f4ce81a4452c4e2e35cfaf98addeed10235f392506c74e8b0",
+      "base_git_sha256": "231610428b9066a92d7405c44e2474fcfe2350fa2998926e8cf502f3392c0a07",
+      "bytes": 29107,
+      "crlf": 787,
+      "lf": 787
+    },
+    {
+      "path": "crates/oa-desktop/src/guide.rs",
+      "sha256": "64c782afebecad5489d3bf06b41f3273904222c18e3244990f2749c991c92b55",
+      "base_git_sha256": "9a6e14ea72c29f4b826e007a4a9836c1c526bd574fc14dd3476ca00a1d80b1c9",
+      "bytes": 115874,
+      "crlf": 1365,
+      "lf": 1376
+    },
+    {
+      "path": "crates/oa-desktop/src/semantic_review/artifacts_view.rs",
+      "sha256": "e8ce3d844d6230c20fe2fda4d0fb256af8043f9b586160a8d110665c45a79561",
+      "base_git_sha256": "2100ff73565765d8293c84f6ce2d8e566610c1524c50e32ce3c37dc33b6686e4",
+      "bytes": 6594,
+      "crlf": 147,
+      "lf": 147
+    },
+    {
+      "path": "crates/oa-desktop/src/semantic_review/attachments_view.rs",
+      "sha256": "cd8c4418b43d207fcc55a82a2364cd84053643e5c09c96de008c94b8372653fa",
+      "base_git_sha256": "932f231554d77c7cb119d33bb06b9879db5e12127aed187e67013e77b6458e78",
+      "bytes": 3111,
+      "crlf": 79,
+      "lf": 79
+    },
+    {
+      "path": "crates/oa-desktop/src/semantic_review/keyed.rs",
+      "sha256": "f8db8578ecff84526bda96c233b50e56f1cf1c5b8ab04cbbaa04f9b5e78300f0",
+      "base_git_sha256": "bdd6c0fdc7108056bc5d7433254503449eed2209813680e717ead24b9d0ce834",
+      "bytes": 14525,
+      "crlf": 350,
+      "lf": 350
+    },
+    {
+      "path": "crates/oa-desktop/src/semantic_review/keyed_rows.rs",
+      "sha256": "af9b137fe56ff3a71378e9998bfbb7b68f035bd542aa6fa90b83e04796cf4b38",
+      "base_git_sha256": "4b7bf25806471ad22d89253b9af8000f5acff53b4cc0aa1c1a83138e7b270eca",
+      "bytes": 13567,
+      "crlf": 345,
+      "lf": 345
+    },
+    {
+      "path": "crates/oa-desktop/src/semantic_review/keyed_tests.rs",
+      "sha256": "112a2d50130407a4a1069827e4e5d5a8681e672dd3e54b559c6d3dde4302a298",
+      "base_git_sha256": "9dc9b989e5a9d408427ca1baf86b2454f9dd3baf40a551c70ca2359dc18a1227",
+      "bytes": 31955,
+      "crlf": 792,
+      "lf": 792
+    },
+    {
+      "path": "crates/oa-desktop/src/semantic_review/ordered.rs",
+      "sha256": "8b809e8b0958e553896829b655684084bf2f0ca7df9d40c6acbdad8749cd6342",
+      "base_git_sha256": "6a1ed894d1b9d0110bc784a75c49444f1d14f1f74620d701f22203b2d8d0a813",
+      "bytes": 9959,
+      "crlf": 254,
+      "lf": 254
+    },
+    {
+      "path": "docs/api.html",
+      "sha256": "6f18cfc2a35eba631dbc61d04cd2721e0e361efff1699bf56d2c450a30a17a0d",
+      "base_git_sha256": "a06126cb741da57e9c06e83fc4137ccde0de05562673546bc9d405878f51ea07",
+      "bytes": 73861,
+      "crlf": 1346,
+      "lf": 1346
+    },
+    {
+      "path": "docs/api.rst",
+      "sha256": "7eb258088824efa5ac94311b07b73eb46edcac3c300a2aac78d3802111e338c4",
+      "base_git_sha256": "ca7d310138c3b4d429d80a1d03d1ac8d4a9296069e205da573034256d10438a7",
+      "bytes": 42711,
+      "crlf": 782,
+      "lf": 782
+    },
+    {
+      "path": "docs/language.html",
+      "sha256": "739a5bb100c7cb0ed70e18afd1e363029757f3cfd6580bc9c5cf77faccb46940",
+      "base_git_sha256": "9660320375b5cb593169433d9b059c2be46be032a0e44fa5220b436beb3f622b",
+      "bytes": 179377,
+      "crlf": 2844,
+      "lf": 2844
+    },
+    {
+      "path": "docs/openapi.json",
+      "sha256": "c6ae512f791a939eaf6ec5e5e78e9468bdee0e028092d00098bd90ad9498d967",
+      "base_git_sha256": "bc5825a3182a4df5f6710a80262f4a09b4c15f0e4cda7ca74e1746ceca81a89b",
+      "bytes": 359757,
+      "crlf": 12837,
+      "lf": 12837
+    },
+    {
+      "path": "harness/fixtures/rest-coverage/coverage-probe.json",
+      "sha256": "699b868dd6c955f7ef02f2f061935471f3d21a406005fcdecba8cc719cc69a1f",
+      "base_git_sha256": "2d1ef7bdb5d7bf17b9fda33b1d1790d1d88289b3fd1e725f89b83a69771f9a43",
+      "bytes": 8008,
+      "crlf": 57,
+      "lf": 57
+    }
+  ],
+  "gui_inputs": {
+    "Cargo.lock": "2b960242c33eb839ff008d01731f6d5cdb4e047ca8cd6e13151cbf9c09913510",
+    "Cargo.toml": "369f5b4b2b60705a94623c8c0b68f8e0b048f263280ce07ae0629ad353797d62",
+    "crates/oa-cli/Cargo.toml": "49c567f1af74a826683b4d96845feb3806fd9bcb7dc2767e16b5509d4e5e1cde",
+    "crates/oa-cli/src/lib.rs": "97bebab63b4a611a1d36ad0c20fe452cbe1985fe3a6fbd39c954603da11410fc",
+    "crates/oa-cli/src/main.rs": "de964f9b6c59c0f31c080afbd3b31d442b07b1b44f6a187a248d3409c45d35fb",
+    "crates/oa-cli/tests/source_cli.rs": "a3a1b856c7a9fd3d80bc8074150a24fbb0ef0e9ddf736c7cea036725fc3dc2b8",
+    "crates/oa-core/Cargo.toml": "64824ec447be777841a972bf06c894ef2624a37e4725583bcfe0389deb9f00a3",
+    "crates/oa-core/build.rs": "ab1be6ae1fd8bf3ebaeef6348347a9d5e666bde693126f199e041659e0b094a9",
+    "crates/oa-core/examples/generate_demo.rs": "e26f432c95331aeca50985dbb3ad2c558affd43023b585811f0f7bfaa59f6661",
+    "crates/oa-core/examples/generate_release1.rs": "1d5f11165d74893e4bc18dbf3a2f2111f4026bd89fd06ee7f0bae69e45c4d4b5",
+    "crates/oa-core/examples/release_dense_views.rs": "a83158488ef9b7394f136c52b1496719be935c4e5bdfe457cab5c9894f5f9412",
+    "crates/oa-core/examples/routing_workshop.rs": "571307b18b6d4fa04700c5a4d4b0c2154c419e93a21292b2028e7b6f46a2faa7",
+    "crates/oa-core/src/data.rs": "7f9c7c7dd8353cb5a38597b92cde6d3e890203d392473187eb387d41ff37414a",
+    "crates/oa-core/src/demo.rs": "ad62123f96c20ff023cafc1a9849b0fa06bc62edd1fb9701799e4599b458600c",
+    "crates/oa-core/src/language.rs": "34cbb144a111e6f0ddadfca7d40636a8e3323fe65ea8920fd2402f0352b41f57",
+    "crates/oa-core/src/language/semantic_source.rs": "584b5bb59d87a7b8d44d5dd2d124c3a1323b21492b138a17bc9526c0087c9e29",
+    "crates/oa-core/src/language_nesting_tests.rs": "bd061611e8cb6f28ab203c73e544ac98bf275eb464cd314ad5fbd25f773df33b",
+    "crates/oa-core/src/language_outline_tests.rs": "4c79a01e8aea243dd9ef66ce71b9fae263d0e79c319a46c51223679897e8b9df",
+    "crates/oa-core/src/lib.rs": "52cb6ee7a4ffc00711ecf121c1a1b14ca154863f7ca27b0d2a8e239edce8aca7",
+    "crates/oa-core/src/migration_v2/README.md": "fb61d3faa33d7bdfba73415415a0882c0fbd3e0b45df42f972a19aec6da927b9",
+    "crates/oa-core/src/migration_v2/adapter.rs": "66741b4c8354a23b8a932ecc5bf1bc3bb6e74279558757b8c35bc2157a7e51b5",
+    "crates/oa-core/src/migration_v2/mod.rs": "857d8bb13b6814daba6780ca770c16352943c01cb130245d055f11b3b957b3e9",
+    "crates/oa-core/src/migration_v2/model.rs": "8ac63eb59b2e57bdecff2477ee0634096090924d3dd1851e1c454880a889dacb",
+    "crates/oa-core/src/migration_v2/references.rs": "33a6819abc83139fdaebeebd1b553238a328637106cce7dd5a535f1791d43e20",
+    "crates/oa-core/src/migration_v2/source.rs": "74fee9b24e7c912182c998ab9d9aeec125e2009c3214959229e844c67afe2bf6",
+    "crates/oa-core/src/migration_v2/state_validation.rs": "e29ef071bab0a68460ddf55c46131c6f66c022d52c3c602c37c013c3649da1b0",
+    "crates/oa-core/src/migration_v2/transitions.rs": "f74174c532ba56b57c80b719a11fb4adea0a78ccc2828fff72fe2b9eda5a10b1",
+    "crates/oa-core/src/migration_v2/validation.rs": "6d5e4a4e2805ae5045bf789a0485e14a61c63346587bace2b4a91173a688f780",
+    "crates/oa-core/src/migration_v3/README.md": "3755a63f840d7f0eadf68afa7a9d587877a9468ff982d3610539e8a0bb067a82",
+    "crates/oa-core/src/migration_v3/mod.rs": "f4edb6a0b50ecfe8670973776d703047b064420cb1f05913129c00fc656b3722",
+    "crates/oa-core/src/migration_v4.rs": "50c652964f0f309e7f3f54b6ef12c40d42fcecc0490f005995c713df1179af70",
+    "crates/oa-core/src/model.rs": "4585c895c64c4a183941c92cf047a9e52ff0cbe41971e16e78d229ea9dc101fb",
+    "crates/oa-core/src/operations.rs": "a5ffbbf54cd440316a106d1188bfb699b57dae59f466edcb33618c333cd19f41",
+    "crates/oa-core/src/persistence.rs": "1c01474f906a63e552c0d590b272c95821c00a100b3e79e58e67dbbeac341a14",
+    "crates/oa-core/src/ports.rs": "5cac12eea70a54ebebbd6be77b63ce92e3195325c4bc7d27705c518686cbac80",
+    "crates/oa-core/src/projection.rs": "69ed12bace2cc5024e151752a174ab14034ac2d05eb741fcf13e9a27521c059b",
+    "crates/oa-core/src/projection/port_layout.rs": "a08d17d10a58bb8b206dd001b19b91d5aa3a9f743b298a4da57d503223c20079",
+    "crates/oa-core/src/projection/state.rs": "73a607bac713ec7ff49a509fefb1a53c7686dca93ee241ffc835564d743afb28",
+    "crates/oa-core/src/references.rs": "93553c234f32da35f1f41a7b83ad81c471c9803efa78ca222cf7de3c2f86c0bb",
+    "crates/oa-core/src/routing.rs": "c5ebb350ba76f731f5c48d968bfbba4b6ef68ec046eb5893d116c4637ef15080",
+    "crates/oa-core/src/semantic.rs": "f9895dd5b8fb27d10d4cfbb41c3542ef2018365a589b8d5778e5674ae5a1f239",
+    "crates/oa-core/src/semantic/catalog.rs": "1ff74fcca18084d178681d7ff38ee1ccac632c27c4de0595ba1ceab8067ab3a4",
+    "crates/oa-core/src/semantic/historical.rs": "eaf3284bf234312698514cdb636bc8348e1b5d746cb16b18df777e77d312abfb",
+    "crates/oa-core/src/semantic/linked.rs": "6f335b14e809aecfc35defcaf77cb821b080d1506dbc46297912b25af98c07a2",
+    "crates/oa-core/src/semantic/mutate.rs": "dc2b4c4a6eb156fe468eaa8c85fd37a505c0cd8ea1f226cb69cd01689afd3d9d",
+    "crates/oa-core/src/semantic/review.rs": "0c157d2c327e72e89cca3b423e71ee73798105c5bb7271439c1a101642c91e3e",
+    "crates/oa-core/src/semantic/types.rs": "6922fe35089f12fad43ab0ce1c6886d01a3855f90b8e2543e99802ac5e6f1bbb",
+    "crates/oa-core/src/session.rs": "1eb77b329b2986fc6f5dc0171e77fd860375cdfd8c769a1367b445d6c49ebe00",
+    "crates/oa-core/src/source_files.rs": "669491dbddb8e8e6556161426dffa1a49ac1c826d31020bff0956d81a4d84683",
+    "crates/oa-core/src/source_project.rs": "1394370bcc5908873b830c2c11312e6e1611af41f46c4f43ca0a6bcb713bb466",
+    "crates/oa-core/src/source_project/source_migration.rs": "add463ae85c420f853d324b00a221f0f874164cc3f3ed6bbb07557a9ed7a8c95",
+    "crates/oa-core/src/source_project/source_structure.rs": "9f1f83315856a7025fe662c0fbb13452f31613224a03663150d6225d1ddc162f",
+    "crates/oa-core/src/state_validation.rs": "e28d7f74385e2a78763716b34491bd73a00bfeccc085970ceb130627e3faee18",
+    "crates/oa-core/src/topology_context.rs": "16de69b297de95d93c73808621607833b713af811dd082f0169186ae1e5c3e2d",
+    "crates/oa-core/src/topology_context/analysis.rs": "dead6194f0aa60cc46045c0e5ee10dbdbb689158c38634dfbbbc45d2ba88ac65",
+    "crates/oa-core/src/topology_context/analysis_tests.rs": "17839263410815e96fe027d4eba3aae0a9ab3b82b16947e2b29ebe0d09782b56",
+    "crates/oa-core/src/transitions.rs": "fadd1b07b89cae4117b91abb4f1ac9ea81ff818ef20f2175e76ee8cf21fb708d",
+    "crates/oa-core/src/transitions/communication.rs": "2b476630a88edd9021b9156ca12a5402e01604095f0d4002afb452671903a028",
+    "crates/oa-core/src/validation.rs": "7c1b4ae5e4ebba13e99af9158ccde138dfc5e9a7afb580e76fba72d0b64ba74e",
+    "crates/oa-core/src/validation/coverage.rs": "b08e4b344ecad055714168c83beff7fe29ba4edc53edbffa2eae04e5580a4d5f",
+    "crates/oa-core/src/view_options.rs": "421ede0a04c593ca1df0e6e0d06fabcfcc8113cdbcfb0adc7f5c8ef4d1724208",
+    "crates/oa-core/src/view_options_tests.rs": "64aac44de2df42a1012239a3dd75c473daf0c8990b3170b7bf7e78a556080208",
+    "crates/oa-core/tests/communication_boundary_scenarios.rs": "e1100b8f363910a487d90c73acc7df543dc6d532158c3c63ad11cd3d40d8e12b",
+    "crates/oa-core/tests/communication_means.rs": "a25f2749180bc6f4beb1445bfad3351eedf0669131a7439b633ab804439e95a4",
+    "crates/oa-core/tests/coverage_diagnostics.rs": "e2e9c3996daab47f2bd23f5d8c48b4e372af33331152f5fc85b76f06d04fcdf4",
+    "crates/oa-core/tests/fixtures/v2-coastal-rescue.arcadia": "f0df129c1914bfc01d0b047b0cd4b520d8cf0c249ea9ced085de400c0be87ff3",
+    "crates/oa-core/tests/fixtures/v2-coastal-rescue.json": "3ed53508eb544bbd788832f7bebea2ec31b3d66191f24f45098cc9750ec4c005",
+    "crates/oa-core/tests/fixtures/v3-data-contract.arcadia": "305f19d1b79f99f8d4cf627ba2e9ca6836bb7959cc0070227815937a699eafea",
+    "crates/oa-core/tests/fixtures/v3-data-contract.json": "1b41299c53204e6232397d25a58d5bccdbbc16e770c75e8edb55ce36ccfe58a2",
+    "crates/oa-core/tests/fixtures/v4-reviewed-prose.arcadia": "5fa53a26a5ad010c8e59eb56d9b2b52003569e66c0377ffb58840590168ad0c1",
+    "crates/oa-core/tests/fixtures/v4-reviewed-prose.json": "2808088afcc165f4bd6da5129151143411c997041c3de61d600ab76e05d24a47",
+    "crates/oa-core/tests/language.rs": "77f6cb2a69976bfb5f60b243b71c07fb0edc7505002c1e9e73fcd6ddf6d9496e",
+    "crates/oa-core/tests/port_anchors.rs": "efbc0fa18733b1aaac501f9785a4c392fc49c05c45a5778d26e9b5dd951ca6fa",
+    "crates/oa-core/tests/port_migration.rs": "1801c376a5435ac7efb2a8342348b2c7ffef930bba65deca4acb66b06e0483d7",
+    "crates/oa-core/tests/port_source.rs": "8d2ddaca4045d330f6eda2591561497b858aad53769a823249d0bea4f5916e12",
+    "crates/oa-core/tests/prepared_commands.rs": "52cab1c668064777412df0a6a3c20d74d579b33794b4b00525b9f151c06eac9b",
+    "crates/oa-core/tests/process_diagnostics.rs": "1dbbc590239ef7542be4a2bdc9543aaa64d108417b03dd312a0894e364745906",
+    "crates/oa-core/tests/r3_constructor_ack.rs": "e5c44676ea0aab97f2e091ddac2f4bc4a4a90f5877f7bbf08b61229600944dd0",
+    "crates/oa-core/tests/r3_migration.rs": "ebd04120f5215b3956fdc79ee78f6e38734c7d13392f1fc28aaba957912265bd",
+    "crates/oa-core/tests/r3_semantic.rs": "49c3763eaf2131070a7c46cc23a84f917d292d41610b6404510e5607f8890c32",
+    "crates/oa-core/tests/r3_source.rs": "f31f60659df3c7ef601650d1cff140589d8729f01a3f65a4a6a6c2272f15c408",
+    "crates/oa-core/tests/r6_data.rs": "5f7ffb3bc73c3c85423623fe56f8680646dc97040327bdbead9d47a37e80f155",
+    "crates/oa-core/tests/r6_migration.rs": "81519bc1512f5e069432e9a1cdad04c10216d492df01b4b75b02102480ebd6a1",
+    "crates/oa-core/tests/r6_source.rs": "88a0aa087a7678e2898ff6057538072ca92072190712f05fff08372cc56ebed6",
+    "crates/oa-core/tests/release1_teaching.rs": "be179290d871125dc97cfd2a3067c7ac89c8a538fdb0afafc5b825bcdfb2bef2",
+    "crates/oa-core/tests/release_capabilities.rs": "b92cba2a562e78287ddd7dc3e94557848d17faa0c8a102601b50286b9af48a30",
+    "crates/oa-core/tests/release_diagrams.rs": "cefcc0582d91266d5de6ee5daefcfe41b606ab971ab235b59034a8e1dbc24b7d",
+    "crates/oa-core/tests/release_language_limits.rs": "8578da4f76bbd2d0e1bfe295ab1259e2162a3fe3d0d2ba8901915d7a40942806",
+    "crates/oa-core/tests/release_ports.rs": "506e62beab0c7ec0cece83e9e0c1a810fa1f99285c9e1cab0c77f06de55a40e1",
+    "crates/oa-core/tests/release_routing.rs": "ae168faaba23769b7ca1fd65f217b9db671726e67276eb5a04e5e72b1447a462",
+    "crates/oa-core/tests/release_scenarios.rs": "0f5d876badeec653fc7b12610a77d867e9a53582e605253deff8d379da21572f",
+    "crates/oa-core/tests/release_states.rs": "b1a26acee95eaba7f9920f9da738a1e33606552eb078e6d298895daff7e3d811",
+    "crates/oa-core/tests/release_topology.rs": "c51dbe5aa5a038f9ed830daa02aa67714472179eb7fd6da5ce36dc6931c8b3a9",
+    "crates/oa-core/tests/review_regressions.rs": "f154e5c88d35e31512e2b07733a1327ea3e2fcfd1ef8eb23066a4e9573f387c1",
+    "crates/oa-core/tests/route_source.rs": "1a73fdbac0d0ae0e84d8d67b6ad398e11223958f5dca007f73757c91827decfb",
+    "crates/oa-core/tests/routing_geometry.rs": "2d8eea4a2bba535ed0ea6daabccdaf87b375828c404baa10518c7bd7fd6253d3",
+    "crates/oa-core/tests/routing_labels.rs": "dff884d799c3c5c9257210248c55767e294e3cb317c605cbd0ddc9600c216eb6",
+    "crates/oa-core/tests/semantic_artifact_absence_oracle.rs": "d93eaf9667f4221232168bef0fe9f069e5be1b1f23410bda5dd67010b96e5c8a",
+    "crates/oa-core/tests/semantic_attachments_gui_oracle.rs": "7f526d363ba05e7ac89faf0fead0796e419c34ee204edf44a1b46c78308b0970",
+    "crates/oa-core/tests/source6_view_contract.rs": "fa566de53946d40bbbd9033edfeed177180c4dc44afa2f2f4667ffdc622eb3bb",
+    "crates/oa-core/tests/source7_contract.rs": "cad4f1a135ddbd947bdf3c71d1b44f1e438725095ea8c4d893464bc721c2363f",
+    "crates/oa-core/tests/source_files.rs": "f0429a0b89a443458ea9af7083c1e4e7411417a7e6b47e618bfbb9266dc164f9",
+    "crates/oa-core/tests/source_identity_updates.rs": "f52aa38b4d317e532c641ad7463472e4b40e802e60052cf0017556ffc63da06c",
+    "crates/oa-core/tests/source_nested_updates.rs": "9ac3390936c0d250651ea94a1b8faf0adfb680f061ececc56f2a52909b5ba855",
+    "crates/oa-core/tests/source_project.rs": "cef58adb16aa4d2527ddc0628aec3e26f0b42b4be70014a7e360fafdac13a942",
+    "crates/oa-core/tests/state_diagrams.rs": "6b02b387a3ae559cb3ad72de24292a5abcb76aaac0adbab5d2aa5211b22cd2e5",
+    "crates/oa-core/tests/workflows.rs": "bd843dfddbd5724ec08f657571f887496203056fe2fa5864ef50a168a613b89b",
+    "crates/oa-desktop/Cargo.toml": "f3547b2b924d5db6706c0a8e069014b440ff65315d82fc8aced0360af4b3cdc9",
+    "crates/oa-desktop/build.rs": "ab1be6ae1fd8bf3ebaeef6348347a9d5e666bde693126f199e041659e0b094a9",
+    "crates/oa-desktop/src/app.rs": "4a41b062da233a72f1b04866898eeddb3f79882918a67f5f09469fe4eadd9929",
+    "crates/oa-desktop/src/app/architecture_authoring.rs": "37c7db33e99dd4adcc5a51f09ee4878af94fd32413359890a541690080885f65",
+    "crates/oa-desktop/src/app/architecture_authoring/palette.rs": "8f9937cb30b48b83759fd084a8a5990a2daa3920280f1210abe048560241985a",
+    "crates/oa-desktop/src/app/architecture_authoring/tests.rs": "ed864839940a1910c97537b6ee151b57ab115ece6f60bae602552b84f9af4a5d",
+    "crates/oa-desktop/src/app/architecture_authoring_tests.rs": "77eb1a0038d038b989f7ac568760e16fe23c4b8d73cd9fbe32b70817ea23cfec",
+    "crates/oa-desktop/src/app/behavior_lifecycle_tests.rs": "1af2e290aa259a6af6b0585950cda93fe3a562c7b8be1e938fe1d80747b11808",
+    "crates/oa-desktop/src/app/checkpoints.rs": "55e5babdcabef767af3bc8be9cc3153b3f5cc0695701b890820ec0225643852e",
+    "crates/oa-desktop/src/app/diagram_selection_tests.rs": "4fa507adbc23db3a6eb202d809c695ec0ebd6181356930c4fa7528a9a0c7be57",
+    "crates/oa-desktop/src/app/hosted.rs": "14e2fcd79558ff56d000571f1f576e5601818d702783634aa4017000d382c62a",
+    "crates/oa-desktop/src/app/hosted/tests.rs": "fa118f64d04b400ccc01e4e67adaf3541975288882afa265a9e7f092cdbda232",
+    "crates/oa-desktop/src/app/process_canvas.rs": "11e991afbce187ae633e01214b2509a13623c940f1f5e6416aaee204158bc5a4",
+    "crates/oa-desktop/src/app/repair_save_state_tests.rs": "5543dcba853bb1513acf824b860249729a6004747e7e320b46efe60ea19e2d83",
+    "crates/oa-desktop/src/app/review_navigation_tests.rs": "5ebba36092cc89fcba394578e69c9507ad5a369e9a26526761716b5d4ee3ad75",
+    "crates/oa-desktop/src/app/save_as_tests.rs": "f8b915793f1a36fd152569c4781a4bdc17f4af404a8ceb373330053413087a1c",
+    "crates/oa-desktop/src/app/source_symbols.rs": "99370865b548b28f32f4c6ce7e9f8eeaa0c80268a644f2ebcc4bd1e11695e59c",
+    "crates/oa-desktop/src/app/source_symbols/tests.rs": "33292a7ce9b61dbc134f74372caa93af9704e2f968cd698da13ea6a1b8cf3ea6",
+    "crates/oa-desktop/src/app/state_diagram.rs": "f7fd50cc9a86adb794713958348af63afc7c698f74965e13188b7b8a9e735c55",
+    "crates/oa-desktop/src/app/state_diagram_tests.rs": "612e414b1a2cab12cbfd8fce23745559ff27577700694d53af67ad1f2883ee2c",
+    "crates/oa-desktop/src/app/transition_context_tests.rs": "47002fb025f3a2f8c53871f9509bfe8611a61db6fb0e1b3125eb6e875425cb1d",
+    "crates/oa-desktop/src/app/view_copy_tests.rs": "296821c51dcde568e7d717039aa26bfc1b56a9074aa16051007bb351b33a4d44",
+    "crates/oa-desktop/src/behavior.rs": "c9e0aea6a24cc982d0d82ee2b9b66f250cdfac037b36bf6b1b9d7dd38246cd3c",
+    "crates/oa-desktop/src/behavior/contextual_source_tests.rs": "5f05318a6533503b9d6febf1ec4dd7256f192394bc1b952a7904c8175bd8ddae",
+    "crates/oa-desktop/src/behavior/creation.rs": "0fb19be3a5688c4bd3ca3643c47a97da7e7f85add8a860cd046a0d9cb3ce9dfc",
+    "crates/oa-desktop/src/behavior/creation/app_tests.rs": "e9c5bf2b07357b7a2f679ae0d8f6904c1c1461aaeb94fa0db478b54d4641ae3e",
+    "crates/oa-desktop/src/behavior/creation/tests.rs": "a0d1daf9fb3920f7e6181a9802d84fbe056cbf0043b9e41dba5fdda687d9818a",
+    "crates/oa-desktop/src/behavior/scenario.rs": "d12a4b1caa61c08f69c4d2a64bd15568c4b7158dea91aac5a52a58a35adb863c",
+    "crates/oa-desktop/src/behavior/scenario/workspace.rs": "69c7ad32e4bdc39f42d2e6c7764cfe1fa7867cd7dbcf9b904dec805e6c912666",
+    "crates/oa-desktop/src/behavior/scenario/workspace/tests.rs": "abfc7caefb0de5bd479eb4af1b159ca77b68e6a157f477939628c3d5c90b44b6",
+    "crates/oa-desktop/src/behavior/scenario_operation_tests.rs": "89fb71c690e07eac314f7a5e05862d5c1e2f9c21039673bf22c4ac894d21c977",
+    "crates/oa-desktop/src/behavior/source_draft.rs": "85d543cc288e48b4c13001e4e386b5b54d9b1e349a5ac31e4e307572f2d8fb3c",
+    "crates/oa-desktop/src/behavior/state_canvas.rs": "2e2ad57b86f4cc1cc0c4c4c230571ef19bcc2f052001a8bdcc44925e5103077a",
+    "crates/oa-desktop/src/behavior/state_edit.rs": "cb2289e727163626152fc2f11195c6ee824851cb9442c57496da97fe7aebfb7c",
+    "crates/oa-desktop/src/behavior/state_menu.rs": "cc87c5caa177e114e4d9a7f7367e37ec2b0d1e1c16b0b99709b05ea0e59cf894",
+    "crates/oa-desktop/src/behavior/state_view.rs": "1eb892a9139ecb0671784c879ee5114f27e598e5b3589f5cdad0abffd5909f24",
+    "crates/oa-desktop/src/behavior/states.rs": "8986ed9492960e20f1254e9dfe3ff91d79ce9fef66f3bda738f9933278043954",
+    "crates/oa-desktop/src/behavior/topology.rs": "d06b2f0fc39b4814e94200297e148f1d4d97e04cb167766030ac9df18689e3b0",
+    "crates/oa-desktop/src/behavior/topology/contextual.rs": "edc84fc69d8d4a8f4ce81a4452c4e2e35cfaf98addeed10235f392506c74e8b0",
+    "crates/oa-desktop/src/behavior/topology/contextual_routing.rs": "d914b0e82aa8d253fe64be2ef74443d1fd2e6cec26d1cf30620a57646e1d426c",
+    "crates/oa-desktop/src/behavior/topology/direct.rs": "413aa2009ee4cba0941836b43e41f16a04c8fc8568b6e92db5bb08516e95c287",
+    "crates/oa-desktop/src/behavior/topology/direct_tests.rs": "ac8c8023117e31723084adb06e3ca7fd4ea3f95ad229622ccc759fa19b50c27e",
+    "crates/oa-desktop/src/behavior/topology/layout_tests.rs": "4529ac8b05de769a2ada112473146fbfa27b0467d97d3541b86c4446b6050b83",
+    "crates/oa-desktop/src/behavior/topology/view.rs": "a7d806cd621bdf857c4e4861685cd3eb556b320de3985b9cc3d9d131dad370dc",
+    "crates/oa-desktop/src/connection_edit.rs": "020581e077f82b43c936b623cc51733b02b88428df4e5f25df74b9705819fa37",
+    "crates/oa-desktop/src/connection_tool.rs": "649da93677d52dae495b0e19bc32f3122ab05a6d84de8402578ff5ce3f6ee1d3",
+    "crates/oa-desktop/src/context_menu.rs": "629354b34dc232763700251f2695b4d4e53d6251c0b1432ecc0dfe424f7dfeac",
+    "crates/oa-desktop/src/data_values.rs": "e1deb1cad551f0a9fdef9653aad257cfb36e6d9c0f93b6245061ec3fab8fd365",
+    "crates/oa-desktop/src/data_view.rs": "158b852be5d3db450aa5cda8b68a35bd96bddce1d8d053a7a23582095c06362d",
+    "crates/oa-desktop/src/diagram.rs": "4580b170e264d14e5cfa874709f6d2e076a05155bfbe1809336a9d05f75e98ef",
+    "crates/oa-desktop/src/diagram/lifecycle_tests.rs": "d0e72cc0574657d5a31c3ce307b58401d0ed77eedccd1aa02377f55ab0bc03f0",
+    "crates/oa-desktop/src/diagram/pointer_tests.rs": "10ca5049034159205ac8f22805354f308b0ba0596f331568c26cd1393bc8cedc",
+    "crates/oa-desktop/src/diagram/port_hit_tests.rs": "d2d0647629bf725b4dddfc211f5a27d495ed093a79af87cdae6c196f09a97b93",
+    "crates/oa-desktop/src/diagram/port_labels.rs": "28782983b82e4fca5dd4410ac8bd562359943b7010c7b24ecc42f0c7ad7fb63e",
+    "crates/oa-desktop/src/diagram/view_options_tests.rs": "cf0c98a7715558baf17b59f67a80556f98ad30262b4434635e617c6601775433",
+    "crates/oa-desktop/src/document.rs": "7c87280b5b8d112c34865253f8ba0f80d43bc9897771943b15dc7b5608eb17a4",
+    "crates/oa-desktop/src/document_save_as_tests.rs": "83dc243a25f4e97674ff0d86c794a490cc923e98f1f9fb05bb038f622f11e20b",
+    "crates/oa-desktop/src/explorer.rs": "fa01c59219564ba9ae5553abc2b6f94e9849f9148d5812ef99b40318fe5dcf9a",
+    "crates/oa-desktop/src/explorer_view.rs": "a720d7484bcc3a24729332a00e005d1cc6f5f945a9cc3965134e0024dffb581f",
+    "crates/oa-desktop/src/forms.rs": "e5c0805b93daf0e8244d4be32e5a0dd3a1856c281a9d9fb5f98497dcc43c4da2",
+    "crates/oa-desktop/src/forms/context_fields.rs": "eaacd474f6500dd344d5a8b63ccb1d1dd86fe2aea78ab708afa8a80d62ce69bf",
+    "crates/oa-desktop/src/forms/data_fields.rs": "f56397886d74086d69783f18fab961e13b0af05a8bb0d10d0dfa187cdad05f5c",
+    "crates/oa-desktop/src/forms/history_fields.rs": "e7100474cde18bdfe95562bcb3c055f29b4b15aa64788a578194464aebcd046e",
+    "crates/oa-desktop/src/forms/history_fields/tests.rs": "16d3c308138c063f45986d53c621ad83c7dc2ce853edd31b7204e2939a382df9",
+    "crates/oa-desktop/src/forms/port_fields.rs": "3fe684d651d5be6203fd9db3979c772913e1af5ac1514e67be386ffd88dc8127",
+    "crates/oa-desktop/src/forms/view_fields.rs": "5184d438f0dfd4e29f284ff048e19da73e71be1f24a6e9f123c7e922aecb85fa",
+    "crates/oa-desktop/src/guide.rs": "64c782afebecad5489d3bf06b41f3273904222c18e3244990f2749c991c92b55",
+    "crates/oa-desktop/src/highlight.rs": "da7c254fff7052e5fd9ec7469f473b91a819406028d7c304f6e22c4169561600",
+    "crates/oa-desktop/src/home.rs": "f03c1071334894f586a5a7c86026602a694db3c2faf902822e1dbe5156a859c2",
+    "crates/oa-desktop/src/home/tests.rs": "3b03ccfc97dfb75954e1e0ed568bb87a632295c07b96cedc05ed381f87b378f3",
+    "crates/oa-desktop/src/hosted/client.rs": "54b24b4b50f8d87d7c92946ea5a2cff4c98760e70555b3ce3d90be27115e95d4",
+    "crates/oa-desktop/src/hosted/client_tests.rs": "3ef70907ca75e098d631c41b90badd4cff1e1eb1b3c78e15a9f811c13ba8ffbe",
+    "crates/oa-desktop/src/hosted/mod.rs": "1b75e11c80fcb38fd20bb3487e3f88729fdac73e471c5ae64da28c249f77c63b",
+    "crates/oa-desktop/src/hosted/view.rs": "fc0c7b7ce3a5f05c49713df6661067751f81e810af11c614ca265ea9490e6463",
+    "crates/oa-desktop/src/main.rs": "cb0a919fd0df0924591283da5b55d64d525d8461640441509350be840235e51a",
+    "crates/oa-desktop/src/model_menu.rs": "12994a5433a91f8295a59d4bf40f35f1edb8d8dbb497a11eae8760299627f1d4",
+    "crates/oa-desktop/src/navigation.rs": "71355a12e1b4791106426d83fe5ebf0b29bce8e1dc594f0655ab85695469669e",
+    "crates/oa-desktop/src/port_edit.rs": "70b99f577c4fdeda8780c8dc1ee7b1639fd77aaca06658f06d725139fb3efb6d",
+    "crates/oa-desktop/src/port_preview.rs": "069487c4ece737d52e8ae4a84dcfb132236aca6799e841c91c8e7244320cf871",
+    "crates/oa-desktop/src/port_workflow.rs": "ccc15f97c3272145a67bb5857b4faeaf7437561bd61912fa27ab26e8824146a0",
+    "crates/oa-desktop/src/recovery.rs": "57e22e5fbb0e994e64ae03e69450271fe9f04a951db1670c2a018abe99db4489",
+    "crates/oa-desktop/src/recovery/fixtures/README.md": "a90002df1e087d2dac7be26926864243568a0de7c4103e4927435b34178e8016",
+    "crates/oa-desktop/src/recovery/fixtures/profiles.json": "2c12ae96b50e6da5d60ce2b7fa00204be71dfbe2fd51311fc337a0de6a4332ff",
+    "crates/oa-desktop/src/recovery/fixtures/source5-bundle.json": "12715995e6f7f35414aea53b3ad720b9b31873ffdeaf4444231db1a5ac3c463e",
+    "crates/oa-desktop/src/recovery/fixtures/source5-model.json": "5535a706df9ec21715e8b6a5aa6dbd79636ae461450aee61305559016167612b",
+    "crates/oa-desktop/src/recovery/fixtures/source6-bundle.json": "ea88890a33f47d67dfb06d6dbbcc179058cf28dad76ae7d615c00aaf30dbbbfe",
+    "crates/oa-desktop/src/recovery/fixtures/source6-model.json": "5bb8db0b6394276666323483f977ac3586f88554c81a148c6d508fca0ef4576f",
+    "crates/oa-desktop/src/recovery/source5.rs": "0f0a763f0c98c2c908d4c2b95d8a4c042b6a255ee1cc16260e5404669691f642",
+    "crates/oa-desktop/src/recovery/source5_tests.rs": "cfd17a742f1f27b523fce7cd9309f0a07a30413395f6c58659fb91d02834a7a3",
+    "crates/oa-desktop/src/recovery/source7_tests.rs": "7ee61de66c75bf949489ba51ddc9677e2b4efc68801cf27909c9b894bfdc9288",
+    "crates/oa-desktop/src/route_edit.rs": "457ae59c2761a43a8620b4d336a7cf0f54b965997110ecaf968756a88b6b0374",
+    "crates/oa-desktop/src/semantic_review.rs": "916192003637b60c12f6b3b3663a5b9c770ae4d10d51a415f6b3e4035e30fe13",
+    "crates/oa-desktop/src/semantic_review/artifacts.rs": "a79236a8150597ff808597e59cf4f1e9e61c74c4901d9c8cf42d3427bb52a9a8",
+    "crates/oa-desktop/src/semantic_review/artifacts_recovery_falsifier_tests.rs": "3f255d04e4bffa5a467b75e3cbf6f7149aa3269a02f2a89fbaa1db0e5df9ae62",
+    "crates/oa-desktop/src/semantic_review/artifacts_tests.rs": "04d0dd2ac453705185663f705282aa4a3a31433466a5be305764248da1a03c32",
+    "crates/oa-desktop/src/semantic_review/artifacts_view.rs": "e8ce3d844d6230c20fe2fda4d0fb256af8043f9b586160a8d110665c45a79561",
+    "crates/oa-desktop/src/semantic_review/attachments.rs": "de0ec0c740895b160ff5b847332c087c3f1a48931583464069470cc61315ed59",
+    "crates/oa-desktop/src/semantic_review/attachments_tests.rs": "8b26be0324e0f33b1e7cf7af340350df8ed98963002d6da8589ee0e6f6900bea",
+    "crates/oa-desktop/src/semantic_review/attachments_view.rs": "cd8c4418b43d207fcc55a82a2364cd84053643e5c09c96de008c94b8372653fa",
+    "crates/oa-desktop/src/semantic_review/batch.rs": "44830e1a9fa572493d423545336f76e79fa24ef29900e4f7927cbc83f9071d17",
+    "crates/oa-desktop/src/semantic_review/batch_tests.rs": "2a8131b81322e6a49b1348c6efec4526a3df53c8eefc0a2b25c746e2b7c6ead8",
+    "crates/oa-desktop/src/semantic_review/compose.rs": "c6adcc9882dde65e9f04f6eda7f0c855c5cbb285cf421123029169112793ce9b",
+    "crates/oa-desktop/src/semantic_review/compose_diagnostic_tests.rs": "440daf8d43278ef981c620d1818d0daaed8fb83193b8e8ff67b2e42fbf882938",
+    "crates/oa-desktop/src/semantic_review/constructor_tests.rs": "85149521ad7df62918f6f2fab6da2b3346c342ab4bce7100de3f6206c1e81096",
+    "crates/oa-desktop/src/semantic_review/constructors.rs": "0982163439b06a42d9af1643530364109282e63f05b323a35a76d8241f3caa32",
+    "crates/oa-desktop/src/semantic_review/history.rs": "df038c2464eab8093a983f3104f0d04ca8f602010a50e1d3eeb8e53f2309e201",
+    "crates/oa-desktop/src/semantic_review/keyed.rs": "f8db8578ecff84526bda96c233b50e56f1cf1c5b8ab04cbbaa04f9b5e78300f0",
+    "crates/oa-desktop/src/semantic_review/keyed_rows.rs": "af9b137fe56ff3a71378e9998bfbb7b68f035bd542aa6fa90b83e04796cf4b38",
+    "crates/oa-desktop/src/semantic_review/keyed_rows_tests.rs": "1a3b09e7ed100411cdf8043f9a78defc664a873ee0201117709185c201a5c57f",
+    "crates/oa-desktop/src/semantic_review/keyed_tests.rs": "112a2d50130407a4a1069827e4e5d5a8681e672dd3e54b559c6d3dde4302a298",
+    "crates/oa-desktop/src/semantic_review/message_kind.rs": "4ed19952ea511d1b3226564a138e3322f994371d6b49794c14bc3689d1393e7f",
+    "crates/oa-desktop/src/semantic_review/message_kind_tests.rs": "5fcf9930e949aebeb12eab0327264f32a2388d62dbf098bd2365711e22623c52",
+    "crates/oa-desktop/src/semantic_review/ordered.rs": "8b809e8b0958e553896829b655684084bf2f0ca7df9d40c6acbdad8749cd6342",
+    "crates/oa-desktop/src/semantic_review/ordered_tests.rs": "5c8ea3a69e3da3b94d13f50f12aa7dc53246ccba25ffcace9552a0eb76b0bf36",
+    "crates/oa-desktop/src/semantic_review/recovery.rs": "88e69044d90c481593bab7cc125f0401c05202fccdde07698cec9483947fe8be",
+    "crates/oa-desktop/src/semantic_review/row.rs": "ecde54540071fde82d8d580d0da2fccd16d6b8e0144bd5e129afe91455f73bb1",
+    "crates/oa-desktop/src/semantic_review/scalar.rs": "9ad202174934dd9a63fbf9cba43135aead571db60846c8b7b1d3019a11df26c2",
+    "crates/oa-desktop/src/semantic_review/source7_tests.rs": "5e8221d77b068fa30c1571988448cb8829711735881d810f3d333cbc95d34a9f",
+    "crates/oa-desktop/src/semantic_review/tests.rs": "8839e241cf81d1e66abe072728eee1870b42341fbbefae9f39bda1b1a020f4ba",
+    "crates/oa-desktop/src/semantic_review/view.rs": "c391814442cd5e95040c6dab9d511a254181de56c68d5c266d879870001561ad",
+    "crates/oa-desktop/src/semantic_review/view_reserved_artifact_tests.rs": "6c766b29c8664d15cb113d2cc71bba9b60ae4ccf7e44c9c5d3c41e1dc4b7ed90",
+    "crates/oa-desktop/src/source_navigation.rs": "3f7007bc3b3ef6266e92ea4121cfbdb32df2e97713797b403ce6649070a90517",
+    "crates/oa-desktop/src/source_navigation/controller.rs": "4ec54ce769f047d6e5c1de6bdbe81648ad63c75cfd04aea5356bd5663126d77c",
+    "crates/oa-desktop/src/source_navigation/interaction.rs": "c6efa6105b8ba46655e27a89b9fa59e6fc01a4c6f331f886e035af1e70cbf8a9",
+    "crates/oa-desktop/src/source_navigation/interaction/tests.rs": "6cf5c5944b9c46c275c9039f7166b627fa9176187b39348152f67040c92c95e1",
+    "crates/oa-desktop/src/source_navigation/query.rs": "aa8e8e9d446b57c30520c4b3ca1ae9fe524cecb2f4f4f4b229d930ea0377ecca",
+    "crates/oa-desktop/src/source_navigation/query_tests.rs": "a4ecc95a49d0a9325cbf1548cf95a8d367f758f8eb1f44346a2b71ef046f6668",
+    "crates/oa-desktop/src/source_navigation/symbols.rs": "d6c9325223fb3f18e887a63187b67aa59735d4e51f501c9e27ebb870944912ec",
+    "crates/oa-desktop/src/source_tree.rs": "4d55e0110a1eb128a5d26c28f3aae5853d79b7245812b7c82bd275f38440a5aa",
+    "crates/oa-desktop/src/source_workspace.rs": "388c71f63829c0c76526a1700ebf5f240c86c467a65aae4fca4cd6c6a88c468b",
+    "crates/oa-desktop/src/style.rs": "05d61bec16141612ccafa0988e8c4827f41754509efdb3b961eab69127ded896",
+    "crates/oa-desktop/src/tests.rs": "94e340b8ef7f9a3bb71fd2a2098dbb9c3d2bb3adba25b5949430b714e36fdfe1",
+    "crates/oa-desktop/src/view_copy.rs": "5630f31c942e1226aafd67eabdace6a5c5494875bdc6f7f077019e8110ba41a9",
+    "crates/oa-desktop/src/views.rs": "e5ed7640fbd2653983c418b88fd2e3612b91f8f02fa2f50f1b5dfd31aab773b2",
+    "crates/oa-desktop/src/views/source_symbols.rs": "9cd536072e110803b6a592bcbcd595b6f9eb32fc1d0b4c9de741247c459abbe5",
+    "crates/oa-desktop/src/views/traceability.rs": "4c89dcf35c25e737d8cce4d543a5989ca104a5678e6cf40df47e457773d2ef94",
+    "crates/oa-desktop/src/workflow.rs": "a00ba19d6d23435d18c9e1f6a0ad2065f889bcfa97aa3840bcdfaa03cb2666aa",
+    "crates/oa-desktop/src/workflow/communication.rs": "34d121ad97706012722e4bb6210072ecc3a5b4718b0ceab0c3d0f14d4cd780a1",
+    "crates/oa-desktop/src/workflow/recovery.rs": "0849b0f34dba5e8761be5fa05784d134ac74e4e9db395d6b9b7d6cff71e3f3dc",
+    "crates/oa-desktop/src/workflow/transition_tests.rs": "589b1b2dbadca74a52c2cfcfd4fe620bd4790abd113ac02182e91616c52d793c",
+    "crates/oa-server/Cargo.toml": "527ff5e15010a8b560a6659aa1ae4bf0c8df0d9e019f03c47529ec6a750c0982",
+    "crates/oa-server/build.rs": "ab1be6ae1fd8bf3ebaeef6348347a9d5e666bde693126f199e041659e0b094a9",
+    "crates/oa-server/src/error.rs": "93817f1502386e4662c96ee1c7d1c4afc4e33bda6fd64e46c86c8e1afd5a9368",
+    "crates/oa-server/src/lib.rs": "20bef350350ed6339588b23af684abf745f97916c7edf3853ee042abe687e664",
+    "crates/oa-server/src/main.rs": "d59a6a2b5c7034bd2e00a516d2d49abb16391bf0316c1c357ddafb9c82d2d1e3",
+    "crates/oa-server/src/preparation_http_tests.rs": "454b90d0055d35644c8d990cd7576ddf675a9b271ca07fe9b0efce25d8ddbc07",
+    "crates/oa-server/src/routes.rs": "3f9a0c22043dbf28f7a8e587d2fc3abf869f76f4d23a46fe0aeb9c4392454a4b",
+    "crates/oa-server/src/store.rs": "37dcfb845b7993d5bced2bcf25fedfcd2a9c20a748f9315afe6cca1f41f89ae5",
+    "crates/oa-server/src/store_preparation_gate.rs": "427c390da3c0281ba1fe115a93ea90800e3b45fce6bcb9185e71982ddd885fec",
+    "crates/oa-server/tests/http.rs": "50daa6a90e96ad6fe3c6a27df2eaebe486270599c203892d09769c547a194975",
+    "crates/oa-server/tests/http/communication_limits.rs": "ba5474dd8e494a0176fffb4548c8e3deb2081b15de33bfce82394c764e0a2c16",
+    "crates/oa-server/tests/http/data_contracts.rs": "8cd456db83f301baca380acf025a5a99db4edf7d8839537dfbd02c4307e10e6b",
+    "crates/oa-server/tests/http/port_anchors.rs": "7199d0a208ddad9e1518b6e3fb390d64da111716d7505ba5c995deae19ad1258",
+    "crates/oa-server/tests/http/semantic_transitions.rs": "856d1c9b633ffb581e3e631f4e5a607789a02181dbf060667f208a569bfa4920",
+    "crates/oa-server/tests/http/source6_views.rs": "867bccda0e030eeeb9976b4ceeb47b21ab5044d700278022d5fb495bbb64ca07",
+    "crates/oa-server/tests/http/source7_contracts.rs": "0e0a467186da7263c0754890aff69ebd0d92d36b5224e4865bb6854b18dab7e8",
+    "crates/oa-server/tests/http/source_projects.rs": "8ff580f317ec267d1cd72ae14d8638f74a77cdf99ca4c78f66f4290c2d77460a",
+    "crates/oa-server/tests/semantic_http_contract.py": "4737ff94f10761f94151a694414c5c62737e0391ec820bca132830652bc4cca2",
+    "crates/oa-server/tests/semantic_schema.py": "70c9d267268bd390680f290a585bd4ae0c6d8ef999ee2f32ece6e172293574f7",
+    "crates/oa-server/tests/state_representation.rs": "6686c826f28248ae4b63ec3f2112e193d4a347724b87974483217fcfee49cd61",
+    "docs/acceptance.md": "32ed3e4fed63f5c464e0937221f401d71623b276dd70f083531ac6ccebbf9050",
+    "docs/api.html": "6f18cfc2a35eba631dbc61d04cd2721e0e361efff1699bf56d2c450a30a17a0d",
+    "docs/api.rst": "7eb258088824efa5ac94311b07b73eb46edcac3c300a2aac78d3802111e338c4",
+    "docs/architecture.md": "a50bd1645222ef3e574fa07a6ab9aa213431ee8833c6c0158ad91ce0f799543c",
+    "docs/language.html": "739a5bb100c7cb0ed70e18afd1e363029757f3cfd6580bc9c5cf77faccb46940",
+    "docs/language.rst": "894a1a77f97d1aa94c11762fe4e84b4d95e181a77c630324c16c307637ed27e1",
+    "docs/linux-packaging.md": "41a1bb1095801df37a1411341c5791d55ea8c365739314d599a60269ac4bc7a0",
+    "docs/openapi.json": "c6ae512f791a939eaf6ec5e5e78e9468bdee0e028092d00098bd90ad9498d967",
+    "docs/research-v2-architecture.md": "1b3809f2dabe6b1805dbf3d3f2625c471cd21356c7bd603916466a8c4ced8090",
+    "docs/research-v2-semantics.md": "b7ec3677300248926a88b84da3e7ffe52f5b73524c7712c927a0e951569db04f",
+    "docs/research-v2-service.md": "4828df5bc679e7c71f49b4b85c9e7dacbec52f46d416fed48af70e08886d4e4e",
+    "docs/research-v2-ui.md": "894e721b59a8ca85f0d95b6706ed5f130a0372def460cf33aeefc9e5e38cde0a",
+    "docs/scope.md": "58b88a7f0b1c8a79edf23c375a141d7b1b821bca4f3212a80e29db5ea3fba796",
+    "docs/server.md": "4eb24937d424ba8b384e1734e02a6f8e963ae11d2715889c92b14b39ff2e4a48",
+    "docs/source-cli.md": "34f12b72cc6d6ead4f47c7818c1897db592f8ad493c70776db2ab48c24d8f051",
+    "docs/v2-interface.md": "c7fbaf0ebd3fc9f6c11f818db2b0b9d68a33f580cfced22bde83ce08ae790bc7",
+    "docs/validation.md": "f46ea950ed1a54409aa07c4f9e90f39f8e2d00c1dd1b6cb805caa3993845967f",
+    "docs/windows-packaging.md": "2c852ff7041713ffbff3c951ac98df647c51fb70b0feba9000f7bfd5bc2703a8",
+    "examples/coastal-rescue.arcadia": "7e183ef9fd8154d3074303f1956cd0d9871c19e3ffc630d333b0bffbd6e30e17",
+    "examples/coastal-rescue.json": "242f0b031229a87af5c4ebe5d651defe59c191a6b7a69dc0a77f7e203411f195",
+    "examples/legacy-v1-coastal-rescue.arcadia": "4dbbbdf8bc7e6cb8e0a81dd678069dae585a9e5187c59bc3665e1fdab3f1a86a",
+    "examples/legacy-v1-coastal-rescue.oa.json": "fd0e9dedfb7adb922dc0575cc2b820d40344d639f1d8052bd70363aa59de9c24",
+    "examples/release1/README.md": "113cfb1cf38a98b51bff60442d86a35d636a3d80ef206bece7d53d0aae67f2d5",
+    "examples/release1/evidence/repair-check.md": "f4db17bdca4ecbb1bf0caef01b2da5f1f7f798ab3152b648ce6dd8696a6a68e5",
+    "examples/release1/expected-diagnostics.json": "3700393d76b940cfc076bf52861bd7b1f43370f8eabce3594531bd0bf1fc851e",
+    "examples/release1/model.json": "ef0ef4006c3e09d5db6e1b621256b3f7d6642f3a7b09cc34607cfbcca830c727",
+    "examples/release1/model.rs": "15f30f6bde655808fe754665c26d560e36f2a9bad340f346b09137d0d05045f5",
+    "examples/release1/oa/activities/activity_oa_restore_work.arcadia": "83e73d0a013d5c3e1a4af0d9139ab0cfa362d25a846671fc2dac59181061a9d4",
+    "examples/release1/oa/behavior/process_oa_assessment_procedure.arcadia": "172c32c044ef4b5bc58a1f4635cc81f48dabb4014479b47dce7b25fedf2dbd0d",
+    "examples/release1/oa/behavior/process_oa_field_procedure.arcadia": "d2552dc5383e2e91cb302a790364e197f663c2edc013a2ab1978789825c9c324",
+    "examples/release1/oa/behavior/process_oa_response.arcadia": "cf86f46fa5c5d70592ef43f1bc1cb4d968efd8add384ba88036bef6b88aa4abc",
+    "examples/release1/oa/behavior/scenario_oa_conversation.arcadia": "b25be524e98a35ebac5e4481b7609c027b32baf9605e8097f807560f94a77ca6",
+    "examples/release1/oa/behavior/scenario_oa_full_scenario.arcadia": "00a1edf2c9707a0eb62ac070c2d02467874f2c9c1f273cc6ddb53d6d65999a1c",
+    "examples/release1/oa/behavior/state_machine_oa_monitor.arcadia": "447c9ad1359f4a31ecf975ad07c0b08d8e7e03191fb0858e2fc56f377b223cd5",
+    "examples/release1/oa/capabilities.arcadia": "fc8012e5554350b12e1cb80080f8feab80d933c9b33c0f2a7bb500cb7d609936",
+    "examples/release1/oa/model.arcadia": "f7cf914766ea73ec53b85e32d117ea9a9dba52d3e038246863541ae7069b1a15",
+    "examples/release1/oa/participants.arcadia": "951764c14179f27c10e315acf2ea37d1fff54c77b8441e23addd239e8c715ce3",
+    "examples/release1/oa/types.arcadia": "9d0396fb82dd5733edd8d1cf52f968ca84906927c704f9cf0944a7fae215cf49",
+    "examples/release1/project.arcadia": "b2674e6bf77cfe0f6f0ba79c81d2e96d92f39c02ca2c6266d80e91723bfb9fda",
+    "examples/release1/sa/behavior/process_sa_assessment_procedure.arcadia": "73928ced61c06cbc08728d7956676a50fd4c05aa5b7f1ff4f29ce27a0b0f2088",
+    "examples/release1/sa/behavior/process_sa_field_procedure.arcadia": "886d462af83110cbfa55dd232a667ea1446761234471357cbb878794e98e8768",
+    "examples/release1/sa/behavior/process_sa_response.arcadia": "041785fc22842423822431bd5e6e8d16094ebd0716965e7c765fb8c1d7549e8a",
+    "examples/release1/sa/behavior/scenario_sa_conversation.arcadia": "97276f5757ee9aa12a0dbd9d3ccd58174b3091162bb8bcce357cec20a45f5d85",
+    "examples/release1/sa/behavior/scenario_sa_full_scenario.arcadia": "e12fc406b99d60a2f7768aaa0b25ba560e8605f0b8e37f3a7cdd3b8443562b74",
+    "examples/release1/sa/behavior/state_machine_sa_monitor.arcadia": "05ce29af99424c491c47fe2450dc6f5f8ce995511c01ec7e17bb5855be3c9736",
+    "examples/release1/sa/capabilities.arcadia": "b6912fb3ece439912345fa71724acd462e716a1e5a88203a1058a5c3b2c20a4f",
+    "examples/release1/sa/functions/function_sa_audit_thresholds.arcadia": "e5a04325d52183956dca814dd90f4e56c96c6b7db0f4f202f203ecb49c3e0f4f",
+    "examples/release1/sa/functions/function_sa_restore_work.arcadia": "fddeb67308051325041fee641fe758ddf43345b7c47b66d433616ad07fdccdd6",
+    "examples/release1/sa/model.arcadia": "d431509251acb859fbb98733b6d18add952495e10a78703fbe8f31e40bc083c4",
+    "examples/release1/sa/participants.arcadia": "780d2eb08b217b67b55febb3d34846f727b8ee9018df6c5741748647e36b2ff8",
+    "examples/release1/sa/types.arcadia": "101fc0fbd99f1101514aa7b6da4f8e535aae0bb94c9e2b9e7e6c151135b28660",
+    "examples/release1/traceability.arcadia": "48a96f543456c9b5a5798fc795594e4119147fe45f11a6f109f141b7f514560f",
+    "examples/release1/transition-before.json": "2253e6434f741687e22327c37d520ed15c043bc36025498650bc2366bb6a874d",
+    "examples/release1/transition-request.json": "43b9a22e5f95ad3bc0ebd2478ead0e14406854abc989ae94ded9367b013d812a",
+    "examples/release1/views/diagram_oa_allocation_view.arcadia": "dfc0eb61e0e2aa5bda45524571fbfa3494f44ce19696f3e15e07438074a07bc7",
+    "examples/release1/views/diagram_sa_allocation_view.arcadia": "b78b43a26a82efb8fbd5374b09c329fa341f57b29f635d397b9ef8aede71d389",
+    "examples/release1/views/diagram_sa_capability_view.arcadia": "75e8dc9fb30f25d6f8fd3c6b595593ab4f98958a25798f961e336e0fac557649",
+    "examples/release1/views/diagram_sa_service_view.arcadia": "b08c84f3ea633e7c78dfdad3272f75415f6256cf3614b6d99bfd4f0269076c9b",
+    "examples/release1/views/diagram_sa_state_view.arcadia": "5f42f4c605e57b817d8400ed21f2b14bfc4e1592aebe941ff113767504c2b869",
+    "examples/routing-workshop.arcadia": "dc6b75da72884d399132ed9e300fa5a26b73d802bb526c9af986ae9eeb0a646a",
+    "examples/routing-workshop.json": "8592714f75b271133f21ce017d87896b6cf91ea0e4837f1c2ed453e21be26b14",
+    "examples/source-project/oa.arcadia": "5f60642f211b2d352a951092faeeb7503d4fb7f6f7fca99e810347231101d31c",
+    "examples/source-project/project.arcadia": "787f6b67b179ffd221f7e5faf1a4edd74cfd116aa1e3b5e9ed9f22fbff612d8d",
+    "examples/source-project/sa/assurance.arcadia": "ab76044836e4dcd42a82d316846ec87da2108939aa2037640c5bca1d2ecdee0f",
+    "examples/source-project/sa/participants.arcadia": "1abad579812e77877b45a3d8e3c3e9da734be2d04a0254cc730a5257ebd2dc88",
+    "examples/source-project/sa/reporting.arcadia": "f0b7443f728912ca163de39b6055876b533a77feaa3219b2d40a2dd65712e058",
+    "examples/source-project/views.arcadia": "e29ad3f406a6a50d2f0ae2ca2a53ee3b0c18222cd4098704a46d4f48b64ea17f",
+    "examples/text-first/README.md": "4ec8250d5ed556f1d496e8c85137e973e802ecb11df1a36488411e8cdc5a9f9e",
+    "examples/text-first/project.arcadia": "f441535c623e0cf20e1875eb2cd33b587ed00e078c37af39cb36d89bb5edc19a",
+    "harness/fixtures/basic-editing/README.md": "3545d9695e7c62e0caa818efd7f4dc426f04876a3626e0f3b1bad606b258cb26",
+    "harness/fixtures/basic-editing/base/expected-baseline.json": "f239e728d650b0af32bb8f3dcaf6b27c99b9c5041132ac14e51756ea6563d978",
+    "harness/fixtures/basic-editing/base/project.arcadia": "045cb047d7bfbca72c3fb30db4c81a30ad463d3af7fc51604906ad7fa75a1ff8",
+    "harness/fixtures/basic-editing/base/rationale.arcadia": "c01867c9dc0d40726853119fac3c6ad24a40d8d362a93a8b9d20df04ec2e273f",
+    "harness/fixtures/basic-editing/manifest.json": "d23c21b02064ddb85e051e10e16ff089daba8d9910bb1a695dfabe2db3757734",
+    "harness/fixtures/behavior-creation/README.md": "9e5fc751424d12cfe76a84abb1da45b2d38947409179451bb90ffe7e7ddc8723",
+    "harness/fixtures/interface-operation-probe/README.md": "088f0bdb3375deb8f2c7e3b749ca8d210ea828ca4dece69b3871b674e3110175",
+    "harness/fixtures/interface-operation-probe/hashes.json": "f6d3e8aa42f40f64ce2ecba7b9cf112eb9091f3cccde3a592b0434e834cf2a6a",
+    "harness/fixtures/interface-operation-probe/output/after-reset-deletion.arcadia": "c0fe9570684c0061efc4cad65e339fede6961b04ca90c6f324c787bd65e61226",
+    "harness/fixtures/interface-operation-probe/output/after-reset-deletion.json": "93187f7a1b476a44185725c6b15f2e1767482b6911ab1280144348d033eb51f0",
+    "harness/fixtures/interface-operation-probe/output/boundary-only.arcadia": "02f85e39957ebe6d56336fa729a5c8b10f51865face9d3b2c9679200571fcfc7",
+    "harness/fixtures/interface-operation-probe/output/boundary-only.json": "756f9710336e6734ce3592ca774c6f104bba5a37c9e165540eb39326682393d1",
+    "harness/fixtures/interface-operation-probe/output/explicit-functional-refinement.arcadia": "ac5b629ba5596464f9f8a975b8bc2764e3007ceb7342de3f828d4b18e4f069b7",
+    "harness/fixtures/interface-operation-probe/output/explicit-functional-refinement.json": "78a47c978dc667aa1c45af711f06aa2a0d3c581003013e30c3e02fb0faae2e64",
+    "harness/fixtures/interface-operation-probe/probe.rs": "72b1b443e25eb20420dec4477b0fb5ef5d1c705e3882c81df88dd578ab96a426",
+    "harness/fixtures/release1-native/README.md": "5f5ba040fd2df9261a29bcab3f9a7ae27c3683265411ad3dda0b467d5df8590e",
+    "harness/fixtures/release1-native/artifacts/README.md": "24200c84ccc2ef3e17c029744074e5cea785188f5549ac54e44cf89682643f81",
+    "harness/fixtures/release1-native/artifacts/generate-semantic-artifacts.rs": "444f360b78df52c5e42046f77b148781e0c9bddc2a09c0b7bd65c7a4f376cfe6",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-create.after.arcadia": "84b22e95c213018612e6e8a84cad68b35a8b495ff3515b0f978c5e7a3d196d79",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-create.after.json": "13a6f99ec2df1dd35ee8b2613f183918cd9537eda4a5da085ad52e65c033db59",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-create.arcadia": "1e0d662ba33071b122ad9206d2d559a8e748c9431eb3ac1b759bde3760ca877c",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-create.json": "fa6a2e3643c0f909b92407abec3edc897033162eeaa501f8d4616f79d41fa044",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-create.manifest.json": "65cb70b0d697a055363ba01bf30bed7e412d43c9978a033549c378d117719ae7",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-create.request.json": "ed905267263e7f8a0cd2dbe833196b30118b6a246815216932fae661ad650699",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-delete.after.arcadia": "e50fc462ec22dbf98011929931dd2489430001c3e6433608685b9d88bceb9acb",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-delete.after.json": "f27a7b38d59c7cefe58cb36783d3d4dd8d8ae1168d9aed1eb61d343c18758908",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-delete.arcadia": "eba2aec39e6efb405eace4bc8ab0c5563907c26d449e71a4aa750df9f73233b4",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-delete.json": "2ef777f19b94f08b5e5ca2ef727777897e1018f1426eee291408b3c69101f596",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-delete.manifest.json": "3af7232ed3056ca84dcaf0f266ead3faaa512a0dc0051c7ba68791c20dbae0cf",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-delete.request.json": "8af21b00b62e620256fbf50e47c6c5836cdb6922d9549cc4b3d86bc03b008073",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-move.after.arcadia": "20bb30473830e44228958e78fb7480269cdcc0580c6c90c718da75f34ca5a43f",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-move.after.json": "44f4b05db49758dcf344788f57cecc0250fd029099b1c54e4e1e3e972f6cf039",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-move.arcadia": "b0fd031671c9f755756922ec5c40a0ce3f40164d22c3c389aec9fd0705344da7",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-move.json": "1acf81e08c51c85aceb14a3efbc39ec680552a19c7824aab4611ac3cf71b9c6d",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-move.manifest.json": "a07978f4b0a3ca83e5ae5f35e7b66b26473b24431fc90e5889d755f1816d52dd",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-move.request.json": "5ff844a038b0030adb5a83d13d81e60f30627543388f6199b6a0e026fc42ea58",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts-native.md": "a51ffbc45b6c172cbfed3b16c249296e6a28d457fea57393dd958cdcfbafbca1",
+    "harness/fixtures/release1-native/artifacts/semantic-artifacts.hashes.json": "3ad8b7428b3ed7585a91e7f5d9d5f4880caccfd0b08dca25d05af523e62e0a10",
+    "harness/fixtures/release1-native/communication-means/README.md": "015c16010c212af283f9def118c6d263ba65a3bc6e81a750f180624ca69bb311",
+    "harness/fixtures/release1-native/communication-means/cm-create.after-template/entry.arcadia": "a6976e7c21031e7cc3cb731e20c3075cf89cf85144dc8d3f52930f8521ea196f",
+    "harness/fixtures/release1-native/communication-means/cm-create.after-template/expected.json": "60c4419415c546f06c9972ac7bb0e530ada7b30a200b59e75ddda231a24f9a3d",
+    "harness/fixtures/release1-native/communication-means/cm-create.after-template/traceability.arcadia": "3c41459f2b0706a767988738bf8126f76540415bb5940d9c5db19cbe8c18182d",
+    "harness/fixtures/release1-native/communication-means/cm-create.request.json": "b16e673b29c96b5aed681389ff7669110abe552939e86dd0ec6011c9a45ed860",
+    "harness/fixtures/release1-native/communication-means/cm-draw.arcadia": "a511a4d817d9c5c80233bce83e84a7056b7dce7afd9fcc25696e333f8f4df055",
+    "harness/fixtures/release1-native/communication-means/cm-draw.json": "7140114926228b1c378c450535f7a70992c71a879a8d2270c49e8d5f04a2f484",
+    "harness/fixtures/release1-native/communication-means/cm-reuse.after-template/entry.arcadia": "910e6dfe609467047ce629ec9c626f4e927cada74bfbfa164414a8fe6783ea87",
+    "harness/fixtures/release1-native/communication-means/cm-reuse.after-template/expected.json": "567259e20c9f6278776e8fa99b8b2fdbbc9a883ad875c5d39dae1b53de3a2924",
+    "harness/fixtures/release1-native/communication-means/cm-reuse.after-template/traceability.arcadia": "997f72fe9258012df66e88344cf39c1a2cebf2327f604056b67f7f2a8ebcfbfa",
+    "harness/fixtures/release1-native/communication-means/cm-reuse.request.json": "cb3fe05859cfffec6f8846c19983dc462413bc0ea4f6e19204f09c259919c4b1",
+    "harness/fixtures/release1-native/communication-means/cm-reverse-behavior.after-template/cm-reverse-scenario.arcadia": "ec826b9b84616507490ac30e4d57100dd6338dba2f7071e879a8fb58820a85c5",
+    "harness/fixtures/release1-native/communication-means/cm-reverse-behavior.after-template/expected.json": "ef07e4d2d3fc36004ff01739838281581d9a703c747611eacc01bb9cc672489f",
+    "harness/fixtures/release1-native/communication-means/cm-reverse-behavior.after-template/oa/behavior/scenario_oa_cm_200.arcadia": "0ec8d7e38f5a5cd56ccf3979757b3a9f412ad0ae36ee6c2690b7872129046d70",
+    "harness/fixtures/release1-native/communication-means/cm-reverse-behavior.after-template/request.json": "c0ac99ee186d126fe3ec57f2c0a4072984d39d36ad21ead357ab66a08ac0065c",
+    "harness/fixtures/release1-native/communication-means/cm-reverse-behavior.after-template/traceability.arcadia": "dd5d356390089e4ec474374956f6219502733987e60ef8ff32920d8b33dce858",
+    "harness/fixtures/release1-native/communication-means/cm-reverse-scenario.after-template/entry.arcadia": "86dd8a355f6c9dadfea56d06e5247c9b0f820819d7df17ef5690671c7c81324b",
+    "harness/fixtures/release1-native/communication-means/cm-reverse-scenario.after-template/expected.json": "980489ec2c483d4f9efada61358c1f29bafb2572fd5b804c656b91b8e9bb4f9a",
+    "harness/fixtures/release1-native/communication-means/cm-reverse-scenario.after-template/oa/behavior/scenario_oa_cm_200.arcadia": "0ec8d7e38f5a5cd56ccf3979757b3a9f412ad0ae36ee6c2690b7872129046d70",
+    "harness/fixtures/release1-native/communication-means/cm-reverse-scenario.after-template/traceability.arcadia": "dd5d356390089e4ec474374956f6219502733987e60ef8ff32920d8b33dce858",
+    "harness/fixtures/release1-native/communication-means/cm-reverse-scenario.arcadia": "1abc4c4cac37cfb06ed3b12a115f9e7e6a2d3affd34b25c355309e5ee465fa40",
+    "harness/fixtures/release1-native/communication-means/cm-reverse-scenario.json": "a5cf4cb2ef390113dd752f4054d43fb789da2ca77799efb5782805ae8aa2dfd5",
+    "harness/fixtures/release1-native/communication-means/cm-reverse-scenario.request.json": "c0ac99ee186d126fe3ec57f2c0a4072984d39d36ad21ead357ab66a08ac0065c",
+    "harness/fixtures/release1-native/communication-means/cm-transition-ready.arcadia": "b761c4c2af5f7064aaf1f887ffd6094eb6ae834b2c8057ecdbc4aa97c042066b",
+    "harness/fixtures/release1-native/communication-means/cm-transition-ready.json": "2536b000de361fb131787e32b466b9123d4e98abf00c099ad32f6cb8e7fb530b",
+    "harness/fixtures/release1-native/communication-means/generate-communication-means.rs": "003521404b702332082e01f2be7676fda1dd7b5bcf220bb81d25120c8984c75d",
+    "harness/fixtures/release1-native/communication-means/hashes.json": "39b4dc02fc8b074015c59354fd1c1061c25832fde25065c7151f36eb0455e6f6",
+    "harness/fixtures/release1-native/communication-means/manifest.json": "fb921f42f2c4a4f8a67d1266f17f8c7750b6a2619554b713aa92b17918f0c43e",
+    "harness/fixtures/release1-native/dense-40/dense-40-oracle.json": "74edca148583f42c269e51f135662f65ef1c9ea1c94516d63e2a5091967dc99b",
+    "harness/fixtures/release1-native/dense-40/dense-40.arcadia": "00b87736b82c5afd33b311df7aebe9a6c8c51b6de66221181b5ea8bc8ca221a3",
+    "harness/fixtures/release1-native/dense-40/dense-40.json": "5dd4f22453330cab3abc059881660190e689a22619853f77cf6d0b52735d97ad",
+    "harness/fixtures/release1-native/semantic-attachments-native.md": "28906924b05f75bbf432389517aef65f1df474d2f2bff79a3586564f7f7328ef",
+    "harness/fixtures/release1-native/semantic-attachments.after.arcadia": "9d084dd75a0251d349cc31f9ee98df58d0bc76859dc3cb1503f242e2f759888a",
+    "harness/fixtures/release1-native/semantic-attachments.after.json": "f09be41afd85c18fd52fdf997e9b81c4b7cb2c41e78d167abcd14caea8110333",
+    "harness/fixtures/release1-native/semantic-attachments.arcadia": "8740f27be99624013d9be876639c0411e1b8c14f0f9a843f43dc71d769efd79a",
+    "harness/fixtures/release1-native/semantic-attachments.hashes.json": "00fc9e2c709bdcd9ee98012176cb0edb635c112153d963cd169bf4bf69a9e010",
+    "harness/fixtures/release1-native/semantic-attachments.json": "9c188f2890630c7feec2be719a7104af9690da7ea836df18fa78da3ff2acfc1b",
+    "harness/fixtures/release1-native/semantic-attachments.manifest.json": "46b40f221ffad614733b615208814ace63947e96b80bbfdec63853ccd4f4e8c8",
+    "harness/fixtures/release1-native/semantic-attachments.request.json": "b57f656f0b9cf2c595e83150c683301909e20f15684d35d108d3c57ee0dc5909",
+    "harness/fixtures/release1-native/semantic-batch-native.md": "dddca2b85f892b05881c75ef3cd62437396cc086a09909b621e02bad0cbe56ff",
+    "harness/fixtures/release1-native/semantic-batch.after.arcadia": "d3315bba762395205ae761e6e64029e8b4070c15a1299c6114075581db7b0974",
+    "harness/fixtures/release1-native/semantic-batch.after.json": "8f36119c7e893a4af374b13b85b1c2cb3df0196df8d06a551386628fc8b8646d",
+    "harness/fixtures/release1-native/semantic-batch.arcadia": "5e1f433e04621424edac43e53411624059e873f88dd531bfdb39093953485ed7",
+    "harness/fixtures/release1-native/semantic-batch.hashes.json": "1bd87700b04e4f169ab5f8aceaa3b0c3ec3a1cc43e1bce135a1cee506fc75d38",
+    "harness/fixtures/release1-native/semantic-batch.json": "1972242d2a8677d004dc3af1081feb292de65fe26128d877dded8661f9906619",
+    "harness/fixtures/release1-native/semantic-batch.manifest.json": "1e440efa02e2ccc27585d9a49c7864d53e3e3e7645ccb219f040e00d95331b8e",
+    "harness/fixtures/release1-native/semantic-batch.request.json": "71f23474614aab90398ce24f00f2cf61d6cb9a3a34faa3e12e0c8104e0a71073",
+    "harness/fixtures/release1-native/semantic-keyed.after-repair.arcadia": "e3ce0347746584f503b825a8b6bd23a7eebf0827940112ef8f36d500c1d0a043",
+    "harness/fixtures/release1-native/semantic-keyed.after-repair.json": "29736f2a619f7f2d0e795229f6e8c3645a1b4eca6292043cd604aa01b1ec9170",
+    "harness/fixtures/release1-native/semantic-keyed.after-take.arcadia": "9ab573c92be66e3bae659dd826923ba6066979b1651edda7bd469056632cd77e",
+    "harness/fixtures/release1-native/semantic-keyed.after-take.json": "828c990c6129692cd31c7f6ed0dd6c952f9cfffdd90bc80171df82d4d929afba",
+    "harness/fixtures/release1-native/semantic-keyed.arcadia": "49214be2ca9c8bb6195c3b39737c053847021839f70f0bb2921d35a1fbd2ac83",
+    "harness/fixtures/release1-native/semantic-keyed.invalid-request.json": "8b02d4739b1be2c8a64da76423b4a6cae7d89c60f4d30723b94f1da3779cbcca",
+    "harness/fixtures/release1-native/semantic-keyed.invalid.txt": "aa536e18bc65325163e9b645a4ad031ab599fcb05948dcf741b725d0f0c8b602",
+    "harness/fixtures/release1-native/semantic-keyed.json": "995dd72f5c1f07f998233ae9847e337cb82de0c2a9053d3905be021d5f8124b9",
+    "harness/fixtures/release1-native/semantic-keyed.manifest.json": "ad315359bfd68ce0d265976dc9e4ea6a502ebbb87d7339dd1af5ef27dd01e433",
+    "harness/fixtures/release1-native/semantic-keyed.repair-plan.json": "27bf316ad66ffa91f6323e75b0c280baf5caec298645793dea72c5d42aa3b782",
+    "harness/fixtures/release1-native/semantic-keyed.repair-request.json": "f4f6b5480ec8927033ea469ea82c1e8411cb6dba95d2da680f15bc193914c9b4",
+    "harness/fixtures/release1-native/semantic-keyed.steps.md": "7d7e38d93641a5f22a2738baa4dbacc392eebb477a855cdce0641961980a19ad",
+    "harness/fixtures/release1-native/semantic-keyed.take-plan.json": "74dd68ba686b8928054480f0bfed55aad91f6f1208803399dc9878e894f57ecb",
+    "harness/fixtures/release1-native/semantic-keyed.take-request.json": "d19a53002a6bf95af3123a3ef9f78baaf7ce1085d4f06f0f4a9d5e5d5accbc0e",
+    "harness/fixtures/release1-native/semantic-ordered-branch-steps.after-order.arcadia": "90277f1780d43a6f0b2184bf00b87e7a4f3518d67c6f10d4793daafe1aabf493",
+    "harness/fixtures/release1-native/semantic-ordered-branch-steps.after-order.json": "5a3c8494f6976c23b990c14b40760fb2f32ca9973caf6f31dab5632310663591",
+    "harness/fixtures/release1-native/semantic-ordered-branch-steps.ambiguous-request.json": "6a86fde194faa55f2d1bdb982571e0e711e5401b53a960e6acb8cf3e17f506c8",
+    "harness/fixtures/release1-native/semantic-ordered-branch-steps.ambiguous.txt": "0f938b23fcfce776a61a57de5a2c82b4a0720b5e5af6780fdb96f5f92b3edd21",
+    "harness/fixtures/release1-native/semantic-ordered-branch-steps.arcadia": "e7c30c5a5c3ba7209c8e223f02da55821d7af10a2f09844a7065ae6cd8f22aa5",
+    "harness/fixtures/release1-native/semantic-ordered-branch-steps.final-plan.json": "d1e5c2ed08e0aa6274a0421a39876d1ba99f4e441c7a0a68660a83b9e017da14",
+    "harness/fixtures/release1-native/semantic-ordered-branch-steps.final-request.json": "433f723252598994dac7184da61f95344b528156cc5a0fba1a7864b2ec9f002b",
+    "harness/fixtures/release1-native/semantic-ordered-branch-steps.json": "9e4e2ce1c7879935ad0860a3ae720506c929a8422b51491b719d88af3fd3ff2d",
+    "harness/fixtures/release1-native/semantic-ordered-branch-steps.manifest.json": "87e8899c7d4e54faedeef32afb7592fb65278d1bd7390850ab198dcf62068329",
+    "harness/fixtures/release1-native/semantic-ordered-fragment.after-order.arcadia": "6c77ed42bbf9f4ebe08bfa233197a4020e5587ce33747f7914430aa0c662d9a3",
+    "harness/fixtures/release1-native/semantic-ordered-fragment.after-order.json": "1dd7ca2bcfc84ac23369c506302b39569d2ebc41e5a4edc99378a1fe01923b7e",
+    "harness/fixtures/release1-native/semantic-ordered-fragment.ambiguous-request.json": "e0ea7aeb25687ae63c65128f1aab78273f14030d179d3fbea63fe91ab5430136",
+    "harness/fixtures/release1-native/semantic-ordered-fragment.ambiguous.txt": "0f938b23fcfce776a61a57de5a2c82b4a0720b5e5af6780fdb96f5f92b3edd21",
+    "harness/fixtures/release1-native/semantic-ordered-fragment.arcadia": "563c36162050c8564ffa25a85c726462ecdaebdb87659b3f3610506bfd5581e6",
+    "harness/fixtures/release1-native/semantic-ordered-fragment.final-plan.json": "f96c43fc58dbe48a044b628b31bb3f0b59171dad5b6982ec6c34a5597e474130",
+    "harness/fixtures/release1-native/semantic-ordered-fragment.final-request.json": "d38fdb13612b07254edad80848f79c1e097d5f868c020feae9ba072aa697a50d",
+    "harness/fixtures/release1-native/semantic-ordered-fragment.json": "2ed0daed118f2df13dcad738dab174ad34d44a15921cf8097415e707978b0968",
+    "harness/fixtures/release1-native/semantic-ordered-fragment.manifest.json": "c79bd12a85d8d4f25cc3ee43581b3e5e74ae9ad7e4de0c72764975ba2b89c279",
+    "harness/fixtures/release1-native/semantic-ordered-reverse.after-order.arcadia": "98020e048ac01f285c6ad8c10ce22bef05e193b5ba0f5558be1fb26a7bf82620",
+    "harness/fixtures/release1-native/semantic-ordered-reverse.after-order.json": "ea3783992488bc6ee944eb91a26ccf3dbc05a3909528fc32ec8023a76765cee6",
+    "harness/fixtures/release1-native/semantic-ordered-reverse.ambiguous-request.json": "ea3cfd25f7a50481805956fb88ab851516dcd602dd6564502a0cc55f7de6a54f",
+    "harness/fixtures/release1-native/semantic-ordered-reverse.ambiguous.txt": "0f938b23fcfce776a61a57de5a2c82b4a0720b5e5af6780fdb96f5f92b3edd21",
+    "harness/fixtures/release1-native/semantic-ordered-reverse.arcadia": "2b7c3694623bbea3e36dcc6f674d4adcd91e23c8e1005ded21e5a69648a048e5",
+    "harness/fixtures/release1-native/semantic-ordered-reverse.final-plan.json": "95a23bd334cffcaef0c3b1012b7555efd2a077ef6f9140d58020910ef8a76723",
+    "harness/fixtures/release1-native/semantic-ordered-reverse.final-request.json": "1e2433ed5821bf65443f56cb27381ee935db81b1955d3a539b7952898312a410",
+    "harness/fixtures/release1-native/semantic-ordered-reverse.json": "0033f8780c2ba69779b811bca792340c25a092f887e5811c6839f0a691d744f2",
+    "harness/fixtures/release1-native/semantic-ordered-reverse.manifest.json": "e3b4a60a56abee779ca8356605c968aa2d99256a3bd3c5601b14b5c5502a1a05",
+    "harness/fixtures/release1-native/semantic-ordered-scenario.after-order.arcadia": "e265cab35097acc46f5123107c13bc35b9f71931ff650557fc1c85779141b327",
+    "harness/fixtures/release1-native/semantic-ordered-scenario.after-order.json": "9b777828d3681138de6bbd08de8bf922bed92c27be60b103d8ff73ce7ddd0a48",
+    "harness/fixtures/release1-native/semantic-ordered-scenario.ambiguous-request.json": "7d124256730bf2feee772c7d0118b87eb288e8aaa9179d69ceb9259dbceb2c71",
+    "harness/fixtures/release1-native/semantic-ordered-scenario.ambiguous.txt": "0f938b23fcfce776a61a57de5a2c82b4a0720b5e5af6780fdb96f5f92b3edd21",
+    "harness/fixtures/release1-native/semantic-ordered-scenario.arcadia": "87a5a3665dab2dd6e595867dcebb1586e93dd067c85d6e24b1a4d3ff0ad6d4ba",
+    "harness/fixtures/release1-native/semantic-ordered-scenario.final-plan.json": "1888ca51e0923866a9afea99cad069fe5d3f19f0a1b24328e20ac1b9f52d8bad",
+    "harness/fixtures/release1-native/semantic-ordered-scenario.final-request.json": "5070a5b85feb1bc7b1fc648cd5d35ef26663492c8666dcd471950c06ec3a6052",
+    "harness/fixtures/release1-native/semantic-ordered-scenario.json": "725b35e36640c81c70c7efea5c3304bf61b49ef9664194ca0d491782cc62191a",
+    "harness/fixtures/release1-native/semantic-ordered-scenario.manifest.json": "1b43abf8fed3061c65a7b7cb103d31ea7ece333a2da83c645f8d228448c4dbb2",
+    "harness/fixtures/release1-native/semantic-ordered.after-order.arcadia": "65a6217f474b5085f37b511151185c2c08ff7a1998e924f1fe01f29c410f6ced",
+    "harness/fixtures/release1-native/semantic-ordered.after-order.json": "8a53bb9b43eab5b6dca5e08deef20c14c96e134b9ee816a99b7960bb5255e008",
+    "harness/fixtures/release1-native/semantic-ordered.ambiguous-request.json": "c704f99245f00d5c3be0562d91931b4e7f1fb3fb36f41991eb76656ffbd6129f",
+    "harness/fixtures/release1-native/semantic-ordered.ambiguous.txt": "0f938b23fcfce776a61a57de5a2c82b4a0720b5e5af6780fdb96f5f92b3edd21",
+    "harness/fixtures/release1-native/semantic-ordered.arcadia": "c59ec1233d5a9fbb8e386f6d9b13f398be21baf813ba215efb51bfc1bb98db36",
+    "harness/fixtures/release1-native/semantic-ordered.final-plan.json": "30c5c3f614a74708763df612016483623792f4c65e2ed2fa662ac417cfb852eb",
+    "harness/fixtures/release1-native/semantic-ordered.final-request.json": "3b6c35ef78133f0980cb6fb53fbc29c5d3c4deb5dc4be01c2c3384e221987b9b",
+    "harness/fixtures/release1-native/semantic-ordered.json": "c159c60403abcf8fefab7f19cbad9989488e8ccc20b82c57597b22a0ae254802",
+    "harness/fixtures/release1-native/semantic-ordered.manifest.json": "af8a314a9b1d85a8f98affa5a6649f43d252851158798e1ad687bb1b6966b14f",
+    "harness/fixtures/release1-native/semantic-ordered.steps.md": "6004894e9d9f478b7fe1c3c3e0706dcc546d5df8557cff91b4cf26f8a4badf24",
+    "harness/fixtures/release1-native/source5-recovery/15000000-0000-4000-8000-000000000010.json": "71cca2a59f36b2a07d11dedbe9101226aa1a4a00d8ac244b5565202e56709f51",
+    "harness/fixtures/release1-native/source5-recovery/generate.py": "e44986c1d563499f25917441220b23883fc9cb0f89faf409873191f0212fbd2f",
+    "harness/fixtures/release1-native/state-actions.arcadia": "9cde82608110e56aa9e14c9e33eb38976f53aed74ab013145d411d5743a0ec26",
+    "harness/fixtures/rest-coverage/README.md": "df4a391312e0c8b20ccdcc850199443b08547be1b10b1f2447a067bf4bf544e6",
+    "harness/fixtures/rest-coverage/coverage-probe.json": "699b868dd6c955f7ef02f2f061935471f3d21a406005fcdecba8cc719cc69a1f",
+    "harness/fixtures/rest-coverage/run-coverage-probe.ps1": "f24f19fca418b76a7249894a08c116e16b465a02f8f899d12b808ccfdd90a3bd",
+    "harness/fixtures/run-timed-bundle-oracle.ps1": "fab696486a574f9867c6e69a8a8b960e7e9722206441b9cc5f36d41f285f1a25",
+    "harness/fixtures/scenario-authoring/README.md": "6b651b180b76d10b00bc49d77a8f5e0b3ba0317446978f41b541f5bb23fedad8",
+    "harness/fixtures/scenario-authoring/base/expected-baseline.json": "abd8246c939ebb8a2162ef82e23d0fb322ee1a8b4d0d7c28a34037e42e86e841",
+    "harness/fixtures/scenario-authoring/base/project.arcadia": "9b1afbe96b0bf8fa613451b00929492f05a59b9eb2ca74c2c374a8b7bb7cba9e",
+    "harness/fixtures/scenario-authoring/base/rationale.arcadia": "82df210f22f6aa336a3e7e00240977d671c7c3923db7bc58fb29e6d98b67ef49",
+    "harness/fixtures/source7-native/README.md": "7abccbc3da0980d1d099761d1a66d12c403a0f543954134537ecd4930d182b4b",
+    "harness/fixtures/source7-native/base/expected-baseline.json": "e2882a58f841f460f45d9d67db1606440e0d7997b9b29a784569ae48e4b23bfb",
+    "harness/fixtures/source7-native/base/project.arcadia": "5474d8ca05fd1375220dc0ad40d913631fde51159e9632bb9f290d1ecdab8dd7",
+    "harness/fixtures/source7-native/base/rationale.arcadia": "e6a600e13036d4ad594a65380ed1b3d82d1772d583041bb0a624c9588a73047a",
+    "harness/fixtures/source7-native/manifest.json": "6c57164a796234d83818d462d0a25f10e77062d405769e602ae2a7bec251e3b6",
+    "harness/fixtures/staged-source-authoring/README.md": "711910a12d5f3960f32da9aa7bc2e647f31d770c84b7fc26e232dcb3a76f8821",
+    "harness/fixtures/staged-source-authoring/base/notes.arcadia": "ad9de02963c20d1f43856455a797deb05ca674659e45f2c4b96b52783024f8bd",
+    "harness/fixtures/staged-source-authoring/base/project.arcadia": "aa844950ec4fb86f262a257e1fc370a26557ea7978d8a4cab78265037660234c"
+  },
+  "shared_non_cargo_inputs": {
+    "LICENSE": "51009f2cb07e5d19645858b2fbc037a672a25f8cbf7999522942b86807ecf365",
+    "docs/openapi.json": "c6ae512f791a939eaf6ec5e5e78e9468bdee0e028092d00098bd90ad9498d967",
+    "build/windows_manifest.rs": "168da2c42ecccfebc11ee3e1b455e653a68fe9c6d30a9842a8b9e7441d086c80",
+    "build/windows.manifest": "9c19c5a02f858ece84c44839ad2b145d9c1d90442da0b15c87fd045f975974eb",
+    "build/windows.rc": "a27385edcae0bcf96f55361056cb7be5f36d76fcddcaefd20647c91959563e1e"
+  },
+  "historical_server_inputs": {
+    "crates/oa-core/Cargo.toml": "64824ec447be777841a972bf06c894ef2624a37e4725583bcfe0389deb9f00a3",
+    "crates/oa-core/build.rs": "ab1be6ae1fd8bf3ebaeef6348347a9d5e666bde693126f199e041659e0b094a9",
+    "crates/oa-core/examples/generate_demo.rs": "e26f432c95331aeca50985dbb3ad2c558affd43023b585811f0f7bfaa59f6661",
+    "crates/oa-core/examples/generate_release1.rs": "1d5f11165d74893e4bc18dbf3a2f2111f4026bd89fd06ee7f0bae69e45c4d4b5",
+    "crates/oa-core/examples/release_dense_views.rs": "a83158488ef9b7394f136c52b1496719be935c4e5bdfe457cab5c9894f5f9412",
+    "crates/oa-core/examples/routing_workshop.rs": "571307b18b6d4fa04700c5a4d4b0c2154c419e93a21292b2028e7b6f46a2faa7",
+    "crates/oa-core/src/data.rs": "7f9c7c7dd8353cb5a38597b92cde6d3e890203d392473187eb387d41ff37414a",
+    "crates/oa-core/src/demo.rs": "ad62123f96c20ff023cafc1a9849b0fa06bc62edd1fb9701799e4599b458600c",
+    "crates/oa-core/src/language.rs": "638f08a42e9cf4996b5d07f69b4d6f517a518369f3604d25be1006e40e080765",
+    "crates/oa-core/src/language/semantic_source.rs": "584b5bb59d87a7b8d44d5dd2d124c3a1323b21492b138a17bc9526c0087c9e29",
+    "crates/oa-core/src/language_nesting_tests.rs": "bd061611e8cb6f28ab203c73e544ac98bf275eb464cd314ad5fbd25f773df33b",
+    "crates/oa-core/src/lib.rs": "52cb6ee7a4ffc00711ecf121c1a1b14ca154863f7ca27b0d2a8e239edce8aca7",
+    "crates/oa-core/src/migration_v2/README.md": "fb61d3faa33d7bdfba73415415a0882c0fbd3e0b45df42f972a19aec6da927b9",
+    "crates/oa-core/src/migration_v2/adapter.rs": "66741b4c8354a23b8a932ecc5bf1bc3bb6e74279558757b8c35bc2157a7e51b5",
+    "crates/oa-core/src/migration_v2/mod.rs": "857d8bb13b6814daba6780ca770c16352943c01cb130245d055f11b3b957b3e9",
+    "crates/oa-core/src/migration_v2/model.rs": "8ac63eb59b2e57bdecff2477ee0634096090924d3dd1851e1c454880a889dacb",
+    "crates/oa-core/src/migration_v2/references.rs": "33a6819abc83139fdaebeebd1b553238a328637106cce7dd5a535f1791d43e20",
+    "crates/oa-core/src/migration_v2/source.rs": "74fee9b24e7c912182c998ab9d9aeec125e2009c3214959229e844c67afe2bf6",
+    "crates/oa-core/src/migration_v2/state_validation.rs": "e29ef071bab0a68460ddf55c46131c6f66c022d52c3c602c37c013c3649da1b0",
+    "crates/oa-core/src/migration_v2/transitions.rs": "f74174c532ba56b57c80b719a11fb4adea0a78ccc2828fff72fe2b9eda5a10b1",
+    "crates/oa-core/src/migration_v2/validation.rs": "6d5e4a4e2805ae5045bf789a0485e14a61c63346587bace2b4a91173a688f780",
+    "crates/oa-core/src/migration_v3/README.md": "3755a63f840d7f0eadf68afa7a9d587877a9468ff982d3610539e8a0bb067a82",
+    "crates/oa-core/src/migration_v3/mod.rs": "f4edb6a0b50ecfe8670973776d703047b064420cb1f05913129c00fc656b3722",
+    "crates/oa-core/src/migration_v4.rs": "50c652964f0f309e7f3f54b6ef12c40d42fcecc0490f005995c713df1179af70",
+    "crates/oa-core/src/model.rs": "4585c895c64c4a183941c92cf047a9e52ff0cbe41971e16e78d229ea9dc101fb",
+    "crates/oa-core/src/operations.rs": "a5ffbbf54cd440316a106d1188bfb699b57dae59f466edcb33618c333cd19f41",
+    "crates/oa-core/src/persistence.rs": "1c01474f906a63e552c0d590b272c95821c00a100b3e79e58e67dbbeac341a14",
+    "crates/oa-core/src/ports.rs": "5cac12eea70a54ebebbd6be77b63ce92e3195325c4bc7d27705c518686cbac80",
+    "crates/oa-core/src/projection.rs": "69ed12bace2cc5024e151752a174ab14034ac2d05eb741fcf13e9a27521c059b",
+    "crates/oa-core/src/projection/port_layout.rs": "a08d17d10a58bb8b206dd001b19b91d5aa3a9f743b298a4da57d503223c20079",
+    "crates/oa-core/src/projection/state.rs": "73a607bac713ec7ff49a509fefb1a53c7686dca93ee241ffc835564d743afb28",
+    "crates/oa-core/src/references.rs": "93553c234f32da35f1f41a7b83ad81c471c9803efa78ca222cf7de3c2f86c0bb",
+    "crates/oa-core/src/routing.rs": "c5ebb350ba76f731f5c48d968bfbba4b6ef68ec046eb5893d116c4637ef15080",
+    "crates/oa-core/src/semantic.rs": "f9895dd5b8fb27d10d4cfbb41c3542ef2018365a589b8d5778e5674ae5a1f239",
+    "crates/oa-core/src/semantic/catalog.rs": "1ff74fcca18084d178681d7ff38ee1ccac632c27c4de0595ba1ceab8067ab3a4",
+    "crates/oa-core/src/semantic/historical.rs": "eaf3284bf234312698514cdb636bc8348e1b5d746cb16b18df777e77d312abfb",
+    "crates/oa-core/src/semantic/linked.rs": "6f335b14e809aecfc35defcaf77cb821b080d1506dbc46297912b25af98c07a2",
+    "crates/oa-core/src/semantic/mutate.rs": "dc2b4c4a6eb156fe468eaa8c85fd37a505c0cd8ea1f226cb69cd01689afd3d9d",
+    "crates/oa-core/src/semantic/review.rs": "0c157d2c327e72e89cca3b423e71ee73798105c5bb7271439c1a101642c91e3e",
+    "crates/oa-core/src/semantic/types.rs": "6922fe35089f12fad43ab0ce1c6886d01a3855f90b8e2543e99802ac5e6f1bbb",
+    "crates/oa-core/src/session.rs": "1eb77b329b2986fc6f5dc0171e77fd860375cdfd8c769a1367b445d6c49ebe00",
+    "crates/oa-core/src/source_files.rs": "669491dbddb8e8e6556161426dffa1a49ac1c826d31020bff0956d81a4d84683",
+    "crates/oa-core/src/source_project.rs": "1394370bcc5908873b830c2c11312e6e1611af41f46c4f43ca0a6bcb713bb466",
+    "crates/oa-core/src/source_project/source_migration.rs": "add463ae85c420f853d324b00a221f0f874164cc3f3ed6bbb07557a9ed7a8c95",
+    "crates/oa-core/src/source_project/source_structure.rs": "9f1f83315856a7025fe662c0fbb13452f31613224a03663150d6225d1ddc162f",
+    "crates/oa-core/src/state_validation.rs": "e28d7f74385e2a78763716b34491bd73a00bfeccc085970ceb130627e3faee18",
+    "crates/oa-core/src/topology_context.rs": "16de69b297de95d93c73808621607833b713af811dd082f0169186ae1e5c3e2d",
+    "crates/oa-core/src/topology_context/analysis.rs": "dead6194f0aa60cc46045c0e5ee10dbdbb689158c38634dfbbbc45d2ba88ac65",
+    "crates/oa-core/src/topology_context/analysis_tests.rs": "17839263410815e96fe027d4eba3aae0a9ab3b82b16947e2b29ebe0d09782b56",
+    "crates/oa-core/src/transitions.rs": "fadd1b07b89cae4117b91abb4f1ac9ea81ff818ef20f2175e76ee8cf21fb708d",
+    "crates/oa-core/src/transitions/communication.rs": "2b476630a88edd9021b9156ca12a5402e01604095f0d4002afb452671903a028",
+    "crates/oa-core/src/validation.rs": "7c1b4ae5e4ebba13e99af9158ccde138dfc5e9a7afb580e76fba72d0b64ba74e",
+    "crates/oa-core/src/validation/coverage.rs": "b08e4b344ecad055714168c83beff7fe29ba4edc53edbffa2eae04e5580a4d5f",
+    "crates/oa-core/src/view_options.rs": "421ede0a04c593ca1df0e6e0d06fabcfcc8113cdbcfb0adc7f5c8ef4d1724208",
+    "crates/oa-core/src/view_options_tests.rs": "64aac44de2df42a1012239a3dd75c473daf0c8990b3170b7bf7e78a556080208",
+    "crates/oa-core/tests/communication_boundary_scenarios.rs": "e1100b8f363910a487d90c73acc7df543dc6d532158c3c63ad11cd3d40d8e12b",
+    "crates/oa-core/tests/communication_means.rs": "a25f2749180bc6f4beb1445bfad3351eedf0669131a7439b633ab804439e95a4",
+    "crates/oa-core/tests/coverage_diagnostics.rs": "e2e9c3996daab47f2bd23f5d8c48b4e372af33331152f5fc85b76f06d04fcdf4",
+    "crates/oa-core/tests/fixtures/v2-coastal-rescue.arcadia": "f0df129c1914bfc01d0b047b0cd4b520d8cf0c249ea9ced085de400c0be87ff3",
+    "crates/oa-core/tests/fixtures/v2-coastal-rescue.json": "3ed53508eb544bbd788832f7bebea2ec31b3d66191f24f45098cc9750ec4c005",
+    "crates/oa-core/tests/fixtures/v3-data-contract.arcadia": "305f19d1b79f99f8d4cf627ba2e9ca6836bb7959cc0070227815937a699eafea",
+    "crates/oa-core/tests/fixtures/v3-data-contract.json": "1b41299c53204e6232397d25a58d5bccdbbc16e770c75e8edb55ce36ccfe58a2",
+    "crates/oa-core/tests/fixtures/v4-reviewed-prose.arcadia": "5fa53a26a5ad010c8e59eb56d9b2b52003569e66c0377ffb58840590168ad0c1",
+    "crates/oa-core/tests/fixtures/v4-reviewed-prose.json": "2808088afcc165f4bd6da5129151143411c997041c3de61d600ab76e05d24a47",
+    "crates/oa-core/tests/language.rs": "77f6cb2a69976bfb5f60b243b71c07fb0edc7505002c1e9e73fcd6ddf6d9496e",
+    "crates/oa-core/tests/port_anchors.rs": "efbc0fa18733b1aaac501f9785a4c392fc49c05c45a5778d26e9b5dd951ca6fa",
+    "crates/oa-core/tests/port_migration.rs": "1801c376a5435ac7efb2a8342348b2c7ffef930bba65deca4acb66b06e0483d7",
+    "crates/oa-core/tests/port_source.rs": "8d2ddaca4045d330f6eda2591561497b858aad53769a823249d0bea4f5916e12",
+    "crates/oa-core/tests/prepared_commands.rs": "52cab1c668064777412df0a6a3c20d74d579b33794b4b00525b9f151c06eac9b",
+    "crates/oa-core/tests/process_diagnostics.rs": "1dbbc590239ef7542be4a2bdc9543aaa64d108417b03dd312a0894e364745906",
+    "crates/oa-core/tests/r3_constructor_ack.rs": "e5c44676ea0aab97f2e091ddac2f4bc4a4a90f5877f7bbf08b61229600944dd0",
+    "crates/oa-core/tests/r3_migration.rs": "ebd04120f5215b3956fdc79ee78f6e38734c7d13392f1fc28aaba957912265bd",
+    "crates/oa-core/tests/r3_semantic.rs": "49c3763eaf2131070a7c46cc23a84f917d292d41610b6404510e5607f8890c32",
+    "crates/oa-core/tests/r3_source.rs": "f31f60659df3c7ef601650d1cff140589d8729f01a3f65a4a6a6c2272f15c408",
+    "crates/oa-core/tests/r6_data.rs": "5f7ffb3bc73c3c85423623fe56f8680646dc97040327bdbead9d47a37e80f155",
+    "crates/oa-core/tests/r6_migration.rs": "81519bc1512f5e069432e9a1cdad04c10216d492df01b4b75b02102480ebd6a1",
+    "crates/oa-core/tests/r6_source.rs": "88a0aa087a7678e2898ff6057538072ca92072190712f05fff08372cc56ebed6",
+    "crates/oa-core/tests/release1_teaching.rs": "be179290d871125dc97cfd2a3067c7ac89c8a538fdb0afafc5b825bcdfb2bef2",
+    "crates/oa-core/tests/release_capabilities.rs": "b92cba2a562e78287ddd7dc3e94557848d17faa0c8a102601b50286b9af48a30",
+    "crates/oa-core/tests/release_diagrams.rs": "cefcc0582d91266d5de6ee5daefcfe41b606ab971ab235b59034a8e1dbc24b7d",
+    "crates/oa-core/tests/release_language_limits.rs": "8578da4f76bbd2d0e1bfe295ab1259e2162a3fe3d0d2ba8901915d7a40942806",
+    "crates/oa-core/tests/release_ports.rs": "506e62beab0c7ec0cece83e9e0c1a810fa1f99285c9e1cab0c77f06de55a40e1",
+    "crates/oa-core/tests/release_routing.rs": "ae168faaba23769b7ca1fd65f217b9db671726e67276eb5a04e5e72b1447a462",
+    "crates/oa-core/tests/release_scenarios.rs": "0f5d876badeec653fc7b12610a77d867e9a53582e605253deff8d379da21572f",
+    "crates/oa-core/tests/release_states.rs": "b1a26acee95eaba7f9920f9da738a1e33606552eb078e6d298895daff7e3d811",
+    "crates/oa-core/tests/release_topology.rs": "c51dbe5aa5a038f9ed830daa02aa67714472179eb7fd6da5ce36dc6931c8b3a9",
+    "crates/oa-core/tests/review_regressions.rs": "f154e5c88d35e31512e2b07733a1327ea3e2fcfd1ef8eb23066a4e9573f387c1",
+    "crates/oa-core/tests/route_source.rs": "1a73fdbac0d0ae0e84d8d67b6ad398e11223958f5dca007f73757c91827decfb",
+    "crates/oa-core/tests/routing_geometry.rs": "2d8eea4a2bba535ed0ea6daabccdaf87b375828c404baa10518c7bd7fd6253d3",
+    "crates/oa-core/tests/routing_labels.rs": "dff884d799c3c5c9257210248c55767e294e3cb317c605cbd0ddc9600c216eb6",
+    "crates/oa-core/tests/semantic_artifact_absence_oracle.rs": "d93eaf9667f4221232168bef0fe9f069e5be1b1f23410bda5dd67010b96e5c8a",
+    "crates/oa-core/tests/semantic_attachments_gui_oracle.rs": "7f526d363ba05e7ac89faf0fead0796e419c34ee204edf44a1b46c78308b0970",
+    "crates/oa-core/tests/source6_view_contract.rs": "fa566de53946d40bbbd9033edfeed177180c4dc44afa2f2f4667ffdc622eb3bb",
+    "crates/oa-core/tests/source7_contract.rs": "cad4f1a135ddbd947bdf3c71d1b44f1e438725095ea8c4d893464bc721c2363f",
+    "crates/oa-core/tests/source_files.rs": "f0429a0b89a443458ea9af7083c1e4e7411417a7e6b47e618bfbb9266dc164f9",
+    "crates/oa-core/tests/source_identity_updates.rs": "f52aa38b4d317e532c641ad7463472e4b40e802e60052cf0017556ffc63da06c",
+    "crates/oa-core/tests/source_nested_updates.rs": "9ac3390936c0d250651ea94a1b8faf0adfb680f061ececc56f2a52909b5ba855",
+    "crates/oa-core/tests/source_project.rs": "cef58adb16aa4d2527ddc0628aec3e26f0b42b4be70014a7e360fafdac13a942",
+    "crates/oa-core/tests/state_diagrams.rs": "6b02b387a3ae559cb3ad72de24292a5abcb76aaac0adbab5d2aa5211b22cd2e5",
+    "crates/oa-core/tests/workflows.rs": "bd843dfddbd5724ec08f657571f887496203056fe2fa5864ef50a168a613b89b",
+    "crates/oa-server/Cargo.toml": "527ff5e15010a8b560a6659aa1ae4bf0c8df0d9e019f03c47529ec6a750c0982",
+    "crates/oa-server/build.rs": "ab1be6ae1fd8bf3ebaeef6348347a9d5e666bde693126f199e041659e0b094a9",
+    "crates/oa-server/src/error.rs": "93817f1502386e4662c96ee1c7d1c4afc4e33bda6fd64e46c86c8e1afd5a9368",
+    "crates/oa-server/src/lib.rs": "20bef350350ed6339588b23af684abf745f97916c7edf3853ee042abe687e664",
+    "crates/oa-server/src/main.rs": "d59a6a2b5c7034bd2e00a516d2d49abb16391bf0316c1c357ddafb9c82d2d1e3",
+    "crates/oa-server/src/preparation_http_tests.rs": "454b90d0055d35644c8d990cd7576ddf675a9b271ca07fe9b0efce25d8ddbc07",
+    "crates/oa-server/src/routes.rs": "3f9a0c22043dbf28f7a8e587d2fc3abf869f76f4d23a46fe0aeb9c4392454a4b",
+    "crates/oa-server/src/store.rs": "37dcfb845b7993d5bced2bcf25fedfcd2a9c20a748f9315afe6cca1f41f89ae5",
+    "crates/oa-server/src/store_preparation_gate.rs": "427c390da3c0281ba1fe115a93ea90800e3b45fce6bcb9185e71982ddd885fec",
+    "crates/oa-server/tests/http.rs": "50daa6a90e96ad6fe3c6a27df2eaebe486270599c203892d09769c547a194975",
+    "crates/oa-server/tests/http/communication_limits.rs": "ba5474dd8e494a0176fffb4548c8e3deb2081b15de33bfce82394c764e0a2c16",
+    "crates/oa-server/tests/http/data_contracts.rs": "8cd456db83f301baca380acf025a5a99db4edf7d8839537dfbd02c4307e10e6b",
+    "crates/oa-server/tests/http/port_anchors.rs": "7199d0a208ddad9e1518b6e3fb390d64da111716d7505ba5c995deae19ad1258",
+    "crates/oa-server/tests/http/semantic_transitions.rs": "856d1c9b633ffb581e3e631f4e5a607789a02181dbf060667f208a569bfa4920",
+    "crates/oa-server/tests/http/source6_views.rs": "867bccda0e030eeeb9976b4ceeb47b21ab5044d700278022d5fb495bbb64ca07",
+    "crates/oa-server/tests/http/source7_contracts.rs": "0e0a467186da7263c0754890aff69ebd0d92d36b5224e4865bb6854b18dab7e8",
+    "crates/oa-server/tests/http/source_projects.rs": "8ff580f317ec267d1cd72ae14d8638f74a77cdf99ca4c78f66f4290c2d77460a",
+    "crates/oa-server/tests/semantic_http_contract.py": "4737ff94f10761f94151a694414c5c62737e0391ec820bca132830652bc4cca2",
+    "crates/oa-server/tests/semantic_schema.py": "70c9d267268bd390680f290a585bd4ae0c6d8ef999ee2f32ece6e172293574f7",
+    "crates/oa-server/tests/state_representation.rs": "6686c826f28248ae4b63ec3f2112e193d4a347724b87974483217fcfee49cd61"
+  },
+  "historical_server_comparison": {
+    "historical_file_count": 120,
+    "changed_current_inputs": [
+      "crates/oa-core/src/language.rs"
+    ],
+    "added_current_files": [
+      "crates/oa-core/src/language_outline_tests.rs"
+    ],
+    "scope": "Historical server inputs verified against their own preserved tar, not required to equal the new GUI source."
+  },
+  "artifacts": [
+    {
+      "source": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\text-repair-save-20260911\\gui-repair.exe",
+      "destination": "bin/arcadia-studio.exe",
+      "sha256": "b183ef31f16b3986538b3f2aba8435eab45978635c47f99ca01be6e72b168848",
+      "bytes": 113206272
+    },
+    {
+      "source": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\contextual-prerelease-20260911\\bin\\arcadia-server.exe",
+      "destination": "bin/arcadia-server.exe",
+      "sha256": "efeeb89c0d2e0f93df4472cb3e9f48b2b722a37ae1043c90a5a56f2e845fe665",
+      "bytes": 39743488
+    },
+    {
+      "source": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\contextual-prerelease-20260911\\bin\\libunwind.dll",
+      "destination": "bin/libunwind.dll",
+      "sha256": "f45604a12e8bcd839fd86f667c1be1cc7c4f9da2b3c69ff381ac708f0e1ae7d4",
+      "bytes": 190976
+    }
+  ],
+  "full_test_counts": {
+    "passed": 755,
+    "failed": 0,
+    "ignored": 1,
+    "measured": 0,
+    "filtered": 0
+  },
+  "root_before": {
+    "head": "33c6d83e9ba9a5b1310b1b627d7c40affcbcf15c",
+    "index_sha256": "24abbc5710951b9123439e8b0b0ccfda78df594c068c20463dddcddd36f1e713",
+    "tracked_status": ""
+  },
+  "root_after": {
+    "head": "33c6d83e9ba9a5b1310b1b627d7c40affcbcf15c",
+    "index_sha256": "24abbc5710951b9123439e8b0b0ccfda78df594c068c20463dddcddd36f1e713",
+    "tracked_status": ""
+  },
+  "prepared": "2026-09-11T21:09:43.793276+00:00",
+  "scope": "Isolated preparation only; package integrity and native acceptance pending."
+}

harness/experiments/navigation-prerelease-20260911/producer/prepare-result.json

@@ -0,0 +1,6 @@
+{
+  "started": "2026-09-11T21:09:04.104156+00:00",
+  "scope": "Preparation only; no application/Cargo/package execution.",
+  "success": true,
+  "finished": "2026-09-11T21:09:43.822788+00:00"
+}

harness/experiments/navigation-prerelease-20260911/producer/prepare.py

@@ -0,0 +1,331 @@
+"""Prepare isolated exact sources/binaries only after recorded GUI/full gates.
+
+Do not execute without root's preparation authorization. Never invokes Cargo,
+launches applications, publishes, or writes the main repository's index/refs.
+"""
+from datetime import datetime, timezone
+import hashlib
+import json
+from pathlib import Path, PurePosixPath
+import re
+import shutil
+import subprocess
+import tarfile
+import traceback
+import sys
+import tomllib
+import zipfile
+
+BASE = Path(__file__).resolve().parent
+ROOT = BASE.parents[1]
+SOURCE = BASE / 'source'
+COMMIT = '33c6d83e9ba9a5b1310b1b627d7c40affcbcf15c'
+BRANCH = 'codex/navigation-repair-prerelease-source-20260911'
+VERSION = '0.2.0-preview.navigation.20260911'
+TARGET = 'x86_64-pc-windows-gnullvm'
+GATES = ROOT / '.local/text-repair-save-20260911'
+HISTORY = ROOT / '.local/contextual-prerelease-20260911/evidence'
+INPUT_SHA = '75a282fd3d4cb2dec6763046ea45d0caa015b998281fbdd6f222d8e3a175b13f'
+ZIP_SHA = '213fdb39ea7c3601b4baac674c3ab3ecc863ac44db1b092d922d3e24f26887b7'
+SERVER_SHA = 'efeeb89c0d2e0f93df4472cb3e9f48b2b722a37ae1043c90a5a56f2e845fe665'
+DLL_SHA = 'f45604a12e8bcd839fd86f667c1be1cc7c4f9da2b3c69ff381ac708f0e1ae7d4'
+HISTORICAL = {
+    'server-original-gates.json': 'b7fdfc55ed4c964d276f20f1c57c81c1e924b8da315171089740ab8335ac9f0d',
+    'server-original-binary-hashes.json': '110a03e323133efb48d50ad065d41414599aa85e0ac420e7d622aa04df4d54f8',
+    'server-prior-input-comparisons.json': '3c78dea4e93dae186fd24ab826c6680178a2c7849c270a22deae2ff732f1857b',
+    'prior-dependency-notices.json': '98fab15c1a2bb3aa727c6d52d5c69435b15efa56b6668ed717e7a04cf86f9b52',
+    'server-source-snapshot.tar.gz': 'cbb371a93a562e1e641d7629fe351e016d63e66fc9112499b3fed6d5cd171f78',
+}
+SCRIPT_HASHES = {
+    'scripts/package-windows.ps1': '28997ff78565619ed9c9b185f66dc922808f1f0be17f522b430c6c415448663d',
+    'scripts/package-common.ps1': 'd859453a8230b4f305d822c8742b371a71e35df698109a5d55c948f6dfaf0640',
+    'scripts/windows-notices.ps1': 'a5328c05579e1b9ca09142ee99e87c12994d12764f7c69448e392883d718ef01',
+}
+
+COMMANDS = {
+    'desktop-tests': ['cargo', 'test', '--locked', '--offline', '-p', 'oa-desktop', '--bin', 'arcadia-studio', '--', '--test-threads=1'],
+    'desktop-clippy': ['cargo', 'clippy', '--locked', '--offline', '-p', 'oa-desktop', '--all-targets', '--', '-D', 'warnings'],
+    'scoped-fmt': ['rustfmt', '--check', '--edition', '2024', '--config', 'skip_children=true', 'crates/oa-desktop/src/app.rs', 'crates/oa-desktop/src/document.rs', 'crates/oa-desktop/src/app/repair_save_state_tests.rs'],
+    'diff-check': ['git', 'diff', '--check'],
+    'gui-build': ['cargo', 'build', '--locked', '--offline', '-p', 'oa-desktop', '--bin', 'arcadia-studio', '--message-format=json-render-diagnostics'],
+}
+
+
+def now():
+    return datetime.now(timezone.utc).isoformat()
+
+
+def ordinary(path):
+    path = Path(path).absolute()
+    for part in (path, *path.parents):
+        if part.exists():
+            assert not part.is_symlink() and not (getattr(part.lstat(), 'st_file_attributes', 0) & 0x400), str(part)
+    return path
+
+
+def sha(path):
+    with ordinary(path).open('rb') as stream:
+        return hashlib.file_digest(stream, 'sha256').hexdigest()
+
+
+def load(path):
+    return json.loads(ordinary(path).read_text(encoding='utf-8-sig'))
+
+
+def record(path, value):
+    ordinary(path)
+    with Path(path).open('x', encoding='utf-8', newline='\n') as stream:
+        json.dump(value, stream, ensure_ascii=False, indent=2)
+        stream.write('\n')
+
+
+_git_call = 0
+
+
+def git(cwd, *args, input=None):
+    global _git_call
+    _git_call += 1
+    result = subprocess.run(['git', *args], cwd=cwd, capture_output=True, input=input)
+    if result.returncode:
+        prefix = BASE / f'git-failure-{_git_call:03d}'
+        with prefix.with_suffix('.stdout.log').open('xb') as out:
+            out.write(result.stdout)
+        with prefix.with_suffix('.stderr.log').open('xb') as err:
+            err.write(result.stderr)
+        record(prefix.with_suffix('.json'), {'command': result.args, 'cwd': str(cwd), 'exitCode': result.returncode,
+               'stdout_sha256': hashlib.sha256(result.stdout).hexdigest(),
+               'stderr_sha256': hashlib.sha256(result.stderr).hexdigest(), 'atUtc': now()})
+        result.check_returncode()
+    return result.stdout
+
+
+def relative(name):
+    p = PurePosixPath(name)
+    assert name == p.as_posix() and not p.is_absolute() and p.parts and all(x not in ('..', '.') for x in p.parts)
+    assert '\\' not in name and ':' not in name and '\n' not in name and '\r' not in name
+    return name
+
+
+def blobs(cwd, revision, paths):
+    paths = list(paths)
+    raw = git(cwd, 'cat-file', '--batch', input=''.join(f'{revision}:{p}\n' for p in paths).encode())
+    cursor, out = 0, {}
+    for path in paths:
+        end = raw.index(b'\n', cursor)
+        header = raw[cursor:end].split()
+        assert len(header) == 3 and header[1] == b'blob', path
+        size = int(header[2])
+        out[path] = raw[end + 1:end + 1 + size]
+        cursor = end + size + 2
+    assert cursor == len(raw)
+    return out
+
+
+def root_identity():
+    index = Path(git(ROOT, 'rev-parse', '--git-path', 'index').decode().strip())
+    if not index.is_absolute():
+        index = ROOT / index
+    return {'head': git(ROOT, 'rev-parse', 'HEAD').decode().strip(), 'index_sha256': sha(index),
+            'tracked_status': git(ROOT, 'status', '--porcelain', '-uno').decode()}
+
+
+def historical_inputs():
+    for name, checksum in HISTORICAL.items():
+        assert sha(HISTORY / name) == checksum, name
+    inventory = load(HISTORY / 'server-prior-input-comparisons.json')
+    entries = inventory['server_source_file_comparisons']
+    expected = {relative(e['path']): e['recorded_sha256'] for e in entries}
+    assert len(expected) == len(entries) and expected
+    found = {}
+    with tarfile.open(HISTORY / 'server-source-snapshot.tar.gz', 'r:gz') as archive:
+        for member in archive.getmembers():
+            name = member.name.removeprefix('./')
+            if name in expected:
+                assert member.isfile() and name not in found, name
+                with archive.extractfile(member) as stream:
+                    found[name] = hashlib.file_digest(stream, 'sha256').hexdigest()
+    assert found == expected
+    assert any(e['Hash'].lower() == SERVER_SHA and Path(e['Path']).name == 'arcadia-server.exe'
+               for e in load(HISTORY / 'server-original-binary-hashes.json'))
+    return expected
+
+
+def admission():
+    assert sha(GATES / 'inputs1.json') == INPUT_SHA
+    assert sha(GATES / 'inputs1.zip') == ZIP_SHA
+    manifest = load(GATES / 'inputs1.json')
+    assert manifest['archiveSha256'] == ZIP_SHA
+    expected = {relative(e['path']): e for e in manifest['files']}
+    assert len(expected) == len(manifest['files']) and expected
+    assert len({p.casefold() for p in expected}) == len(expected)
+    with zipfile.ZipFile(GATES / 'inputs1.zip') as archive:
+        assert len(archive.namelist()) == len(expected) and set(archive.namelist()) == set(expected)
+        frozen = {name: archive.read(name) for name in expected}
+    for name, raw in frozen.items():
+        assert len(raw) == expected[name]['bytes'] and hashlib.sha256(raw).hexdigest() == expected[name]['sha256'], name
+    assert len(expected) == 500
+    complete = load(GATES / 'complete.json')
+    assert complete['archiveSha256'] == ZIP_SHA and complete['inputsUnchanged'] is True
+    assert complete['gates'] == list(COMMANDS) and complete['sourceHead'] == manifest['head']
+    # The gates captured eeeaa126 plus the repair delta; COMMIT commits those
+    # exact raw inputs. Never relabel the captured sourceHead as a clean build.
+    assert manifest['head'] == 'eeeaa1262748800c4c9aaa1eca79a7de96757358'
+    for name, command in COMMANDS.items():
+        receipt = load(GATES / (name + '-result.json'))
+        assert receipt['exitCode'] == 0 and receipt['inputsUnchanged'] is True and receipt['command'] == command
+        assert sha(GATES / (name + '-stdout.log')) == receipt['stdoutSha256']
+        assert sha(GATES / (name + '-stderr.log')) == receipt['stderrSha256']
+    build = load(GATES / 'gui-build-result.json')['binary']
+    artifact = build['artifact']
+    assert artifact['target']['name'] == 'arcadia-studio' and artifact['profile']['test'] is False
+    assert artifact['profile']['opt_level'] == '0' and artifact['profile']['debug_assertions'] is True
+    assert Path(artifact['executable']).resolve() == Path(build['path']).resolve()
+    assert Path(build['path']).resolve().is_relative_to(ROOT / '.local/target-gnullvm')
+    gui = GATES / 'gui-repair.exe'
+    assert sha(gui) == build['sha256'] == 'b183ef31f16b3986538b3f2aba8435eab45978635c47f99ca01be6e72b168848'
+    assert gui.stat().st_size == build['bytes'] == 113206272
+    summaries = re.findall(r'test result: ok\. (\d+) passed; (\d+) failed; (\d+) ignored; (\d+) measured; (\d+) filtered out;',
+                           (GATES / 'desktop-tests-stdout.log').read_text(encoding='utf-8'))
+    assert summaries == [('755', '0', '1', '0', '0')]
+    counts = dict(zip(('passed', 'failed', 'ignored', 'measured', 'filtered'), map(int, summaries[0])))
+    server = ROOT / '.local/contextual-prerelease-20260911/bin/arcadia-server.exe'
+    dll = ROOT / '.local/contextual-prerelease-20260911/bin/libunwind.dll'
+    assert sha(server) == SERVER_SHA and sha(dll) == DLL_SHA
+    old = historical_inputs()
+    return manifest, frozen, build, gui, counts, server, dll, old
+
+
+def main():
+    ordinary(BASE)
+    for name in ('source', 'source-roundtrip', 'bin', 'evidence', 'preparation.json', 'committed-roundtrip.json', 'build-evidence.json', 'evidence-manifest.json'):
+        assert not (BASE / name).exists(), f'Refusing existing output: {name}'
+    before = root_identity()
+    assert not before['tracked_status'], 'Root tracked edits must be frozen before preparation.'
+    assert git(ROOT, 'rev-parse', COMMIT).decode().strip() == COMMIT
+    # Later root commits may record evidence only. Do not silently package later
+    # production/docs/dependency or instruction changes under the tested source.
+    git(ROOT, 'merge-base', '--is-ancestor', COMMIT, before['head'])
+    later = git(ROOT, 'diff', '--name-only', '-z', COMMIT, before['head']).decode().split('\0')[:-1]
+    assert all(p.startswith('harness/') and not p.startswith('harness/fixtures/') for p in later), later
+    manifest, frozen, build, gui, counts, server, dll, old = admission()
+    for path, raw in frozen.items():
+        assert ordinary(ROOT / path).read_bytes() == raw, f'Current frozen input changed: {path}'
+    selectors = ['crates', '.cargo', 'Cargo.toml', 'Cargo.lock', 'docs', 'examples', 'harness/fixtures']
+    current_paths = git(ROOT, 'ls-files', '-z', '--cached', '--others', '--exclude-standard', '--', *selectors).decode().split('\0')[:-1]
+    assert sorted(current_paths) == sorted(frozen), 'Current input file set differs from the successful freeze.'
+    committed_paths = git(ROOT, 'ls-tree', '-r', '--name-only', '-z', COMMIT, '--', *selectors).decode().split('\0')[:-1]
+    assert sorted(committed_paths) == sorted(frozen), 'Committed input file set differs from the successful gate freeze.'
+    assert shutil.disk_usage(BASE).free >= 2 * 1024 ** 3
+    original = blobs(ROOT, COMMIT, frozen)
+    for path, raw in frozen.items():
+        assert original[path].replace(b'\r\n', b'\n') == raw.replace(b'\r\n', b'\n'), f'Non-newline source mismatch: {path}'
+    notice = load(HISTORY / 'prior-dependency-notices.json')
+    shared = {p: h for p, h in notice['workspace_build_inputs_sha256'].items() if p not in ('Cargo.toml', 'Cargo.lock')}
+    for p, raw in blobs(ROOT, COMMIT, shared).items():
+        assert hashlib.sha256(raw).hexdigest() == shared[p] or raw.replace(b'\r\n', b'\n') == (ROOT / p).read_bytes().replace(b'\r\n', b'\n')
+        assert sha(ROOT / p) == shared[p], p
+        if p in frozen:
+            assert frozen[p] == (ROOT / p).read_bytes(), p
+        frozen[p] = (ROOT / p).read_bytes()
+    registry = {(x['name'], x['version'], x['source']): x['registry_checksum']
+                for x in notice['packages'] if x['source']}
+    locked = {(x['name'], x['version'], x.get('source')): x.get('checksum')
+              for x in tomllib.loads(frozen['Cargo.lock'].decode())['package']}
+    assert registry and all(locked.get(k) == v for k, v in registry.items()), 'Historical registry coverage differs.'
+    # Local clone has its own index/refs and does not create a worktree in ROOT.
+    git(ROOT, 'clone', '--no-hardlinks', '--no-checkout', str(ROOT), str(SOURCE))
+    git(SOURCE, 'checkout', '-b', BRANCH, COMMIT)
+    checks = {p: hashlib.sha256(raw).hexdigest() for p, raw in frozen.items()}
+    original = blobs(SOURCE, COMMIT, checks)
+    restores = []
+    for p, raw in frozen.items():
+        assert original[p].replace(b'\r\n', b'\n') == raw.replace(b'\r\n', b'\n'), p
+        if hashlib.sha256(original[p]).hexdigest() != checks[p] or sha(SOURCE / p) != checks[p]:
+            assert re.fullmatch(r'[A-Za-z0-9_./-]+', p), 'Attribute path needs explicit quoting review.'
+            ordinary(SOURCE / p).write_bytes(raw)
+            restores.append({'path': p, 'sha256': checks[p], 'base_git_sha256': hashlib.sha256(original[p]).hexdigest(),
+                             'bytes': len(raw), 'crlf': raw.count(b'\r\n'), 'lf': raw.count(b'\n')})
+    if restores:
+        with (SOURCE / '.gitattributes').open('ab') as out:
+            out.write(b'\n# Exact frozen navigation GUI input bytes; historical server source is separate.\n')
+            for item in restores:
+                out.write((item['path'] + ' -text\n').encode())
+        git(SOURCE, 'add', '--renormalize', '--', '.gitattributes', *[x['path'] for x in restores])
+        git(SOURCE, '-c', 'user.name=Codex-9e8r6t', '-c', 'user.email=codex-9e8r6t@local.invalid',
+            'commit', '-m', 'Preserve exact navigation prerelease GUI inputs')
+    reconstruction = git(SOURCE, 'rev-parse', 'HEAD').decode().strip()
+    committed = blobs(SOURCE, 'HEAD', checks)
+    fresh = BASE / 'source-roundtrip'
+    fresh.mkdir()
+    git(SOURCE, '-c', 'core.longpaths=true', 'checkout-index', '--all', '--prefix=' + fresh.as_posix() + '/')
+    for p, checksum in checks.items():
+        assert hashlib.sha256(committed[p]).hexdigest() == sha(SOURCE / p) == sha(fresh / p) == checksum, p
+    for p, checksum in SCRIPT_HASHES.items():
+        assert sha(SOURCE / p) == checksum, p
+    assert not git(SOURCE, 'status', '--porcelain').strip()
+    comparison = {'historical_file_count': len(old), 'changed_current_inputs': [p for p, h in old.items() if sha(SOURCE / p) != h],
+                  'added_current_files': sorted(p.relative_to(SOURCE).as_posix() for crate in ('oa-core', 'oa-server')
+                      for p in (SOURCE / 'crates' / crate).rglob('*') if p.is_file() and p.relative_to(SOURCE).as_posix() not in old),
+                  'scope': 'Historical server inputs verified against their own preserved tar, not required to equal the new GUI source.'}
+    assert comparison['changed_current_inputs'] == ['crates/oa-core/src/language.rs']
+    assert comparison['added_current_files'] == ['crates/oa-core/src/language_outline_tests.rs']
+    (BASE / 'bin').mkdir()
+    artifacts = []
+    for source, name, checksum in ((gui, 'arcadia-studio.exe', build['sha256']), (server, 'arcadia-server.exe', SERVER_SHA), (dll, 'libunwind.dll', DLL_SHA)):
+        assert sha(source) == checksum
+        target = BASE / 'bin' / name
+        with source.open('rb') as src, target.open('xb') as dst:
+            shutil.copyfileobj(src, dst)
+        assert sha(source) == sha(target) == checksum
+        artifacts.append({'source': str(source), 'destination': 'bin/' + name, 'sha256': checksum, 'bytes': target.stat().st_size})
+    provenance = {name: HISTORY / name for name in HISTORICAL}
+    provenance.update({'gui-inputs1.json': GATES / 'inputs1.json', 'gui-complete.json': GATES / 'complete.json',
+                       'gui-gate-run.py': GATES / 'run.py'})
+    for name in COMMANDS:
+        for suffix in ('-result.json', '-stdout.log', '-stderr.log'):
+            provenance['gui-' + name + suffix] = GATES / (name + suffix)
+    (BASE / 'evidence').mkdir()
+    evidence = []
+    for name, source in provenance.items():
+        checksum = sha(source)
+        destination = BASE / 'evidence' / name
+        with source.open('rb') as src, destination.open('xb') as dst:
+            shutil.copyfileobj(src, dst)
+        assert sha(source) == sha(destination) == checksum
+        evidence.append({'source': str(source), 'destination': 'evidence/' + name, 'sha256': checksum, 'bytes': destination.stat().st_size})
+    record(BASE / 'evidence-manifest.json', evidence)
+    record(BASE / 'committed-roundtrip.json', {'base_commit': COMMIT, 'reconstruction_commit': reconstruction, 'checks': checks, 'clean': True})
+    record(BASE / 'build-evidence.json', {
+        'source_identity': f'GUI exact-byte reconstruction {reconstruction} from {COMMIT}; {len(manifest["files"])} frozen GUI gate inputs plus separately verified shared build resources. This is not the original build commit. EFEE server retains its separate September 7 source snapshot; its old language.rs differs from current GUI core. No current-source server claim.',
+        'profile': f'Prebuilt Windows development GUI, actual full desktop result {counts}. Retained EFEE server is the historical development artifact, not rebuilt. Native/package acceptance remains pending.',
+        'compiler': 'Original GUI Cargo artifact/profile and server build records retained separately; package collector records current compiler/sysroot facts. No reproducible build or new server build claimed.',
+        'target': TARGET, 'binary_sha256': {'arcadia-studio.exe': build['sha256'], 'arcadia-server.exe': SERVER_SHA},
+        'provenance_reference_base': 'evidence/ references are external preparation records, not files inside the ZIP.',
+        'per_binary_provenance': {
+            'arcadia-studio.exe': {'build': 'evidence/gui-gui-build-result.json', 'inputs': 'evidence/gui-inputs1.json', 'full_gate': 'evidence/gui-desktop-tests-result.json', 'complete': 'evidence/gui-complete.json', 'captured_head': manifest['head'], 'scope': 'Built from captured eeeaa126 plus exact repair input delta; those bytes are committed at base_commit, then reconstructed without changing code.'},
+            'arcadia-server.exe': {'build': 'evidence/server-original-gates.json', 'hashes': 'evidence/server-original-binary-hashes.json', 'source_tar': 'evidence/server-source-snapshot.tar.gz', 'source_inventory': 'evidence/server-prior-input-comparisons.json', 'notices': 'evidence/prior-dependency-notices.json', 'scope': 'Unchanged historical EFEE; separate source, not rebuilt from navigation source.'}}})
+    after = root_identity()
+    assert after == before, 'Root HEAD/index/tracked state changed during preparation; inspect before proceeding.'
+    record(BASE / 'preparation.json', {'version': VERSION, 'target': TARGET, 'base_commit': COMMIT, 'reconstruction_commit': reconstruction,
+        'branch': BRANCH, 'record_only_root_paths_after_base': later, 'historical_registry_count': len(registry), 'source_repository': str(SOURCE), 'restorations': restores, 'gui_inputs': {e['path']: e['sha256'] for e in manifest['files']},
+        'shared_non_cargo_inputs': shared, 'historical_server_inputs': old, 'historical_server_comparison': comparison,
+        'artifacts': artifacts, 'full_test_counts': counts, 'root_before': before, 'root_after': after, 'prepared': now(),
+        'scope': 'Isolated preparation only; package integrity and native acceptance pending.'})
+    print(json.dumps({'success': True, 'reconstruction': reconstruction, 'gui_inputs': len(manifest['files']), 'restorations': len(restores), 'historical_server_inputs': len(old)}))
+
+
+if __name__ == '__main__':
+    sys.stdout.reconfigure(encoding='utf-8')
+    sys.stderr.reconfigure(encoding='utf-8')
+    assert not (BASE / 'prepare-result.json').exists()
+    status = {'started': now(), 'scope': 'Preparation only; no application/Cargo/package execution.'}
+    try:
+        main()
+        status['success'] = True
+    except BaseException as error:
+        status.update(success=False, error=repr(error))
+        traceback.print_exc()
+        raise
+    finally:
+        status['finished'] = now()
+        record(BASE / 'prepare-result.json', status)

harness/experiments/navigation-prerelease-20260911/producer/push-source.py

@@ -0,0 +1,75 @@
+"""Publish the verified raw-input reconstruction; no tag or release operation."""
+import base64
+from datetime import datetime, timezone
+import hashlib
+import json
+import os
+from pathlib import Path
+import subprocess
+import tomllib
+import urllib.request
+
+BASE = Path(__file__).resolve().parent
+SOURCE = BASE / 'source'
+COMMIT = '802855f7e6f2f00a107a12196b458b267f586b8d'
+BRANCH = 'codex/navigation-repair-prerelease-source-20260911'
+ORIGIN = 'http://217.177.34.108:3000'
+REMOTE = ORIGIN + '/sorokin.oleg.edu/ARCADIA-Studio.git'
+RESULT = BASE / 'source-push-result.json'
+assert not RESULT.exists()
+readback_bytes = (BASE / 'package-readback.json').read_bytes()
+assert hashlib.sha256(readback_bytes).hexdigest() == 'db0053ce70648b517942cfc8c915e826a7afd688129fcb4a813e11990820f498'
+readback = json.loads(readback_bytes)
+assert readback['status'] == 'PASS' and readback['source_commit'] == COMMIT
+assert readback['archive_sha256'] == 'd7228c542f162663933ea002739a78c722bcca41e437df63b7c868ea2af201f1'
+
+token = tomllib.loads((Path.home() / '.codex/config.toml').read_text(encoding='utf-8'))['mcp_servers']['gitea']['env']['GITEA_ACCESS_TOKEN']
+
+class NoRedirect(urllib.request.HTTPRedirectHandler):
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        raise RuntimeError('Unexpected redirect; credentials not forwarded')
+
+opener = urllib.request.build_opener(urllib.request.ProxyHandler({}), NoRedirect)
+with opener.open(urllib.request.Request(ORIGIN + '/api/v1/user', headers={'Authorization': 'token ' + token}), timeout=30) as response:
+    username = json.load(response)['login']
+credential = base64.b64encode((username + ':' + token).encode()).decode()
+env = {k: v for k, v in os.environ.items() if not k.startswith(('GIT_TRACE', 'GIT_CONFIG_', 'GIT_CURL_VERBOSE'))}
+env.update({'GIT_TERMINAL_PROMPT': '0', 'GIT_CONFIG_COUNT': '4',
+            'GIT_CONFIG_KEY_0': 'credential.helper', 'GIT_CONFIG_VALUE_0': '',
+            'GIT_CONFIG_KEY_1': 'http.' + ORIGIN + '/.extraHeader', 'GIT_CONFIG_VALUE_1': 'Authorization: Basic ' + credential,
+            'GIT_CONFIG_KEY_2': 'http.followRedirects', 'GIT_CONFIG_VALUE_2': 'false',
+            'GIT_CONFIG_KEY_3': 'http.proxy', 'GIT_CONFIG_VALUE_3': ''})
+
+def redact(value):
+    return value.replace(token, '[redacted]').replace(credential, '[redacted]')
+
+def git(*args):
+    result = subprocess.run(['git', *args], cwd=SOURCE, env=env, capture_output=True, text=True, timeout=120)
+    if result.returncode:
+        raise RuntimeError(f'Git exit {result.returncode}: ' + redact(result.stderr))
+    return result.stdout.strip()
+
+receipt = {'started': datetime.now(timezone.utc).isoformat(), 'branch': BRANCH, 'commit': COMMIT,
+           'scope': 'One exact raw-source branch; no force, tag, release or asset operation.'}
+try:
+    assert git('rev-parse', 'HEAD') == COMMIT
+    assert git('branch', '--show-current') == BRANCH
+    assert not git('status', '--porcelain')
+    before = git('ls-remote', REMOTE, 'refs/heads/' + BRANCH)
+    receipt['before'] = before
+    # A prior independent publication must already be this exact immutable commit.
+    assert not before or before.split()[0] == COMMIT, 'Different source branch exists; review before publishing'
+    if not before:
+        git('push', REMOTE, COMMIT + ':refs/heads/' + BRANCH)
+    after = git('ls-remote', REMOTE, 'refs/heads/' + BRANCH)
+    assert after.split()[0] == COMMIT
+    receipt.update(success=True, after=after, user=username)
+except BaseException as error:
+    receipt.update(success=False, error=redact(str(error)))
+    raise
+finally:
+    receipt['finished'] = datetime.now(timezone.utc).isoformat()
+    with RESULT.open('x', encoding='utf-8', newline='\n') as output:
+        json.dump(receipt, output, indent=2)
+        output.write('\n')
+    print(json.dumps(receipt), flush=True)

harness/experiments/navigation-prerelease-20260911/producer/readback.py

@@ -0,0 +1,105 @@
+"""Read back the produced ZIP/stage/source without launching either executable."""
+from datetime import datetime, timezone
+import hashlib
+import json
+from pathlib import Path
+import stat
+import sys
+import zipfile
+from prepare import BASE, SOURCE, VERSION, TARGET, COMMIT, SERVER_SHA, DLL_SHA, ordinary, sha, load, record, git, relative, historical_inputs, HISTORY
+
+
+def main():
+    assert not (BASE / 'package-readback.json').exists()
+    preparation = load(BASE / 'preparation.json')
+    terminal = load(BASE / 'package2-result.json')
+    assert terminal['success'] is True and terminal['metadata_calls'] == 1
+    assert preparation['base_commit'] == COMMIT and preparation['version'] == VERSION and preparation['target'] == TARGET
+    name = f'ArcadiaStudio-{VERSION}-{TARGET}'
+    archive_path = BASE / 'packages' / (name + '.zip')
+    stage = BASE / 'packages' / name
+    assert Path(terminal['archive']).resolve() == archive_path.resolve()
+    assert terminal['archive_sha256'] == sha(archive_path) and terminal['archive_bytes'] == archive_path.stat().st_size
+    actual = {}
+    with zipfile.ZipFile(archive_path) as archive:
+        entries = archive.infolist()
+        assert entries and len({e.filename.casefold() for e in entries}) == len(entries)
+        for entry in entries:
+            assert entry.filename.startswith(name + '/') and not entry.is_dir()
+            path = relative(entry.filename[len(name) + 1:])
+            assert not (entry.flag_bits & 1) and not stat.S_ISLNK(entry.external_attr >> 16)
+            assert entry.date_time == (2000, 1, 1, 0, 0, 0)
+            with archive.open(entry) as stream:
+                checksum = hashlib.file_digest(stream, 'sha256').hexdigest()
+            assert sha(stage / path) == checksum and (stage / path).stat().st_size == entry.file_size
+            actual[path] = {'sha256': checksum, 'bytes': entry.file_size}
+    files = {ordinary(p).relative_to(stage).as_posix() for p in stage.rglob('*') if p.is_file()}
+    assert set(actual) == files
+    sums = {}
+    for line in (stage / 'SHA256SUMS.txt').read_text(encoding='utf-8').splitlines():
+        checksum, path = line.split('  ', 1)
+        assert relative(path) not in sums
+        sums[path] = checksum
+    assert set(sums) == set(actual) - {'SHA256SUMS.txt'}
+    assert all(actual[p]['sha256'] == h for p, h in sums.items())
+    companion = (archive_path.with_suffix('.zip.sha256')).read_text(encoding='utf-8').strip().split()
+    assert companion == [terminal['archive_sha256'], archive_path.name]
+    for item in preparation['artifacts']:
+        p = Path(item['destination']).name
+        assert actual[p]['sha256'] == sha(BASE / item['destination']) == item['sha256']
+    assert actual['arcadia-server.exe']['sha256'] == SERVER_SHA and actual['libunwind.dll']['sha256'] == DLL_SHA
+    assert git(SOURCE, 'rev-parse', 'HEAD').decode().strip() == preparation['reconstruction_commit']
+    assert not git(SOURCE, 'status', '--porcelain').strip()
+    for mapping in (preparation['gui_inputs'], preparation['shared_non_cargo_inputs']):
+        for path, checksum in mapping.items():
+            assert sha(SOURCE / path) == checksum
+    # This comparison deliberately uses the old server tar, never GUI source.
+    assert historical_inputs() == preparation['historical_server_inputs']
+    for item in load(BASE / 'evidence-manifest.json'):
+        assert sha(BASE / item['destination']) == item['sha256'] and (BASE / item['destination']).stat().st_size == item['bytes']
+    package = load(stage / 'package.json')
+    assert package['version'] == VERSION and package['target'] == TARGET
+    assert package['build_evidence']['evidence'] == load(BASE / 'build-evidence.json')
+    for path, checksum in package['input_sha256'].items():
+        assert actual[path]['sha256'] == checksum
+    notices = load(stage / 'dependency-notices.json')
+    previous = load(HISTORY / 'prior-dependency-notices.json')
+    def registry_key(item):
+        return item['name'], item['version'], item['source'], item['registry_checksum']
+    collected = {registry_key(x): x for x in notices['packages'] if x['source']}
+    covered = 0
+    for old in previous['packages']:
+        if not old['source']:
+            continue
+        current = collected[registry_key(old)]
+        assert old['license'] == current['license']
+        assert set(old['features']).issubset(current['features'])
+        # Exact recorded notice files must remain in the actual ZIP. Current
+        # metadata does not substitute for the historical server's provenance.
+        new_notices = {(n['path'], n['sha256']) for n in current['notices']}
+        for item in old['notices']:
+            assert (item['path'], item['sha256']) in new_notices
+            assert actual[item['path']]['sha256'] == item['sha256']
+        assert old['embedded_fonts'] == current['embedded_fonts']
+        for font in old['embedded_fonts']:
+            for item in font['notices']:
+                assert actual[item['path']]['sha256'] == item['sha256']
+        covered += 1
+    assert covered == preparation['historical_registry_count']
+    docs = load(stage / 'documentation-check.json')
+    result = {'atUtc': datetime.now(timezone.utc).isoformat(), 'status': 'PASS', 'archive_sha256': sha(archive_path),
+        'archive_bytes': archive_path.stat().st_size, 'file_count': len(actual), 'files': actual,
+        'manifest_entries': len(sums), 'source_commit': preparation['reconstruction_commit'],
+        'gui_inputs_verified': len(preparation['gui_inputs']), 'historical_server_inputs_verified': len(preparation['historical_server_inputs']),
+        'historical_server_comparison': preparation['historical_server_comparison'],
+        'historical_registry_packages_covered': covered, 'notice_roots': notices['root_packages'], 'notice_package_count': len(notices['packages']),
+        'documentation_check': docs, 'binary_imports': package['imports'],
+        'scope': 'Producer packaging readback only; no application launch or independent/native acceptance.'}
+    record(BASE / 'package-readback.json', result)
+    print(json.dumps({k: v for k, v in result.items() if k != 'files'}, ensure_ascii=False, indent=2))
+
+
+if __name__ == '__main__':
+    sys.stdout.reconfigure(encoding='utf-8')
+    sys.stderr.reconfigure(encoding='utf-8')
+    main()

harness/experiments/navigation-prerelease-20260911/producer/source-push-result.json

@@ -0,0 +1,11 @@
+{
+  "started": "2026-09-11T21:16:51.511220+00:00",
+  "branch": "codex/navigation-repair-prerelease-source-20260911",
+  "commit": "802855f7e6f2f00a107a12196b458b267f586b8d",
+  "scope": "One exact raw-source branch; no force, tag, release or asset operation.",
+  "before": "",
+  "success": true,
+  "after": "802855f7e6f2f00a107a12196b458b267f586b8d\trefs/heads/codex/navigation-repair-prerelease-source-20260911",
+  "user": "Codex-9e8r6t",
+  "finished": "2026-09-11T21:17:00.851446+00:00"
+}

harness/experiments/navigation-prerelease-20260911/readback.json

@@ -0,0 +1,10 @@
+{
+  "originalCopiesByteExact": true,
+  "referencedCommittedCopiesByteExact": true,
+  "historicalServerGitAndTarInputs": 120,
+  "tarInventoryFiles": 459,
+  "manifestSha256": "dc35192a128ff6164835fe7176c8664f971d47799ff085953e748a886b060e93",
+  "packageZipSha256": "d7228c542f162663933ea002739a78c722bcca41e437df63b7c868ea2af201f1",
+  "packageZipCopied": false,
+  "sourceBranchPushReceiptVerified": true
+}

harness/experiments/navigation-prerelease-20260911/references.json

@@ -0,0 +1,138 @@
+[
+  {
+    "original": ".local/nav-repair-retry-20260911/evidence/gui-complete.json",
+    "sha256": "20034a0ccfd935fbcac0218ff0f1e370899e5f8a32b6dde35aebb62a7d0b98c8",
+    "bytes": 359,
+    "committedEquivalent": "harness/experiments/text-navigation-native-20260911/repair-save-correction/gates/complete.json"
+  },
+  {
+    "original": ".local/nav-repair-retry-20260911/evidence/gui-desktop-clippy-result.json",
+    "sha256": "b3ea09aa7097400077f13e809c44e908469c37e844c47b73ef25813c484279b9",
+    "bytes": 521,
+    "committedEquivalent": "harness/experiments/text-navigation-native-20260911/repair-save-correction/gates/desktop-clippy-result.json"
+  },
+  {
+    "original": ".local/nav-repair-retry-20260911/evidence/gui-desktop-clippy-stderr.log",
+    "sha256": "21b277b6aa7d27f9ecb0692579527a8d798083c24a3cbfeef29bdafd9fe71889",
+    "bytes": 155,
+    "committedEquivalent": "harness/experiments/text-navigation-native-20260911/repair-save-correction/gates/desktop-clippy-stderr.log"
+  },
+  {
+    "original": ".local/nav-repair-retry-20260911/evidence/gui-desktop-clippy-stdout.log",
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "bytes": 0,
+    "committedEquivalent": "harness/experiments/text-navigation-native-20260911/repair-save-correction/gates/desktop-clippy-stdout.log"
+  },
+  {
+    "original": ".local/nav-repair-retry-20260911/evidence/gui-desktop-tests-result.json",
+    "sha256": "e6873ad9ac0bd3451785608618c7dbc11aceb05858fb4eee21aff472c14ef9c5",
+    "bytes": 531,
+    "committedEquivalent": "harness/experiments/text-navigation-native-20260911/repair-save-correction/gates/desktop-tests-result.json"
+  },
+  {
+    "original": ".local/nav-repair-retry-20260911/evidence/gui-desktop-tests-stderr.log",
+    "sha256": "a0bb3154f9204d12e7ccc7934953af5cca8f4a4b9496a2d3ca3d93ed96d99db5",
+    "bytes": 262,
+    "committedEquivalent": "harness/experiments/text-navigation-native-20260911/repair-save-correction/gates/desktop-tests-stderr.log"
+  },
+  {
+    "original": ".local/nav-repair-retry-20260911/evidence/gui-desktop-tests-stdout.log",
+    "sha256": "a7e1a1dd98adc5de453ffc6b888c42d90f7f64d33fa7b76f4271faa93344ccd9",
+    "bytes": 85051,
+    "committedEquivalent": "harness/experiments/text-navigation-native-20260911/repair-save-correction/gates/desktop-tests-stdout.log"
+  },
+  {
+    "original": ".local/nav-repair-retry-20260911/evidence/gui-diff-check-result.json",
+    "sha256": "cec5b925f98e43f9c8d29e0ef99b3b0d817f7433f4d5464acda974b8bd516a81",
+    "bytes": 416,
+    "committedEquivalent": "harness/experiments/text-navigation-native-20260911/repair-save-correction/gates/diff-check-result.json"
+  },
+  {
+    "original": ".local/nav-repair-retry-20260911/evidence/gui-diff-check-stderr.log",
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "bytes": 0,
+    "committedEquivalent": "harness/experiments/text-navigation-native-20260911/repair-save-correction/gates/diff-check-stderr.log"
+  },
+  {
+    "original": ".local/nav-repair-retry-20260911/evidence/gui-diff-check-stdout.log",
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "bytes": 0,
+    "committedEquivalent": "harness/experiments/text-navigation-native-20260911/repair-save-correction/gates/diff-check-stdout.log"
+  },
+  {
+    "original": ".local/nav-repair-retry-20260911/evidence/gui-gate-run.py",
+    "sha256": "ddac72721ff6ce8df37d9b1fff0136f82c5f744d349725fa4eef7aa8c466afcc",
+    "bytes": 4917,
+    "committedEquivalent": "harness/experiments/text-navigation-native-20260911/repair-save-correction/gates/run.py"
+  },
+  {
+    "original": ".local/nav-repair-retry-20260911/evidence/gui-gui-build-result.json",
+    "sha256": "044588599aad6a8b879288050fb2eda204854cf3048c3deef164367eac22bbdf",
+    "bytes": 1883,
+    "committedEquivalent": "harness/experiments/text-navigation-native-20260911/repair-save-correction/gates/gui-build-result.json"
+  },
+  {
+    "original": ".local/nav-repair-retry-20260911/evidence/gui-gui-build-stderr.log",
+    "sha256": "472f3b59616dd2e571d5fe4751da2e99da0431cdc2de0312507fd4fc303a2b60",
+    "bytes": 155,
+    "committedEquivalent": "harness/experiments/text-navigation-native-20260911/repair-save-correction/gates/gui-build-stderr.log"
+  },
+  {
+    "original": ".local/nav-repair-retry-20260911/evidence/gui-gui-build-stdout.log",
+    "sha256": "4340de1b0c0207d6c898ea105e34451671ad6a92b4414c6f8f6da4e8978268cd",
+    "bytes": 282605,
+    "committedEquivalent": "harness/experiments/text-navigation-native-20260911/repair-save-correction/gates/gui-build-stdout.log"
+  },
+  {
+    "original": ".local/nav-repair-retry-20260911/evidence/gui-inputs1.json",
+    "sha256": "75a282fd3d4cb2dec6763046ea45d0caa015b998281fbdd6f222d8e3a175b13f",
+    "bytes": 93531,
+    "committedEquivalent": "harness/experiments/text-navigation-native-20260911/repair-save-correction/gates/inputs1.json"
+  },
+  {
+    "original": ".local/nav-repair-retry-20260911/evidence/gui-scoped-fmt-result.json",
+    "sha256": "9906fb9bde7e0f6a9037ea0b2ccb61f4b9c61c7741c69a52ce995850259ac020",
+    "bytes": 615,
+    "committedEquivalent": "harness/experiments/text-navigation-native-20260911/repair-save-correction/gates/scoped-fmt-result.json"
+  },
+  {
+    "original": ".local/nav-repair-retry-20260911/evidence/gui-scoped-fmt-stderr.log",
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "bytes": 0,
+    "committedEquivalent": "harness/experiments/text-navigation-native-20260911/repair-save-correction/gates/scoped-fmt-stderr.log"
+  },
+  {
+    "original": ".local/nav-repair-retry-20260911/evidence/gui-scoped-fmt-stdout.log",
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "bytes": 0,
+    "committedEquivalent": "harness/experiments/text-navigation-native-20260911/repair-save-correction/gates/scoped-fmt-stdout.log"
+  },
+  {
+    "original": ".local/nav-repair-retry-20260911/evidence/server-original-binary-hashes.json",
+    "sha256": "110a03e323133efb48d50ad065d41414599aa85e0ac420e7d622aa04df4d54f8",
+    "bytes": 744,
+    "committedEquivalent": "harness/experiments/contextual-prerelease-20260911/producer/evidence/server-original-binary-hashes.json"
+  },
+  {
+    "original": ".local/nav-repair-retry-20260911/evidence/server-original-gates.json",
+    "sha256": "b7fdfc55ed4c964d276f20f1c57c81c1e924b8da315171089740ab8335ac9f0d",
+    "bytes": 2572,
+    "committedEquivalent": "harness/experiments/contextual-prerelease-20260911/producer/evidence/server-original-gates.json"
+  },
+  {
+    "original": ".local/nav-repair-retry-20260911/evidence/server-prior-input-comparisons.json",
+    "sha256": "3c78dea4e93dae186fd24ab826c6680178a2c7849c270a22deae2ff732f1857b",
+    "bytes": 66465,
+    "committedEquivalent": "harness/experiments/contextual-prerelease-20260911/producer/evidence/server-prior-input-comparisons.json"
+  },
+  {
+    "original": ".local/nav-repair-retry-20260911/evidence/server-source-snapshot.tar.gz",
+    "sha256": "cbb371a93a562e1e641d7629fe351e016d63e66fc9112499b3fed6d5cd171f78",
+    "bytes": 2089801
+  },
+  {
+    "original": ".local/nav-repair-retry-20260911/packages/ArcadiaStudio-0.2.0-preview.navigation.20260911-x86_64-pc-windows-gnullvm.zip",
+    "sha256": "d7228c542f162663933ea002739a78c722bcca41e437df63b7c868ea2af201f1",
+    "bytes": 32971712
+  }
+]

harness/experiments/navigation-prerelease-20260911/reviews/nav-repair-retry-review-20260911/adapter-review.md

@@ -0,0 +1,21 @@
+# Navigation repair packaging retry: independent static closure
+
+Codex-9e8r6t /root/behavior_audit · 2026-09-11
+
+READY for the root-owned fresh retry. No material finding. Reviewed the exact code diff against the previously reviewed C00C prepare adapter, final README and manifest; package2.ps1 and readback.py remain byte-identical to their previously reviewed versions.
+
+Only operational changes are command-local git -c core.longpaths=true on the complete checkout-index --all command, and a Git wrapper preserving failed command/cwd/exit plus exclusive raw stdout/stderr and hashes. cat-file now passes through that same wrapper. No global or repository configuration is written. Fresh source, fresh roundtrip, all 500/shared byte checks, provenance, exclusive outputs and root-state guards remain unchanged. The retry uses a new shorter directory and does not reuse partial output.
+
+Independent read-only measurement reproduced all failure-audit facts: 2,174 tracked paths, exactly seven missing from the old roundtrip, missing absolute lengths 260–266 and maximum present length 259. The old failure-result SHA and reconstruction 613c480a match the audit. The correlation strongly supports MAX_PATH but does not recover the missing original stderr. This distinction is accurately stated. The failed attempt remains preserved.
+
+Final README correctly identifies the generator in the earlier navigation-repair-prerelease directory and says the retry contains no generator. All six final manifest entries match sizes/hashes. New retry outputs were absent during this review. No adapter import/execution, clone, metadata, packaging, application, compiler or Git mutation was performed; only this new private review note was written.
+
+Final identities:
+
+- prepare.py: 403844BAF739A524C23B8E3F5C3D989979F4292F2E6D8E380FDDE119E121698E.
+- README.md: F85504003B2D45C7D0BC2C2A1530166F67446864167D064723A956EBCF0E0BEB.
+- adapter-manifest.json: BBD08342632E463C9BB7B79FF7E467E0CB8FAA6B6B085D6C54BD75FBF1750BB9.
+
+This is static closure, not successful preparation or package/runtime acceptance. Actual execution and subsequent independent archive/server/native checks remain separate.
+
+Recorded 2026-09-11T21:09:27.063594+00:00.

harness/experiments/navigation-prerelease-20260911/reviews/navigation-repair-prerelease-review-20260911/adapter-review.md

@@ -0,0 +1,27 @@
+# Repaired navigation prerelease adapters: independent static review
+
+Codex-9e8r6t /root/behavior_audit · 2026-09-11
+
+READY for root's separately authorized preparation and packaging sequence. No material finding in the exact frozen adapter set. This is not an actual reconstruction/package/server/native acceptance result.
+
+Read prepare.py, package2.ps1, readback.py, README.md, VALIDATION.pending.md and adapter-manifest.json; compared production adapters against the previously reviewed set and traced their unchanged strict packaging dependencies. Current Gitea #6 gate/ownership records were read. adapt.py is historical generation evidence, not an executable step in the final flow.
+
+Independent read-only evidence verification found:
+
+- All seven manifest-listed files match exact sizes/hashes; manifest SHA256 24DBF41E533C502AB42FE9F3BD69D4446CB9B1513387B5EBAD604CD0E592F061.
+- All 500 files / 9,482,855 raw bytes match inputs1.json, ZIP213fdb39ea7c3601b4baac674c3ab3ecc863ac44db1b092d922d3e24f26887b7 and current working files. The immutable 33c6d83 tree and current tracked/untracked input set match that inventory. Exactly 15 Git/raw differences are newline-only; no semantic source difference was found. Shared build-resource overlap is exact.
+- All five command receipts have exit 0, unchanged-input assertions, exact expected arguments and matching stdout/stderr hashes. The full terminal summary is 755 passed / 0 failed / 1 ignored / 0 measured / 0 filtered. The embedded GUI artifact equals the one in actual hash-bound Cargo stdout; preserved B183EF31F16B3986538B3F2ABA8435EAB45978635C47F99CA01BE6E72B168848 is 113,206,272 bytes.
+- Captured gate HEAD remains eeeaa126 plus its repair delta; 33c6d83 is its committed equivalent. README/evidence generation do not relabel the earlier capture as a clean 33c build. Future reconstruction is a separate exact-byte commit, not an original build commit.
+- Hard-pinned historical records and tar reproduce all 120 server inputs. Current core differs only in language.rs, with language_outline_tests.rs added. EFEE server and F456 runtime match hard pins. All 263 historical registry identities/checksums remain locked.
+
+Source review confirms fresh exclusive clone/outputs, clone-owned index/branch, current file-set/byte preflight, immutable base ancestry and later harness-only/nonfixture path restriction, measured narrow newline restorations, byte-exact committed/fresh-checkout comparison and root HEAD/index/tracked-state readback. The PowerShell wrapper retains one exact offline metadata admission and existing native exit/refusal checks. No later root record is silently packaged from current HEAD.
+
+The new producer readback requires historical registry package identity, license, feature subset, exact notice paths/hashes and exact embedded-font records, then verifies their actual ZIP payload hashes. This is stricter coverage checking rather than retroactive EFEE source/compiler provenance. Current generated notices and the preserved historical server records remain separately identified. No generated coverage result is claimed before packaging.
+
+Limits: no adapter import/execution, clone, metadata, compiler, packaging or application run occurred. Package/preparation outputs were absent during this readback. No failure injection was performed. Future source round-trip, package inventory/ZIP hash, collected notices and extracted server/native behavior still require their actual gates. The earlier adapter directory/review and all existing evidence remain untouched. This note modifies only the reviewer's new private directory.
+
+Evidence: static-readback.json SHA256 A6ED03C83C6D341D2044B706F3CD0794EF2F5E535D4D01EEC6A75C0E7B75A396 contains exact per-file/per-gate hashes, 15 newline paths and current ancestry observations.
+
+Frozen scripts: prepare.py C00C89181F58A9F4AFBB29EEA7EB7C9C8473DEEE280531FD2D6BE2D88D49A07C; package2.ps1 1BD9C4B47D03F7479DFB627E8EF845A6F5770782A1CFA58E44B0E9B28B45AC64; readback.py 81BAD82AED8522D5377FB671B71F4BD7BA329206BEB9E96C4CD11F3A8FB343CF.
+
+Recorded 2026-09-11T21:03:54.859171+00:00.

harness/experiments/navigation-prerelease-20260911/reviews/navigation-repair-prerelease-review-20260911/static-readback.json

@@ -0,0 +1,137 @@
+{
+  "atUtc": "2026-09-11T21:02:42.004070+00:00",
+  "scope": "Independent read-only source/receipt/blob verification; no adapter execution/import, clone, metadata, build, package or application run.",
+  "adapter_manifest_sha256": "24dbf41e533c502ab42fe9f3bd69d4446cb9b1513387b5ebad604cd0e592f061",
+  "adapter_files": [
+    {
+      "path": "prepare.py",
+      "bytes": 19816,
+      "sha256": "c00c89181f58a9f4afbb29eea7eb7c9c8473deee280531fd2d6be2d88d49a07c"
+    },
+    {
+      "path": "package2.ps1",
+      "bytes": 5189,
+      "sha256": "1bd9c4b47d03f7479dfb627e8ef845a6f5770782a1cfa58e44b0e9b28b45ac64"
+    },
+    {
+      "path": "readback.py",
+      "bytes": 6307,
+      "sha256": "81bad82aed8522d5377fb671b71f4bd7ba329206beb9e96c4cd11f3a8fb343cf"
+    },
+    {
+      "path": "README.md",
+      "bytes": 4909,
+      "sha256": "00fa3176fce5e4e044c8966e4d820e7f3fedb82634e5680b4d957d726e8bdcf2"
+    },
+    {
+      "path": "VALIDATION.pending.md",
+      "bytes": 1219,
+      "sha256": "694a2274ed5c71c3707a90698f7c3254ef4d86233b4bac2d3730b24b970bce1d"
+    },
+    {
+      "path": "adapt.py",
+      "bytes": 8836,
+      "sha256": "ae0f6eb162a27d13c7f3e2dd636bd5b67068e1b9b30a2d29b275a3112f00ab5f"
+    },
+    {
+      "path": "static-source-readback.json",
+      "bytes": 1071,
+      "sha256": "171f6d080e7d95f24c8563bae5e6d6e2d8e00e7802116ce47bdac700c249c520"
+    }
+  ],
+  "input_count": 500,
+  "input_bytes": 9482855,
+  "source_archive_sha256": "213fdb39ea7c3601b4baac674c3ab3ecc863ac44db1b092d922d3e24f26887b7",
+  "captured_head": "eeeaa1262748800c4c9aaa1eca79a7de96757358",
+  "committed_equivalent": "33c6d83e9ba9a5b1310b1b627d7c40affcbcf15c",
+  "observed_head": "33c6d83e9ba9a5b1310b1b627d7c40affcbcf15c",
+  "later_harness_only_paths": [],
+  "newline_differences": [
+    "crates/oa-desktop/src/behavior/creation.rs",
+    "crates/oa-desktop/src/behavior/scenario/workspace.rs",
+    "crates/oa-desktop/src/behavior/topology/contextual.rs",
+    "crates/oa-desktop/src/guide.rs",
+    "crates/oa-desktop/src/semantic_review/artifacts_view.rs",
+    "crates/oa-desktop/src/semantic_review/attachments_view.rs",
+    "crates/oa-desktop/src/semantic_review/keyed.rs",
+    "crates/oa-desktop/src/semantic_review/keyed_rows.rs",
+    "crates/oa-desktop/src/semantic_review/keyed_tests.rs",
+    "crates/oa-desktop/src/semantic_review/ordered.rs",
+    "docs/api.html",
+    "docs/api.rst",
+    "docs/language.html",
+    "docs/openapi.json",
+    "harness/fixtures/rest-coverage/coverage-probe.json"
+  ],
+  "shared_non_cargo_inputs": {
+    "LICENSE": "51009f2cb07e5d19645858b2fbc037a672a25f8cbf7999522942b86807ecf365",
+    "docs/openapi.json": "c6ae512f791a939eaf6ec5e5e78e9468bdee0e028092d00098bd90ad9498d967",
+    "build/windows_manifest.rs": "168da2c42ecccfebc11ee3e1b455e653a68fe9c6d30a9842a8b9e7441d086c80",
+    "build/windows.manifest": "9c19c5a02f858ece84c44839ad2b145d9c1d90442da0b15c87fd045f975974eb",
+    "build/windows.rc": "a27385edcae0bcf96f55361056cb7be5f36d76fcddcaefd20647c91959563e1e"
+  },
+  "gates": {
+    "desktop-tests": {
+      "receipt_sha256": "e6873ad9ac0bd3451785608618c7dbc11aceb05858fb4eee21aff472c14ef9c5",
+      "stdout_sha256": "a7e1a1dd98adc5de453ffc6b888c42d90f7f64d33fa7b76f4271faa93344ccd9",
+      "stderr_sha256": "a0bb3154f9204d12e7ccc7934953af5cca8f4a4b9496a2d3ca3d93ed96d99db5",
+      "exit_code": 0
+    },
+    "desktop-clippy": {
+      "receipt_sha256": "b3ea09aa7097400077f13e809c44e908469c37e844c47b73ef25813c484279b9",
+      "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "stderr_sha256": "21b277b6aa7d27f9ecb0692579527a8d798083c24a3cbfeef29bdafd9fe71889",
+      "exit_code": 0
+    },
+    "scoped-fmt": {
+      "receipt_sha256": "9906fb9bde7e0f6a9037ea0b2ccb61f4b9c61c7741c69a52ce995850259ac020",
+      "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "exit_code": 0
+    },
+    "diff-check": {
+      "receipt_sha256": "cec5b925f98e43f9c8d29e0ef99b3b0d817f7433f4d5464acda974b8bd516a81",
+      "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "exit_code": 0
+    },
+    "gui-build": {
+      "receipt_sha256": "044588599aad6a8b879288050fb2eda204854cf3048c3deef164367eac22bbdf",
+      "stdout_sha256": "4340de1b0c0207d6c898ea105e34451671ad6a92b4414c6f8f6da4e8978268cd",
+      "stderr_sha256": "472f3b59616dd2e571d5fe4751da2e99da0431cdc2de0312507fd4fc303a2b60",
+      "exit_code": 0
+    }
+  },
+  "full_counts": [
+    755,
+    0,
+    1,
+    0,
+    0
+  ],
+  "gui_sha256": "b183ef31f16b3986538b3f2aba8435eab45978635c47f99ca01be6e72b168848",
+  "gui_bytes": 113206272,
+  "historical_server_inputs": 120,
+  "historical_changed_source": [
+    "crates/oa-core/src/language.rs"
+  ],
+  "historical_added_source": [
+    "crates/oa-core/src/language_outline_tests.rs"
+  ],
+  "historical_registry_identities_locked": 263,
+  "historical_font_records": 2,
+  "outputs_verified_absent": [
+    "source",
+    "source-roundtrip",
+    "bin",
+    "evidence",
+    "preparation.json",
+    "prepare-result.json",
+    "committed-roundtrip.json",
+    "build-evidence.json",
+    "evidence-manifest.json",
+    "packages",
+    "package2-result.json",
+    "package-readback.json"
+  ]
+}

harness/experiments/navigation-prerelease-20260911/source-identity/comparison.json

@@ -0,0 +1,7 @@
+{
+  "sameTree": "09741096d6074291e22a967855e7b81e247d3e09",
+  "sameParent": "33c6d83e9ba9a5b1310b1b627d7c40affcbcf15c",
+  "onlyCommitTimestampDiffers": true,
+  "initialCommit": "613c480a27426dd25f17b339803f789ac3dbf0ea",
+  "successfulRetryCommit": "802855f7e6f2f00a107a12196b458b267f586b8d"
+}

harness/experiments/navigation-prerelease-20260911/source-identity/initial-commit.txt

@@ -0,0 +1,6 @@
+tree 09741096d6074291e22a967855e7b81e247d3e09
+parent 33c6d83e9ba9a5b1310b1b627d7c40affcbcf15c
+author Codex-9e8r6t <codex-9e8r6t@local.invalid> 1789160608 -0700
+committer Codex-9e8r6t <codex-9e8r6t@local.invalid> 1789160608 -0700
+
+Preserve exact navigation prerelease GUI inputs

harness/experiments/navigation-prerelease-20260911/source-identity/reconstructed.gitattributes

@@ -0,0 +1,90 @@
+* text=auto eol=lf
+*.rs text eol=lf
+*.toml text eol=lf
+*.lock text eol=lf
+*.md text eol=lf
+*.rst text eol=lf
+*.json text eol=lf
+*.arcadia text eol=lf
+*.yml text eol=lf
+*.yaml text eol=lf
+*.sh text eol=lf
+*.png binary
+*.jpg binary
+*.zip binary
+
+# Exact source/recovery oracles and archived ledgers retain their measured bytes.
+# Keep ordinary text diffs; only disable checkout/check-in newline conversion.
+harness/fixtures/release1-native/** -text
+harness/fixtures/interface-operation-probe/** -text
+harness/history/2026-09-06-ledgers-before-consolidation/** -text
+harness/history/2026-09-10-ledgers-before-second-consolidation/** -text whitespace=blank-at-eol,blank-at-eof,space-before-tab,cr-at-eol
+harness/experiments/textual-authoring-20260911-local/** -text whitespace=blank-at-eol,blank-at-eof,space-before-tab,cr-at-eol
+harness/experiments/constructor-defaults-20260911/** -text whitespace=blank-at-eol,blank-at-eof,space-before-tab,cr-at-eol
+harness/experiments/constructor-defaults-20260911/results/*.arcadia whitespace=-blank-at-eol,cr-at-eol
+harness/experiments/behavior-creation-native-20260911/** -text whitespace=blank-at-eol,blank-at-eof,space-before-tab,cr-at-eol
+harness/experiments/analysis-context-20260911/** -text whitespace=cr-at-eol
+harness/experiments/textual-authoring-20260911/** -text whitespace=cr-at-eol
+harness/experiments/textual-authoring-20260911/observed/split-entry.arcadia whitespace=-blank-at-eol,cr-at-eol
+harness/fixtures/scenario-authoring/base/** -text whitespace=cr-at-eol
+crates/oa-desktop/src/recovery/fixtures/*.json -text
+harness/fixtures/source7-native/** -text
+harness/fixtures/basic-editing/** -text
+harness/behavior-creation-contract.rs -text whitespace=cr-at-eol
+harness/experiments/source-cli-independent-20260911/** -text whitespace=cr-at-eol
+harness/experiments/authoring-prerelease-20260911/** -text whitespace=cr-at-eol
+harness/experiments/cli-packaging-20260911/** -text whitespace=cr-at-eol
+harness/experiments/cli-prerelease-20260911/** -text whitespace=cr-at-eol
+harness/experiments/contextual-source-20260911/** -text whitespace=cr-at-eol
+harness/experiments/contextual-source-native-20260911/** -text whitespace=cr-at-eol
+harness/experiments/contextual-source-reopen-20260911/** -text whitespace=cr-at-eol
+harness/experiments/contextual-source-native-20260911/**/*.arcadia whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
+harness/experiments/contextual-source-layout-reboot-20260911/** -text whitespace=cr-at-eol
+harness/experiments/contextual-source-layout-reboot-20260911/run-gates2.ps1 whitespace=-blank-at-eof,cr-at-eol
+harness/experiments/contextual-source-20260911/**/*.log whitespace=-blank-at-eof,cr-at-eol
+harness/experiments/scenario-native-local-20260911/** -text whitespace=cr-at-eol
+harness/experiments/scenario-native-local-20260911/**/*.log whitespace=-blank-at-eof,cr-at-eol
+harness/experiments/scenario-native-local-20260911/**/*.arcadia whitespace=-blank-at-eol,cr-at-eol
+harness/fixtures/staged-source-authoring/** -text whitespace=cr-at-eol
+harness/staged-source-authoring-contract.rs -text whitespace=cr-at-eol
+
+# Preserve checksum-bound font notices verbatim through Git round trips.
+harness/experiments/wsl-capacity-20260911/** -text whitespace=cr-at-eol
+harness/experiments/wsl-postboot-9e8r6t-20260911/** -text whitespace=-blank-at-eof,cr-at-eol
+harness/experiments/contextual-source-layout-postboot-20260911/** -text whitespace=-blank-at-eof,cr-at-eol
+harness/experiments/contextual-source-layout-verified-20260911/** -text whitespace=-blank-at-eof,cr-at-eol
+harness/experiments/contextual-source-layout-full-20260911/** -text whitespace=-blank-at-eof,cr-at-eol
+scripts/windows-notices/GNOME-Cantarell-61362600e104-COPYING -text
+scripts/windows-notices/Fira-OFL.txt -text
+scripts/windows-notices/FiraSans-Regular-NOTICE.txt -text
+harness/experiments/contextual-source-recovery-20260911/** -text whitespace=-blank-at-eof,cr-at-eol
+harness/experiments/contextual-source-machine-v2-20260911/** -text whitespace=-blank-at-eof,cr-at-eol
+harness/experiments/contextual-source-lifeline-v2-20260911/** -text whitespace=-blank-at-eof,cr-at-eol
+harness/experiments/contextual-source-lifeline-v2-20260911/**/*.arcadia whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
+harness/experiments/contextual-source-machine-v2-20260911/**/*.arcadia whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
+harness/experiments/contextual-source-reopen-20260911/launch-method.ps1 whitespace=-blank-at-eof,cr-at-eol
+# Raw compact.exe output includes CR-CR-LF and incidental trailing spaces.
+harness/experiments/wsl-capacity-20260911/*.log -whitespace
+harness/experiments/contextual-prerelease-20260911/** -text whitespace=cr-at-eol
+harness/experiments/contextual-prerelease-publication-20260911/** -text whitespace=cr-at-eol
+harness/history/2026-09-11-state-before-gitea-migration/** -text whitespace=cr-at-eol
+harness/experiments/contextual-prerelease-20260911/native/**/*.arcadia whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
+harness/experiments/contextual-prerelease-20260911/producer/package*.log whitespace=-blank-at-eof,cr-at-eol
+harness/experiments/contextual-prerelease-20260911/producer/source-push.log -whitespace
+
+# Exact frozen navigation GUI input bytes; historical server source is separate.
+crates/oa-desktop/src/behavior/creation.rs -text
+crates/oa-desktop/src/behavior/scenario/workspace.rs -text
+crates/oa-desktop/src/behavior/topology/contextual.rs -text
+crates/oa-desktop/src/guide.rs -text
+crates/oa-desktop/src/semantic_review/artifacts_view.rs -text
+crates/oa-desktop/src/semantic_review/attachments_view.rs -text
+crates/oa-desktop/src/semantic_review/keyed.rs -text
+crates/oa-desktop/src/semantic_review/keyed_rows.rs -text
+crates/oa-desktop/src/semantic_review/keyed_tests.rs -text
+crates/oa-desktop/src/semantic_review/ordered.rs -text
+docs/api.html -text
+docs/api.rst -text
+docs/language.html -text
+docs/openapi.json -text
+harness/fixtures/rest-coverage/coverage-probe.json -text

harness/experiments/navigation-prerelease-20260911/source-identity/retry-commit.txt

@@ -0,0 +1,6 @@
+tree 09741096d6074291e22a967855e7b81e247d3e09
+parent 33c6d83e9ba9a5b1310b1b627d7c40affcbcf15c
+author Codex-9e8r6t <codex-9e8r6t@local.invalid> 1789160963 -0700
+committer Codex-9e8r6t <codex-9e8r6t@local.invalid> 1789160963 -0700
+
+Preserve exact navigation prerelease GUI inputs

harness/experiments/navigation-prerelease-20260911/verify_archive.py

@@ -0,0 +1,47 @@
+"""Read-only producer archive verification; no package/application/compiler run."""
+import hashlib
+import json
+from pathlib import Path
+
+base = Path(__file__).resolve().parent
+root = base.parents[2]
+read = lambda path: json.loads(path.read_text(encoding="utf-8"))
+sha = lambda path: hashlib.sha256(path.read_bytes()).hexdigest()
+manifest = read(base / "manifest.json")
+assert {p.relative_to(base).as_posix() for p in base.rglob("*") if p.is_file()} == {item["path"] for item in manifest["files"]} | {"manifest.json", "readback.json"}
+for item in manifest["files"]:
+    path = base / item["path"]
+    assert path.stat().st_size == item["bytes"] and sha(path) == item["sha256"], item["path"]
+assert sha(base / "manifest.json") == read(base / "readback.json")["manifestSha256"]
+for item in read(base / "references.json"):
+    if "committedEquivalent" in item:
+        assert sha(root / item["committedEquivalent"]) == item["sha256"]
+assert read(base / "initial-failed/prepare-result.json")["success"] is False
+assert len(read(base / "producer/failure-audit.json")["missing"]) == 7
+assert read(base / "producer/prepare-result.json")["success"] is True
+prepared = read(base / "producer/preparation.json")
+assert len(prepared["gui_inputs"]) == 500 and len(prepared["restorations"]) == 15
+assert prepared["root_before"] == prepared["root_after"]
+assert prepared["reconstruction_commit"] == "802855f7e6f2f00a107a12196b458b267f586b8d"
+assert read(base / "producer/metadata2-result.json")["exitCode"] == 0
+package = read(base / "producer/package2-result.json")
+result = read(base / "producer/package-readback.json")
+assert package["success"] and result["status"] == "PASS"
+assert result["archive_sha256"] == package["archive_sha256"] == "d7228c542f162663933ea002739a78c722bcca41e437df63b7c868ea2af201f1"
+assert result["file_count"] == len(result["files"]) == 559
+assert result["gui_inputs_verified"] == 500 and result["historical_server_inputs_verified"] == 120
+push = read(base / "producer/source-push-result.json")
+assert push["success"] and push["before"] == ""
+assert push["commit"] == prepared["reconstruction_commit"] == push["after"].split()[0]
+for path in (base / "package-metadata").iterdir():
+    if path.name in result["files"]:
+        assert sha(path) == result["files"][path.name]["sha256"]
+historical = read(base / "historical-server/git-inputs.json")
+tar = read(base / "historical-server/tar-inventory.json")
+assert len(historical["inputs"]) == 120 and len(tar["files"]) == 459
+hashes = {item["path"]: item["sha256"] for item in tar["files"]}
+assert all(hashes[item["path"]] == item["sha256"] for item in historical["inputs"])
+for path in (base / "historical-server/original-workspace").rglob("*"):
+    if path.is_file():
+        assert sha(path) == hashes[path.relative_to(base / "historical-server/original-workspace").as_posix()]
+print(json.dumps({"passed": True, "payloadFiles": len(manifest["files"]), "producerPackageFiles": 559, "guiInputs": 500, "historicalServerInputs": 120, "scope": "Producer receipts and archive integrity only"}))

harness/experiments/navigation-prerelease-native-20260911/.gitattributes

@@ -0,0 +1 @@
+* -text

harness/experiments/navigation-prerelease-native-20260911/MANIFEST.json

@@ -0,0 +1,314 @@
+{
+  "files": [
+    {
+      "path": ".gitattributes",
+      "bytes": 9,
+      "sha256": "8b9c3028d6467ff3be7c793141927841d70f47f52d0590677438f488ca154992"
+    },
+    {
+      "path": "ORIGINALS.json",
+      "bytes": 10761,
+      "sha256": "ef655a81362a661d9ffe0d534b760c6d9b395b5aa05f5b0b4d9194ac645743fa"
+    },
+    {
+      "path": "payload/binding.json",
+      "bytes": 846,
+      "sha256": "82606e6b3a5fb5dada3e55adcd5cd76792c9f938e6907313539dae7fc5125657"
+    },
+    {
+      "path": "payload/binding.pending.json",
+      "bytes": 306,
+      "sha256": "1c39142ec0e11067a4ff12911156741b73c3c305148a38fee861320dd1eedf7e"
+    },
+    {
+      "path": "payload/close_readonly.py",
+      "bytes": 4793,
+      "sha256": "16921ad616344132c4f1a7cd8fc49276dbbb8ee32415432d5b1604eb73fae43c"
+    },
+    {
+      "path": "payload/closure-preparation.md",
+      "bytes": 2294,
+      "sha256": "00b790280e8d6358b9554b847c5ad8ac38f17352b65e3bac192a7d53bd3704b6"
+    },
+    {
+      "path": "payload/draft-manifest.json",
+      "bytes": 735,
+      "sha256": "826b29480f80dbeb1aa5e54310ad7584d9fd804ec33810d6ec3acc05c91ccb2c"
+    },
+    {
+      "path": "payload/final-manifest.json",
+      "bytes": 787,
+      "sha256": "78dc734df23df02405248bd50beb5dfa325d19e465b91d2eceb9c00aa43efc01"
+    },
+    {
+      "path": "payload/helper.py",
+      "bytes": 12807,
+      "sha256": "11e1ac5379c28e17b8a9f5b883ddf0640994eea34de257f4e66efe6033190877"
+    },
+    {
+      "path": "payload/loaded-modules.ps1",
+      "bytes": 2889,
+      "sha256": "39527416b3043de1a360788436a330c5293b8941a3317defad6e2c82e6ee31fe"
+    },
+    {
+      "path": "payload/original-close-observation.json",
+      "bytes": 1005,
+      "sha256": "2dafca8092237da77a688a060069f94a8c180adc16e677a0f5196c57edbdfd59"
+    },
+    {
+      "path": "payload/README.md",
+      "bytes": 4520,
+      "sha256": "b873d46d74ff029a131a4c911924ea699c785a1d14b475b7c40721fb23bbad36"
+    },
+    {
+      "path": "payload/trial/admission.json",
+      "bytes": 1173,
+      "sha256": "f290d1d056494afa340fcfaa39b71024d104726ce1e92bc42a87f40d822821c8"
+    },
+    {
+      "path": "payload/trial/after-close-readonly-package.json",
+      "bytes": 71730,
+      "sha256": "5f6183a039fdcc2d98d1d331eb74fdf7fe34cad0e3fbb7d58a0b88bdc0adc788"
+    },
+    {
+      "path": "payload/trial/checkpoints/navigation-final-saved/result.json",
+      "bytes": 727,
+      "sha256": "cf653c9a2b0d5529c0875b8bf1990d29fb05b1bf06c52249ceb89cb35780a68a"
+    },
+    {
+      "path": "payload/trial/checkpoints/navigation-final-saved/sources/links.arcadia",
+      "bytes": 211,
+      "sha256": "d3229ecf6300804103eb7f85bd5891c022f6f6c194dbdbbdcb54e9550338dc3b"
+    },
+    {
+      "path": "payload/trial/checkpoints/navigation-final-saved/sources/project.arcadia",
+      "bytes": 277,
+      "sha256": "79e26836c048a35aaf98b21ff006ae8ac931160abd9913b9e67b542303215414"
+    },
+    {
+      "path": "payload/trial/checkpoints/navigation-final-saved/sources/\u6551\u63f4/assess.arcadia",
+      "bytes": 192,
+      "sha256": "d99593537e67b2dfd293623f467ffbd46af4ea259dffae55d1fe9995c86e6992"
+    },
+    {
+      "path": "payload/trial/checkpoints/navigation-final-saved/sources/\u6551\u63f4/confirm.arcadia",
+      "bytes": 92,
+      "sha256": "591b32db3b1282825750d002d9293cfc450d55252506623302ce36c949fe9919"
+    },
+    {
+      "path": "payload/trial/checkpoints/navigation-final-saved/sources.json",
+      "bytes": 370,
+      "sha256": "c95318db2acc1114ca743d8dcbf2b216093970f5b7680361c047c32de5385c80"
+    },
+    {
+      "path": "payload/trial/checkpoints/navigation-final-saved/stderr.log",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "path": "payload/trial/checkpoints/navigation-final-saved/stdout.log",
+      "bytes": 86,
+      "sha256": "5ac622cfcc05242dca7c1368aba77293d42ab9ce5e56df7b2aedd2287d66d5e7"
+    },
+    {
+      "path": "payload/trial/closed-readonly-process.json",
+      "bytes": 290,
+      "sha256": "c3817bf30d81079200e6319d0fd5e47dd2c052293552e686182a8c5475d88ae2"
+    },
+    {
+      "path": "payload/trial/closed-readonly.json",
+      "bytes": 619,
+      "sha256": "3696d2e9d4b12816f5cd5a799061832cef23636be8e6816d1c19b4d43a0e470d"
+    },
+    {
+      "path": "payload/trial/launch.json",
+      "bytes": 1515,
+      "sha256": "16ebc30a4809ebcfa9edb6caec5c8caa1a2ead3b8f1f7e9f38fc29e5dc4b7e0d"
+    },
+    {
+      "path": "payload/trial/loaded-modules.json",
+      "bytes": 31759,
+      "sha256": "7708fde788be507d1dcc8707a8988a35145652dfb9e499deffcbe077bb5f5ce5"
+    },
+    {
+      "path": "payload/trial/navigation-final-saved-after-oracle-package.json",
+      "bytes": 71730,
+      "sha256": "57341745fc11d217be6a9a4c0dccaa24119e0641b114982bee9bee1b39b1b956"
+    },
+    {
+      "path": "payload/trial/navigation-final-saved-package.json",
+      "bytes": 71730,
+      "sha256": "a0ecb22c6fcfcb3f422a46642cc9276244074fe8413d67f5ee11518beebf5e0e"
+    },
+    {
+      "path": "payload/trial/package-before.json",
+      "bytes": 70373,
+      "sha256": "9a6fccf759cc69577f9758a4f9883de5b8206b9ad7d5c8b96a89bc0b2ea638fd"
+    },
+    {
+      "path": "payload/trial/process-identity.json",
+      "bytes": 257,
+      "sha256": "7b1eba466dd99edcdfb3679d9183a1807442987369d86d36fe632195639ddc20"
+    },
+    {
+      "path": "payload/trial/screenshots/01-home-0.jpg",
+      "bytes": 98174,
+      "sha256": "2b4471f300f258cba60dbcf9ab073468dcb223d8486b59da47f58292b89d88d0"
+    },
+    {
+      "path": "payload/trial/screenshots/01-home.json",
+      "bytes": 579,
+      "sha256": "46d52029df7c85accd35d1e14887ec741c28c667bedb5d56a86f8a08ab6fdb46"
+    },
+    {
+      "path": "payload/trial/screenshots/02-offline-guide-0.jpg",
+      "bytes": 170744,
+      "sha256": "461a24e56b2e3cb51b9423550dcdb34136f1cc68655c374edf6a73af589e65e8"
+    },
+    {
+      "path": "payload/trial/screenshots/02-offline-guide.json",
+      "bytes": 588,
+      "sha256": "3d7c6e4cd5b92f01a2d3ee5e82d981160126a13576833efb45f78ae4f0a4b1e8"
+    },
+    {
+      "path": "payload/trial/screenshots/03-model-open-0.jpg",
+      "bytes": 92462,
+      "sha256": "5e793f3412d4db69d8befbc139b0d5d11820b7dd0c537e355109c1ca5ac15870"
+    },
+    {
+      "path": "payload/trial/screenshots/03-model-open.json",
+      "bytes": 585,
+      "sha256": "3add2c198726762cc5de7cead995d0ca5730542b8ac89ea08c67237c322475ce"
+    },
+    {
+      "path": "payload/trial/screenshots/04-reference-caret-0.jpg",
+      "bytes": 108583,
+      "sha256": "fe667a3efad1f7a2419a80f8f8d7d1a16c61cfb0b145bf3733ccf3717fa1774b"
+    },
+    {
+      "path": "payload/trial/screenshots/04-reference-caret.json",
+      "bytes": 595,
+      "sha256": "18cbefb8fe9a5a40d47a5bdefa363adf7df91ad7e1a6f5958ac6575b5c3a656c"
+    },
+    {
+      "path": "payload/trial/screenshots/05-definition-0.jpg",
+      "bytes": 118079,
+      "sha256": "50f5824b830f02cfb453557263aa21e6fc95f1e48dfb4ac2a6dd23f49f908bea"
+    },
+    {
+      "path": "payload/trial/screenshots/05-definition.json",
+      "bytes": 590,
+      "sha256": "60d9512fc3b45f8e0b8ec76bd5bf37f4e278a60676f44c78fcd3e76226d866a2"
+    },
+    {
+      "path": "payload/trial/screenshots/06-references-0.jpg",
+      "bytes": 123669,
+      "sha256": "c9b04d7bf1ad77f148c3a66d47142acc921eac66beaf68136da97845a158b703"
+    },
+    {
+      "path": "payload/trial/screenshots/06-references.json",
+      "bytes": 590,
+      "sha256": "669507d37d451ede66c06e6f15cf7212aef2026822d1687dd3385ee9008a1604"
+    },
+    {
+      "path": "payload/trial/screenshots/07-back-0.jpg",
+      "bytes": 124149,
+      "sha256": "44fb1e9881512ac007b5e3bf4affc0adf759e887616ed65ec544ec4dc1e2ff70"
+    },
+    {
+      "path": "payload/trial/screenshots/07-back.json",
+      "bytes": 584,
+      "sha256": "549cddd42d83126b153c881ba7961c9692824669f3ecffb3afa221bd6789446e"
+    },
+    {
+      "path": "payload/trial/screenshots/08-edit-stale-0.jpg",
+      "bytes": 106871,
+      "sha256": "8c6abf74bd9f916aa8638f1e444c35363846701aea38686dd9d1a17ecc7eda3a"
+    },
+    {
+      "path": "payload/trial/screenshots/08-edit-stale.json",
+      "bytes": 592,
+      "sha256": "3910fe4f54807cf85f090c79e5000fecd327e4c65f75785131e89a7e09f1b55b"
+    },
+    {
+      "path": "payload/trial/screenshots/09-undo-clean-0.jpg",
+      "bytes": 123237,
+      "sha256": "5d42d655e3e4cb52aae610cc45943676cb84605ef49a29268ad40c1acbf21200"
+    },
+    {
+      "path": "payload/trial/screenshots/09-undo-clean.json",
+      "bytes": 590,
+      "sha256": "1e7da0341df4bf85f14102cfce493d2095c3b282f27d930a7182d5ee9b73ca48"
+    },
+    {
+      "path": "payload/trial/screenshots/10-apply-clean-0.jpg",
+      "bytes": 121686,
+      "sha256": "b9420697d2f8ecf7969f7be85a753b54c43bfd0eeb81e5265c5ccf8f2a8222fc"
+    },
+    {
+      "path": "payload/trial/screenshots/10-apply-clean.json",
+      "bytes": 591,
+      "sha256": "7c0ee386f3df1e64b3256be41351e4b6005100f36e4b2a683e5211eb35c287a9"
+    },
+    {
+      "path": "payload/trial/screenshots/11-saved-0.jpg",
+      "bytes": 119727,
+      "sha256": "d99afd9fd1e2b35ba13091e57975fe687c251e7de67385992a98e932bebb1878"
+    },
+    {
+      "path": "payload/trial/screenshots/11-saved.json",
+      "bytes": 585,
+      "sha256": "678106fe7850ca7af9ab4c66bd30be8040dc7020821a32bb4d8e88fec9ff1aac"
+    },
+    {
+      "path": "payload/trial/source-before.json",
+      "bytes": 370,
+      "sha256": "c95318db2acc1114ca743d8dcbf2b216093970f5b7680361c047c32de5385c80"
+    },
+    {
+      "path": "payload/trial/stderr.log",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "path": "payload/trial/stdout.log",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "path": "payload/unbound-draft/binding.pending.json",
+      "bytes": 306,
+      "sha256": "1c39142ec0e11067a4ff12911156741b73c3c305148a38fee861320dd1eedf7e"
+    },
+    {
+      "path": "payload/unbound-draft/draft-manifest.json",
+      "bytes": 735,
+      "sha256": "826b29480f80dbeb1aa5e54310ad7584d9fd804ec33810d6ec3acc05c91ccb2c"
+    },
+    {
+      "path": "payload/unbound-draft/helper.py",
+      "bytes": 12804,
+      "sha256": "01285a8bdf0efe4b7dff6de6136fdfe22db8f9807c8b29f69c8384bbb9ddffa6"
+    },
+    {
+      "path": "payload/unbound-draft/loaded-modules.ps1",
+      "bytes": 2889,
+      "sha256": "39527416b3043de1a360788436a330c5293b8941a3317defad6e2c82e6ee31fe"
+    },
+    {
+      "path": "payload/unbound-draft/README.md",
+      "bytes": 4176,
+      "sha256": "0ab3178d5d43fe4e87d96882cd1a71a451eb7fc4c894d6db4bd8e0d7af3182c2"
+    },
+    {
+      "path": "README.md",
+      "bytes": 1563,
+      "sha256": "f5499a4ae08f77032c1719997bce063544cc66c8430a75a1051167fe6bde2bfd"
+    },
+    {
+      "path": "verify.py",
+      "bytes": 4497,
+      "sha256": "5a77a0e684a67fcf80f900f92d6d9f29e1cd6193cf7e6675153bb50385631cf6"
+    }
+  ]
+}

harness/experiments/navigation-prerelease-native-20260911/ORIGINALS.json

@@ -0,0 +1,296 @@
+{
+  "source": ".local/navigation-repair-package-native-20260911",
+  "scope": "Byte-exact explicit whitelist readback; no execution of historical helpers. Profiles, work duplicate, tmp and caches excluded.",
+  "files": [
+    {
+      "path": "payload/binding.json",
+      "bytes": 846,
+      "sha256": "82606e6b3a5fb5dada3e55adcd5cd76792c9f938e6907313539dae7fc5125657"
+    },
+    {
+      "path": "payload/binding.pending.json",
+      "bytes": 306,
+      "sha256": "1c39142ec0e11067a4ff12911156741b73c3c305148a38fee861320dd1eedf7e"
+    },
+    {
+      "path": "payload/close_readonly.py",
+      "bytes": 4793,
+      "sha256": "16921ad616344132c4f1a7cd8fc49276dbbb8ee32415432d5b1604eb73fae43c"
+    },
+    {
+      "path": "payload/closure-preparation.md",
+      "bytes": 2294,
+      "sha256": "00b790280e8d6358b9554b847c5ad8ac38f17352b65e3bac192a7d53bd3704b6"
+    },
+    {
+      "path": "payload/draft-manifest.json",
+      "bytes": 735,
+      "sha256": "826b29480f80dbeb1aa5e54310ad7584d9fd804ec33810d6ec3acc05c91ccb2c"
+    },
+    {
+      "path": "payload/final-manifest.json",
+      "bytes": 787,
+      "sha256": "78dc734df23df02405248bd50beb5dfa325d19e465b91d2eceb9c00aa43efc01"
+    },
+    {
+      "path": "payload/helper.py",
+      "bytes": 12807,
+      "sha256": "11e1ac5379c28e17b8a9f5b883ddf0640994eea34de257f4e66efe6033190877"
+    },
+    {
+      "path": "payload/loaded-modules.ps1",
+      "bytes": 2889,
+      "sha256": "39527416b3043de1a360788436a330c5293b8941a3317defad6e2c82e6ee31fe"
+    },
+    {
+      "path": "payload/original-close-observation.json",
+      "bytes": 1005,
+      "sha256": "2dafca8092237da77a688a060069f94a8c180adc16e677a0f5196c57edbdfd59"
+    },
+    {
+      "path": "payload/README.md",
+      "bytes": 4520,
+      "sha256": "b873d46d74ff029a131a4c911924ea699c785a1d14b475b7c40721fb23bbad36"
+    },
+    {
+      "path": "payload/trial/admission.json",
+      "bytes": 1173,
+      "sha256": "f290d1d056494afa340fcfaa39b71024d104726ce1e92bc42a87f40d822821c8"
+    },
+    {
+      "path": "payload/trial/after-close-readonly-package.json",
+      "bytes": 71730,
+      "sha256": "5f6183a039fdcc2d98d1d331eb74fdf7fe34cad0e3fbb7d58a0b88bdc0adc788"
+    },
+    {
+      "path": "payload/trial/checkpoints/navigation-final-saved/result.json",
+      "bytes": 727,
+      "sha256": "cf653c9a2b0d5529c0875b8bf1990d29fb05b1bf06c52249ceb89cb35780a68a"
+    },
+    {
+      "path": "payload/trial/checkpoints/navigation-final-saved/sources/links.arcadia",
+      "bytes": 211,
+      "sha256": "d3229ecf6300804103eb7f85bd5891c022f6f6c194dbdbbdcb54e9550338dc3b"
+    },
+    {
+      "path": "payload/trial/checkpoints/navigation-final-saved/sources/project.arcadia",
+      "bytes": 277,
+      "sha256": "79e26836c048a35aaf98b21ff006ae8ac931160abd9913b9e67b542303215414"
+    },
+    {
+      "path": "payload/trial/checkpoints/navigation-final-saved/sources/\u6551\u63f4/assess.arcadia",
+      "bytes": 192,
+      "sha256": "d99593537e67b2dfd293623f467ffbd46af4ea259dffae55d1fe9995c86e6992"
+    },
+    {
+      "path": "payload/trial/checkpoints/navigation-final-saved/sources/\u6551\u63f4/confirm.arcadia",
+      "bytes": 92,
+      "sha256": "591b32db3b1282825750d002d9293cfc450d55252506623302ce36c949fe9919"
+    },
+    {
+      "path": "payload/trial/checkpoints/navigation-final-saved/sources.json",
+      "bytes": 370,
+      "sha256": "c95318db2acc1114ca743d8dcbf2b216093970f5b7680361c047c32de5385c80"
+    },
+    {
+      "path": "payload/trial/checkpoints/navigation-final-saved/stderr.log",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "path": "payload/trial/checkpoints/navigation-final-saved/stdout.log",
+      "bytes": 86,
+      "sha256": "5ac622cfcc05242dca7c1368aba77293d42ab9ce5e56df7b2aedd2287d66d5e7"
+    },
+    {
+      "path": "payload/trial/closed-readonly-process.json",
+      "bytes": 290,
+      "sha256": "c3817bf30d81079200e6319d0fd5e47dd2c052293552e686182a8c5475d88ae2"
+    },
+    {
+      "path": "payload/trial/closed-readonly.json",
+      "bytes": 619,
+      "sha256": "3696d2e9d4b12816f5cd5a799061832cef23636be8e6816d1c19b4d43a0e470d"
+    },
+    {
+      "path": "payload/trial/launch.json",
+      "bytes": 1515,
+      "sha256": "16ebc30a4809ebcfa9edb6caec5c8caa1a2ead3b8f1f7e9f38fc29e5dc4b7e0d"
+    },
+    {
+      "path": "payload/trial/loaded-modules.json",
+      "bytes": 31759,
+      "sha256": "7708fde788be507d1dcc8707a8988a35145652dfb9e499deffcbe077bb5f5ce5"
+    },
+    {
+      "path": "payload/trial/navigation-final-saved-after-oracle-package.json",
+      "bytes": 71730,
+      "sha256": "57341745fc11d217be6a9a4c0dccaa24119e0641b114982bee9bee1b39b1b956"
+    },
+    {
+      "path": "payload/trial/navigation-final-saved-package.json",
+      "bytes": 71730,
+      "sha256": "a0ecb22c6fcfcb3f422a46642cc9276244074fe8413d67f5ee11518beebf5e0e"
+    },
+    {
+      "path": "payload/trial/package-before.json",
+      "bytes": 70373,
+      "sha256": "9a6fccf759cc69577f9758a4f9883de5b8206b9ad7d5c8b96a89bc0b2ea638fd"
+    },
+    {
+      "path": "payload/trial/process-identity.json",
+      "bytes": 257,
+      "sha256": "7b1eba466dd99edcdfb3679d9183a1807442987369d86d36fe632195639ddc20"
+    },
+    {
+      "path": "payload/trial/screenshots/01-home-0.jpg",
+      "bytes": 98174,
+      "sha256": "2b4471f300f258cba60dbcf9ab073468dcb223d8486b59da47f58292b89d88d0"
+    },
+    {
+      "path": "payload/trial/screenshots/01-home.json",
+      "bytes": 579,
+      "sha256": "46d52029df7c85accd35d1e14887ec741c28c667bedb5d56a86f8a08ab6fdb46"
+    },
+    {
+      "path": "payload/trial/screenshots/02-offline-guide-0.jpg",
+      "bytes": 170744,
+      "sha256": "461a24e56b2e3cb51b9423550dcdb34136f1cc68655c374edf6a73af589e65e8"
+    },
+    {
+      "path": "payload/trial/screenshots/02-offline-guide.json",
+      "bytes": 588,
+      "sha256": "3d7c6e4cd5b92f01a2d3ee5e82d981160126a13576833efb45f78ae4f0a4b1e8"
+    },
+    {
+      "path": "payload/trial/screenshots/03-model-open-0.jpg",
+      "bytes": 92462,
+      "sha256": "5e793f3412d4db69d8befbc139b0d5d11820b7dd0c537e355109c1ca5ac15870"
+    },
+    {
+      "path": "payload/trial/screenshots/03-model-open.json",
+      "bytes": 585,
+      "sha256": "3add2c198726762cc5de7cead995d0ca5730542b8ac89ea08c67237c322475ce"
+    },
+    {
+      "path": "payload/trial/screenshots/04-reference-caret-0.jpg",
+      "bytes": 108583,
+      "sha256": "fe667a3efad1f7a2419a80f8f8d7d1a16c61cfb0b145bf3733ccf3717fa1774b"
+    },
+    {
+      "path": "payload/trial/screenshots/04-reference-caret.json",
+      "bytes": 595,
+      "sha256": "18cbefb8fe9a5a40d47a5bdefa363adf7df91ad7e1a6f5958ac6575b5c3a656c"
+    },
+    {
+      "path": "payload/trial/screenshots/05-definition-0.jpg",
+      "bytes": 118079,
+      "sha256": "50f5824b830f02cfb453557263aa21e6fc95f1e48dfb4ac2a6dd23f49f908bea"
+    },
+    {
+      "path": "payload/trial/screenshots/05-definition.json",
+      "bytes": 590,
+      "sha256": "60d9512fc3b45f8e0b8ec76bd5bf37f4e278a60676f44c78fcd3e76226d866a2"
+    },
+    {
+      "path": "payload/trial/screenshots/06-references-0.jpg",
+      "bytes": 123669,
+      "sha256": "c9b04d7bf1ad77f148c3a66d47142acc921eac66beaf68136da97845a158b703"
+    },
+    {
+      "path": "payload/trial/screenshots/06-references.json",
+      "bytes": 590,
+      "sha256": "669507d37d451ede66c06e6f15cf7212aef2026822d1687dd3385ee9008a1604"
+    },
+    {
+      "path": "payload/trial/screenshots/07-back-0.jpg",
+      "bytes": 124149,
+      "sha256": "44fb1e9881512ac007b5e3bf4affc0adf759e887616ed65ec544ec4dc1e2ff70"
+    },
+    {
+      "path": "payload/trial/screenshots/07-back.json",
+      "bytes": 584,
+      "sha256": "549cddd42d83126b153c881ba7961c9692824669f3ecffb3afa221bd6789446e"
+    },
+    {
+      "path": "payload/trial/screenshots/08-edit-stale-0.jpg",
+      "bytes": 106871,
+      "sha256": "8c6abf74bd9f916aa8638f1e444c35363846701aea38686dd9d1a17ecc7eda3a"
+    },
+    {
+      "path": "payload/trial/screenshots/08-edit-stale.json",
+      "bytes": 592,
+      "sha256": "3910fe4f54807cf85f090c79e5000fecd327e4c65f75785131e89a7e09f1b55b"
+    },
+    {
+      "path": "payload/trial/screenshots/09-undo-clean-0.jpg",
+      "bytes": 123237,
+      "sha256": "5d42d655e3e4cb52aae610cc45943676cb84605ef49a29268ad40c1acbf21200"
+    },
+    {
+      "path": "payload/trial/screenshots/09-undo-clean.json",
+      "bytes": 590,
+      "sha256": "1e7da0341df4bf85f14102cfce493d2095c3b282f27d930a7182d5ee9b73ca48"
+    },
+    {
+      "path": "payload/trial/screenshots/10-apply-clean-0.jpg",
+      "bytes": 121686,
+      "sha256": "b9420697d2f8ecf7969f7be85a753b54c43bfd0eeb81e5265c5ccf8f2a8222fc"
+    },
+    {
+      "path": "payload/trial/screenshots/10-apply-clean.json",
+      "bytes": 591,
+      "sha256": "7c0ee386f3df1e64b3256be41351e4b6005100f36e4b2a683e5211eb35c287a9"
+    },
+    {
+      "path": "payload/trial/screenshots/11-saved-0.jpg",
+      "bytes": 119727,
+      "sha256": "d99afd9fd1e2b35ba13091e57975fe687c251e7de67385992a98e932bebb1878"
+    },
+    {
+      "path": "payload/trial/screenshots/11-saved.json",
+      "bytes": 585,
+      "sha256": "678106fe7850ca7af9ab4c66bd30be8040dc7020821a32bb4d8e88fec9ff1aac"
+    },
+    {
+      "path": "payload/trial/source-before.json",
+      "bytes": 370,
+      "sha256": "c95318db2acc1114ca743d8dcbf2b216093970f5b7680361c047c32de5385c80"
+    },
+    {
+      "path": "payload/trial/stderr.log",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "path": "payload/trial/stdout.log",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "path": "payload/unbound-draft/binding.pending.json",
+      "bytes": 306,
+      "sha256": "1c39142ec0e11067a4ff12911156741b73c3c305148a38fee861320dd1eedf7e"
+    },
+    {
+      "path": "payload/unbound-draft/draft-manifest.json",
+      "bytes": 735,
+      "sha256": "826b29480f80dbeb1aa5e54310ad7584d9fd804ec33810d6ec3acc05c91ccb2c"
+    },
+    {
+      "path": "payload/unbound-draft/helper.py",
+      "bytes": 12804,
+      "sha256": "01285a8bdf0efe4b7dff6de6136fdfe22db8f9807c8b29f69c8384bbb9ddffa6"
+    },
+    {
+      "path": "payload/unbound-draft/loaded-modules.ps1",
+      "bytes": 2889,
+      "sha256": "39527416b3043de1a360788436a330c5293b8941a3317defad6e2c82e6ee31fe"
+    },
+    {
+      "path": "payload/unbound-draft/README.md",
+      "bytes": 4176,
+      "sha256": "0ab3178d5d43fe4e87d96882cd1a71a451eb7fc4c894d6db4bd8e0d7af3182c2"
+    }
+  ]
+}

harness/experiments/navigation-prerelease-native-20260911/README.md

@@ -0,0 +1,7 @@
+# Packaged navigation native evidence
+
+See [the trial report](../../release-navigation-prerelease-native-20260911.md). This archive preserves 58 original files (1,689,243 bytes) from the completed root trial. `payload/` contains frozen preparation, unbound drafts, binding, the original failure attribution, the separately reviewed closure helper, receipts, 11 original JPEG captures and their metadata, and one four-source saved checkpoint with oracle output. It excludes executables, ZIP, extracted package, profiles, caches, temporary directories and the duplicate working sources.
+
+The preparation README and manifests describe their historical preparation state; their pending language is intentionally preserved. The final trial receipts and report establish subsequent events. `original-close-observation.json` is an attributed root transcription, not raw stderr. There is no successful original `closed.json`. The separate `closed-readonly.json` records the later process/package observation.
+
+`ORIGINALS.json` records exact source-to-archive byte readback, SHA256 `ef655a81362a661d9ffe0d534b760c6d9b395b5aa05f5b0b4d9194ac645743fa`. `MANIFEST.json` covers all archive files except itself. Run `python verify.py` to read only this archive and check hashes and recorded relationships. It writes nothing, accesses no original workspace or package, and runs no helper, oracle, process query, application, network request or test. Historical helpers are evidence, not portable replay instructions. Git and publication readback belong to the integration owner.

harness/experiments/navigation-prerelease-native-20260911/payload/README.md

@@ -0,0 +1,26 @@
+# Packaged repaired navigation trial — preparation only
+
+Root owns GUI input and acceptance. No launcher, oracle, process/module check or package action has been executed during this preparation. This helper uses the future independently reviewed package extraction directly, never the mutable target executable or producer stage. It does not repeat invalid-source repair/recovery tests already covered by the B183 v4 trial.
+
+The candidate is B183EF31…B168848 from source 33c6d83, retained historical EFEE server and F456 DLL. Version is 0.2.0-preview.navigation.20260911. The server remains separately sourced. Native acceptance must distinguish this new package trial from the prior source-native v3/v4 trials.
+
+## Binding and future execution
+
+The unbound draft and its original hashes are preserved byte-exact under unbound-draft/. `binding.pending.json` remains historical. Final binding.json SHA256 is `82606e6b3a5fb5dada3e55adcd5cd76792c9f938e6907313539dae7fc5125657`, pinned in helper.py. It identifies the actual ZIP `d7228c542f162663933ea002739a78c722bcca41e437df63b7c868ea2af201f1` (32,971,712 bytes), producer readback DB0053CE…20F498, and independent artifact PASS 03D3E990…FF06F2. All 559 extraction hashes were read back against both maps before binding. Extraction is the reviewer's `.local/navigation-package-review-20260911/extracted/ArcadiaStudio-0.2.0-preview.navigation.20260911-x86_64-pc-windows-gnullvm`. Root reviews the final helper and binding before explicit execution; no helper action has run. Arbitrary package paths cannot be supplied on the command line.
+
+Admission verifies the binding, actual ZIP bytes, producer and reviewer PASS/hash/size/full file maps, every extracted file, ZIP entry contents and all three binary hashes. A fresh exclusive trial/ contains private profile/Desktop/APPDATA/LOCALAPPDATA/TEMP, screenshots and work. Standard nonsecret Windows paths are inherited explicitly; PATH contains only Windows directories. The package working directory remains the extraction, allowing full-map checks to detect incidental added files. Package contents are never modified by the helper. Initial work is an exact private copy of the pinned valid navigation fixture: four Arcadia files, Unicode path, two activities and one interaction. No baseline oracle is run merely to copy this already pinned fixture.
+
+Future authorized commands from repository cwd, using `C:/Users/User/.cache/codex-runtimes/codex-primary-runtime/dependencies/python/python.exe`:
+
+```text
+python .local/navigation-repair-package-native-20260911/helper.py launch
+pwsh -NoProfile -File .local/navigation-repair-package-native-20260911/loaded-modules.ps1
+python .local/navigation-repair-package-native-20260911/helper.py saved --label navigation-final-saved --after-visible-save
+python .local/navigation-repair-package-native-20260911/helper.py closed --observed-absent
+```
+
+These commands have not been executed. Replace python with the absolute bundled executable. Root first opens trial/work/project.arcadia through the real file dialog, exercises F12, References and Back, edits then restores using Undo/Apply as intended, explicitly saves the baseline, and observes success. Only then is saved allowed. It preserves an exact source checkpoint and requires all four raw files equal the pinned baseline before running the complete same oracle967. The oracle gets only the package directory plus Windows PATH for F456 resolution. Raw stdout/stderr/exit and before/after package guards are retained. Any unexpected package addition/removal/change writes the exact delta before refusal. This is saved model/source evidence, not a synthetic assertion that GUI actions happened.
+
+Root closes normally, observes the window absent, then invokes closed. The helper checks the original PID plus creation identity is absent (a reused PID is distinguished), and checks the entire ZIP/package map again. It does not close/kill any process or fabricate a numeric exit code. The optional loaded-modules.ps1 is a separate read-only query of the exact PID/path/creation identity; it records paths/hashes and flags modules outside Windows or the reviewed package. It does not operate the GUI or launch a server.
+
+All operations refuse existing receipts/trials. Do not delete or overwrite a failed trial; retain evidence and prepare a separately reviewed trial if needed. No compilation, source edits, publishing, tags or WSL operations are included. Old contextual and navigation trials/helpers remain untouched.

harness/experiments/navigation-prerelease-native-20260911/payload/binding.json

@@ -0,0 +1,12 @@
+{
+  "status": "READY",
+  "source_commit": "33c6d83e9ba9a5b1310b1b627d7c40affcbcf15c",
+  "archive_path": ".local/nav-repair-retry-20260911/packages/ArcadiaStudio-0.2.0-preview.navigation.20260911-x86_64-pc-windows-gnullvm.zip",
+  "archive_sha256": "d7228c542f162663933ea002739a78c722bcca41e437df63b7c868ea2af201f1",
+  "archive_bytes": 32971712,
+  "review_path": ".local/navigation-package-review-20260911/artifact-result.json",
+  "review_sha256": "03d3e9909ed982caa9a7a7085bebdff12c0ef268929474459e2ad83af9ff06f2",
+  "producer_readback_path": ".local/nav-repair-retry-20260911/package-readback.json",
+  "producer_readback_sha256": "db0053ce70648b517942cfc8c915e826a7afd688129fcb4a813e11990820f498",
+  "package_path": ".local/navigation-package-review-20260911/extracted/ArcadiaStudio-0.2.0-preview.navigation.20260911-x86_64-pc-windows-gnullvm"
+}

harness/experiments/navigation-prerelease-native-20260911/payload/binding.pending.json

@@ -0,0 +1,12 @@
+{
+  "status": "PENDING",
+  "source_commit": "33c6d83e9ba9a5b1310b1b627d7c40affcbcf15c",
+  "archive_path": null,
+  "archive_sha256": null,
+  "archive_bytes": null,
+  "review_path": null,
+  "review_sha256": null,
+  "producer_readback_path": null,
+  "producer_readback_sha256": null,
+  "package_path": null
+}

harness/experiments/navigation-prerelease-native-20260911/payload/close_readonly.py

@@ -0,0 +1,87 @@
+"""Separate read-only process/package closure; never launches or stops anything.
+
+Original helper.py remains unchanged. This avoids its post-exit image-path query.
+Run only after root has observed the relevant GUI window absent.
+"""
+import argparse
+import ctypes
+from ctypes import wintypes
+import hashlib
+from pathlib import Path
+import sys
+
+BASE = Path(__file__).resolve().parent
+EXPECTED_HELPER = '11e1ac5379c28e17b8a9f5b883ddf0640994eea34de257f4e66efe6033190877'
+
+
+def process_state(pid, creation):
+    api = ctypes.WinDLL('kernel32', use_last_error=True)
+    api.OpenProcess.argtypes = [wintypes.DWORD, wintypes.BOOL, wintypes.DWORD]
+    api.OpenProcess.restype = wintypes.HANDLE
+    api.CloseHandle.argtypes = [wintypes.HANDLE]
+    api.CloseHandle.restype = wintypes.BOOL
+    api.GetProcessTimes.argtypes = [wintypes.HANDLE] + [ctypes.POINTER(wintypes.FILETIME)] * 4
+    api.GetProcessTimes.restype = wintypes.BOOL
+    api.GetExitCodeProcess.argtypes = [wintypes.HANDLE, ctypes.POINTER(wintypes.DWORD)]
+    api.GetExitCodeProcess.restype = wintypes.BOOL
+    handle = api.OpenProcess(0x1000, False, pid)
+    if not handle:
+        error = ctypes.get_last_error()
+        return {'originalProcessAbsent': error == 87, 'openProcessError': error,
+                'reason': 'PID is absent' if error == 87 else 'Process query refused; absence unproven'}
+    try:
+        created, exited, kernel, user = (wintypes.FILETIME() for _ in range(4))
+        if not api.GetProcessTimes(handle, ctypes.byref(created), ctypes.byref(exited), ctypes.byref(kernel), ctypes.byref(user)):
+            return {'originalProcessAbsent': False, 'getProcessTimesError': ctypes.get_last_error()}
+        actual_creation = (created.dwHighDateTime << 32) | created.dwLowDateTime
+        if actual_creation != creation:
+            return {'originalProcessAbsent': True, 'pidReused': True, 'currentCreationFiletime': actual_creation,
+                    'reason': 'PID now belongs to a different process creation'}
+        code = wintypes.DWORD()
+        if not api.GetExitCodeProcess(handle, ctypes.byref(code)):
+            return {'originalProcessAbsent': False, 'getExitCodeProcessError': ctypes.get_last_error()}
+        return {'originalProcessAbsent': code.value != 259, 'pidReused': False,
+                'currentCreationFiletime': actual_creation, 'exitCodeQueried': code.value,
+                'reason': 'Original process is still active' if code.value == 259 else 'Original process has terminated'}
+    finally:
+        api.CloseHandle(handle)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--observed-absent', action='store_true')
+    args = parser.parse_args()
+    assert args.observed_absent, 'Root must observe the GUI window absent first.'
+    # Import only the exact reviewed, guarded module. Its main action dispatch is
+    # not executed by import; we call no launch/oracle/original closure function.
+    assert hashlib.sha256((BASE / 'helper.py').read_bytes()).hexdigest() == EXPECTED_HELPER
+    sys.dont_write_bytecode = True
+    import helper as original
+    result_path = original.TRIAL / 'closed-readonly.json'
+    process_path = original.TRIAL / 'closed-readonly-process.json'
+    package_path = original.TRIAL / 'after-close-readonly-package.json'
+    assert not any(p.exists() for p in (result_path, process_path, package_path)), 'Preserve previous closure evidence.'
+    result = {'started': original.now(), 'status': 'PENDING', 'original_helper_sha256': EXPECTED_HELPER,
+              'scope': 'Root-observed window absence, read-only process state and exact bound ZIP/package map; no GUI or oracle rerun.'}
+    try:
+        launch = original.load(original.TRIAL / 'launch.json')
+        identity = original.load(original.TRIAL / 'process-identity.json')
+        state = process_state(launch['pid'], identity['creation_filetime'])
+        original.record(process_path, {'atUtc': original.now(), 'pid': launch['pid'], 'originalCreationFiletime': identity['creation_filetime'], **state})
+        assert state['originalProcessAbsent'], state
+        original.package_guard('after-close-readonly')
+        result.update(status='PASS', pid=launch['pid'], originalProcessAbsent=True, completePackageUnchanged=True,
+                      process_receipt_sha256=original.sha(process_path), package_receipt_sha256=original.sha(package_path))
+    except BaseException as error:
+        result.update(status='FAIL', error=repr(error))
+        raise
+    finally:
+        result['finished'] = original.now()
+        original.record(result_path, result)
+    print('PASS: original process absent; bound ZIP and complete package unchanged.')
+
+
+if __name__ == '__main__':
+    sys.stdout.reconfigure(encoding='utf-8')
+    sys.stderr.reconfigure(encoding='utf-8')
+    main()

harness/experiments/navigation-prerelease-native-20260911/payload/closure-preparation.md

@@ -0,0 +1,15 @@
+# Separate read-only closure preparation
+
+Root reports that the native packaged workflow succeeded, followed by actual window Close. The original helper's closed action failed around 21:29 UTC at its QueryFullProcessImageNameW assertion after OpenProcess/GetProcessTimes succeeded. It did not preserve the failing Win32 error. Its root cause is therefore unknown; this note does not infer a particular Windows error or process state from the assertion. Root separately observed Get-Process PID 1348 absent at 21:29:31.264 UTC and no Studio window. That observation is distinct from a successful original helper closure receipt, which does not exist.
+
+Original helper.py remains byte-exact SHA256 11E1AC5379C28E17B8A9F5B883DDF0640994EEA34DE257F4E66EFE6033190877. The separate close_readonly.py verifies that hash before importing its definitions. It never calls launch, saved, original closed or process_identity. It queries only PID creation identity and GetExitCodeProcess, avoiding the failed image-path query. Invalid PID error87 establishes absence; any other open/query error is preserved and refuses acceptance. A different creation identifies PID reuse. The same process creation must have a terminal exit state rather than STILL_ACTIVE259; a later actual queried code is recorded as new evidence, never reconstructed for the original failure.
+
+After process closure is established, the original frozen binding/ZIP/reviewer/producer/full-package guard is called, preserving all 559-file checks and any package delta. It writes new closed-readonly-process.json, after-close-readonly-package.json and closed-readonly.json only. Existing trial/model/package/helper/manifests remain untouched. There is no termination, launch, GUI automation, model change, compiler, WSL or oracle execution.
+
+Root-reviewed future command from repository cwd (not executed during preparation):
+
+```text
+python .local/navigation-repair-package-native-20260911/close_readonly.py --observed-absent
+```
+
+Use bundled Python at C:/Users/User/.cache/codex-runtimes/codex-primary-runtime/dependencies/python/python.exe. The closure result remains pending until root executes and reads the actual new receipts. Archive/report finalization must retain the original failed close alongside the separate terminal result.

harness/experiments/navigation-prerelease-native-20260911/payload/draft-manifest.json

@@ -0,0 +1,25 @@
+{
+  "scope": "Unbound packaged native helper draft; no helper/module/oracle/package execution",
+  "files": [
+    {
+      "path": "helper.py",
+      "sha256": "01285a8bdf0efe4b7dff6de6136fdfe22db8f9807c8b29f69c8384bbb9ddffa6",
+      "bytes": 12804
+    },
+    {
+      "path": "loaded-modules.ps1",
+      "sha256": "39527416b3043de1a360788436a330c5293b8941a3317defad6e2c82e6ee31fe",
+      "bytes": 2889
+    },
+    {
+      "path": "README.md",
+      "sha256": "0ab3178d5d43fe4e87d96882cd1a71a451eb7fc4c894d6db4bd8e0d7af3182c2",
+      "bytes": 4176
+    },
+    {
+      "path": "binding.pending.json",
+      "sha256": "1c39142ec0e11067a4ff12911156741b73c3c305148a38fee861320dd1eedf7e",
+      "bytes": 306
+    }
+  ]
+}

harness/experiments/navigation-prerelease-native-20260911/payload/final-manifest.json

@@ -0,0 +1,26 @@
+{
+  "scope": "Bound helper preparation and independent artifact-map readback only; no helper/oracle/process/module/GUI execution",
+  "files": [
+    {
+      "path": "helper.py",
+      "sha256": "11e1ac5379c28e17b8a9f5b883ddf0640994eea34de257f4e66efe6033190877",
+      "bytes": 12807
+    },
+    {
+      "path": "loaded-modules.ps1",
+      "sha256": "39527416b3043de1a360788436a330c5293b8941a3317defad6e2c82e6ee31fe",
+      "bytes": 2889
+    },
+    {
+      "path": "README.md",
+      "sha256": "b873d46d74ff029a131a4c911924ea699c785a1d14b475b7c40721fb23bbad36",
+      "bytes": 4520
+    },
+    {
+      "path": "binding.json",
+      "sha256": "82606e6b3a5fb5dada3e55adcd5cd76792c9f938e6907313539dae7fc5125657",
+      "bytes": 846
+    }
+  ],
+  "trial_absent": true
+}

harness/experiments/navigation-prerelease-native-20260911/payload/helper.py

@@ -0,0 +1,266 @@
+"""Packaged navigation trial; GUI input and release acceptance belong to root.
+
+No execution is admitted until binding.json is completed and its SHA is pinned
+after independent artifact review. Nothing here operates the GUI or compiles.
+"""
+import argparse
+import ctypes
+from ctypes import wintypes
+from datetime import datetime, timezone
+import hashlib
+import json
+import os
+from pathlib import Path, PurePosixPath
+import re
+import shutil
+import subprocess
+import sys
+import zipfile
+
+ROOT = Path(__file__).resolve().parents[2]
+BASE = Path(__file__).resolve().parent
+TRIAL = BASE / 'trial'
+BINDING_SHA = '82606e6b3a5fb5dada3e55adcd5cd76792c9f938e6907313539dae7fc5125657'
+SOURCE = '33c6d83e9ba9a5b1310b1b627d7c40affcbcf15c'
+NAME = 'ArcadiaStudio-0.2.0-preview.navigation.20260911-x86_64-pc-windows-gnullvm'
+EXPECTED = {
+    'arcadia-studio.exe': 'b183ef31f16b3986538b3f2aba8435eab45978635c47f99ca01be6e72b168848',
+    'arcadia-server.exe': 'efeeb89c0d2e0f93df4472cb3e9f48b2b722a37ae1043c90a5a56f2e845fe665',
+    'libunwind.dll': 'f45604a12e8bcd839fd86f667c1be1cc7c4f9da2b3c69ff381ac708f0e1ae7d4',
+}
+FIXTURES = ROOT / '.local/text-navigation-native-20260911-preparation'
+FIXTURE_SHA = 'edd4157fc31823f4494dee91862728b87f12ef51c49b8d1fd86a954bc9ecc1ed'
+ORACLE = ROOT / '.local/staged-source-oracle-20260911/staged-source-authoring-contract.exe'
+ORACLE_SHA = '967d9ba3c6fb3a7efb410833903ec94556ca2d48a67d5072c8bb160f40a00f9c'
+
+
+def now():
+    return datetime.now(timezone.utc).isoformat()
+
+
+def ordinary(path):
+    path = Path(path).absolute()
+    for p in (path, *path.parents):
+        if p.exists():
+            assert not p.is_symlink() and not (getattr(p.lstat(), 'st_file_attributes', 0) & 0x400), str(p)
+    return path
+
+
+def sha(path):
+    with ordinary(path).open('rb') as stream:
+        return hashlib.file_digest(stream, 'sha256').hexdigest()
+
+
+def load(path):
+    return json.loads(ordinary(path).read_text(encoding='utf-8-sig'))
+
+
+def record(path, value):
+    ordinary(path)
+    with path.open('x', encoding='utf-8', newline='\n') as out:
+        json.dump(value, out, ensure_ascii=False, indent=2)
+        out.write('\n')
+
+
+def relative(name):
+    p = PurePosixPath(name)
+    assert name == p.as_posix() and not p.is_absolute() and p.parts
+    assert all(x not in ('.', '..') for x in p.parts)
+    assert not any(c in name for c in '\\:\r\n')
+    return name
+
+
+def local(name):
+    p = ordinary(ROOT / relative(name))
+    assert p.resolve().is_relative_to(ROOT / '.local')
+    return p
+
+
+def inventory(folder):
+    ordinary(folder)
+    found = {}
+    for p in folder.rglob('*'):
+        ordinary(p)
+        if p.is_file():
+            found[p.relative_to(folder).as_posix()] = sha(p)
+    assert len({p.casefold() for p in found}) == len(found)
+    return found
+
+
+def copy_exact(source, destination):
+    before = inventory(source)
+    assert not destination.exists()
+    shutil.copytree(source, destination)
+    assert inventory(source) == inventory(destination) == before
+    return before
+
+
+def environment():
+    parent = {k.upper(): v for k, v in os.environ.items()}
+    standard = {k: parent[k.upper()] for k in ('SystemRoot', 'SystemDrive', 'ProgramData', 'ALLUSERSPROFILE', 'PUBLIC')}
+    assert all(v and '%' not in v for v in standard.values())
+    system = standard['SystemRoot']
+    return {**standard, 'WINDIR': system, 'PATH': system + '\\System32;' + system,
+            'USERPROFILE': str(TRIAL / 'profile'), 'APPDATA': str(TRIAL / 'profile/roaming'),
+            'LOCALAPPDATA': str(TRIAL / 'profile/local'), 'TEMP': str(TRIAL / 'tmp'), 'TMP': str(TRIAL / 'tmp')}
+
+
+def process_identity(pid):
+    """Read-only process query; invalid PID means absent, access errors refuse."""
+    api = ctypes.WinDLL('kernel32', use_last_error=True)
+    api.OpenProcess.argtypes = [wintypes.DWORD, wintypes.BOOL, wintypes.DWORD]
+    api.OpenProcess.restype = wintypes.HANDLE
+    api.CloseHandle.argtypes = [wintypes.HANDLE]
+    api.GetProcessTimes.argtypes = [wintypes.HANDLE] + [ctypes.POINTER(wintypes.FILETIME)] * 4
+    api.GetProcessTimes.restype = wintypes.BOOL
+    api.QueryFullProcessImageNameW.argtypes = [wintypes.HANDLE, wintypes.DWORD, wintypes.LPWSTR, ctypes.POINTER(wintypes.DWORD)]
+    api.QueryFullProcessImageNameW.restype = wintypes.BOOL
+    handle = api.OpenProcess(0x1000, False, pid)
+    if not handle:
+        error = ctypes.get_last_error()
+        assert error == 87, f'Process query failed: {error}'
+        return None
+    try:
+        created, exited, kernel, user = (wintypes.FILETIME() for _ in range(4))
+        assert api.GetProcessTimes(handle, ctypes.byref(created), ctypes.byref(exited), ctypes.byref(kernel), ctypes.byref(user))
+        buffer, count = ctypes.create_unicode_buffer(32768), wintypes.DWORD(32768)
+        assert api.QueryFullProcessImageNameW(handle, 0, buffer, ctypes.byref(count))
+        return {'path': str(Path(buffer.value).resolve()), 'creation_filetime': (created.dwHighDateTime << 32) | created.dwLowDateTime}
+    finally:
+        api.CloseHandle(handle)
+
+
+def admission(verify_inventory=True):
+    assert BINDING_SHA and sha(BASE / 'binding.json') == BINDING_SHA, 'Package binding is pending or changed.'
+    binding = load(BASE / 'binding.json')
+    assert binding['status'] == 'READY' and binding['source_commit'] == SOURCE
+    archive, review_path, producer_path, package = (local(binding[k]) for k in ('archive_path', 'review_path', 'producer_readback_path', 'package_path'))
+    assert archive.name == NAME + '.zip' and package.name == NAME
+    assert package.resolve() != (producer_path.parent / 'packages' / NAME).resolve(), 'Use independent extraction, not producer stage.'
+    assert sha(archive) == binding['archive_sha256'] and archive.stat().st_size == binding['archive_bytes']
+    assert sha(review_path) == binding['review_sha256'] and sha(producer_path) == binding['producer_readback_sha256']
+    review, producer = load(review_path), load(producer_path)
+    assert review['status'] == producer['status'] == 'PASS'
+    assert review['archive']['sha256'] == producer['archive_sha256'] == binding['archive_sha256']
+    assert review['archive']['bytes'] == producer['archive_bytes'] == binding['archive_bytes']
+    assert Path(review['archive']['path']).resolve() == archive.resolve()
+    expected = review['archive']['files']
+    assert expected == {p: v['sha256'] for p, v in producer['files'].items()}
+    assert review['archive']['file_count'] == producer['file_count'] == len(expected)
+    if verify_inventory:
+        assert inventory(package) == expected
+    for p, h in EXPECTED.items():
+        assert expected[p] == h
+    zipped = {}
+    with zipfile.ZipFile(archive) as z:
+        for item in z.infolist():
+            assert item.filename.startswith(NAME + '/') and not item.is_dir()
+            p = relative(item.filename[len(NAME) + 1:])
+            assert p not in zipped
+            zipped[p] = hashlib.sha256(z.read(item)).hexdigest()
+    assert zipped == expected
+    return binding, package, expected
+
+
+def fixture():
+    assert sha(FIXTURES / 'fixture-manifest.json') == FIXTURE_SHA
+    expected = {e['path'].removeprefix('valid-baseline/'): e['sha256'] for e in load(FIXTURES / 'fixture-manifest.json') if e['path'].startswith('valid-baseline/')}
+    assert len(expected) == 4 and inventory(FIXTURES / 'valid-baseline') == expected
+    assert sha(ORACLE) == ORACLE_SHA
+    return FIXTURES / 'valid-baseline', expected
+
+
+def launch():
+    assert not TRIAL.exists(), 'Preserve old trial; never overwrite.'
+    binding, package, expected = admission()
+    baseline, files = fixture()
+    TRIAL.mkdir()
+    for folder in ('profile/local', 'profile/roaming', 'profile/Desktop', 'tmp', 'screenshots', 'checkpoints'):
+        (TRIAL / folder).mkdir(parents=True)
+    assert copy_exact(baseline, TRIAL / 'work') == files
+    record(TRIAL / 'package-before.json', expected)
+    record(TRIAL / 'source-before.json', files)
+    record(TRIAL / 'admission.json', {'atUtc': now(), 'binding_sha256': BINDING_SHA, 'binding': binding, 'fixture_sha256': FIXTURE_SHA, 'scope': 'Artifact/fixture admission, not native acceptance.'})
+    env = environment()
+    startup = subprocess.STARTUPINFO()
+    startup.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+    startup.wShowWindow = 0
+    with (TRIAL / 'stdout.log').open('xb') as out, (TRIAL / 'stderr.log').open('xb') as err:
+        process = subprocess.Popen([str(package / 'arcadia-studio.exe')], cwd=package, env=env, stdout=out, stderr=err, startupinfo=startup)
+    # Preserve PID immediately even if a subsequent read-only identity query fails.
+    receipt = {'atUtc': now(), 'pid': process.pid, 'package': str(package), 'environment': env,
+               'binding_sha256': BINDING_SHA, 'source': str(TRIAL / 'work/project.arcadia'), 'scope': 'Identified packaged GUI launched; native acceptance pending.'}
+    record(TRIAL / 'launch.json', receipt)
+    identity = process_identity(process.pid)
+    assert identity and Path(identity['path']) == (package / 'arcadia-studio.exe').resolve()
+    record(TRIAL / 'process-identity.json', identity)
+    print(json.dumps(receipt, ensure_ascii=False, indent=2))
+
+
+def package_guard(label):
+    binding, package, expected = admission(verify_inventory=False)
+    launch_receipt = load(TRIAL / 'launch.json')
+    assert launch_receipt['binding_sha256'] == BINDING_SHA and Path(launch_receipt['package']).resolve() == package.resolve()
+    assert load(TRIAL / 'package-before.json') == expected
+    actual = inventory(package)
+    unchanged = actual == expected
+    record(TRIAL / (label + '-package.json'), {'atUtc': now(), 'archive_sha256': binding['archive_sha256'], 'files': actual,
+           'added': sorted(actual.keys() - expected.keys()), 'removed': sorted(expected.keys() - actual.keys()),
+           'changed': sorted(p for p in actual.keys() & expected.keys() if actual[p] != expected[p]),
+           'completeInventoryUnchanged': unchanged})
+    assert unchanged, 'Package changed; exact delta receipt preserved.'
+    return package
+
+
+def saved(args):
+    assert args.after_visible_save, 'Root must observe successful Save first.'
+    assert re.fullmatch('[a-z0-9][a-z0-9-]{0,79}', args.label)
+    folder = TRIAL / 'checkpoints' / args.label
+    assert not folder.exists()
+    package = package_guard(args.label)
+    baseline, expected = fixture()
+    folder.mkdir()
+    actual = copy_exact(TRIAL / 'work', folder / 'sources')
+    record(folder / 'sources.json', actual)
+    assert actual == expected, 'Saved exact baseline files differ; preserve and inspect.'
+    env = environment()
+    env['PATH'] = str(package) + ';' + env['PATH']
+    command = [str(ORACLE), 'same', str(baseline / 'project.arcadia'), str(folder / 'sources/project.arcadia')]
+    result = subprocess.run(command, cwd=folder, env=env, capture_output=True)
+    (folder / 'stdout.log').write_bytes(result.stdout)
+    (folder / 'stderr.log').write_bytes(result.stderr)
+    record(folder / 'result.json', {'atUtc': now(), 'command': command, 'exitCode': result.returncode, 'oracle_sha256': ORACLE_SHA,
+                                  'scope': 'Saved disk/model oracle after root-observed Save; no independent UI assertion.'})
+    assert result.returncode == 0
+    package_guard(args.label + '-after-oracle')
+    print(json.dumps({'action': 'saved', 'oracle_exit': 0, 'source_files': len(actual)}))
+
+
+def closed(args):
+    assert args.observed_absent, 'Root must first observe the GUI/window absent.'
+    launch_receipt = load(TRIAL / 'launch.json')
+    current = process_identity(launch_receipt['pid'])
+    original = load(TRIAL / 'process-identity.json')
+    assert current is None or current['creation_filetime'] != original['creation_filetime'], 'Original GUI process remains present.'
+    package = package_guard('after-close')
+    record(TRIAL / 'closed.json', {'atUtc': now(), 'pid': launch_receipt['pid'], 'originalProcessAbsent': True,
+                                 'pidReused': current is not None, 'completePackageUnchanged': True,
+                                 'scope': 'Root-observed window absence plus read-only process identity and package check; no numeric exit code observed.'})
+    print(json.dumps({'action': 'closed', 'package': str(package), 'result': 'PASS'}))
+
+
+if __name__ == '__main__':
+    sys.stdout.reconfigure(encoding='utf-8')
+    sys.stderr.reconfigure(encoding='utf-8')
+    parser = argparse.ArgumentParser()
+    parser.add_argument('action', choices=('launch', 'saved', 'closed'))
+    parser.add_argument('--label')
+    parser.add_argument('--after-visible-save', action='store_true')
+    parser.add_argument('--observed-absent', action='store_true')
+    args = parser.parse_args()
+    if args.action == 'launch':
+        launch()
+    elif args.action == 'saved':
+        saved(args)
+    else:
+        closed(args)

harness/experiments/navigation-prerelease-native-20260911/payload/loaded-modules.ps1

@@ -0,0 +1,44 @@
+# Optional read-only process inventory. Never launches, closes or controls a GUI.
+#Requires -Version 7.0
+$ErrorActionPreference = 'Stop'
+$trialPath = Join-Path $PSScriptRoot 'trial'
+$resultPath = Join-Path $trialPath 'loaded-modules.json'
+if (Test-Path -LiteralPath $resultPath) { throw 'Preserve existing module receipt.' }
+$launch = Get-Content -LiteralPath (Join-Path $trialPath 'launch.json') -Raw | ConvertFrom-Json
+$identity = Get-Content -LiteralPath (Join-Path $trialPath 'process-identity.json') -Raw | ConvertFrom-Json
+$before = Get-Content -LiteralPath (Join-Path $trialPath 'package-before.json') -Raw | ConvertFrom-Json
+$receipt = [ordered]@{ atUtc = [DateTime]::UtcNow.ToString('o'); pid = $launch.pid; status = 'PENDING'; modules = @(); scope = 'Point-in-time loaded modules of the exact launched process; no GUI action or universal runtime dependency claim.' }
+try {
+    $guiProcess = Get-Process -Id $launch.pid -ErrorAction Stop
+    if (-not [string]::Equals($guiProcess.Path, $identity.path, [StringComparison]::OrdinalIgnoreCase) -or
+        $guiProcess.StartTime.ToUniversalTime().ToFileTimeUtc() -ne $identity.creation_filetime) {
+        throw 'PID no longer identifies the original launch.'
+    }
+    $receipt.creation_filetime = $identity.creation_filetime
+    $systemRoot = [IO.Path]::GetFullPath($launch.environment.SystemRoot).TrimEnd('\') + '\'
+    $packageRoot = [IO.Path]::GetFullPath($launch.package).TrimEnd('\') + '\'
+    $items = foreach ($module in $guiProcess.Modules) {
+        $full = [IO.Path]::GetFullPath($module.FileName)
+        $inWindows = $full.StartsWith($systemRoot, [StringComparison]::OrdinalIgnoreCase)
+        $inPackage = $full.StartsWith($packageRoot, [StringComparison]::OrdinalIgnoreCase)
+        $hash = (Get-FileHash -LiteralPath $full -Algorithm SHA256).Hash.ToLowerInvariant()
+        if ($inPackage) {
+            $relative = $full.Substring($packageRoot.Length).Replace('\', '/')
+            $recorded = $before.PSObject.Properties[$relative]
+            if (-not $recorded -or $recorded.Value -cne $hash) { throw "Package module differs: $relative" }
+        }
+        [ordered]@{ name = $module.ModuleName; path = $full; sha256 = $hash; windowsPath = $inWindows; packagePath = $inPackage }
+    }
+    $receipt.modules = @($items)
+    if (-not $receipt.modules.Count) { throw 'No modules observed.' }
+    $unexpected = @($items | Where-Object { -not $_.windowsPath -and -not $_.packagePath })
+    $receipt.unexpected = $unexpected
+    if ($unexpected.Count) { throw 'Unexpected non-Windows, non-package module; inspect receipt.' }
+    $receipt.status = 'PASS'
+} catch {
+    $receipt.status = 'FAIL'
+    $receipt.error = $_.ToString()
+} finally {
+    [IO.File]::WriteAllText($resultPath, ($receipt | ConvertTo-Json -Depth 10) + "`n", [Text.UTF8Encoding]::new($false))
+}
+if ($receipt.status -ne 'PASS') { throw $receipt.error }

harness/experiments/navigation-prerelease-native-20260911/payload/original-close-observation.json

@@ -0,0 +1,21 @@
+{
+  "record_kind": "Attributed transcription of root's tool-result observation; not raw stderr",
+  "reported_by": "Codex-9e8r6t /root",
+  "action": "Original helper.py closed --observed-absent",
+  "time_scope": "Around 2026-09-11 21:29 UTC",
+  "reported_stack": [
+    "helper.py:266 closed(args)",
+    "helper.py:242 current = process_identity(pid)",
+    "helper.py:127 assert api.QueryFullProcessImageNameW(handle, 0, buffer, ctypes.byref(count))",
+    "AssertionError"
+  ],
+  "original_win32_error": null,
+  "original_win32_error_scope": "Not captured; cause unknown",
+  "original_closed_receipt": "Not written; subsequent Get-Content found closed.json absent",
+  "independent_followup": {
+    "command": "Get-Process -Id 1348",
+    "reported_result": "PID 1348 absent",
+    "atUtc": "2026-09-11T21:29:31.2640881Z"
+  },
+  "scope": "Preserves failed helper history and separate root absence observation without inventing a raw log or numeric exit code. Separate closure-helper result remains pending."
+}